test: test_classic_mailing_list: Check contact auth and display names

Merge pull request #5296 from deltachat/link2xt/imap-session
refactor: move more methods from Imap into Session
2026-04-05 06:52:10 +03:00 · 2024-02-29 14:25:25 -03:00 · 2024-02-29 02:29:52 +00:00 · 2024-02-29 02:29:18 +00:00 · 2024-02-28 23:18:30 +00:00 · 2024-02-28 22:51:07 +00:00
119 changed files with 4634 additions and 2310 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -24,9 +24,11 @@ jobs:
    name: Lint Rust
    runs-on: ubuntu-latest
    env:
-      RUSTUP_TOOLCHAIN: 1.74.1
+      RUSTUP_TOOLCHAIN: 1.76.0
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
+        with:
+          show-progress: false
      - name: Install rustfmt and clippy
        run: rustup toolchain install $RUSTUP_TOOLCHAIN --profile minimal --component rustfmt --component clippy
      - name: Cache rust cargo artifacts
@@ -42,7 +44,9 @@ jobs:
    name: cargo deny
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
+        with:
+          show-progress: false
      - uses: EmbarkStudios/cargo-deny-action@v1
        with:
          arguments: --all-features --workspace
@@ -53,7 +57,9 @@ jobs:
    name: Check provider database
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
+        with:
+          show-progress: false
      - name: Check provider database
        run: scripts/update-provider-database.sh

@@ -63,8 +69,9 @@ jobs:
    env:
      RUSTDOCFLAGS: -Dwarnings
    steps:
-      - name: Checkout sources
-        uses: actions/checkout@v3
+      - uses: actions/checkout@v4
+        with:
+          show-progress: false
      - name: Cache rust cargo artifacts
        uses: swatinem/rust-cache@v2
      - name: Rustdoc
@@ -76,18 +83,20 @@ jobs:
      matrix:
        include:
          - os: ubuntu-latest
-            rust: 1.74.1
+            rust: 1.76.0
          - os: windows-latest
-            rust: 1.74.1
+            rust: 1.76.0
          - os: macos-latest
-            rust: 1.74.1
+            rust: 1.76.0

          # Minimum Supported Rust Version = 1.70.0
          - os: ubuntu-latest
            rust: 1.70.0
    runs-on: ${{ matrix.os }}
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
+        with:
+          show-progress: false

      - name: Install Rust ${{ matrix.rust }}
        run: rustup toolchain install --profile minimal ${{ matrix.rust }}
@@ -111,7 +120,9 @@ jobs:
        os: [ubuntu-latest, macos-latest]
    runs-on: ${{ matrix.os }}
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
+        with:
+          show-progress: false

      - name: Cache rust cargo artifacts
        uses: swatinem/rust-cache@v2
@@ -120,7 +131,7 @@ jobs:
        run: cargo build -p deltachat_ffi --features jsonrpc

      - name: Upload C library
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
        with:
          name: ${{ matrix.os }}-libdeltachat.a
          path: target/debug/libdeltachat.a
@@ -133,7 +144,9 @@ jobs:
        os: [ubuntu-latest, macos-latest, windows-latest]
    runs-on: ${{ matrix.os }}
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
+        with:
+          show-progress: false

      - name: Cache rust cargo artifacts
        uses: swatinem/rust-cache@v2
@@ -142,7 +155,7 @@ jobs:
        run: cargo build -p deltachat-rpc-server

      - name: Upload deltachat-rpc-server
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
        with:
          name: ${{ matrix.os }}-deltachat-rpc-server
          path: ${{ matrix.os == 'windows-latest' && 'target/debug/deltachat-rpc-server.exe' || 'target/debug/deltachat-rpc-server' }}
@@ -152,8 +165,9 @@ jobs:
    name: Python lint
    runs-on: ubuntu-latest
    steps:
-      - name: Checkout sources
-        uses: actions/checkout@v3
+      - uses: actions/checkout@v4
+        with:
+          show-progress: false

      - name: Install tox
        run: pip install tox
@@ -193,16 +207,18 @@ jobs:

    runs-on: ${{ matrix.os }}
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
+        with:
+          show-progress: false

      - name: Download libdeltachat.a
-        uses: actions/download-artifact@v3
+        uses: actions/download-artifact@v4
        with:
          name: ${{ matrix.os }}-libdeltachat.a
          path: target/debug

      - name: Install python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
        with:
          python-version: ${{ matrix.python }}

@@ -243,10 +259,12 @@ jobs:

    runs-on: ${{ matrix.os }}
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
+        with:
+          show-progress: false

      - name: Install python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
        with:
          python-version: ${{ matrix.python }}

@@ -254,7 +272,7 @@ jobs:
        run: pip install tox

      - name: Download deltachat-rpc-server
-        uses: actions/download-artifact@v3
+        uses: actions/download-artifact@v4
        with:
          name: ${{ matrix.os }}-deltachat-rpc-server
          path: target/debug
--- a/.github/workflows/deltachat-rpc-server.yml
+++ b/.github/workflows/deltachat-rpc-server.yml
@@ -21,22 +21,27 @@ jobs:
  # Build a version statically linked against musl libc
  # to avoid problems with glibc version incompatibility.
  build_linux:
-    name: Cross-compile deltachat-rpc-server for x86_64, i686, aarch64 and armv7 Linux
-    runs-on: ubuntu-22.04
+    name: Build deltachat-rpc-server for Linux
+    strategy:
+      fail-fast: false
+      matrix:
+        arch: [aarch64, armv7l, armv6l, i686, x86_64]
+    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v3
-
-      - name: Install ziglang
-        run: pip install wheel ziglang==0.11.0
+      - uses: actions/checkout@v4
+        with:
+          show-progress: false
+      - uses: DeterminateSystems/nix-installer-action@main
+      - uses: DeterminateSystems/magic-nix-cache-action@main

      - name: Build deltachat-rpc-server binaries
-        run: sh scripts/zig-rpc-server.sh
+        run: nix build .#deltachat-rpc-server-${{ matrix.arch }}-linux

-      - name: Upload dist directory with Linux binaries
-        uses: actions/upload-artifact@v3
+      - name: Upload binary
+        uses: actions/upload-artifact@v4
        with:
-          name: linux
-          path: dist/
+          name: deltachat-rpc-server-${{ matrix.arch }}-linux
+          path: result/bin/deltachat-rpc-server
          if-no-files-found: error

  build_windows:
@@ -44,32 +49,23 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        include:
-          - os: windows-latest
-            artifact: win32.exe
-            path: deltachat-rpc-server.exe
-            target: i686-pc-windows-msvc
-
-          - os: windows-latest
-            artifact: win64.exe
-            path: deltachat-rpc-server.exe
-            target: x86_64-pc-windows-msvc
-
-    runs-on: ${{ matrix.os }}
+        arch: [win32, win64]
+    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
+        with:
+          show-progress: false
+      - uses: DeterminateSystems/nix-installer-action@main
+      - uses: DeterminateSystems/magic-nix-cache-action@main

-      - name: Setup rust target
-        run: rustup target add ${{ matrix.target }}
-
-      - name: Build
-        run: cargo build --release --package deltachat-rpc-server --target ${{ matrix.target }} --features vendored
+      - name: Build deltachat-rpc-server binaries
+        run: nix build .#deltachat-rpc-server-${{ matrix.arch }}

      - name: Upload binary
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
        with:
-          name: deltachat-rpc-server-${{ matrix.artifact }}
-          path: target/${{ matrix.target}}/release/${{ matrix.path }}
+          name: deltachat-rpc-server-${{ matrix.arch }}
+          path: result/bin/deltachat-rpc-server.exe
          if-no-files-found: error

  build_macos:
@@ -77,13 +73,13 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        include:
-          - arch: x86_64
-          - arch: aarch64
+        arch: [x86_64, aarch64]

    runs-on: macos-latest
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
+        with:
+          show-progress: false

      - name: Setup rust target
        run: rustup target add ${{ matrix.arch }}-apple-darwin
@@ -92,7 +88,7 @@ jobs:
        run: cargo build --release --package deltachat-rpc-server --target ${{ matrix.arch }}-apple-darwin --features vendored

      - name: Upload binary
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
        with:
          name: deltachat-rpc-server-${{ matrix.arch }}-macos
          path: target/${{ matrix.arch }}-apple-darwin/release/deltachat-rpc-server
@@ -100,53 +96,85 @@ jobs:

  publish:
    name: Build wheels and upload binaries to the release
-    needs: ["build_linux", "build_windows", "build_macos"]
+    needs: ["build_linux", "build_macos"]
    permissions:
      contents: write
    runs-on: "ubuntu-latest"
    steps:
-      - uses: actions/checkout@v3
-
-      - name: Download Linux binaries
-        uses: actions/download-artifact@v3
+      - uses: actions/checkout@v4
        with:
-          name: linux
-          path: dist/
+          show-progress: false

-      - name: Download win32 binary
-        uses: actions/download-artifact@v3
+      - name: Download Linux aarch64 binary
+        uses: actions/download-artifact@v4
        with:
-          name: deltachat-rpc-server-win32.exe
-          path: deltachat-rpc-server-win32.exe.d
+          name: deltachat-rpc-server-aarch64-linux
+          path: deltachat-rpc-server-aarch64-linux.d

-      - name: Download win64 binary
-        uses: actions/download-artifact@v3
+      - name: Download Linux armv7l binary
+        uses: actions/download-artifact@v4
        with:
-          name: deltachat-rpc-server-win64.exe
-          path: deltachat-rpc-server-win64.exe.d
+          name: deltachat-rpc-server-armv7l-linux
+          path: deltachat-rpc-server-armv7l-linux.d
+
+      - name: Download Linux armv6l binary
+        uses: actions/download-artifact@v4
+        with:
+          name: deltachat-rpc-server-armv6l-linux
+          path: deltachat-rpc-server-armv6l-linux.d
+
+      - name: Download Linux i686 binary
+        uses: actions/download-artifact@v4
+        with:
+          name: deltachat-rpc-server-i686-linux
+          path: deltachat-rpc-server-i686-linux.d
+
+      - name: Download Linux x86_64 binary
+        uses: actions/download-artifact@v4
+        with:
+          name: deltachat-rpc-server-x86_64-linux
+          path: deltachat-rpc-server-x86_64-linux.d
+
+      - name: Download Win32 binary
+        uses: actions/download-artifact@v4
+        with:
+          name: deltachat-rpc-server-win32
+          path: deltachat-rpc-server-win32.d
+
+      - name: Download Win64 binary
+        uses: actions/download-artifact@v4
+        with:
+          name: deltachat-rpc-server-win64
+          path: deltachat-rpc-server-win64.d

      - name: Download macOS binary for x86_64
-        uses: actions/download-artifact@v3
+        uses: actions/download-artifact@v4
        with:
          name: deltachat-rpc-server-x86_64-macos
          path: deltachat-rpc-server-x86_64-macos.d

      - name: Download macOS binary for aarch64
-        uses: actions/download-artifact@v3
+        uses: actions/download-artifact@v4
        with:
          name: deltachat-rpc-server-aarch64-macos
          path: deltachat-rpc-server-aarch64-macos.d

      - name: Flatten dist/ directory
        run: |
-          mv deltachat-rpc-server-win32.exe.d/deltachat-rpc-server.exe dist/deltachat-rpc-server-win32.exe
-          mv deltachat-rpc-server-win64.exe.d/deltachat-rpc-server.exe dist/deltachat-rpc-server-win64.exe
+          mkdir -p dist
+          mv deltachat-rpc-server-aarch64-linux.d/deltachat-rpc-server dist/deltachat-rpc-server-aarch64-linux
+          mv deltachat-rpc-server-armv7l-linux.d/deltachat-rpc-server dist/deltachat-rpc-server-armv7l-linux
+          mv deltachat-rpc-server-armv6l-linux.d/deltachat-rpc-server dist/deltachat-rpc-server-armv6l-linux
+          mv deltachat-rpc-server-i686-linux.d/deltachat-rpc-server dist/deltachat-rpc-server-i686-linux
+          mv deltachat-rpc-server-x86_64-linux.d/deltachat-rpc-server dist/deltachat-rpc-server-x86_64-linux
+          mv deltachat-rpc-server-win32.d/deltachat-rpc-server.exe dist/deltachat-rpc-server-win32.exe
+          mv deltachat-rpc-server-win64.d/deltachat-rpc-server.exe dist/deltachat-rpc-server-win64.exe
          mv deltachat-rpc-server-x86_64-macos.d/deltachat-rpc-server dist/deltachat-rpc-server-x86_64-macos
          mv deltachat-rpc-server-aarch64-macos.d/deltachat-rpc-server dist/deltachat-rpc-server-aarch64-macos

      # Python 3.11 is needed for tomllib used in scripts/wheel-rpc-server.py
      - name: Install python 3.12
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
        with:
          python-version: 3.12

@@ -160,6 +188,7 @@ jobs:
        run: ls -l dist/

      - name: Upload binaries to the GitHub release
+        if: github.event_name == 'release'
        env:
          GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
        run: |
--- a/.github/workflows/jsonrpc-client-npm-package.yml
+++ b/.github/workflows/jsonrpc-client-npm-package.yml
@@ -13,8 +13,9 @@ jobs:
    steps:
      - name: Install tree
        run: sudo apt install tree
-      - name: Checkout
-        uses: actions/checkout@v3
+      - uses: actions/checkout@v4
+        with:
+          show-progress: false
      - uses: actions/setup-node@v3
        with:
          node-version: "18"
@@ -49,7 +50,7 @@ jobs:
          ls -lah
          mv $(find deltachat-jsonrpc-client-*) $DELTACHAT_JSONRPC_TAR_GZ
      - name: Upload Prebuild
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
        with:
          name: deltachat-jsonrpc-client.tgz
          path: deltachat-jsonrpc/typescript/${{ env.DELTACHAT_JSONRPC_TAR_GZ }}
--- a/.github/workflows/jsonrpc.yml
+++ b/.github/workflows/jsonrpc.yml
@@ -14,7 +14,9 @@ jobs:
  build_and_test:
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
+        with:
+          show-progress: false
      - name: Use Node.js 18.x
        uses: actions/setup-node@v3
        with:
--- a/.github/workflows/node-docs.yml
+++ b/.github/workflows/node-docs.yml
@@ -14,7 +14,9 @@ jobs:
  generate:
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
+        with:
+          show-progress: false

      - name: Use Node.js 18.x
        uses: actions/setup-node@v3
--- a/.github/workflows/node-package.yml
+++ b/.github/workflows/node-package.yml
@@ -14,8 +14,9 @@ jobs:
      matrix:
        os: [macos-latest, windows-latest]
    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
+      - uses: actions/checkout@v4
+        with:
+          show-progress: false
      - uses: actions/setup-node@v3
        with:
          node-version: "18"
@@ -56,7 +57,7 @@ jobs:
          tar -zcvf "${{ matrix.os }}.tar.gz" -C prebuilds .

      - name: Upload Prebuild
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
        with:
          name: ${{ matrix.os }}
          path: node/${{ matrix.os }}.tar.gz
@@ -74,8 +75,9 @@ jobs:
      - name: Change working directory owner
        run: chown root:root .

-      - name: Checkout
-        uses: actions/checkout@v3
+      - uses: actions/checkout@v4
+        with:
+          show-progress: false
      - uses: actions/setup-node@v3
        with:
          node-version: "18"
@@ -125,7 +127,7 @@ jobs:
          tar -zcvf "linux.tar.gz" -C prebuilds .

      - name: Upload Prebuild
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
        with:
          name: linux
          path: node/linux.tar.gz
@@ -137,8 +139,9 @@ jobs:
    steps:
      - name: Install tree
        run: sudo apt install tree
-      - name: Checkout
-        uses: actions/checkout@v3
+      - uses: actions/checkout@v4
+        with:
+          show-progress: false
      - uses: actions/setup-node@v2
        with:
          node-version: "18"
@@ -165,23 +168,23 @@ jobs:
          node --version
          echo $DELTACHAT_NODE_TAR_GZ
      - name: Download Linux prebuild
-        uses: actions/download-artifact@v1
+        uses: actions/download-artifact@v4
        with:
          name: linux
      - name: Download macOS prebuild
-        uses: actions/download-artifact@v1
+        uses: actions/download-artifact@v4
        with:
          name: macos-latest
      - name: Download Windows prebuild
-        uses: actions/download-artifact@v1
+        uses: actions/download-artifact@v4
        with:
          name: windows-latest
      - shell: bash
        run: |
          mkdir node/prebuilds
-          tar -xvzf linux/linux.tar.gz -C node/prebuilds
-          tar -xvzf macos-latest/macos-latest.tar.gz -C node/prebuilds
-          tar -xvzf windows-latest/windows-latest.tar.gz -C node/prebuilds
+          tar -xvzf linux.tar.gz -C node/prebuilds
+          tar -xvzf macos-latest.tar.gz -C node/prebuilds
+          tar -xvzf windows-latest.tar.gz -C node/prebuilds
          tree node/prebuilds
          rm -rf linux macos-latest windows-latest
      - name: Install dependencies without running scripts
@@ -201,7 +204,7 @@ jobs:
          ls -lah
          mv $(find deltachat-node-*) $DELTACHAT_NODE_TAR_GZ
      - name: Upload prebuild
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
        with:
          name: deltachat-node.tgz
          path: ${{ env.DELTACHAT_NODE_TAR_GZ }}
--- a/.github/workflows/node-tests.yml
+++ b/.github/workflows/node-tests.yml
@@ -23,8 +23,9 @@ jobs:
      matrix:
        os: [ubuntu-latest, macos-latest, windows-latest]
    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
+      - uses: actions/checkout@v4
+        with:
+          show-progress: false
      - uses: actions/setup-node@v3
        with:
          node-version: "18"
--- a/.github/workflows/repl.yml
+++ b/.github/workflows/repl.yml
@@ -10,15 +10,17 @@ on:
 jobs:
  build_repl:
    name: Build REPL example
-    runs-on: windows-latest
+    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v3
-
+      - uses: actions/checkout@v4
+        with:
+          show-progress: false
+      - uses: DeterminateSystems/nix-installer-action@main
+      - uses: DeterminateSystems/magic-nix-cache-action@main
      - name: Build
-        run: cargo build -p deltachat-repl --features vendored
-
+        run: nix build .#deltachat-repl-win64
      - name: Upload binary
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
        with:
          name: repl.exe
-          path: "target/debug/deltachat-repl.exe"
+          path: "result/bin/deltachat-repl.exe"
--- a/.github/workflows/upload-docs.yml
+++ b/.github/workflows/upload-docs.yml
@@ -10,7 +10,9 @@ jobs:
    runs-on: ubuntu-latest

    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
+        with:
+          show-progress: false
      - name: Build the documentation with cargo
        run: |
          cargo doc --package deltachat --no-deps --document-private-items
--- a/.github/workflows/upload-ffi-docs.yml
+++ b/.github/workflows/upload-ffi-docs.yml
@@ -14,7 +14,9 @@ jobs:
    runs-on: ubuntu-latest

    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
+        with:
+          show-progress: false
      - name: Build the documentation with cargo
        run: |
          cargo doc --package deltachat_ffi --no-deps
--- a/.github/workflows/upload-python-docs.yml
+++ b/.github/workflows/upload-python-docs.yml
@@ -10,8 +10,9 @@ jobs:
    runs-on: ubuntu-latest

    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
        with:
+          show-progress: false
          fetch-depth: 0 # Fetch history to calculate VCS version number.
      - name: Build Python documentation
        run: scripts/build-python-docs.sh
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,259 @@
 # Changelog

+## [1.135.1] - 2024-02-20
+
+### Features / Changes
+
+- Sync self-avatar across devices ([#4893](https://github.com/deltachat/deltachat-core-rust/pull/4893)).
+- Sync Config::Selfstatus across devices ([#4893](https://github.com/deltachat/deltachat-core-rust/pull/4893)).
+- Remove webxdc sending limit.
+
+### Fixes
+
+- Never encrypt `{vc,vg}-request` SecureJoin messages.
+- Apply Autocrypt headers if timestamp is unchanged.
+- `Context::get_info`: Report displayname as "displayname" (w/o underscore).
+
+### Tests
+
+- Mock `SystemTime::now()` for the tests.
+- Add a test on protection message sort timestamp ([#5088](https://github.com/deltachat/deltachat-core-rust/pull/5088)).
+
+### Build system
+
+- Add flake.nix.
+- Add footer template for git-cliff.
+
+### CI
+
+- Update GitHub Actions `actions/upload-artifact`, `actions/download-artifact`, `actions/checkout`.
+- Build deltachat-repl for Windows with nix.
+- Build deltachat-rpc-server with nix.
+- Try to upload deltachat-rpc-server only on release.
+
+### Refactor
+
+- `create_keypair`: Remove unnecessary `map_err`.
+- Return error with a cause when failing to export keys.
+- Rename incorrectly named variables in `create_keypair`.
+
+## [1.135.1] - 2024-02-20
+
+### CI
+
+- Update actions/upload-artifact.
+- Use actions/download-artifact@v4.
+- Replace download-artifact v1 with v4.
+- Update to actions/checkout@v4.
+- Fixup node-package.yml after artifact actions upgrade.
+
+### Features / Changes
+
+- Mock SystemTime::now() for the tests.
+- Remove webxdc sending limit.
+- Sync self-avatar across devices ([#4893](https://github.com/deltachat/deltachat-core-rust/pull/4893)).
+- Sync Config::Selfstatus across devices ([#4893](https://github.com/deltachat/deltachat-core-rust/pull/4893)).
+
+### Fixes
+
+- Context::get_info: Report displayname as "displayname" (w/o underscore).
+- Never encrypt {vc,vg}-request.
+
+### Other
+
+- Cleanup changelog ([#5265](https://github.com/deltachat/deltachat-core-rust/pull/5265))
+
+somehow a whole issue sneaked in :).
+
+### Refactor
+
+- create_keypair: Remove unnecessary map_err.
+- Return error with a cause when failing to export keys.
+- Rename incorrectly named variables in create_keypair.
+
+### Tests
+
+- Add a test on protection message sort timestamp ([#5088](https://github.com/deltachat/deltachat-core-rust/pull/5088)).
+
+## [1.135.0] - 2024-02-13
+
+### Features / Changes
+
+- Add wildcard pattern support to provider database.
+- Add device message about outgoing undecryptable messages ([#5164](https://github.com/deltachat/deltachat-core-rust/pull/5164)).
+- Context::set_config(): Restart IO scheduler if needed ([#5111](https://github.com/deltachat/deltachat-core-rust/pull/5111)).
+- Server_sent_unsolicited_exists(): Log folder name.
+- Cache system time instead of looking at the clock several times in a row.
+- Basic self-reporting ([#5129](https://github.com/deltachat/deltachat-core-rust/pull/5129)).
+
+### Fixes
+
+- Dehtml: Don't just truncate text when trying to decode ([#5223](https://github.com/deltachat/deltachat-core-rust/pull/5223)).
+- Mark the gossip keys from the message as verified, not the ones from the db ([#5247](https://github.com/deltachat/deltachat-core-rust/pull/5247)).
+- Guarantee immediate message deletion if delete_server_after == 0 ([#5201](https://github.com/deltachat/deltachat-core-rust/pull/5201)).
+- Never allow a message timestamp to be a lot in the future ([#5249](https://github.com/deltachat/deltachat-core-rust/pull/5249)).
+- Imap::configure_mvbox: Do select_with_uidvalidity() before return.
+- ImapSession::select_or_create_folder(): Don't fail if folder is created in parallel.
+- Emit ConfigSynced event on the second device.
+- Create mvbox on setting mvbox_move.
+- Use SystemTime instead of Instant everywhere.
+- Restore database rows removed in previous release; this ensures compatibility when adding second device or importing backup and not all devices run the new core ([#5254](https://github.com/deltachat/deltachat-core-rust/pull/5254))
+
+### Miscellaneous Tasks
+
+- cargo: Bump image from 0.24.7 to 0.24.8.
+- cargo: Bump chrono from 0.4.31 to 0.4.33.
+- cargo: Bump futures-lite from 2.1.0 to 2.2.0.
+- cargo: Bump pin-project from 1.1.3 to 1.1.4.
+- cargo: Bump iana-time-zone from yanked 0.1.59 to 0.1.60.
+- cargo: Bump smallvec from 1.11.2 to 1.13.1.
+- cargo: Bump base64 from 0.21.5 to 0.21.7.
+- cargo: Bump regex from 1.10.2 to 1.10.3.
+- cargo: Bump libc from 0.2.151 to 0.2.153.
+- cargo: Bump reqwest from 0.11.23 to 0.11.24.
+- cargo: Bump axum from 0.7.3 to 0.7.4.
+- cargo: Bump uuid from 1.6.1 to 1.7.0.
+- cargo: Bump fast-socks5 from 0.9.2 to 0.9.5.
+- cargo: Bump serde_json from 1.0.111 to 1.0.113.
+- cargo: Bump syn from 2.0.46 to 2.0.48.
+- cargo: Bump serde from 1.0.194 to 1.0.196.
+- cargo: Bump toml from 0.8.8 to 0.8.10.
+- cargo: Update to strum 0.26.
+- Cargo update.
+- scripts: Do not install deltachat-rpc-client twice.
+
+### Other
+
+- Update welcome image, thanks @paulaluap
+- Merge pull request #5243 from deltachat/dependabot/cargo/pin-project-1.1.4
+- Merge pull request #5241 from deltachat/dependabot/cargo/futures-lite-2.2.0
+- Merge pull request #5236 from deltachat/dependabot/cargo/chrono-0.4.33
+- Merge pull request #5235 from deltachat/dependabot/cargo/image-0.24.8
+
+
+### Refactor
+
+- Resultify token::exists.
+
+### Tests
+
+- Delete_server_after="1" should cause immediate message deletion ([#5201](https://github.com/deltachat/deltachat-core-rust/pull/5201)).
+
+## [1.134.0] - 2024-01-31
+
+### API-Changes
+
+- [**breaking**] JSON-RPC: device message api now requires `Option<MessageData>` instead of `String` for the message ([#5211](https://github.com/deltachat/deltachat-core-rust/pull/5211)).
+- CFFI: add `dc_accounts_background_fetch` and event `DC_EVENT_ACCOUNTS_BACKGROUND_FETCH_DONE`.
+- JSON-RPC: add `accounts_background_fetch`.
+
+### Features / Changes
+
+- `Qr::check_qr()`: Accept i.delta.chat invite links ([#5217](https://github.com/deltachat/deltachat-core-rust/pull/5217)).
+- Add support for IMAP METADATA, fetching `/shared/comment` and `/shared/admin` and displaying it in account info.
+
+### Fixes
+
+- Add tolerance for macOS and iOS changing `#` to `%23`.
+- Do not drop unknown report attachments, such as TLS reports.
+- Treat only "Auto-Submitted: auto-generated" messages as bot-sent ([#5213](https://github.com/deltachat/deltachat-core-rust/pull/5213)).
+- `Chat::resend_msgs`: Guarantee strictly increasing time in the `Date` header.
+- Delete resent messages on receiver side ([#5155](https://github.com/deltachat/deltachat-core-rust/pull/5155)).
+- Fix iOS build issue.
+
+### CI
+
+- Add/remove necessary newlines to fix Python lint.
+
+### Tests
+
+- `test_import_export_online_all`: Send the message to the existing address to avoid errors ([#5220](https://github.com/deltachat/deltachat-core-rust/pull/5220)).
+
+## [1.133.2] - 2024-01-24
+
+### Fixes
+
+- Downgrade OpenSSL from 3.2.0 to 3.1.4 ([#5206](https://github.com/deltachat/deltachat-core-rust/issues/5206))
+- No new chats for MDNs with alias ([#5196](https://github.com/deltachat/deltachat-core-rust/issues/5196)) ([#5199](https://github.com/deltachat/deltachat-core-rust/pull/5199)).
+
+## [1.133.1] - 2024-01-21
+
+### API-Changes
+
+- Add `is_bot` to cffi and jsonrpc ([#5197](https://github.com/deltachat/deltachat-core-rust/pull/5197)).
+
+### Features / Changes
+
+- Add system message when provider does not allow unencrypted messages ([#5195](https://github.com/deltachat/deltachat-core-rust/pull/5195)).
+
+### Fixes
+
+- `Chat::send_msg`: Remove encryption-related params from already sent message. This allows to send received encrypted `dc_msg_t` object to unencrypted chat, e.g. in a Python bot.
+- Set message download state to Failure on IMAP errors. This avoids partially downloaded messages getting stuck in "Downloading..." state without actually being in a download queue.
+- BCC-to-self even if server deletion is set to "at once". This is a workaround for SMTP servers which do not return response in time, BCC-self works as a confirmation that message was sent out successfully and does not need more retries.
+- node: Run tests with native ESM modules instead of `esm` ([#5194](https://github.com/deltachat/deltachat-core-rust/pull/5194)).
+- Use Quoted-Printable MIME encoding for the text part ([#3986](https://github.com/deltachat/deltachat-core-rust/pull/3986)).
+
+### Tests
+
+- python: Add `get_protected_chat` to testplugin.py.
+
+## [1.133.0] - 2024-01-14
+
+### Features / Changes
+
+- Securejoin protocol implementation refinements
+  - Track forward and backward verification separately ([#5089](https://github.com/deltachat/deltachat-core-rust/pull/5089)) to avoid inconsistent states.
+  - Mark 1:1 chat as verified for Bob early. 1:1 chat with Alice is verified as soon as Alice's key is verified rather than at the end of the protocol.
+- Put Message-ID into hidden headers and take it from there on receiver ([#4798](https://github.com/deltachat/deltachat-core-rust/pull/4798)). This works around servers which generate their own Message-ID and overwrite the one generated by Delta Chat.
+- deltachat-repl: Enable INFO logging by default and add timestamps.
+- Add `ConfigSynced` (`DC_EVENT_CONFIG_SYNCED`) event which is emitted when configuration is changed via synchronization message or synchronization message for configuration is sent. UI may refresh elments based on the configuration key which is a part of the event.
+- Sync contact creation/rename across devices ([#5163](https://github.com/deltachat/deltachat-core-rust/pull/5163)).
+- Encrypt MDNs ([#5175](https://github.com/deltachat/deltachat-core-rust/pull/5175)).
+- Only try to configure non-strict TLS checks if explicitly set ([#5181](https://github.com/deltachat/deltachat-core-rust/pull/5181)).
+
+### Build system
+
+- Use released version of iroh 0.4.2 for "setup second device" feature.
+
+### CI
+
+- Update to Rust 1.75.0.
+- Downgrade `chai` from 4.4.0 to 4.3.10.
+
+### Documentation
+
+- Add a link <https://www.ietf.org/archive/id/draft-bucksch-autoconfig-00.html> to autoconfig RFC draft.
+- Update securejoin link in `standards.md` from <https://countermitm.readthedocs.io/> to <https://securejoin.readthedocs.io>.
+- Restore "Constants" page in Doxygen >=1.9.8
+
+### Fixes
+
+- imap: Limit the rate of LOGIN attempts rather than connection attempts. This is to avoid having to wait for rate limiter right after switching from a bad or offline network to a working network while still guarding against reconnection loop.
+- Do not ignore `peerstate.save_to_db()` errors.
+- securejoin: Mark 1:1s as protected regardless of the Config::VerifiedOneOnOneChats.
+- Delete received outgoing messages from SMTP queue ([#5115](https://github.com/deltachat/deltachat-core-rust/pull/5115)).
+- imap: Fail fast on `LIST` errors to avoid busy loop when connection is lost.
+- Split SMTP jobs already in `chat::create_send_msg_jobs()` ([#5115](https://github.com/deltachat/deltachat-core-rust/pull/5115)).
+- Do not remove contents from unencrypted [Schleuder](https://schleuder.org/) mailing lists messages.
+- Reset message error when scheduling resending ([#5119](https://github.com/deltachat/deltachat-core-rust/pull/5119)).
+- Emit events more reliably when starting and stopping I/O ([#5101](https://github.com/deltachat/deltachat-core-rust/pull/5101)).
+- Fix timestamp of chat protection info message for correct message ordering after restoring a backup ([#5088](https://github.com/deltachat/deltachat-core-rust/pull/5088)).
+
+### Refactor
+
+- sql: Recreate `config` table with UNIQUE constraint.
+- sql: Recreate `keypairs` table to remove unused `addr` and `created` fields and move `is_default` flag to `config` table.
+- Send `Secure-Join-Fingerprint` only in `*-request-with-auth`.
+
+### Tests
+
+- Test joining non-protected group.
+- Test that read receipts don't degrade encryption.
+- Test that changing default private key breaks backward verification.
+- Test recovery from lost vc-contact-confirm.
+- Use `wait_for_incoming_msg_event()` more.
+
 ## [1.132.1] - 2023-12-12

 ### Features / Changes
@@ -3357,3 +3611,9 @@ https://github.com/deltachat/deltachat-core-rust/pulls?q=is%3Apr+is%3Aclosed
 [1.131.9]: https://github.com/deltachat/deltachat-core-rust/compare/v1.131.8...v1.131.9
 [1.132.0]: https://github.com/deltachat/deltachat-core-rust/compare/v1.131.9...v1.132.0
 [1.132.1]: https://github.com/deltachat/deltachat-core-rust/compare/v1.132.0...v1.132.1
+[1.133.0]: https://github.com/deltachat/deltachat-core-rust/compare/v1.132.1...v1.133.0
+[1.133.1]: https://github.com/deltachat/deltachat-core-rust/compare/v1.133.0...v1.133.1
+[1.133.2]: https://github.com/deltachat/deltachat-core-rust/compare/v1.133.1...v1.133.2
+[1.134.0]: https://github.com/deltachat/deltachat-core-rust/compare/v1.133.2...v1.134.0
+[1.135.0]: https://github.com/deltachat/deltachat-core-rust/compare/v1.134.0...v1.135.0
+[1.135.1]: https://github.com/deltachat/deltachat-core-rust/compare/v1.135.0...v1.135.1
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "deltachat"
-version = "1.132.1"
+version = "1.135.1"
 edition = "2021"
 license = "MPL-2.0"
 rust-version = "1.70"
@@ -30,17 +30,15 @@ opt-level = "z"
 codegen-units = 1
 strip = true

-[patch.crates-io]
-imap-proto = { git = "https://github.com/djc/tokio-imap.git", rev = "01ff256a7e42a9f7d2732706f8b71a16ce93427e" }
-
 [dependencies]
 deltachat_derive = { path = "./deltachat_derive" }
+deltachat-time = { path = "./deltachat-time" }
 format-flowed = { path = "./format-flowed" }
 ratelimit = { path = "./deltachat-ratelimit" }

 anyhow = "1"
 async-channel = "2.0.0"
-async-imap = { version = "0.9.5", default-features = false, features = ["runtime-tokio"] }
+async-imap = { version = "0.9.7", default-features = false, features = ["runtime-tokio"] }
 async-native-tls = { version = "0.5", default-features = false, features = ["runtime-tokio"] }
 async-smtp = { version = "0.9", default-features = false, features = ["runtime-tokio"] }
 async_zip = { version = "0.0.12", default-features = false, features = ["deflate", "fs"] }
@@ -54,11 +52,11 @@ escaper = "0.1"
 fast-socks5 = "0.9"
 fd-lock = "4"
 futures = "0.3"
-futures-lite = "2.0.0"
+futures-lite = "2.2.0"
 hex = "0.4.0"
 hickory-resolver = "0.24"
 humansize = "2"
-image = { version = "0.24.7", default-features=false, features = ["gif", "jpeg", "ico", "png", "pnm", "webp", "bmp"] }
+image = { version = "0.24.8", default-features=false, features = ["gif", "jpeg", "ico", "png", "pnm", "webp", "bmp"] }
 iroh = { version = "0.4.2", default-features = false }
 kamadak-exif = "0.5"
 lettre_email = { git = "https://github.com/deltachat/lettre", branch = "master" }
@@ -71,14 +69,15 @@ num-traits = "0.2"
 once_cell = "1.18.0"
 percent-encoding = "2.3"
 parking_lot = "0.12"
-pgp = { version = "0.10", default-features = false }
+pgp = { version = "0.11", default-features = false }
 pin-project = "1"
 pretty_env_logger = { version = "0.5", optional = true }
 qrcodegen = "1.7.0"
 quick-xml = "0.31"
+quoted_printable = "0.5"
 rand = "0.8"
-regex = "1.9"
-reqwest = { version = "0.11.23", features = ["json"] }
+regex = "1.10"
+reqwest = { version = "0.11.24", features = ["json"] }
 rusqlite = { version = "0.30", features = ["sqlcipher"] }
 rust-hsluv = "0.1"
 sanitize-filename = "0.5"
@@ -87,8 +86,8 @@ serde = { version = "1.0", features = ["derive"] }
 sha-1 = "0.10"
 sha2 = "0.10"
 smallvec = "1"
-strum = "0.25"
-strum_macros = "0.25"
+strum = "0.26"
+strum_macros = "0.26"
 tagger = "4.3.4"
 textwrap = "0.16.0"
 thiserror = "1"
@@ -105,7 +104,7 @@ uuid = { version = "1", features = ["serde", "v4"] }
 ansi_term = "0.12.0"
 anyhow = { version = "1", features = ["backtrace"] } # Enable `backtrace` feature in tests.
 criterion = { version = "0.5.1", features = ["async_tokio"] }
-futures-lite = "2.0.0"
+futures-lite = "2.2.0"
 log = "0.4"
 pretty_env_logger = "0.5"
 proptest = { version = "1", default-features = false, features = ["std"] }
@@ -122,6 +121,7 @@ members = [
  "deltachat-rpc-server",
  "deltachat-ratelimit",
  "deltachat-repl",
+  "deltachat-time",
  "format-flowed",
 ]

--- a/RELEASE.md
+++ b/RELEASE.md
@@ -9,13 +9,16 @@ For example, to release version 1.116.0 of the core, do the following steps.

 3. Update the changelog: `git cliff --unreleased --tag 1.116.0 --prepend CHANGELOG.md` or `git cliff -u -t 1.116.0 -p CHANGELOG.md`.

-4. Update the version by running `scripts/set_core_version.py 1.116.0`.
+4. add a link to compare previous with current version to the end of CHANGELOG.md:
+  `[1.116.0]: https://github.com/deltachat/deltachat-core-rust/compare/v1.115.2...v1.116.0`

-5. Commit the changes as `chore(release): prepare for 1.116.0`.
+5. Update the version by running `scripts/set_core_version.py 1.116.0`.
+
+6. Commit the changes as `chore(release): prepare for 1.116.0`.
   Optionally, use a separate branch like `prep-1.116.0` for this commit and open a PR for review.

-6. Tag the release: `git tag -a v1.116.0`.
+7. Tag the release: `git tag -a v1.116.0`.

-7. Push the release tag: `git push origin v1.116.0`.
+8. Push the release tag: `git push origin v1.116.0`.

-8. Create a GitHub release: `gh release create v1.116.0 -n ''`.
+9. Create a GitHub release: `gh release create v1.116.0 -n ''`.
--- a/assets/welcome-image.jpg
+++ b/assets/welcome-image.jpg
--- a/cliff.toml
+++ b/cliff.toml
@@ -77,3 +77,17 @@ body = """
 """
 # remove the leading and trailing whitespace from the template
 trim = true
+footer = """
+{% for release in releases -%}
+    {% if release.version -%}
+        {% if release.previous.version -%}
+            [{{ release.version | trim_start_matches(pat="v") }}]: \
+                https://github.com/deltachat/deltachat-core-rust\
+                    /compare/{{ release.previous.version }}..{{ release.version }}
+        {% endif -%}
+    {% else -%}
+        [unreleased]: https://github.com/deltachat/deltachat-core-rust\
+            /compare/{{ release.previous.version }}..HEAD
+    {% endif -%}
+{% endfor %}
+"""
--- a/deltachat-ffi/Cargo.toml
+++ b/deltachat-ffi/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "deltachat_ffi"
-version = "1.132.1"
+version = "1.135.1"
 description = "Deltachat FFI"
 edition = "2018"
 readme = "README.md"
--- a/deltachat-ffi/DoxygenLayout.xml
+++ b/deltachat-ffi/DoxygenLayout.xml
@@ -9,7 +9,7 @@
      <tab type="hierarchy" visible="no" title="" intro=""/>
      <tab type="classmembers" visible="no" title="" intro=""/>
    </tab>
-    <tab type="modules" visible="yes" title="Constants" intro="Here is a list of constants:"/>
+    <tab type="topics" visible="yes" title="Constants" intro="Here is a list of constants:"/>
    <tab type="pages" visible="yes" title="" intro=""/>
    <tab type="namespaces" visible="yes" title="">
      <tab type="namespacelist" visible="yes" title="" intro=""/>
--- a/deltachat-ffi/deltachat.h
+++ b/deltachat-ffi/deltachat.h
@@ -423,19 +423,16 @@ char*           dc_get_blobdir               (const dc_context_t* context);
 *                    Sending messages to self is needed for a proper multi-account setup,
 *                    however, on the other hand, may lead to unwanted notifications in non-delta clients.
 * - `sentbox_watch`= 1=watch `Sent`-folder for changes,
- *                    0=do not watch the `Sent`-folder (default),
- *                    changes require restarting IO by calling dc_stop_io() and then dc_start_io().
+ *                    0=do not watch the `Sent`-folder (default).
 * - `mvbox_move`   = 1=detect chat messages,
 *                    move them to the `DeltaChat` folder,
 *                    and watch the `DeltaChat` folder for updates (default),
 *                    0=do not move chat-messages
- *                    changes require restarting IO by calling dc_stop_io() and then dc_start_io().
 * - `only_fetch_mvbox` = 1=Do not fetch messages from folders other than the
 *                    `DeltaChat` folder. Messages will still be fetched from the
 *                    spam folder and `sendbox_watch` will also still be respected
 *                    if enabled.
 *                    0=watch all folders normally (default)
- *                    changes require restarting IO by calling dc_stop_io() and then dc_start_io().
 * - `show_emails`  = DC_SHOW_EMAILS_OFF (0)=
 *                    show direct replies to chats only,
 *                    DC_SHOW_EMAILS_ACCEPTED_CONTACTS (1)=
@@ -3151,6 +3148,23 @@ void           dc_accounts_maybe_network        (dc_accounts_t* accounts);
 void           dc_accounts_maybe_network_lost    (dc_accounts_t* accounts);


+/**
+ * Perform a background fetch for all accounts in parallel with a timeout.
+ * Pauses the scheduler, fetches messages from imap and then resumes the scheduler.
+ *
+ * dc_accounts_background_fetch() was created for the iOS Background fetch.
+ *
+ * The `DC_EVENT_ACCOUNTS_BACKGROUND_FETCH_DONE` event is emitted at the end
+ * even in case of timeout, unless the function fails and returns 0.
+ * Process all events until you get this one and you can safely return to the background
+ * without forgetting to create notifications caused by timing race conditions.
+ *
+ * @memberof dc_accounts_t
+ * @param timeout The timeout in seconds
+ * @return Return 1 if DC_EVENT_ACCOUNTS_BACKGROUND_FETCH_DONE was emitted and 0 otherwise.
+ */
+int            dc_accounts_background_fetch    (dc_accounts_t* accounts, uint64_t timeout);
+
 /**
 * Create the event emitter that is used to receive events.
 *
@@ -4397,6 +4411,9 @@ int             dc_msg_is_info                (const dc_msg_t* msg);
 * Currently, the following types are defined:
 * - DC_INFO_PROTECTION_ENABLED (11) - Info-message for "Chat is now protected"
 * - DC_INFO_PROTECTION_DISABLED (12) - Info-message for "Chat is no longer protected"
+ * - DC_INFO_INVALID_UNENCRYPTED_MAIL (13) - Info-message for "Provider requires end-to-end encryption which is not setup yet",
+ *   the UI should change the corresponding string using #DC_STR_INVALID_UNENCRYPTED_MAIL
+ *   and also offer a way to fix the encryption, eg. by a button offering a QR scan
 *
 * Even when you display an icon,
 * you should still display the text of the informational message using dc_msg_get_text()
@@ -4423,6 +4440,7 @@ int             dc_msg_get_info_type          (const dc_msg_t* msg);
 #define         DC_INFO_EPHEMERAL_TIMER_CHANGED   10
 #define         DC_INFO_PROTECTION_ENABLED        11
 #define         DC_INFO_PROTECTION_DISABLED       12
+#define         DC_INFO_INVALID_UNENCRYPTED_MAIL  13
 #define         DC_INFO_WEBXDC_INFO_MESSAGE       32

 /**
@@ -5068,6 +5086,15 @@ int             dc_contact_is_blocked        (const dc_contact_t* contact);
 */
 int             dc_contact_is_verified       (dc_contact_t* contact);

+/**
+ * Returns whether contact is a bot.
+ *
+ * @memberof dc_contact_t
+ * @param contact The contact object.
+ * @return 0 if the contact is not a bot, 1 otherwise.
+ */
+int             dc_contact_is_bot            (dc_contact_t* contact);
+

 /**
 * Return the contact ID that verified a contact.
@@ -6206,6 +6233,18 @@ void dc_event_unref(dc_event_t* event);
 #define DC_EVENT_SELFAVATAR_CHANGED               2110


+/**
+ * A multi-device synced config value changed. Maybe the app needs to refresh smth. For uniformity
+ * this is emitted on the source device too. The value isn't reported, otherwise it would be logged
+ * which might not be good for privacy. You can get the new value with
+ * `dc_get_config(context, data2)`.
+ *
+ * @param data1 0
+ * @param data2 (char*) Configuration key.
+ */
+#define DC_EVENT_CONFIG_SYNCED                    2111
+
+
 /**
 * webxdc status update received.
 * To get the received status update, use dc_get_webxdc_status_updates() with
@@ -6230,6 +6269,16 @@ void dc_event_unref(dc_event_t* event);

 #define DC_EVENT_WEBXDC_INSTANCE_DELETED          2121

+/**
+ * Tells that the Background fetch was completed (or timed out).
+ *
+ * This event acts as a marker, when you reach this event you can be sure
+ * that all events emitted during the background fetch were processed.
+ * 
+ * This event is only emitted by the account manager
+ */
+
+#define DC_EVENT_ACCOUNTS_BACKGROUND_FETCH_DONE  2200

 /**
 * @}
@@ -6998,6 +7047,8 @@ void dc_event_unref(dc_event_t* event);
 /// "You added member %1$s."
 ///
 /// Used in status messages.
+///
+/// `%1$s` will be replaced by the added member's name.
 #define DC_STR_ADD_MEMBER_BY_YOU 128

 /// "Member %1$s added by %2$s."
@@ -7219,6 +7270,21 @@ void dc_event_unref(dc_event_t* event);
 /// Used as the first info messages in newly created groups.
 #define DC_STR_NEW_GROUP_SEND_FIRST_MESSAGE 172

+/// "Member %1$s added."
+///
+/// Used as info messages.
+///
+/// `%1$s` will be replaced by the added member's name.
+#define DC_STR_MESSAGE_ADD_MEMBER 173
+
+/// "Your email provider %1$s requires end-to-end encryption which is not setup yet."
+///
+/// Used as info messages when a message cannot be sent because it cannot be encrypted.
+///
+/// `%1$s` will be replaced by the provider's domain.
+#define DC_STR_INVALID_UNENCRYPTED_MAIL 174
+
+
 /**
 * @}
 */
--- a/deltachat-ffi/src/lib.rs
+++ b/deltachat-ffi/src/lib.rs
@@ -556,8 +556,10 @@ pub unsafe extern "C" fn dc_event_get_id(event: *mut dc_event_t) -> libc::c_int
        EventType::SecurejoinJoinerProgress { .. } => 2061,
        EventType::ConnectivityChanged => 2100,
        EventType::SelfavatarChanged => 2110,
+        EventType::ConfigSynced { .. } => 2111,
        EventType::WebxdcStatusUpdate { .. } => 2120,
        EventType::WebxdcInstanceDeleted { .. } => 2121,
+        EventType::AccountsBackgroundFetchDone => 2200,
    }
 }

@@ -583,8 +585,10 @@ pub unsafe extern "C" fn dc_event_get_data1_int(event: *mut dc_event_t) -> libc:
        | EventType::Error(_)
        | EventType::ConnectivityChanged
        | EventType::SelfavatarChanged
+        | EventType::ConfigSynced { .. }
        | EventType::IncomingMsgBunch { .. }
-        | EventType::ErrorSelfNotInGroup(_) => 0,
+        | EventType::ErrorSelfNotInGroup(_)
+        | EventType::AccountsBackgroundFetchDone => 0,
        EventType::MsgsChanged { chat_id, .. }
        | EventType::ReactionsChanged { chat_id, .. }
        | EventType::IncomingMsg { chat_id, .. }
@@ -643,7 +647,9 @@ pub unsafe extern "C" fn dc_event_get_data2_int(event: *mut dc_event_t) -> libc:
        | EventType::ConnectivityChanged
        | EventType::WebxdcInstanceDeleted { .. }
        | EventType::IncomingMsgBunch { .. }
-        | EventType::SelfavatarChanged => 0,
+        | EventType::SelfavatarChanged
+        | EventType::AccountsBackgroundFetchDone
+        | EventType::ConfigSynced { .. } => 0,
        EventType::ChatModified(_) => 0,
        EventType::MsgsChanged { msg_id, .. }
        | EventType::ReactionsChanged { msg_id, .. }
@@ -705,6 +711,7 @@ pub unsafe extern "C" fn dc_event_get_data2_str(event: *mut dc_event_t) -> *mut
        | EventType::SelfavatarChanged
        | EventType::WebxdcStatusUpdate { .. }
        | EventType::WebxdcInstanceDeleted { .. }
+        | EventType::AccountsBackgroundFetchDone
        | EventType::ChatEphemeralTimerModified { .. } => ptr::null_mut(),
        EventType::ConfigureProgress { comment, .. } => {
            if let Some(comment) = comment {
@@ -722,6 +729,10 @@ pub unsafe extern "C" fn dc_event_get_data2_str(event: *mut dc_event_t) -> *mut
            .to_c_string()
            .unwrap_or_default()
            .into_raw(),
+        EventType::ConfigSynced { key } => {
+            let data2 = key.to_string().to_c_string().unwrap_or_default();
+            data2.into_raw()
+        }
    }
 }

@@ -4125,6 +4136,15 @@ pub unsafe extern "C" fn dc_contact_is_verified(contact: *mut dc_contact_t) -> l
    }
 }

+#[no_mangle]
+pub unsafe extern "C" fn dc_contact_is_bot(contact: *mut dc_contact_t) -> libc::c_int {
+    if contact.is_null() {
+        eprintln!("ignoring careless call to dc_contact_is_bot()");
+        return 0;
+    }
+    (*contact).contact.is_bot() as libc::c_int
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn dc_contact_get_verifier_id(contact: *mut dc_contact_t) -> u32 {
    if contact.is_null() {
@@ -4882,6 +4902,26 @@ pub unsafe extern "C" fn dc_accounts_maybe_network_lost(accounts: *mut dc_accoun
    block_on(async move { accounts.write().await.maybe_network_lost().await });
 }

+#[no_mangle]
+pub unsafe extern "C" fn dc_accounts_background_fetch(
+    accounts: *mut dc_accounts_t,
+    timeout_in_seconds: u64,
+) -> libc::c_int {
+    if accounts.is_null() || timeout_in_seconds <= 2 {
+        eprintln!("ignoring careless call to dc_accounts_background_fetch()");
+        return 0;
+    }
+
+    let accounts = &*accounts;
+    block_on(async move {
+        let accounts = accounts.read().await;
+        accounts
+            .background_fetch(Duration::from_secs(timeout_in_seconds))
+            .await;
+    });
+    1
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn dc_accounts_get_event_emitter(
    accounts: *mut dc_accounts_t,
--- a/deltachat-jsonrpc/Cargo.toml
+++ b/deltachat-jsonrpc/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "deltachat-jsonrpc"
-version = "1.132.1"
+version = "1.135.1"
 description = "DeltaChat JSON-RPC API"
 edition = "2021"
 default-run = "deltachat-jsonrpc-server"
--- a/deltachat-jsonrpc/src/api.rs
+++ b/deltachat-jsonrpc/src/api.rs
@@ -231,13 +231,27 @@ impl CommandApi {
        Ok(())
    }

+    /// Performs a background fetch for all accounts in parallel with a timeout.
+    ///
+    /// The `AccountsBackgroundFetchDone` event is emitted at the end even in case of timeout.
+    /// Process all events until you get this one and you can safely return to the background
+    /// without forgetting to create notifications caused by timing race conditions.
+    async fn accounts_background_fetch(&self, timeout_in_seconds: f64) -> Result<()> {
+        self.accounts
+            .write()
+            .await
+            .background_fetch(std::time::Duration::from_secs_f64(timeout_in_seconds))
+            .await;
+        Ok(())
+    }
+
    // ---------------------------------------------
    // Methods that work on individual accounts
    // ---------------------------------------------

    /// Starts background tasks for a single account.
    async fn start_io(&self, account_id: u32) -> Result<()> {
-        let mut ctx = self.get_context(account_id).await?;
+        let ctx = self.get_context(account_id).await?;
        ctx.start_io().await;
        Ok(())
    }
@@ -311,6 +325,11 @@ impl CommandApi {
        ctx.get_info().await
    }

+    async fn draft_self_report(&self, account_id: u32) -> Result<u32> {
+        let ctx = self.get_context(account_id).await?;
+        Ok(ctx.draft_self_report().await?.to_u32())
+    }
+
    /// Sets the given configuration key.
    async fn set_config(&self, account_id: u32, key: String, value: Option<String>) -> Result<()> {
        let ctx = self.get_context(account_id).await?;
@@ -383,7 +402,7 @@ impl CommandApi {
    /// Configures this account with the currently set parameters.
    /// Setup the credential config before calling this.
    async fn configure(&self, account_id: u32) -> Result<()> {
-        let mut ctx = self.get_context(account_id).await?;
+        let ctx = self.get_context(account_id).await?;
        ctx.stop_io().await;
        let result = ctx.configure().await;
        if result.is_err() {
@@ -896,19 +915,35 @@ impl CommandApi {
            .to_u32())
    }

-    // for now only text messages, because we only used text messages in desktop thusfar
+    /// Add a message to the device-chat.
+    /// Device-messages usually contain update information
+    /// and some hints that are added during the program runs, multi-device etc.
+    /// The device-message may be defined by a label;
+    /// if a message with the same label was added or skipped before,
+    /// the message is not added again, even if the message was deleted in between.
+    /// If needed, the device-chat is created before.
+    ///
+    /// Sends the `MsgsChanged` event on success.
+    ///
+    /// Setting msg to None will prevent the device message with this label from being added in the future.
    async fn add_device_message(
        &self,
        account_id: u32,
        label: String,
-        text: String,
-    ) -> Result<u32> {
+        msg: Option<MessageData>,
+    ) -> Result<Option<u32>> {
        let ctx = self.get_context(account_id).await?;
-        let mut msg = Message::new(Viewtype::Text);
-        msg.set_text(text);
-        let message_id =
-            deltachat::chat::add_device_msg(&ctx, Some(&label), Some(&mut msg)).await?;
-        Ok(message_id.to_u32())
+        if let Some(msg) = msg {
+            let mut message = msg.create_message(&ctx).await?;
+            let message_id =
+                deltachat::chat::add_device_msg(&ctx, Some(&label), Some(&mut message)).await?;
+            if !message_id.is_unset() {
+                return Ok(Some(message_id.to_u32()));
+            }
+        } else {
+            deltachat::chat::add_device_msg(&ctx, Some(&label), None).await?;
+        }
+        Ok(None)
    }

    ///  Mark all messages in a chat as _noticed_.
@@ -1808,38 +1843,7 @@ impl CommandApi {

    async fn send_msg(&self, account_id: u32, chat_id: u32, data: MessageData) -> Result<u32> {
        let ctx = self.get_context(account_id).await?;
-        let mut message = Message::new(if let Some(viewtype) = data.viewtype {
-            viewtype.into()
-        } else if data.file.is_some() {
-            Viewtype::File
-        } else {
-            Viewtype::Text
-        });
-        message.set_text(data.text.unwrap_or_default());
-        if data.html.is_some() {
-            message.set_html(data.html);
-        }
-        if data.override_sender_name.is_some() {
-            message.set_override_sender_name(data.override_sender_name);
-        }
-        if let Some(file) = data.file {
-            message.set_file(file, None);
-        }
-        if let Some((latitude, longitude)) = data.location {
-            message.set_location(latitude, longitude);
-        }
-        if let Some(id) = data.quoted_message_id {
-            message
-                .set_quote(
-                    &ctx,
-                    Some(
-                        &Message::load_from_db(&ctx, MsgId::new(id))
-                            .await
-                            .context("message to quote could not be loaded")?,
-                    ),
-                )
-                .await?;
-        }
+        let mut message = data.create_message(&ctx).await?;
        let msg_id = chat::send_msg(&ctx, ChatId::new(chat_id), &mut message)
            .await?
            .to_u32();
@@ -2121,13 +2125,6 @@ async fn set_config(
            value,
        )
        .await?;
-
-        match key {
-            "sentbox_watch" | "mvbox_move" | "only_fetch_mvbox" => {
-                ctx.restart_io_if_running().await;
-            }
-            _ => {}
-        }
    }
    Ok(())
 }
--- a/deltachat-jsonrpc/src/api/types/chat.rs
+++ b/deltachat-jsonrpc/src/api/types/chat.rs
@@ -85,7 +85,7 @@ impl FullChat {
        let can_send = chat.can_send(context).await?;

        let was_seen_recently = if chat.get_type() == Chattype::Single {
-            match contact_ids.get(0) {
+            match contact_ids.first() {
                Some(contact) => Contact::get_by_id(context, *contact)
                    .await
                    .context("failed to load contact for was_seen_recently")?
--- a/deltachat-jsonrpc/src/api/types/chat_list.rs
+++ b/deltachat-jsonrpc/src/api/types/chat_list.rs
@@ -102,7 +102,7 @@ pub(crate) async fn get_chat_list_item_by_id(
    let self_in_group = chat_contacts.contains(&ContactId::SELF);

    let (dm_chat_contact, was_seen_recently) = if chat.get_type() == Chattype::Single {
-        let contact = chat_contacts.get(0);
+        let contact = chat_contacts.first();
        let was_seen_recently = match contact {
            Some(contact) => Contact::get_by_id(ctx, *contact)
                .await
--- a/deltachat-jsonrpc/src/api/types/contact.rs
+++ b/deltachat-jsonrpc/src/api/types/contact.rs
@@ -45,6 +45,9 @@ pub struct ContactObject {
    /// the contact's last seen timestamp
    last_seen: i64,
    was_seen_recently: bool,
+
+    /// If the contact is a bot.
+    is_bot: bool,
 }

 impl ContactObject {
@@ -80,6 +83,7 @@ impl ContactObject {
            verifier_id,
            last_seen: contact.last_seen(),
            was_seen_recently: contact.was_seen_recently(),
+            is_bot: contact.is_bot(),
        })
    }
 }
--- a/deltachat-jsonrpc/src/api/types/events.rs
+++ b/deltachat-jsonrpc/src/api/types/events.rs
@@ -28,55 +28,37 @@ pub enum EventType {
    ///
    /// This event should *not* be reported to the end-user using a popup or something like
    /// that.
-    Info {
-        msg: String,
-    },
+    Info { msg: String },

    /// Emitted when SMTP connection is established and login was successful.
-    SmtpConnected {
-        msg: String,
-    },
+    SmtpConnected { msg: String },

    /// Emitted when IMAP connection is established and login was successful.
-    ImapConnected {
-        msg: String,
-    },
+    ImapConnected { msg: String },

    /// Emitted when a message was successfully sent to the SMTP server.
-    SmtpMessageSent {
-        msg: String,
-    },
+    SmtpMessageSent { msg: String },

    /// Emitted when an IMAP message has been marked as deleted
-    ImapMessageDeleted {
-        msg: String,
-    },
+    ImapMessageDeleted { msg: String },

    /// Emitted when an IMAP message has been moved
-    ImapMessageMoved {
-        msg: String,
-    },
+    ImapMessageMoved { msg: String },

    /// Emitted before going into IDLE on the Inbox folder.
    ImapInboxIdle,

    /// Emitted when an new file in the $BLOBDIR was created
-    NewBlobFile {
-        file: String,
-    },
+    NewBlobFile { file: String },

    /// Emitted when an file in the $BLOBDIR was deleted
-    DeletedBlobFile {
-        file: String,
-    },
+    DeletedBlobFile { file: String },

    /// The library-user should write a warning string to the log.
    ///
    /// This event should *not* be reported to the end-user using a popup or something like
    /// that.
-    Warning {
-        msg: String,
-    },
+    Warning { msg: String },

    /// The library-user should report an error to the end-user.
    ///
@@ -88,18 +70,14 @@ pub enum EventType {
    /// it might be better to delay showing these events until the function has really
    /// failed (returned false). It should be sufficient to report only the *last* error
    /// in a messasge box then.
-    Error {
-        msg: String,
-    },
+    Error { msg: String },

    /// An action cannot be performed because the user is not in the group.
    /// Reported eg. after a call to
    /// setChatName(), setChatProfileImage(),
    /// addContactToChat(), removeContactFromChat(),
    /// and messages sending functions.
-    ErrorSelfNotInGroup {
-        msg: String,
-    },
+    ErrorSelfNotInGroup { msg: String },

    /// Messages or chats changed.  One or more messages or chats changed for various
    /// reasons in the database:
@@ -110,10 +88,7 @@ pub enum EventType {
    /// `chatId` is set if only a single chat is affected by the changes, otherwise 0.
    /// `msgId` is set if only a single message is affected by the changes, otherwise 0.
    #[serde(rename_all = "camelCase")]
-    MsgsChanged {
-        chat_id: u32,
-        msg_id: u32,
-    },
+    MsgsChanged { chat_id: u32, msg_id: u32 },

    /// Reactions for the message changed.
    #[serde(rename_all = "camelCase")]
@@ -128,10 +103,7 @@ pub enum EventType {
    ///
    /// There is no extra #DC_EVENT_MSGS_CHANGED event send together with this event.
    #[serde(rename_all = "camelCase")]
-    IncomingMsg {
-        chat_id: u32,
-        msg_id: u32,
-    },
+    IncomingMsg { chat_id: u32, msg_id: u32 },

    /// Downloading a bunch of messages just finished. This is an experimental
    /// event to allow the UI to only show one notification per message bunch,
@@ -139,47 +111,31 @@ pub enum EventType {
    ///
    /// msg_ids contains the message ids.
    #[serde(rename_all = "camelCase")]
-    IncomingMsgBunch {
-        msg_ids: Vec<u32>,
-    },
+    IncomingMsgBunch { msg_ids: Vec<u32> },

    /// Messages were seen or noticed.
    /// chat id is always set.
    #[serde(rename_all = "camelCase")]
-    MsgsNoticed {
-        chat_id: u32,
-    },
+    MsgsNoticed { chat_id: u32 },

    /// A single message is sent successfully. State changed from  DC_STATE_OUT_PENDING to
    /// DC_STATE_OUT_DELIVERED, see `Message.state`.
    #[serde(rename_all = "camelCase")]
-    MsgDelivered {
-        chat_id: u32,
-        msg_id: u32,
-    },
+    MsgDelivered { chat_id: u32, msg_id: u32 },

    /// A single message could not be sent. State changed from DC_STATE_OUT_PENDING or DC_STATE_OUT_DELIVERED to
    /// DC_STATE_OUT_FAILED, see `Message.state`.
    #[serde(rename_all = "camelCase")]
-    MsgFailed {
-        chat_id: u32,
-        msg_id: u32,
-    },
+    MsgFailed { chat_id: u32, msg_id: u32 },

    /// A single message is read by the receiver. State changed from DC_STATE_OUT_DELIVERED to
    /// DC_STATE_OUT_MDN_RCVD, see `Message.state`.
    #[serde(rename_all = "camelCase")]
-    MsgRead {
-        chat_id: u32,
-        msg_id: u32,
-    },
+    MsgRead { chat_id: u32, msg_id: u32 },

    /// A single message is deleted.
    #[serde(rename_all = "camelCase")]
-    MsgDeleted {
-        chat_id: u32,
-        msg_id: u32,
-    },
+    MsgDeleted { chat_id: u32, msg_id: u32 },

    /// Chat changed.  The name or the image of a chat group was changed or members were added or removed.
    /// Or the verify state of a chat has changed.
@@ -189,24 +145,17 @@ pub enum EventType {
    /// This event does not include ephemeral timer modification, which
    /// is a separate event.
    #[serde(rename_all = "camelCase")]
-    ChatModified {
-        chat_id: u32,
-    },
+    ChatModified { chat_id: u32 },

    /// Chat ephemeral timer changed.
    #[serde(rename_all = "camelCase")]
-    ChatEphemeralTimerModified {
-        chat_id: u32,
-        timer: u32,
-    },
+    ChatEphemeralTimerModified { chat_id: u32, timer: u32 },

    /// Contact(s) created, renamed, blocked or deleted.
    ///
    /// @param data1 (int) If set, this is the contact_id of an added contact that should be selected.
    #[serde(rename_all = "camelCase")]
-    ContactsChanged {
-        contact_id: Option<u32>,
-    },
+    ContactsChanged { contact_id: Option<u32> },

    /// Location of one or more contact has changed.
    ///
@@ -214,9 +163,7 @@ pub enum EventType {
    ///     If the locations of several contacts have been changed,
    ///     this parameter is set to `None`.
    #[serde(rename_all = "camelCase")]
-    LocationChanged {
-        contact_id: Option<u32>,
-    },
+    LocationChanged { contact_id: Option<u32> },

    /// Inform about the configuration progress started by configure().
    ConfigureProgress {
@@ -234,9 +181,7 @@ pub enum EventType {
    /// @param data1 (usize) 0=error, 1-999=progress in permille, 1000=success and done
    /// @param data2 0
    #[serde(rename_all = "camelCase")]
-    ImexProgress {
-        progress: usize,
-    },
+    ImexProgress { progress: usize },

    /// A file has been exported. A file has been written by imex().
    /// This event may be sent multiple times by a single call to imex().
@@ -246,9 +191,7 @@ pub enum EventType {
    ///
    /// @param data2 0
    #[serde(rename_all = "camelCase")]
-    ImexFileWritten {
-        path: String,
-    },
+    ImexFileWritten { path: String },

    /// Progress information of a secure-join handshake from the view of the inviter
    /// (Alice, the person who shows the QR code).
@@ -263,10 +206,7 @@ pub enum EventType {
    ///     800=vg-member-added-received received, shown as "bob@addr securely joined GROUP", only sent for the verified-group-protocol.
    ///     1000=Protocol finished for this contact.
    #[serde(rename_all = "camelCase")]
-    SecurejoinInviterProgress {
-        contact_id: u32,
-        progress: usize,
-    },
+    SecurejoinInviterProgress { contact_id: u32, progress: usize },

    /// Progress information of a secure-join handshake from the view of the joiner
    /// (Bob, the person who scans the QR code).
@@ -277,10 +217,7 @@ pub enum EventType {
    ///     400=vg-/vc-request-with-auth sent, typically shown as "alice@addr verified, introducing myself."
    ///     (Bob has verified alice and waits until Alice does the same for him)
    #[serde(rename_all = "camelCase")]
-    SecurejoinJoinerProgress {
-        contact_id: u32,
-        progress: usize,
-    },
+    SecurejoinJoinerProgress { contact_id: u32, progress: usize },

    /// The connectivity to the server changed.
    /// This means that you should refresh the connectivity view
@@ -288,8 +225,17 @@ pub enum EventType {
    /// getConnectivityHtml() for details.
    ConnectivityChanged,

+    /// Deprecated by `ConfigSynced`.
    SelfavatarChanged,

+    /// A multi-device synced config value changed. Maybe the app needs to refresh smth. For
+    /// uniformity this is emitted on the source device too. The value isn't here, otherwise it
+    /// would be logged which might not be good for privacy.
+    ConfigSynced {
+        /// Configuration key.
+        key: String,
+    },
+
    #[serde(rename_all = "camelCase")]
    WebxdcStatusUpdate {
        msg_id: u32,
@@ -298,9 +244,14 @@ pub enum EventType {

    /// Inform that a message containing a webxdc instance has been deleted
    #[serde(rename_all = "camelCase")]
-    WebxdcInstanceDeleted {
-        msg_id: u32,
-    },
+    WebxdcInstanceDeleted { msg_id: u32 },
+
+    /// Tells that the Background fetch was completed (or timed out).
+    /// This event acts as a marker, when you reach this event you can be sure
+    /// that all events emitted during the background fetch were processed.
+    ///
+    /// This event is only emitted by the account manager
+    AccountsBackgroundFetchDone,
 }

 impl From<CoreEventType> for EventType {
@@ -396,6 +347,9 @@ impl From<CoreEventType> for EventType {
            },
            CoreEventType::ConnectivityChanged => ConnectivityChanged,
            CoreEventType::SelfavatarChanged => SelfavatarChanged,
+            CoreEventType::ConfigSynced { key } => ConfigSynced {
+                key: key.to_string(),
+            },
            CoreEventType::WebxdcStatusUpdate {
                msg_id,
                status_update_serial,
@@ -406,6 +360,7 @@ impl From<CoreEventType> for EventType {
            CoreEventType::WebxdcInstanceDeleted { msg_id } => WebxdcInstanceDeleted {
                msg_id: msg_id.to_u32(),
            },
+            CoreEventType::AccountsBackgroundFetchDone => AccountsBackgroundFetchDone,
        }
    }
 }
--- a/deltachat-jsonrpc/src/api/types/message.rs
+++ b/deltachat-jsonrpc/src/api/types/message.rs
@@ -345,6 +345,7 @@ pub enum SystemMessageType {
    SecurejoinMessage,
    LocationStreamingEnabled,
    LocationOnly,
+    InvalidUnencryptedMail,

    /// Chat ephemeral message timer is changed.
    EphemeralTimerChanged,
@@ -385,6 +386,7 @@ impl From<deltachat::mimeparser::SystemMessage> for SystemMessageType {
            SystemMessage::MultiDeviceSync => SystemMessageType::MultiDeviceSync,
            SystemMessage::WebxdcStatusUpdate => SystemMessageType::WebxdcStatusUpdate,
            SystemMessage::WebxdcInfoMessage => SystemMessageType::WebxdcInfoMessage,
+            SystemMessage::InvalidUnencryptedMail => SystemMessageType::InvalidUnencryptedMail,
        }
    }
 }
@@ -546,6 +548,44 @@ pub struct MessageData {
    pub quoted_message_id: Option<u32>,
 }

+impl MessageData {
+    pub(crate) async fn create_message(self, context: &Context) -> Result<Message> {
+        let mut message = Message::new(if let Some(viewtype) = self.viewtype {
+            viewtype.into()
+        } else if self.file.is_some() {
+            Viewtype::File
+        } else {
+            Viewtype::Text
+        });
+        message.set_text(self.text.unwrap_or_default());
+        if self.html.is_some() {
+            message.set_html(self.html);
+        }
+        if self.override_sender_name.is_some() {
+            message.set_override_sender_name(self.override_sender_name);
+        }
+        if let Some(file) = self.file {
+            message.set_file(file, None);
+        }
+        if let Some((latitude, longitude)) = self.location {
+            message.set_location(latitude, longitude);
+        }
+        if let Some(id) = self.quoted_message_id {
+            message
+                .set_quote(
+                    context,
+                    Some(
+                        &Message::load_from_db(context, MsgId::new(id))
+                            .await
+                            .context("message to quote could not be loaded")?,
+                    ),
+                )
+                .await?;
+        }
+        Ok(message)
+    }
+}
+
 #[derive(Serialize, TypeDef, schemars::JsonSchema)]
 #[serde(rename_all = "camelCase")]
 pub struct MessageReadReceipt {
--- a/deltachat-jsonrpc/typescript/package.json
+++ b/deltachat-jsonrpc/typescript/package.json
@@ -53,5 +53,5 @@
  },
  "type": "module",
  "types": "dist/deltachat.d.ts",
-  "version": "1.132.1"
+  "version": "1.135.1"
 }
--- a/deltachat-repl/Cargo.toml
+++ b/deltachat-repl/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "deltachat-repl"
-version = "1.132.1"
+version = "1.135.1"
 license = "MPL-2.0"
 edition = "2021"

@@ -12,7 +12,7 @@ dirs = "5"
 log = "0.4.20"
 pretty_env_logger = "0.5"
 rusqlite = "0.30"
-rustyline = "12"
+rustyline = "13"
 tokio = { version = "1", features = ["fs", "rt-multi-thread", "macros"] }

 [features]
--- a/deltachat-repl/src/main.rs
+++ b/deltachat-repl/src/main.rs
@@ -299,8 +299,8 @@ impl Highlighter for DcHelper {
        self.highlighter.highlight(line, pos)
    }

-    fn highlight_char(&self, line: &str, pos: usize) -> bool {
-        self.highlighter.highlight_char(line, pos)
+    fn highlight_char(&self, line: &str, pos: usize, forced: bool) -> bool {
+        self.highlighter.highlight_char(line, pos, forced)
    }
 }

@@ -401,7 +401,7 @@ enum ExitResult {

 async fn handle_cmd(
    line: &str,
-    mut ctx: Context,
+    ctx: Context,
    selected_chat: &mut ChatId,
 ) -> Result<ExitResult, Error> {
    let mut args = line.splitn(2, ' ');
--- a/deltachat-rpc-client/src/deltachat_rpc_client/init.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/init.py
@@ -1,4 +1,5 @@
 """Delta Chat JSON-RPC high-level API"""
+
 from ._utils import AttrDict, run_bot_cli, run_client_cli
 from .account import Account
 from .chat import Chat
--- a/deltachat-rpc-client/src/deltachat_rpc_client/client.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/client.py
@@ -1,4 +1,5 @@
 """Event loop implementations offering high level event handling/hooking."""
+
 import logging
 from typing import (
    TYPE_CHECKING,
--- a/deltachat-rpc-client/src/deltachat_rpc_client/events.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/events.py
@@ -1,4 +1,5 @@
 """High-level classes for event processing and filtering."""
+
 import re
 from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING, Callable, Iterable, Iterator, Optional, Set, Tuple, Union
--- a/deltachat-rpc-client/tests/test_securejoin.py
+++ b/deltachat-rpc-client/tests/test_securejoin.py
@@ -164,6 +164,21 @@ def test_qr_readreceipt(acfactory) -> None:
    assert not bob.get_chat_by_contact(bob_contact_charlie)


+def test_setup_contact_resetup(acfactory) -> None:
+    """Tests that setup contact works after Alice resets the device and changes the key."""
+    alice, bob = acfactory.get_online_accounts(2)
+
+    qr_code, _svg = alice.get_qr_code()
+    bob.secure_join(qr_code)
+    bob.wait_for_securejoin_joiner_success()
+
+    alice = acfactory.resetup_account(alice)
+
+    qr_code, _svg = alice.get_qr_code()
+    bob.secure_join(qr_code)
+    bob.wait_for_securejoin_joiner_success()
+
+
 def test_verified_group_recovery(acfactory) -> None:
    """Tests verified group recovery by reverifying a member and sending a message in a group."""
    ac1, ac2, ac3 = acfactory.get_online_accounts(3)
@@ -175,7 +190,7 @@ def test_verified_group_recovery(acfactory) -> None:
    logging.info("ac2 joins verified group")
    qr_code, _svg = chat.get_qr_code()
    ac2.secure_join(qr_code)
-    ac1.wait_for_securejoin_inviter_success()
+    ac2.wait_for_securejoin_joiner_success()

    # ac1 has ac2 directly verified.
    ac1_contact_ac2 = ac1.get_contact_by_addr(ac2.get_config("addr"))
@@ -183,7 +198,8 @@ def test_verified_group_recovery(acfactory) -> None:

    logging.info("ac3 joins verified group")
    ac3_chat = ac3.secure_join(qr_code)
-    ac1.wait_for_securejoin_inviter_success()
+    ac3.wait_for_securejoin_joiner_success()
+    ac3.wait_for_incoming_msg_event()  # Member added

    logging.info("ac2 logs in on a new device")
    ac2 = acfactory.resetup_account(ac2)
@@ -191,8 +207,7 @@ def test_verified_group_recovery(acfactory) -> None:
    logging.info("ac2 reverifies with ac3")
    qr_code, _svg = ac3.get_qr_code()
    ac2.secure_join(qr_code)
-
-    ac3.wait_for_securejoin_inviter_success()
+    ac2.wait_for_securejoin_joiner_success()

    logging.info("ac3 sends a message to the group")
    assert len(ac3_chat.get_contacts()) == 3
@@ -239,7 +254,7 @@ def test_verified_group_member_added_recovery(acfactory) -> None:
    logging.info("ac2 joins verified group")
    qr_code, _svg = chat.get_qr_code()
    ac2.secure_join(qr_code)
-    ac1.wait_for_securejoin_inviter_success()
+    ac2.wait_for_securejoin_joiner_success()

    # ac1 has ac2 directly verified.
    ac1_contact_ac2 = ac1.get_contact_by_addr(ac2.get_config("addr"))
@@ -247,7 +262,8 @@ def test_verified_group_member_added_recovery(acfactory) -> None:

    logging.info("ac3 joins verified group")
    ac3_chat = ac3.secure_join(qr_code)
-    ac1.wait_for_securejoin_inviter_success()
+    ac3.wait_for_securejoin_joiner_success()
+    ac3.wait_for_incoming_msg_event()  # Member added

    logging.info("ac2 logs in on a new device")
    ac2 = acfactory.resetup_account(ac2)
@@ -255,8 +271,7 @@ def test_verified_group_member_added_recovery(acfactory) -> None:
    logging.info("ac2 reverifies with ac3")
    qr_code, _svg = ac3.get_qr_code()
    ac2.secure_join(qr_code)
-
-    ac3.wait_for_securejoin_inviter_success()
+    ac2.wait_for_securejoin_joiner_success()

    logging.info("ac3 sends a message to the group")
    assert len(ac3_chat.get_contacts()) == 3
--- a/deltachat-rpc-server/Cargo.toml
+++ b/deltachat-rpc-server/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "deltachat-rpc-server"
-version = "1.132.1"
+version = "1.135.1"
 description = "DeltaChat JSON-RPC server"
 edition = "2021"
 readme = "README.md"
@@ -15,7 +15,7 @@ deltachat = { path = "..", default-features = false }

 anyhow = "1"
 env_logger = { version = "0.10.0" }
-futures-lite = "2.0.0"
+futures-lite = "2.2.0"
 log = "0.4"
 serde_json = "1"
 serde = { version = "1.0", features = ["derive"] }
--- a/deltachat-time/Cargo.toml
+++ b/deltachat-time/Cargo.toml
@@ -0,0 +1,8 @@
+[package]
+name = "deltachat-time"
+version = "1.0.0"
+description = "Time-related tools"
+edition = "2021"
+license = "MPL-2.0"
+
+[dependencies]
--- a/deltachat-time/src/lib.rs
+++ b/deltachat-time/src/lib.rs
@@ -0,0 +1,35 @@
+#![allow(missing_docs)]
+
+use std::sync::RwLock;
+use std::time::{Duration, SystemTime};
+
+static SYSTEM_TIME_SHIFT: RwLock<Duration> = RwLock::new(Duration::new(0, 0));
+
+/// Fake struct for mocking `SystemTime::now()` for test purposes. You still need to use
+/// `SystemTime` as a struct representing a system time.
+pub struct SystemTimeTools();
+
+impl SystemTimeTools {
+    pub const UNIX_EPOCH: SystemTime = SystemTime::UNIX_EPOCH;
+
+    pub fn now() -> SystemTime {
+        return SystemTime::now() + *SYSTEM_TIME_SHIFT.read().unwrap();
+    }
+
+    /// Simulates a system clock forward adjustment by `duration`.
+    pub fn shift(duration: Duration) {
+        *SYSTEM_TIME_SHIFT.write().unwrap() += duration;
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn it_works() {
+        SystemTimeTools::shift(Duration::from_secs(60));
+        let t = SystemTimeTools::now();
+        assert!(t > SystemTime::now());
+    }
+}
--- a/deny.toml
+++ b/deny.toml
@@ -33,7 +33,6 @@ skip = [
     { name = "ed25519-dalek", version = "1.0.1" },
     { name = "ed25519", version = "1.5.3" },
     { name = "event-listener", version = "2.5.3" },
-     { name = "fd-lock", version = "3.0.13" },
     { name = "getrandom", version = "<0.2" },
     { name = "h2", version = "0.3.22" },
     { name = "http-body", version = "0.4.5" },
@@ -57,6 +56,7 @@ skip = [
     { name = "spki", version = "0.6.0" },
     { name = "syn", version = "1.0.109" },
     { name = "time", version = "<0.3" },
+     { name = "toml_edit", version = "0.21.1" },
     { name = "untrusted", version = "0.7.1" },
     { name = "wasi", version = "<0.11" },
     { name = "windows_aarch64_gnullvm", version = "<0.52" },
@@ -100,5 +100,4 @@ license-files = [
 github = [
       "async-email",
       "deltachat",
-       "djc",
 ]
--- a/flake.lock
+++ b/flake.lock
@@ -0,0 +1,163 @@
+{
+  "nodes": {
+    "fenix": {
+      "inputs": {
+        "nixpkgs": "nixpkgs",
+        "rust-analyzer-src": "rust-analyzer-src"
+      },
+      "locked": {
+        "lastModified": 1707891749,
+        "narHash": "sha256-SeikNYElHgv8uVMbiA9/pU3Cce7ssIsiM8CnEiwd1Nc=",
+        "owner": "nix-community",
+        "repo": "fenix",
+        "rev": "3115aab064ef38cccd792c45429af8df43d6d277",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-community",
+        "repo": "fenix",
+        "type": "github"
+      }
+    },
+    "flake-utils": {
+      "inputs": {
+        "systems": "systems"
+      },
+      "locked": {
+        "lastModified": 1705309234,
+        "narHash": "sha256-uNRRNRKmJyCRC/8y1RqBkqWBLM034y4qN7EprSdmgyA=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "1ef2e671c3b0c19053962c07dbda38332dcebf26",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "naersk": {
+      "inputs": {
+        "nixpkgs": "nixpkgs_2"
+      },
+      "locked": {
+        "lastModified": 1698420672,
+        "narHash": "sha256-/TdeHMPRjjdJub7p7+w55vyABrsJlt5QkznPYy55vKA=",
+        "owner": "nix-community",
+        "repo": "naersk",
+        "rev": "aeb58d5e8faead8980a807c840232697982d47b9",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-community",
+        "repo": "naersk",
+        "type": "github"
+      }
+    },
+    "nix-filter": {
+      "locked": {
+        "lastModified": 1705332318,
+        "narHash": "sha256-kcw1yFeJe9N4PjQji9ZeX47jg0p9A0DuU4djKvg1a7I=",
+        "owner": "numtide",
+        "repo": "nix-filter",
+        "rev": "3449dc925982ad46246cfc36469baf66e1b64f17",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "nix-filter",
+        "type": "github"
+      }
+    },
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1707689078,
+        "narHash": "sha256-UUGmRa84ZJHpGZ1WZEBEUOzaPOWG8LZ0yPg1pdDF/yM=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "f9d39fb9aff0efee4a3d5f4a6d7c17701d38a1d8",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs_2": {
+      "locked": {
+        "lastModified": 1707743206,
+        "narHash": "sha256-AehgH64b28yKobC/DAWYZWkJBxL/vP83vkY+ag2Hhy4=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "2d627a2a704708673e56346fcb13d25344b8eaf3",
+        "type": "github"
+      },
+      "original": {
+        "id": "nixpkgs",
+        "type": "indirect"
+      }
+    },
+    "nixpkgs_3": {
+      "locked": {
+        "lastModified": 1707689078,
+        "narHash": "sha256-UUGmRa84ZJHpGZ1WZEBEUOzaPOWG8LZ0yPg1pdDF/yM=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "f9d39fb9aff0efee4a3d5f4a6d7c17701d38a1d8",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "fenix": "fenix",
+        "flake-utils": "flake-utils",
+        "naersk": "naersk",
+        "nix-filter": "nix-filter",
+        "nixpkgs": "nixpkgs_3"
+      }
+    },
+    "rust-analyzer-src": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1707849817,
+        "narHash": "sha256-If6T0MDErp3/z7DBlpG4bV46IPP+7BWSlgTI88cmbw0=",
+        "owner": "rust-lang",
+        "repo": "rust-analyzer",
+        "rev": "a02a219773629686bd8ff123ca1aa995fa50d976",
+        "type": "github"
+      },
+      "original": {
+        "owner": "rust-lang",
+        "ref": "nightly",
+        "repo": "rust-analyzer",
+        "type": "github"
+      }
+    },
+    "systems": {
+      "locked": {
+        "lastModified": 1681028828,
+        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}
--- a/flake.nix
+++ b/flake.nix
@@ -0,0 +1,330 @@
+{
+  description = "Delta Chat core";
+  inputs = {
+    fenix.url = "github:nix-community/fenix";
+    flake-utils.url = "github:numtide/flake-utils";
+    naersk.url = "github:nix-community/naersk";
+    nix-filter.url = "github:numtide/nix-filter";
+    nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";
+  };
+  outputs = { self, nixpkgs, flake-utils, nix-filter, naersk, fenix }:
+    flake-utils.lib.eachDefaultSystem (system:
+      let
+        pkgs = nixpkgs.legacyPackages.${system};
+        fenixPkgs = fenix.packages.${system};
+        naersk' = pkgs.callPackage naersk { };
+        manifest = (pkgs.lib.importTOML ./Cargo.toml).package;
+        cargoLock = {
+          lockFile = ./Cargo.lock;
+          outputHashes = {
+            "email-0.0.20" = "sha256-rV4Uzqt2Qdrfi5Ti1r+Si1c2iW1kKyWLwOgLkQ5JGGw=";
+            "encoded-words-0.2.0" = "sha256-KK9st0hLFh4dsrnLd6D8lC6pRFFs8W+WpZSGMGJcosk=";
+            "lettre-0.9.2" = "sha256-+hU1cFacyyeC9UGVBpS14BWlJjHy90i/3ynMkKAzclk=";
+          };
+        };
+        mkRustPackage = packageName:
+          naersk'.buildPackage {
+            pname = packageName;
+            cargoBuildOptions = x: x ++ [ "--package" packageName ];
+            version = manifest.version;
+            src = pkgs.lib.cleanSource ./.;
+            nativeBuildInputs = [
+              pkgs.perl # Needed to build vendored OpenSSL.
+            ];
+            auditable = false; # Avoid cargo-auditable failures.
+            doCheck = false; # Disable test as it requires network access.
+          };
+        pkgsWin64 = pkgs.pkgsCross.mingwW64;
+        mkWin64RustPackage = packageName:
+          let
+            rustTarget = "x86_64-pc-windows-gnu";
+          in
+          let
+            toolchainWin = fenixPkgs.combine [
+              fenixPkgs.stable.rustc
+              fenixPkgs.stable.cargo
+              fenixPkgs.targets.${rustTarget}.stable.rust-std
+            ];
+            naerskWin = pkgs.callPackage naersk {
+              cargo = toolchainWin;
+              rustc = toolchainWin;
+            };
+          in
+          naerskWin.buildPackage rec {
+            pname = packageName;
+            cargoBuildOptions = x: x ++ [ "--package" packageName ];
+            version = manifest.version;
+            strictDeps = true;
+            src = pkgs.lib.cleanSource ./.;
+            nativeBuildInputs = [
+              pkgs.perl # Needed to build vendored OpenSSL.
+            ];
+            depsBuildBuild = [
+              pkgsWin64.stdenv.cc
+              pkgsWin64.windows.pthreads
+            ];
+            auditable = false; # Avoid cargo-auditable failures.
+            doCheck = false; # Disable test as it requires network access.
+
+            CARGO_BUILD_TARGET = rustTarget;
+            TARGET_CC = "${pkgsWin64.stdenv.cc}/bin/${pkgsWin64.stdenv.cc.targetPrefix}cc";
+            CARGO_BUILD_RUSTFLAGS = [
+              "-C"
+              "linker=${TARGET_CC}"
+            ];
+
+            CC = "${pkgsWin64.stdenv.cc}/bin/${pkgsWin64.stdenv.cc.targetPrefix}cc";
+            LD = "${pkgsWin64.stdenv.cc}/bin/${pkgsWin64.stdenv.cc.targetPrefix}cc";
+          };
+
+        pkgsWin32 = pkgs.pkgsCross.mingw32;
+        mkWin32RustPackage = packageName:
+          let
+            rustTarget = "i686-pc-windows-gnu";
+          in
+          let
+            toolchainWin = fenixPkgs.combine [
+              fenixPkgs.stable.rustc
+              fenixPkgs.stable.cargo
+              fenixPkgs.targets.${rustTarget}.stable.rust-std
+            ];
+            naerskWin = pkgs.callPackage naersk {
+              cargo = toolchainWin;
+              rustc = toolchainWin;
+            };
+
+            # Get rid of MCF Gthread library.
+            # See <https://github.com/NixOS/nixpkgs/issues/156343>
+            # and <https://discourse.nixos.org/t/statically-linked-mingw-binaries/38395>
+            # for details.
+            #
+            # Use DWARF-2 instead of SJLJ for exception handling.
+            winCC = pkgsWin32.buildPackages.wrapCC (
+              (pkgsWin32.buildPackages.gcc-unwrapped.override
+                ({
+                  threadsCross = {
+                    model = "win32";
+                    package = null;
+                  };
+                })).overrideAttrs (oldAttr: rec{
+                configureFlags = oldAttr.configureFlags ++ [
+                  "--disable-sjlj-exceptions --with-dwarf2"
+                ];
+              })
+            );
+            winStdenv = pkgsWin32.buildPackages.overrideCC pkgsWin32.stdenv winCC;
+          in
+          naerskWin.buildPackage rec {
+            pname = packageName;
+            cargoBuildOptions = x: x ++ [ "--package" packageName ];
+            version = manifest.version;
+            strictDeps = true;
+            src = pkgs.lib.cleanSource ./.;
+            nativeBuildInputs = [
+              pkgs.perl # Needed to build vendored OpenSSL.
+            ];
+            depsBuildBuild = [
+              winCC
+              pkgsWin32.windows.pthreads
+            ];
+            auditable = false; # Avoid cargo-auditable failures.
+            doCheck = false; # Disable test as it requires network access.
+
+            CARGO_BUILD_TARGET = rustTarget;
+            TARGET_CC = "${winCC}/bin/${winCC.targetPrefix}cc";
+            CARGO_BUILD_RUSTFLAGS = [
+              "-C"
+              "linker=${TARGET_CC}"
+            ];
+
+            CC = "${winCC}/bin/${winCC.targetPrefix}cc";
+            LD = "${winCC}/bin/${winCC.targetPrefix}cc";
+          };
+
+        mkCrossRustPackage = rustTarget: crossTarget: packageName:
+          let
+            pkgsCross = import nixpkgs {
+              system = system;
+              crossSystem.config = crossTarget;
+            };
+          in
+          let
+            toolchain = fenixPkgs.combine [
+              fenixPkgs.stable.rustc
+              fenixPkgs.stable.cargo
+              fenixPkgs.targets.${rustTarget}.stable.rust-std
+            ];
+            naersk-lib = pkgs.callPackage naersk {
+              cargo = toolchain;
+              rustc = toolchain;
+            };
+          in
+          naersk-lib.buildPackage rec {
+            pname = packageName;
+            cargoBuildOptions = x: x ++ [ "--package" packageName ];
+            version = manifest.version;
+            strictDeps = true;
+            src = pkgs.lib.cleanSource ./.;
+            nativeBuildInputs = [
+              pkgs.perl # Needed to build vendored OpenSSL.
+            ];
+            auditable = false; # Avoid cargo-auditable failures.
+            doCheck = false; # Disable test as it requires network access.
+
+            CARGO_BUILD_TARGET = rustTarget;
+            TARGET_CC = "${pkgsCross.stdenv.cc}/bin/${pkgsCross.stdenv.cc.targetPrefix}cc";
+            CARGO_BUILD_RUSTFLAGS = [
+              "-C"
+              "linker=${TARGET_CC}"
+            ];
+
+            CC = "${pkgsCross.stdenv.cc}/bin/${pkgsCross.stdenv.cc.targetPrefix}cc";
+            LD = "${pkgsCross.stdenv.cc}/bin/${pkgsCross.stdenv.cc.targetPrefix}cc";
+          };
+
+        mk-aarch64-RustPackage = mkCrossRustPackage "aarch64-unknown-linux-musl" "aarch64-unknown-linux-musl";
+        mk-i686-RustPackage = mkCrossRustPackage "i686-unknown-linux-musl" "i686-unknown-linux-musl";
+        mk-x86_64-RustPackage = mkCrossRustPackage "x86_64-unknown-linux-musl" "x86_64-unknown-linux-musl";
+        mk-armv7l-RustPackage = mkCrossRustPackage "armv7-unknown-linux-musleabihf" "armv7l-unknown-linux-musleabihf";
+        mk-armv6l-RustPackage = mkCrossRustPackage "arm-unknown-linux-musleabihf" "armv6l-unknown-linux-musleabihf";
+      in
+      {
+        formatter = pkgs.nixpkgs-fmt;
+
+        packages = rec {
+          # Run with `nix run .#deltachat-repl foo.db`.
+          deltachat-repl = mkRustPackage "deltachat-repl";
+          deltachat-rpc-server = mkRustPackage "deltachat-rpc-server";
+
+          deltachat-repl-win64 = mkWin64RustPackage "deltachat-repl";
+          deltachat-rpc-server-win64 = mkWin64RustPackage "deltachat-rpc-server";
+
+          deltachat-repl-win32 = mkWin32RustPackage "deltachat-repl";
+          deltachat-rpc-server-win32 = mkWin32RustPackage "deltachat-rpc-server";
+
+          deltachat-repl-aarch64-linux = mk-aarch64-RustPackage "deltachat-repl";
+          deltachat-rpc-server-aarch64-linux = mk-aarch64-RustPackage "deltachat-rpc-server";
+
+          deltachat-repl-i686-linux = mk-i686-RustPackage "deltachat-repl";
+          deltachat-rpc-server-i686-linux = mk-i686-RustPackage "deltachat-rpc-server";
+
+          deltachat-repl-x86_64-linux = mk-x86_64-RustPackage "deltachat-repl";
+          deltachat-rpc-server-x86_64-linux = mk-x86_64-RustPackage "deltachat-rpc-server";
+
+          deltachat-repl-armv7l-linux = mk-armv7l-RustPackage "deltachat-repl";
+          deltachat-rpc-server-armv7l-linux = mk-armv7l-RustPackage "deltachat-rpc-server";
+
+          deltachat-repl-armv6l-linux = mk-armv6l-RustPackage "deltachat-repl";
+          deltachat-rpc-server-armv6l-linux = mk-armv6l-RustPackage "deltachat-rpc-server";
+
+          # Run `nix build .#docs` to get C docs generated in `./result/`.
+          docs =
+            pkgs.stdenv.mkDerivation {
+              pname = "docs";
+              version = manifest.version;
+              src = pkgs.lib.cleanSource ./.;
+              nativeBuildInputs = [ pkgs.doxygen ];
+              buildPhase = ''scripts/run-doxygen.sh'';
+              installPhase = ''mkdir -p $out; cp -av deltachat-ffi/html deltachat-ffi/xml $out'';
+            };
+
+          libdeltachat =
+            pkgs.stdenv.mkDerivation rec {
+              pname = "libdeltachat";
+              version = manifest.version;
+              src = nix-filter.lib {
+                root = ./.;
+
+                # Include only necessary files
+                # to avoid rebuilds e.g. when README.md or flake.nix changes.
+                include = [
+                  ./benches
+                  ./assets
+                  ./Cargo.lock
+                  ./Cargo.toml
+                  ./CMakeLists.txt
+                  ./CONTRIBUTING.md
+                  ./deltachat_derive
+                  ./deltachat-ffi
+                  ./deltachat-jsonrpc
+                  ./deltachat-ratelimit
+                  ./deltachat-repl
+                  ./deltachat-rpc-client
+                  ./deltachat-rpc-server
+                  ./format-flowed
+                  ./release-date.in
+                  ./src
+                ];
+                exclude = [
+                  (nix-filter.lib.matchExt "nix")
+                  "flake.lock"
+                ];
+              };
+              cargoDeps = pkgs.rustPlatform.importCargoLock cargoLock;
+
+              nativeBuildInputs = [
+                pkgs.perl # Needed to build vendored OpenSSL.
+                pkgs.cmake
+                pkgs.rustPlatform.cargoSetupHook
+                pkgs.cargo
+              ];
+
+              postInstall = ''
+                substituteInPlace $out/include/deltachat.h \
+                  --replace __FILE__ '"${placeholder "out"}/include/deltachat.h"'
+              '';
+            };
+
+          deltachat-rpc-client =
+            pkgs.python3Packages.buildPythonPackage rec {
+              pname = "deltachat-rpc-client";
+              version = manifest.version;
+              src = pkgs.lib.cleanSource ./deltachat-rpc-client;
+              format = "pyproject";
+              propagatedBuildInputs = [
+                pkgs.python3Packages.setuptools
+                pkgs.python3Packages.setuptools_scm
+              ];
+            };
+
+          deltachat-python =
+            pkgs.python3Packages.buildPythonPackage rec {
+              pname = "deltachat-python";
+              version = manifest.version;
+              src = pkgs.lib.cleanSource ./python;
+              format = "pyproject";
+              buildInputs = [
+                libdeltachat
+              ];
+              nativeBuildInputs = [
+                pkgs.pkg-config
+              ];
+              propagatedBuildInputs = [
+                pkgs.python3Packages.setuptools
+                pkgs.python3Packages.setuptools_scm
+                pkgs.python3Packages.pkgconfig
+                pkgs.python3Packages.cffi
+                pkgs.python3Packages.imap-tools
+                pkgs.python3Packages.pluggy
+                pkgs.python3Packages.requests
+              ];
+            };
+          python-docs =
+            pkgs.stdenv.mkDerivation {
+              pname = "docs";
+              version = manifest.version;
+              src = pkgs.lib.cleanSource ./.;
+              buildInputs = [
+                deltachat-python
+                deltachat-rpc-client
+                pkgs.python3Packages.breathe
+                pkgs.python3Packages.sphinx_rtd_theme
+              ];
+              nativeBuildInputs = [ pkgs.sphinx ];
+              buildPhase = ''sphinx-build -b html -a python/doc/ dist/html'';
+              installPhase = ''mkdir -p $out; cp -av dist/html $out'';
+            };
+        };
+      }
+    );
+}
--- a/fuzz/Cargo.lock
+++ b/fuzz/Cargo.lock
@@ -190,11 +190,11 @@ dependencies = [

 [[package]]
 name = "async-imap"
-version = "0.9.1"
+version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b538b767cbf9c162a6c5795d4b932bd2c20ba10b5a91a94d2b2b6886c1dce6a8"
+checksum = "a9d69fc1499878158750f644c4eb46aff55bb9d32d77e3dc4aecf8308d5c3ba6"
 dependencies = [
- "async-channel 1.8.0",
+ "async-channel 2.1.1",
 "base64 0.21.0",
 "bytes",
 "chrono",
@@ -922,7 +922,7 @@ dependencies = [

 [[package]]
 name = "deltachat"
-version = "1.131.9"
+version = "1.133.0"
 dependencies = [
 "anyhow",
 "async-channel 2.1.1",
@@ -963,6 +963,7 @@ dependencies = [
 "pin-project",
 "qrcodegen",
 "quick-xml",
+ "quoted_printable 0.5.0",
 "rand 0.8.5",
 "ratelimit",
 "regex",
@@ -1859,9 +1860,9 @@ dependencies = [

 [[package]]
 name = "h2"
-version = "0.3.17"
+version = "0.3.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "66b91535aa35fea1523ad1b86cb6b53c28e0ae566ba4a460f4457e936cad7c6f"
+checksum = "bb2c4422095b67ee78da96fbb51a4cc413b3b25883c7717ff7ca1ab31022c9c9"
 dependencies = [
 "bytes",
 "fnv",
@@ -1869,7 +1870,7 @@ dependencies = [
 "futures-sink",
 "futures-util",
 "http",
- "indexmap 1.9.2",
+ "indexmap",
 "slab",
 "tokio",
 "tokio-util",
@@ -2146,16 +2147,6 @@ dependencies = [
 "nom",
 ]

-[[package]]
-name = "indexmap"
-version = "1.9.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1885e79c1fc4b10f0e172c475f458b7f7b93061064d98c3293e98c5ba0c8b399"
-dependencies = [
- "autocfg",
- "hashbrown 0.12.3",
-]
-
 [[package]]
 name = "indexmap"
 version = "2.1.0"
@@ -2215,7 +2206,8 @@ checksum = "11b0d96e660696543b251e58030cf9787df56da39dab19ad60eae7353040917e"
 [[package]]
 name = "iroh"
 version = "0.4.2"
-source = "git+https://github.com/n0-computer/iroh?branch=maint-0.4#9881b7886235035a1124e4371f7a4cd59379e51b"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85075391dcb8491a4939266334b28601052d418b37d20b33c58ffb5776adc912"
 dependencies = [
 "abao",
 "anyhow",
@@ -2420,7 +2412,7 @@ checksum = "8cae768a50835557749599277fc59f7c728118724eb34185e8feb633ef266a32"
 dependencies = [
 "charset",
 "data-encoding",
- "quoted_printable",
+ "quoted_printable 0.4.6",
 ]

 [[package]]
@@ -2431,7 +2423,7 @@ checksum = "6b56570f5f8c0047260d1c8b5b331f62eb9c660b9dd4071a8c46f8c7d3f280aa"
 dependencies = [
 "charset",
 "data-encoding",
- "quoted_printable",
+ "quoted_printable 0.4.6",
 ]

 [[package]]
@@ -3258,6 +3250,12 @@ version = "0.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "20f14e071918cbeefc5edc986a7aa92c425dae244e003a35e1cdddb5ca39b5cb"

+[[package]]
+name = "quoted_printable"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "79ec282e887b434b68c18fe5c121d38e72a5cf35119b59e54ec5b992ea9c8eb0"
+
 [[package]]
 name = "rand"
 version = "0.7.3"
@@ -3411,9 +3409,9 @@ checksum = "dbb5fb1acd8a1a18b3dd5be62d25485eb770e05afb408a9627d14d451bae12da"

 [[package]]
 name = "reqwest"
-version = "0.11.20"
+version = "0.11.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e9ad3fe7488d7e34558a2033d45a0c90b72d97b4f80705666fea71472e2e6a1"
+checksum = "37b1ae8d9ac08420c66222fb9096fc5de435c3c48542bc5336c51892cffafb41"
 dependencies = [
 "base64 0.21.0",
 "bytes",
@@ -3436,6 +3434,7 @@ dependencies = [
 "serde",
 "serde_json",
 "serde_urlencoded",
+ "system-configuration",
 "tokio",
 "tokio-native-tls",
 "tower-service",
@@ -4156,9 +4155,9 @@ dependencies = [

 [[package]]
 name = "system-configuration"
-version = "0.5.0"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d75182f12f490e953596550b65ee31bda7c8e043d9386174b353bda50838c3fd"
+checksum = "ba3a3adc5c275d719af8cb4272ea1c4a6d668a777f37e115f6d11ddbc1c8e0e7"
 dependencies = [
 "bitflags 1.3.2",
 "core-foundation",
@@ -4429,7 +4428,7 @@ version = "0.21.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d34d383cd00a163b4a5b85053df514d45bc330f6de7737edfe0a93311d1eaa03"
 dependencies = [
- "indexmap 2.1.0",
+ "indexmap",
 "serde",
 "serde_spanned",
 "toml_datetime",
--- a/node/constants.js
+++ b/node/constants.js
@@ -29,9 +29,11 @@ module.exports = {
  DC_DOWNLOAD_FAILURE: 20,
  DC_DOWNLOAD_IN_PROGRESS: 1000,
  DC_DOWNLOAD_UNDECIPHERABLE: 30,
+  DC_EVENT_ACCOUNTS_BACKGROUND_FETCH_DONE: 2200,
  DC_EVENT_CHAT_EPHEMERAL_TIMER_MODIFIED: 2021,
  DC_EVENT_CHAT_MODIFIED: 2020,
  DC_EVENT_CONFIGURE_PROGRESS: 2041,
+  DC_EVENT_CONFIG_SYNCED: 2111,
  DC_EVENT_CONNECTIVITY_CHANGED: 2100,
  DC_EVENT_CONTACTS_CHANGED: 2030,
  DC_EVENT_DELETED_BLOB_FILE: 151,
@@ -79,6 +81,7 @@ module.exports = {
  DC_INFO_EPHEMERAL_TIMER_CHANGED: 10,
  DC_INFO_GROUP_IMAGE_CHANGED: 3,
  DC_INFO_GROUP_NAME_CHANGED: 2,
+  DC_INFO_INVALID_UNENCRYPTED_MAIL: 13,
  DC_INFO_LOCATIONSTREAMING_ENABLED: 8,
  DC_INFO_LOCATION_ONLY: 9,
  DC_INFO_MEMBER_ADDED_TO_GROUP: 4,
@@ -225,11 +228,13 @@ module.exports = {
  DC_STR_GROUP_NAME_CHANGED_BY_YOU: 124,
  DC_STR_IMAGE: 9,
  DC_STR_INCOMING_MESSAGES: 103,
+  DC_STR_INVALID_UNENCRYPTED_MAIL: 174,
  DC_STR_LAST_MSG_SENT_SUCCESSFULLY: 111,
  DC_STR_LOCATION: 66,
  DC_STR_LOCATION_ENABLED_BY_OTHER: 137,
  DC_STR_LOCATION_ENABLED_BY_YOU: 136,
  DC_STR_MESSAGES: 114,
+  DC_STR_MESSAGE_ADD_MEMBER: 173,
  DC_STR_MSGACTIONBYME: 63,
  DC_STR_MSGACTIONBYUSER: 62,
  DC_STR_MSGADDMEMBER: 17,
--- a/node/events.js
+++ b/node/events.js
@@ -34,6 +34,8 @@ module.exports = {
  2061: 'DC_EVENT_SECUREJOIN_JOINER_PROGRESS',
  2100: 'DC_EVENT_CONNECTIVITY_CHANGED',
  2110: 'DC_EVENT_SELFAVATAR_CHANGED',
+  2111: 'DC_EVENT_CONFIG_SYNCED',
  2120: 'DC_EVENT_WEBXDC_STATUS_UPDATE',
-  2121: 'DC_EVENT_WEBXDC_INSTANCE_DELETED'
+  2121: 'DC_EVENT_WEBXDC_INSTANCE_DELETED',
+  2200: 'DC_EVENT_ACCOUNTS_BACKGROUND_FETCH_DONE'
 }
--- a/node/lib/constants.ts
+++ b/node/lib/constants.ts
@@ -29,9 +29,11 @@ export enum C {
  DC_DOWNLOAD_FAILURE = 20,
  DC_DOWNLOAD_IN_PROGRESS = 1000,
  DC_DOWNLOAD_UNDECIPHERABLE = 30,
+  DC_EVENT_ACCOUNTS_BACKGROUND_FETCH_DONE = 2200,
  DC_EVENT_CHAT_EPHEMERAL_TIMER_MODIFIED = 2021,
  DC_EVENT_CHAT_MODIFIED = 2020,
  DC_EVENT_CONFIGURE_PROGRESS = 2041,
+  DC_EVENT_CONFIG_SYNCED = 2111,
  DC_EVENT_CONNECTIVITY_CHANGED = 2100,
  DC_EVENT_CONTACTS_CHANGED = 2030,
  DC_EVENT_DELETED_BLOB_FILE = 151,
@@ -79,6 +81,7 @@ export enum C {
  DC_INFO_EPHEMERAL_TIMER_CHANGED = 10,
  DC_INFO_GROUP_IMAGE_CHANGED = 3,
  DC_INFO_GROUP_NAME_CHANGED = 2,
+  DC_INFO_INVALID_UNENCRYPTED_MAIL = 13,
  DC_INFO_LOCATIONSTREAMING_ENABLED = 8,
  DC_INFO_LOCATION_ONLY = 9,
  DC_INFO_MEMBER_ADDED_TO_GROUP = 4,
@@ -225,11 +228,13 @@ export enum C {
  DC_STR_GROUP_NAME_CHANGED_BY_YOU = 124,
  DC_STR_IMAGE = 9,
  DC_STR_INCOMING_MESSAGES = 103,
+  DC_STR_INVALID_UNENCRYPTED_MAIL = 174,
  DC_STR_LAST_MSG_SENT_SUCCESSFULLY = 111,
  DC_STR_LOCATION = 66,
  DC_STR_LOCATION_ENABLED_BY_OTHER = 137,
  DC_STR_LOCATION_ENABLED_BY_YOU = 136,
  DC_STR_MESSAGES = 114,
+  DC_STR_MESSAGE_ADD_MEMBER = 173,
  DC_STR_MSGACTIONBYME = 63,
  DC_STR_MSGACTIONBYUSER = 62,
  DC_STR_MSGADDMEMBER = 17,
@@ -319,6 +324,8 @@ export const EventId2EventName: { [key: number]: string } = {
  2061: 'DC_EVENT_SECUREJOIN_JOINER_PROGRESS',
  2100: 'DC_EVENT_CONNECTIVITY_CHANGED',
  2110: 'DC_EVENT_SELFAVATAR_CHANGED',
+  2111: 'DC_EVENT_CONFIG_SYNCED',
  2120: 'DC_EVENT_WEBXDC_STATUS_UPDATE',
  2121: 'DC_EVENT_WEBXDC_INSTANCE_DELETED',
+  2200: 'DC_EVENT_ACCOUNTS_BACKGROUND_FETCH_DONE',
 }
--- a/node/lib/deltachat.ts
+++ b/node/lib/deltachat.ts
@@ -178,7 +178,7 @@ export class AccountManager extends EventEmitter {
  static newTemporary() {
    let directory = null
    while (true) {
-      const randomString = Math.random().toString(36).substr(2, 5)
+      const randomString = Math.random().toString(36).substring(2, 5)
      directory = join(tmpdir(), 'deltachat-' + randomString)
      if (!existsSync(directory)) break
    }
--- a/node/test/test.mjs
+++ b/node/test/test.mjs
@@ -1,13 +1,17 @@
 // @ts-check
-import DeltaChat from '../dist'
+import { DeltaChat } from '../dist/index.js'

 import { deepStrictEqual, strictEqual } from 'assert'
 import chai, { expect } from 'chai'
 import chaiAsPromised from 'chai-as-promised'
-import { EventId2EventName, C } from '../dist/constants'
+import { EventId2EventName, C } from '../dist/constants.js'
 import { join } from 'path'
 import { statSync } from 'fs'
-import { Context } from '../dist/context'
+import { Context } from '../dist/context.js'
+import {fileURLToPath} from 'url';
+
+const __dirname = fileURLToPath(new URL('.', import.meta.url));
+
 chai.use(chaiAsPromised)
 chai.config.truncateThreshold = 0 // Do not truncate assertion errors.

@@ -235,7 +239,7 @@ describe('Basic offline Tests', function () {
      'delete_device_after',
      'delete_server_after',
      'deltachat_core_version',
-      'display_name',
+      'displayname',
      'download_limit',
      'e2ee_enabled',
      'entered_account_settings',
@@ -246,6 +250,7 @@ describe('Basic offline Tests', function () {
      'journal_mode',
      'key_gen_type',
      'last_housekeeping',
+      'last_cant_decrypt_outgoing_msgs',
      'level',
      'mdns_enabled',
      'media_quality',
--- a/package.json
+++ b/package.json
@@ -10,7 +10,6 @@
    "@types/node": "^20.8.10",
    "chai": "~4.3.10",
    "chai-as-promised": "^7.1.1",
-    "esm": "^3.2.25",
    "mocha": "^8.2.1",
    "node-gyp": "^10.0.0",
    "prebuildify": "^5.0.1",
@@ -53,8 +52,8 @@
    "prebuildify": "cd node && prebuildify -t 18.0.0 --napi --strip --postinstall \"node scripts/postinstall.js --prebuild\"",
    "test": "npm run test:lint && npm run test:mocha",
    "test:lint": "npm run lint",
-    "test:mocha": "mocha -r esm node/test/test.js --growl --reporter=spec --bail --exit"
+    "test:mocha": "mocha node/test/test.mjs --growl --reporter=spec --bail --exit"
  },
  "types": "node/dist/index.d.ts",
-  "version": "1.132.1"
+  "version": "1.135.1"
 }
--- a/python/src/deltachat/account.py
+++ b/python/src/deltachat/account.py
@@ -1,6 +1,5 @@
 """Account class implementation."""

-
 import os
 from array import array
 from contextlib import contextmanager
@@ -478,6 +477,16 @@ class Account:
        msg_ids = [msg.id for msg in messages]
        lib.dc_forward_msgs(self._dc_context, msg_ids, len(msg_ids), chat.id)

+    def resend_messages(self, messages: List[Message]) -> None:
+        """Resend list of messages.
+
+        :param messages: list of :class:`deltachat.message.Message` object.
+        :returns: None
+        """
+        msg_ids = [msg.id for msg in messages]
+        if lib.dc_resend_msgs(self._dc_context, msg_ids, len(msg_ids)) != 1:
+            raise ValueError(f"could not resend messages {msg_ids}")
+
    def delete_messages(self, messages: List[Message]) -> None:
        """delete messages (local and remote).

--- a/python/src/deltachat/testplugin.py
+++ b/python/src/deltachat/testplugin.py
@@ -10,6 +10,7 @@ import time
 import weakref
 import random
 from queue import Queue
+from threading import Event
 from typing import Callable, Dict, List, Optional, Set

 import pytest
@@ -590,6 +591,27 @@ class ACFactory:
        ac2.create_chat(ac1)
        return ac1.create_chat(ac2)

+    def get_protected_chat(self, ac1: Account, ac2: Account):
+        class SetupPlugin:
+            def __init__(self) -> None:
+                self.member_added = Event()
+
+            @account_hookimpl
+            def ac_member_added(self, chat: deltachat.Chat, contact, actor, message):
+                self.member_added.set()
+
+        setupplugin = SetupPlugin()
+        ac1.add_account_plugin(setupplugin)
+        chat = ac1.create_group_chat("Protected Group", verified=True)
+        qr = chat.get_join_qr()
+        ac2.qr_join_chat(qr)
+        setupplugin.member_added.wait()
+        msg = ac2.wait_next_incoming_message()
+        assert msg.text == "Messages are guaranteed to be end-to-end encrypted from now on."
+        msg = ac2.wait_next_incoming_message()
+        assert "Member Me " in msg.text and " added by " in msg.text
+        return chat
+
    def introduce_each_other(self, accounts, sending=True):
        to_wait = []
        for i, acc in enumerate(accounts):
--- a/python/tests/test_1_online.py
+++ b/python/tests/test_1_online.py
@@ -382,6 +382,21 @@ def test_webxdc_download_on_demand(acfactory, data, lp):
    assert msgs_changed_event.data2 == 0


+def test_enable_mvbox_move(acfactory, lp):
+    (ac1,) = acfactory.get_online_accounts(1)
+
+    lp.sec("ac2: start without mvbox thread")
+    ac2 = acfactory.new_online_configuring_account(mvbox_move=False)
+    acfactory.bring_accounts_online()
+
+    lp.sec("ac2: configuring mvbox")
+    ac2.set_config("mvbox_move", "1")
+
+    lp.sec("ac1: send message and wait for ac2 to receive it")
+    acfactory.get_accepted_chat(ac1, ac2).send_text("message1")
+    assert ac2._evtracker.wait_next_incoming_message().text == "message1"
+
+
 def test_mvbox_sentbox_threads(acfactory, lp):
    lp.sec("ac1: start with mvbox thread")
    ac1 = acfactory.new_online_configuring_account(mvbox_move=True, sentbox_watch=True)
@@ -498,6 +513,26 @@ def test_forward_messages(acfactory, lp):
    assert not chat3.get_messages()


+def test_forward_encrypted_to_unencrypted(acfactory, lp):
+    ac1, ac2, ac3 = acfactory.get_online_accounts(3)
+    chat = acfactory.get_protected_chat(ac1, ac2)
+
+    lp.sec("ac1: send encrypted message to ac2")
+    txt = "This should be encrypted"
+    chat.send_text(txt)
+    msg = ac2.wait_next_incoming_message()
+    assert msg.text == txt
+    assert msg.is_encrypted()
+
+    lp.sec("ac2: forward message to ac3 unencrypted")
+    unencrypted_chat = ac2.create_chat(ac3)
+    msg_id = msg.id
+    msg2 = unencrypted_chat.send_msg(msg)
+    assert msg2 == msg
+    assert msg.id != msg_id
+    assert not msg.is_encrypted()
+
+
 def test_forward_own_message(acfactory, lp):
    ac1, ac2 = acfactory.get_online_accounts(2)
    chat = acfactory.get_accepted_chat(ac1, ac2)
@@ -523,6 +558,27 @@ def test_forward_own_message(acfactory, lp):
    assert msg_in.is_forwarded()


+def test_resend_message(acfactory, lp):
+    ac1, ac2 = acfactory.get_online_accounts(2)
+    chat1 = ac1.create_chat(ac2)
+
+    lp.sec("ac1: send message to ac2")
+    chat1.send_text("message")
+
+    lp.sec("ac2: receive message")
+    msg_in = ac2._evtracker.wait_next_incoming_message()
+    assert msg_in.text == "message"
+    chat2 = msg_in.chat
+    chat2_msg_cnt = len(chat2.get_messages())
+
+    lp.sec("ac1: resend message")
+    ac1.resend_messages([msg_in])
+
+    lp.sec("ac2: check that message is deleted")
+    ac2._evtracker.get_matching("DC_EVENT_IMAP_MESSAGE_DELETED")
+    assert len(chat2.get_messages()) == chat2_msg_cnt
+
+
 def test_long_group_name(acfactory, lp):
    """See bug https://github.com/deltachat/deltachat-core-rust/issues/3650 "Space added before long
    group names after MIME serialization/deserialization".
@@ -1531,10 +1587,11 @@ def test_reactions_for_a_reordering_move(acfactory, lp):


 def test_import_export_online_all(acfactory, tmp_path, data, lp):
-    (ac1,) = acfactory.get_online_accounts(1)
+    (ac1, some1) = acfactory.get_online_accounts(2)

    lp.sec("create some chat content")
-    chat1 = ac1.create_contact("some1@example.org", name="some1").create_chat()
+    some1_addr = some1.get_config("addr")
+    chat1 = ac1.create_contact(some1_addr, name="some1").create_chat()
    chat1.send_text("msg1")
    assert len(ac1.get_contacts(query="some1")) == 1

@@ -1551,7 +1608,7 @@ def test_import_export_online_all(acfactory, tmp_path, data, lp):
        contacts = ac.get_contacts(query="some1")
        assert len(contacts) == 1
        contact2 = contacts[0]
-        assert contact2.addr == "some1@example.org"
+        assert contact2.addr == some1_addr
        chat2 = contact2.create_chat()
        messages = chat2.get_messages()
        assert len(messages) == 3
--- a/release-date.in
+++ b/release-date.in
@@ -1 +1 @@
-2023-12-12
+2024-02-20
--- a/scripts/README.md
+++ b/scripts/README.md
@@ -35,8 +35,6 @@ and an own build machine.

 - `run_all.sh` builds Python wheels

- `zig-rpc-server.sh` compiles binaries of `deltachat-rpc-server` using Zig toolchain statically linked against musl libc.
-
 - `android-rpc-server.sh` compiles binaries of `deltachat-rpc-server` using Android NDK.

 - `build-python-docs.sh` builds Python documentation into `dist/html/`.
--- a/scripts/build-python-docs.sh
+++ b/scripts/build-python-docs.sh
@@ -9,5 +9,4 @@ python3 -m venv venv
 venv/bin/pip install ./python
 venv/bin/pip install ./deltachat-rpc-client
 venv/bin/pip install sphinx breathe sphinx_rtd_theme
-venv/bin/pip install ./deltachat-rpc-client
 venv/bin/sphinx-build -b html -a python/doc/ dist/html
--- a/scripts/create-provider-data-rs.py
+++ b/scripts/create-provider-data-rs.py
@@ -220,9 +220,9 @@ if __name__ == "__main__":

    process_dir(Path(sys.argv[1]))

-    out_all += "pub(crate) static PROVIDER_DATA: Lazy<HashMap<&'static str, &'static Provider>> = Lazy::new(|| HashMap::from([\n"
+    out_all += "pub(crate) static PROVIDER_DATA: [(&str, &Provider); " + str(len(domains_set)) + "] = [\n";
    out_all += out_domains
-    out_all += "]));\n\n"
+    out_all += "];\n\n"

    out_all += "pub(crate) static PROVIDER_IDS: Lazy<HashMap<&'static str, &'static Provider>> = Lazy::new(|| HashMap::from([\n"
    out_all += out_ids
--- a/scripts/set_core_version.py
+++ b/scripts/set_core_version.py
@@ -102,7 +102,7 @@ def main():
                found = True
        if not found:
            raise SystemExit(
-                f"{changelog_name} contains no entry for version: {newversion}"
+                f"CHANGELOG.md contains no entry for version: {newversion}"
            )

    for toml_filename in toml_list:
--- a/scripts/update-provider-database.sh
+++ b/scripts/update-provider-database.sh
@@ -6,7 +6,7 @@ set -euo pipefail
 export TZ=UTC

 # Provider database revision.
-REV=18f714cf73d0bdfb8b013fa344494ab80c92b477
+REV=2f3db24107e4802c2df0aa0a40f0e144006c0a9b

 CORE_ROOT="$PWD"
 TMP="$(mktemp -d)"
--- a/scripts/wheel-rpc-server.py
+++ b/scripts/wheel-rpc-server.py
@@ -1,6 +1,5 @@
 #!/usr/bin/env python3
-"""Build Python wheels for deltachat-rpc-server.
-Run scripts/zig-rpc-server.sh first."""
+"""Build Python wheels for deltachat-rpc-server."""
 from pathlib import Path
 from wheel.wheelfile import WheelFile
 import tomllib
@@ -157,8 +156,13 @@ def main():
    )
    build_wheel(
        version,
-        "dist/deltachat-rpc-server-armv7-linux",
-        "py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.musllinux_1_1_armv7l",
+        "dist/deltachat-rpc-server-armv7l-linux",
+        "py3-none-linux_armv7l.manylinux_2_17_armv7l.manylinux2014_armv7l.musllinux_1_1_armv7l",
+    )
+    build_wheel(
+        version,
+        "dist/deltachat-rpc-server-armv6l-linux",
+        "py3-none-linux_armv6l",
    )
    build_wheel(
        version,
--- a/scripts/zig-cc
+++ b/scripts/zig-cc
@@ -1,57 +0,0 @@
-#!/usr/bin/env python
-# /// pyproject
-# [run]
-# dependencies = [
-#   "ziglang==0.11.0"
-# ]
-# ///
-import os
-import subprocess
-import sys
-
-
-def flag_filter(flag: str) -> bool:
-    # Workaround for <https://github.com/sfackler/rust-openssl/issues/2043>.
-    if flag == "-latomic":
-        return False
-
-    if flag == "-lc":
-        return False
-    if flag == "-Wl,-melf_i386":
-        return False
-    if "self-contained" in flag and "crt" in flag:
-        return False
-    return True
-
-
-def main():
-    args = [flag for flag in sys.argv[1:] if flag_filter(flag)]
-    zig_target = os.environ["ZIG_TARGET"]
-    zig_cpu = os.environ.get("ZIG_CPU")
-    if zig_cpu:
-        zig_cpu_args = ["-mcpu=" + zig_cpu]
-        args = [x for x in args if not x.startswith("-march")]
-    else:
-        zig_cpu_args = []
-
-    # Disable atomics and use locks instead in OpenSSL.
-    # Zig toolchains do not provide atomics.
-    # This is a workaround for <https://github.com/deltachat/deltachat-core-rust/issues/4799>
-    args += ["-DBROKEN_CLANG_ATOMICS"]
-
-    subprocess.run(
-        [
-            sys.executable,
-            "-m",
-            "ziglang",
-            "cc",
-            "-target",
-            zig_target,
-            *zig_cpu_args,
-            *args,
-        ],
-        check=True,
-    )
-
-
-main()
--- a/scripts/zig-rpc-server.sh
+++ b/scripts/zig-rpc-server.sh
@@ -1,50 +0,0 @@
-#!/bin/sh
-#
-# Build statically linked deltachat-rpc-server using zig.
-
-set -x
-set -e
-
-unset RUSTFLAGS
-
-# Pin Rust version to avoid uncontrolled changes in the compiler and linker flags.
-export RUSTUP_TOOLCHAIN=1.72.0
-
-rustup target add i686-unknown-linux-musl
-CC="$PWD/scripts/zig-cc" \
-TARGET_CC="$PWD/scripts/zig-cc" \
-CARGO_TARGET_I686_UNKNOWN_LINUX_MUSL_LINKER="$PWD/scripts/zig-cc" \
-LD="$PWD/scripts/zig-cc" \
-ZIG_TARGET="x86-linux-musl" \
-cargo build --release --target i686-unknown-linux-musl -p deltachat-rpc-server --features vendored
-
-rustup target add armv7-unknown-linux-musleabihf
-CC="$PWD/scripts/zig-cc" \
-TARGET_CC="$PWD/scripts/zig-cc" \
-CARGO_TARGET_ARMV7_UNKNOWN_LINUX_MUSLEABIHF_LINKER="$PWD/scripts/zig-cc" \
-LD="$PWD/scripts/zig-cc" \
-ZIG_TARGET="arm-linux-musleabihf" \
-ZIG_CPU="generic+v7a+vfp3-d32+thumb2-neon" \
-cargo build --release --target armv7-unknown-linux-musleabihf -p deltachat-rpc-server --features vendored
-
-rustup target add x86_64-unknown-linux-musl
-CC="$PWD/scripts/zig-cc" \
-TARGET_CC="$PWD/scripts/zig-cc" \
-CARGO_TARGET_X86_64_UNKNOWN_LINUX_MUSL_LINKER="$PWD/scripts/zig-cc" \
-LD="$PWD/scripts/zig-cc" \
-ZIG_TARGET="x86_64-linux-musl" \
-cargo build --release --target x86_64-unknown-linux-musl -p deltachat-rpc-server --features vendored
-
-rustup target add aarch64-unknown-linux-musl
-CC="$PWD/scripts/zig-cc" \
-TARGET_CC="$PWD/scripts/zig-cc" \
-CARGO_TARGET_AARCH64_UNKNOWN_LINUX_MUSL_LINKER="$PWD/scripts/zig-cc" \
-LD="$PWD/scripts/zig-cc" \
-ZIG_TARGET="aarch64-linux-musl" \
-cargo build --release --target aarch64-unknown-linux-musl -p deltachat-rpc-server --features vendored
-
-mkdir -p dist
-cp target/x86_64-unknown-linux-musl/release/deltachat-rpc-server dist/deltachat-rpc-server-x86_64-linux
-cp target/i686-unknown-linux-musl/release/deltachat-rpc-server dist/deltachat-rpc-server-i686-linux
-cp target/aarch64-unknown-linux-musl/release/deltachat-rpc-server dist/deltachat-rpc-server-aarch64-linux
-cp target/armv7-unknown-linux-musleabihf/release/deltachat-rpc-server dist/deltachat-rpc-server-armv7-linux
--- a/src/accounts.rs
+++ b/src/accounts.rs
@@ -5,6 +5,7 @@ use std::future::Future;
 use std::path::{Path, PathBuf};

 use anyhow::{ensure, Context as _, Result};
+use futures::future::join_all;
 use serde::{Deserialize, Serialize};
 use tokio::fs;
 use tokio::io::AsyncWriteExt;
@@ -291,6 +292,42 @@ impl Accounts {
        }
    }

+    /// Performs a background fetch for all accounts in parallel.
+    ///
+    /// This is an auxiliary function and not part of public API.
+    /// Use [Accounts::background_fetch] instead.
+    async fn background_fetch_without_timeout(&self) {
+        async fn background_fetch_and_log_error(account: Context) {
+            if let Err(error) = account.background_fetch().await {
+                warn!(account, "{error:#}");
+            }
+        }
+
+        join_all(
+            self.accounts
+                .values()
+                .cloned()
+                .map(background_fetch_and_log_error),
+        )
+        .await;
+    }
+
+    /// Performs a background fetch for all accounts in parallel with a timeout.
+    ///
+    /// The `AccountsBackgroundFetchDone` event is emitted at the end,
+    /// process all events until you get this one and you can safely return to the background
+    /// without forgetting to create notifications caused by timing race conditions.
+    pub async fn background_fetch(&self, timeout: std::time::Duration) {
+        if let Err(_err) =
+            tokio::time::timeout(timeout, self.background_fetch_without_timeout()).await
+        {
+            self.emit_event(EventType::Warning(
+                "Background fetch timed out.".to_string(),
+            ));
+        }
+        self.emit_event(EventType::AccountsBackgroundFetchDone);
+    }
+
    /// Emits a single event.
    pub fn emit_event(&self, event: EventType) {
        self.events.emit(Event { id: 0, typ: event })
@@ -546,8 +583,12 @@ impl Config {
            }
            if self.inner.selected_account == id {
                // reset selected account
-                self.inner.selected_account =
-                    self.inner.accounts.get(0).map(|e| e.id).unwrap_or_default();
+                self.inner.selected_account = self
+                    .inner
+                    .accounts
+                    .first()
+                    .map(|e| e.id)
+                    .unwrap_or_default();
            }
        }

--- a/src/authres.rs
+++ b/src/authres.rs
@@ -216,7 +216,7 @@ async fn update_authservid_candidates(
    if old_ids != new_ids {
        let new_config = new_ids.into_iter().collect::<Vec<_>>().join(" ");
        context
-            .set_config(Config::AuthservIdCandidates, Some(&new_config))
+            .set_config_internal(Config::AuthservIdCandidates, Some(&new_config))
            .await?;
        // Updating the authservid candidates may mean that we now consider
        // emails as "failed" which "passed" previously, so we need to
--- a/src/blob.rs
+++ b/src/blob.rs
@@ -8,6 +8,7 @@ use std::iter::FusedIterator;
 use std::path::{Path, PathBuf};

 use anyhow::{format_err, Context as _, Result};
+use base64::Engine as _;
 use futures::StreamExt;
 use image::{DynamicImage, GenericImageView, ImageFormat, ImageOutputFormat};
 use num_traits::FromPrimitive;
@@ -312,6 +313,30 @@ impl<'a> BlobObject<'a> {
        true
    }

+    /// Returns path to the stored Base64-decoded blob.
+    ///
+    /// If `data` represents an image of known format, this adds the corresponding extension to
+    /// `suggested_file_stem`.
+    pub(crate) async fn store_from_base64(
+        context: &Context,
+        data: &str,
+        suggested_file_stem: &str,
+    ) -> Result<String> {
+        let buf = base64::engine::general_purpose::STANDARD.decode(data)?;
+        let ext = if let Ok(format) = image::guess_format(&buf) {
+            if let Some(ext) = format.extensions_str().first() {
+                format!(".{ext}")
+            } else {
+                String::new()
+            }
+        } else {
+            String::new()
+        };
+        let blob =
+            BlobObject::create(context, &format!("{suggested_file_stem}{ext}"), &buf).await?;
+        Ok(blob.as_name().to_string())
+    }
+
    pub async fn recode_to_avatar_size(&mut self, context: &Context) -> Result<()> {
        let blob_abs = self.to_abs_path();

--- a/src/chat.rs
+++ b/src/chat.rs
@@ -6,7 +6,7 @@ use std::convert::{TryFrom, TryInto};
 use std::fmt;
 use std::path::{Path, PathBuf};
 use std::str::FromStr;
-use std::time::{Duration, SystemTime};
+use std::time::Duration;

 use anyhow::{anyhow, bail, ensure, Context as _, Result};
 use deltachat_derive::{FromSql, ToSql};
@@ -44,7 +44,7 @@ use crate::sync::{self, Sync::*, SyncData};
 use crate::tools::{
    buf_compress, create_id, create_outgoing_rfc724_mid, create_smeared_timestamp,
    create_smeared_timestamps, get_abs_path, gm2local_offset, improve_single_line_input,
-    smeared_time, strip_rtlo_characters, time, IsNoneOrEmpty,
+    smeared_time, strip_rtlo_characters, time, IsNoneOrEmpty, SystemTime,
 };
 use crate::webxdc::WEBXDC_SUFFIX;

@@ -783,7 +783,9 @@ impl ChatId {

        context.emit_msgs_changed_without_ids();

-        context.set_config(Config::LastHousekeeping, None).await?;
+        context
+            .set_config_internal(Config::LastHousekeeping, None)
+            .await?;
        context.scheduler.interrupt_inbox().await;

        if chat.is_self_talk() {
@@ -2104,7 +2106,7 @@ impl Chat {
    }
 }

-async fn sync(context: &Context, id: SyncId, action: SyncAction) -> Result<()> {
+pub(crate) async fn sync(context: &Context, id: SyncId, action: SyncAction) -> Result<()> {
    context
        .add_sync_item(SyncData::AlterChat { id, action })
        .await?;
@@ -2657,6 +2659,11 @@ pub async fn send_msg(context: &Context, chat_id: ChatId, msg: &mut Message) ->
        return send_msg_inner(context, chat_id, msg).await;
    }

+    if msg.state != MessageState::Undefined && msg.state != MessageState::OutPreparing {
+        msg.param.remove(Param::GuaranteeE2ee);
+        msg.param.remove(Param::ForcePlaintext);
+        msg.update_param(context).await?;
+    }
    send_msg_inner(context, chat_id, msg).await
 }

@@ -2746,10 +2753,18 @@ pub(crate) async fn create_send_msg_jobs(context: &Context, msg: &mut Message) -
    let from = context.get_primary_self_addr().await?;
    let lowercase_from = from.to_lowercase();

-    // Send BCC to self if it is enabled and we are not going to
-    // delete it immediately. `from` must be the last addr, see `receive_imf_inner()` why.
+    // Send BCC to self if it is enabled.
+    //
+    // Previous versions of Delta Chat did not send BCC self
+    // if DeleteServerAfter was set to immediately delete messages
+    // from the server. This is not the case anymore
+    // because BCC-self messages are also used to detect
+    // that message was sent if SMTP server is slow to respond
+    // and connection is frequently lost
+    // before receiving status line.
+    //
+    // `from` must be the last addr, see `receive_imf_inner()` why.
    if context.get_config_bool(Config::BccSelf).await?
-        && context.get_config_delete_server_after().await? != Some(0)
        && !recipients
            .iter()
            .any(|x| x.to_lowercase() == lowercase_from)
@@ -2791,12 +2806,14 @@ pub(crate) async fn create_send_msg_jobs(context: &Context, msg: &mut Message) -
        );
    }

+    let now = time();
+
    if rendered_msg.is_gossiped {
-        msg.chat_id.set_gossiped_timestamp(context, time()).await?;
+        msg.chat_id.set_gossiped_timestamp(context, now).await?;
    }

    if let Some(last_added_location_id) = rendered_msg.last_added_location_id {
-        if let Err(err) = location::set_kml_sent_timestamp(context, msg.chat_id, time()).await {
+        if let Err(err) = location::set_kml_sent_timestamp(context, msg.chat_id, now).await {
            error!(context, "Failed to set kml sent_timestamp: {err:#}.");
        }
        if !msg.hidden {
@@ -2815,7 +2832,7 @@ pub(crate) async fn create_send_msg_jobs(context: &Context, msg: &mut Message) -
    }

    if attach_selfavatar {
-        if let Err(err) = msg.chat_id.set_selfavatar_timestamp(context, time()).await {
+        if let Err(err) = msg.chat_id.set_selfavatar_timestamp(context, now).await {
            error!(context, "Failed to set selfavatar timestamp: {err:#}.");
        }
    }
@@ -3639,7 +3656,7 @@ pub enum MuteDuration {
    Forever,

    /// Chat is muted for a limited period of time.
-    Until(SystemTime),
+    Until(std::time::SystemTime),
 }

 impl rusqlite::types::ToSql for MuteDuration {
@@ -4063,6 +4080,7 @@ pub async fn resend_msgs(context: &Context, msg_ids: &[MsgId]) -> Result<()> {
            chat_id: msg.chat_id,
            msg_id: msg.id,
        });
+        msg.timestamp_sort = create_smeared_timestamp(context);
        if !create_send_msg_jobs(context, &mut msg).await?.is_empty() {
            context.scheduler.interrupt_smtp().await;
        }
@@ -4252,7 +4270,9 @@ pub(crate) async fn delete_and_reset_all_device_msgs(context: &Context) -> Resul
            (),
        )
        .await?;
-    context.set_config(Config::QuotaExceeding, None).await?;
+    context
+        .set_config_internal(Config::QuotaExceeding, None)
+        .await?;
    Ok(())
 }

@@ -4398,6 +4418,10 @@ impl Context {
    pub(crate) async fn sync_alter_chat(&self, id: &SyncId, action: &SyncAction) -> Result<()> {
        let chat_id = match id {
            SyncId::ContactAddr(addr) => {
+                if let SyncAction::Rename(to) = action {
+                    Contact::create_ex(self, Nosync, to, addr).await?;
+                    return Ok(());
+                }
                let contact_id = Contact::lookup_id_by_addr_ex(self, addr, Origin::Unknown, None)
                    .await?
                    .with_context(|| format!("No contact for addr '{addr}'"))?;
@@ -6485,6 +6509,7 @@ mod tests {
        // Bob receives all messages
        let bob = TestContext::new_bob().await;
        let msg = bob.recv_msg(&sent1).await;
+        let sent1_ts_sent = msg.timestamp_sent;
        assert_eq!(msg.get_text(), "alice->bob");
        assert_eq!(get_chat_contacts(&bob, msg.chat_id).await?.len(), 2);
        assert_eq!(get_chat_msgs(&bob, msg.chat_id).await?.len(), 1);
@@ -6507,6 +6532,7 @@ mod tests {
        assert_eq!(get_chat_msgs(&claire, msg.chat_id).await?.len(), 2);
        let msg_from = Contact::get_by_id(&claire, msg.get_from_id()).await?;
        assert_eq!(msg_from.get_addr(), "alice@example.org");
+        assert!(sent1_ts_sent < msg.timestamp_sent);

        Ok(())
    }
--- a/src/config.rs
+++ b/src/config.rs
@@ -5,12 +5,14 @@ use std::path::Path;
 use std::str::FromStr;

 use anyhow::{ensure, Context as _, Result};
+use base64::Engine as _;
 use serde::{Deserialize, Serialize};
 use strum::{EnumProperty, IntoEnumIterator};
 use strum_macros::{AsRefStr, Display, EnumIter, EnumProperty, EnumString};
+use tokio::fs;

 use crate::blob::BlobObject;
-use crate::constants::DC_VERSION_STR;
+use crate::constants::{self, DC_VERSION_STR};
 use crate::contact::addr_cmp;
 use crate::context::Context;
 use crate::events::EventType;
@@ -291,6 +293,9 @@ pub enum Config {
    /// Timestamp of the last time housekeeping was run
    LastHousekeeping,

+    /// Timestamp of the last `CantDecryptOutgoingMsgs` notification.
+    LastCantDecryptOutgoingMsgs,
+
    /// To how many seconds to debounce scan_all_folders. Used mainly in tests, to disable debouncing completely.
    #[strum(props(default = "60"))]
    ScanAllFoldersDebounceSecs,
@@ -347,6 +352,10 @@ pub enum Config {
    /// Row ID of the key in the `keypairs` table
    /// used for signatures, encryption to self and included in `Autocrypt` header.
    KeyId,
+
+    /// This key is sent to the self_reporting bot so that the bot can recognize the user
+    /// without storing the email address
+    SelfReportingId,
 }

 impl Config {
@@ -354,15 +363,31 @@ impl Config {
    ///
    /// This must be checked on both sides so that if there are different client versions, the
    /// synchronisation of a particular option is either done or not done in both directions.
-    /// Moreover, receivers of a config value need to check if a key can be synced because some
-    /// settings (e.g. Avatar path) could otherwise lead to exfiltration of files from a receiver's
+    /// Moreover, receivers of a config value need to check if a key can be synced because if it is
+    /// a file path, it could otherwise lead to exfiltration of files from a receiver's
    /// device if we assume an attacker to have control of a device in a multi-device setting or if
    /// multiple users are sharing an account. Another example is `Self::SyncMsgs` itself which
    /// mustn't be controlled by other devices.
    pub(crate) fn is_synced(&self) -> bool {
+        // We don't restart IO from the synchronisation code, so this is to be on the safe side.
+        if self.needs_io_restart() {
+            return false;
+        }
        matches!(
            self,
-            Self::Displayname | Self::MdnsEnabled | Self::ShowEmails
+            Self::Displayname
+                | Self::MdnsEnabled
+                | Self::ShowEmails
+                | Self::Selfavatar
+                | Self::Selfstatus,
+        )
+    }
+
+    /// Whether the config option needs an IO scheduler restart to take effect.
+    pub(crate) fn needs_io_restart(&self) -> bool {
+        matches!(
+            self,
+            Config::MvboxMove | Config::OnlyFetchMvbox | Config::SentboxWatch
        )
    }
 }
@@ -484,51 +509,25 @@ impl Context {
        }
    }

-    /// Set the given config key.
-    /// If `None` is passed as a value the value is cleared and set to the default if there is one.
-    pub async fn set_config(&self, key: Config, value: Option<&str>) -> Result<()> {
-        self.set_config_ex(key.is_synced().into(), key, value).await
+    /// Executes [`SyncData::Config`] item sent by other device.
+    pub(crate) async fn sync_config(&self, key: &Config, value: &str) -> Result<()> {
+        let config_value;
+        let value = match key {
+            Config::Selfavatar if value.is_empty() => None,
+            Config::Selfavatar => {
+                config_value = BlobObject::store_from_base64(self, value, "avatar").await?;
+                Some(config_value.as_str())
+            }
+            _ => Some(value),
+        };
+        match key.is_synced() {
+            true => self.set_config_ex(Nosync, *key, value).await,
+            false => Ok(()),
+        }
    }

-    pub(crate) async fn set_config_ex(
-        &self,
-        sync: sync::Sync,
-        key: Config,
-        mut value: Option<&str>,
-    ) -> Result<()> {
-        let better_value;
+    fn check_config(key: Config, value: Option<&str>) -> Result<()> {
        match key {
-            Config::Selfavatar => {
-                self.sql
-                    .execute("UPDATE contacts SET selfavatar_sent=0;", ())
-                    .await?;
-                match value {
-                    Some(value) => {
-                        let mut blob = BlobObject::new_from_path(self, value.as_ref()).await?;
-                        blob.recode_to_avatar_size(self).await?;
-                        self.sql
-                            .set_raw_config(key.as_ref(), Some(blob.as_name()))
-                            .await?;
-                    }
-                    None => {
-                        self.sql.set_raw_config(key.as_ref(), None).await?;
-                    }
-                }
-                self.emit_event(EventType::SelfavatarChanged);
-            }
-            Config::DeleteDeviceAfter => {
-                let ret = self.sql.set_raw_config(key.as_ref(), value).await;
-                // Interrupt ephemeral loop to delete old messages immediately.
-                self.scheduler.interrupt_ephemeral_task().await;
-                ret?
-            }
-            Config::Displayname => {
-                if let Some(v) = value {
-                    better_value = improve_single_line_input(v);
-                    value = Some(&better_value);
-                }
-                self.sql.set_raw_config(key.as_ref(), value).await?;
-            }
            Config::Socks5Enabled
            | Config::BccSelf
            | Config::E2eeEnabled
@@ -549,6 +548,79 @@ impl Context {
                    matches!(value, None | Some("0") | Some("1")),
                    "Boolean value must be either 0 or 1"
                );
+            }
+            _ => (),
+        }
+        Ok(())
+    }
+
+    /// Set the given config key and make it effective.
+    /// This may restart the IO scheduler. If `None` is passed as a value the value is cleared and
+    /// set to the default if there is one.
+    pub async fn set_config(&self, key: Config, value: Option<&str>) -> Result<()> {
+        Self::check_config(key, value)?;
+
+        let _pause = match key.needs_io_restart() {
+            true => self.scheduler.pause(self.clone()).await?,
+            _ => Default::default(),
+        };
+        self.set_config_internal(key, value).await?;
+        Ok(())
+    }
+
+    pub(crate) async fn set_config_internal(&self, key: Config, value: Option<&str>) -> Result<()> {
+        self.set_config_ex(Sync, key, value).await
+    }
+
+    pub(crate) async fn set_config_ex(
+        &self,
+        sync: sync::Sync,
+        key: Config,
+        mut value: Option<&str>,
+    ) -> Result<()> {
+        Self::check_config(key, value)?;
+        let sync = sync == Sync && key.is_synced();
+        let better_value;
+
+        match key {
+            Config::Selfavatar => {
+                self.sql
+                    .execute("UPDATE contacts SET selfavatar_sent=0;", ())
+                    .await?;
+                match value {
+                    Some(path) => {
+                        let mut blob = BlobObject::new_from_path(self, path.as_ref()).await?;
+                        blob.recode_to_avatar_size(self).await?;
+                        self.sql
+                            .set_raw_config(key.as_ref(), Some(blob.as_name()))
+                            .await?;
+                        if sync {
+                            let buf = fs::read(blob.to_abs_path()).await?;
+                            better_value = base64::engine::general_purpose::STANDARD.encode(buf);
+                            value = Some(&better_value);
+                        }
+                    }
+                    None => {
+                        self.sql.set_raw_config(key.as_ref(), None).await?;
+                        if sync {
+                            better_value = String::new();
+                            value = Some(&better_value);
+                        }
+                    }
+                }
+                self.emit_event(EventType::SelfavatarChanged);
+            }
+            Config::DeleteDeviceAfter => {
+                let ret = self.sql.set_raw_config(key.as_ref(), value).await;
+                // Interrupt ephemeral loop to delete old messages immediately.
+                self.scheduler.interrupt_ephemeral_task().await;
+                ret?
+            }
+            Config::Displayname => {
+                if let Some(v) = value {
+                    better_value = improve_single_line_input(v);
+                    value = Some(&better_value);
+                }
                self.sql.set_raw_config(key.as_ref(), value).await?;
            }
            Config::Addr => {
@@ -556,12 +628,20 @@ impl Context {
                    .set_raw_config(key.as_ref(), value.map(|s| s.to_lowercase()).as_deref())
                    .await?;
            }
+            Config::MvboxMove => {
+                self.sql.set_raw_config(key.as_ref(), value).await?;
+                self.sql
+                    .set_raw_config(constants::DC_FOLDERS_CONFIGURED_KEY, None)
+                    .await?;
+            }
            _ => {
                self.sql.set_raw_config(key.as_ref(), value).await?;
            }
        }
-
-        if sync != Sync {
+        if key.is_synced() {
+            self.emit_event(EventType::ConfigSynced { key });
+        }
+        if !sync {
            return Ok(());
        }
        let Some(val) = value else {
@@ -588,8 +668,7 @@ impl Context {

    /// Set the given config to a boolean value.
    pub async fn set_config_bool(&self, key: Config, value: bool) -> Result<()> {
-        self.set_config(key, if value { Some("1") } else { Some("0") })
-            .await?;
+        self.set_config(key, from_bool(value)).await?;
        Ok(())
    }

@@ -609,6 +688,11 @@ impl Context {
    }
 }

+/// Returns a value for use in `Context::set_config_*()` for the given `bool`.
+pub(crate) fn from_bool(val: bool) -> Option<&'static str> {
+    Some(if val { "1" } else { "0" })
+}
+
 // Separate impl block for self address handling
 impl Context {
    /// Determine whether the specified addr maps to the/a self addr.
@@ -635,13 +719,13 @@ impl Context {
        let mut secondary_addrs = self.get_all_self_addrs().await?;
        // never store a primary address also as a secondary
        secondary_addrs.retain(|a| !addr_cmp(a, primary_new));
-        self.set_config(
+        self.set_config_internal(
            Config::SecondaryAddrs,
            Some(secondary_addrs.join(" ").as_str()),
        )
        .await?;

-        self.set_config(Config::ConfiguredAddr, Some(primary_new))
+        self.set_config_internal(Config::ConfiguredAddr, Some(primary_new))
            .await?;

        Ok(())
@@ -695,7 +779,7 @@ mod tests {

    use super::*;
    use crate::constants;
-    use crate::test_utils::{sync, TestContext};
+    use crate::test_utils::{sync, TestContext, TestContextManager};

    #[test]
    fn test_to_string() {
@@ -866,10 +950,10 @@ mod tests {
        // Reset to default. Test that it's not synced because defaults may differ across client
        // versions.
        alice0.set_config(Config::MdnsEnabled, None).await?;
-        assert!(alice0.get_config_bool(Config::MdnsEnabled).await?);
+        assert_eq!(alice0.get_config_bool(Config::MdnsEnabled).await?, true);
        alice0.set_config_bool(Config::MdnsEnabled, false).await?;
        sync(&alice0, &alice1).await;
-        assert!(!alice1.get_config_bool(Config::MdnsEnabled).await?);
+        assert_eq!(alice1.get_config_bool(Config::MdnsEnabled).await?, false);

        let show_emails = alice0.get_config_bool(Config::ShowEmails).await?;
        alice0
@@ -889,14 +973,150 @@ mod tests {
        assert!(alice1.get_config_bool(Config::MdnsEnabled).await?);

        // Usual sync scenario.
+        async fn test_config_str(
+            alice0: &TestContext,
+            alice1: &TestContext,
+            key: Config,
+            val: &str,
+        ) -> Result<()> {
+            alice0.set_config(key, Some(val)).await?;
+            sync(alice0, alice1).await;
+            assert_eq!(alice1.get_config(key).await?, Some(val.to_string()));
+            Ok(())
+        }
+        test_config_str(&alice0, &alice1, Config::Displayname, "Alice Sync").await?;
+        test_config_str(&alice0, &alice1, Config::Selfstatus, "My status").await?;
+
+        assert!(alice0.get_config(Config::Selfavatar).await?.is_none());
+        let file = alice0.dir.path().join("avatar.png");
+        let bytes = include_bytes!("../test-data/image/avatar64x64.png");
+        tokio::fs::write(&file, bytes).await?;
+        alice0
+            .set_config(Config::Selfavatar, Some(file.to_str().unwrap()))
+            .await?;
+        sync(&alice0, &alice1).await;
+        assert!(alice1
+            .get_config(Config::Selfavatar)
+            .await?
+            .filter(|path| path.ends_with(".png"))
+            .is_some());
+        alice0.set_config(Config::Selfavatar, None).await?;
+        sync(&alice0, &alice1).await;
+        assert!(alice1.get_config(Config::Selfavatar).await?.is_none());
+
+        Ok(())
+    }
+
+    /// Sync message mustn't be sent if self-{status,avatar} is changed by a self-sent message.
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn test_no_sync_on_self_sent_msg() -> Result<()> {
+        let mut tcm = TestContextManager::new();
+        let alice0 = &tcm.alice().await;
+        let alice1 = &tcm.alice().await;
+        for a in [alice0, alice1] {
+            a.set_config_bool(Config::SyncMsgs, true).await?;
+        }
+
+        let status = "Synced via usual message";
+        alice0.set_config(Config::Selfstatus, Some(status)).await?;
+        alice0.pop_sent_msg().await; // Sync message
+        let status1 = "Synced via sync message";
+        alice1.set_config(Config::Selfstatus, Some(status1)).await?;
+        tcm.send_recv(alice0, alice1, "hi Alice!").await;
+        assert_eq!(
+            alice1.get_config(Config::Selfstatus).await?,
+            Some(status.to_string())
+        );
+        sync(alice1, alice0).await;
+        assert_eq!(
+            alice0.get_config(Config::Selfstatus).await?,
+            Some(status1.to_string())
+        );
+
+        // Need a chat with another contact to send self-avatar.
+        let bob = &tcm.bob().await;
+        let a0b_chat_id = tcm.send_recv_accept(bob, alice0, "hi").await.chat_id;
+        let file = alice0.dir.path().join("avatar.png");
+        let bytes = include_bytes!("../test-data/image/avatar64x64.png");
+        tokio::fs::write(&file, bytes).await?;
+        alice0
+            .set_config(Config::Selfavatar, Some(file.to_str().unwrap()))
+            .await?;
+        alice0.pop_sent_msg().await; // Sync message
+        let file = alice1.dir.path().join("avatar.jpg");
+        let bytes = include_bytes!("../test-data/image/avatar1000x1000.jpg");
+        tokio::fs::write(&file, bytes).await?;
+        alice1
+            .set_config(Config::Selfavatar, Some(file.to_str().unwrap()))
+            .await?;
+        let sent_msg = alice0.send_text(a0b_chat_id, "hi").await;
+        alice1.recv_msg(&sent_msg).await;
+        assert!(alice1
+            .get_config(Config::Selfavatar)
+            .await?
+            .filter(|path| path.ends_with(".png"))
+            .is_some());
+        sync(alice1, alice0).await;
+        assert!(alice0
+            .get_config(Config::Selfavatar)
+            .await?
+            .filter(|path| path.ends_with(".jpg"))
+            .is_some());
+
+        Ok(())
+    }
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn test_event_config_synced() -> Result<()> {
+        let alice0 = TestContext::new_alice().await;
+        let alice1 = TestContext::new_alice().await;
+        for a in [&alice0, &alice1] {
+            a.set_config_bool(Config::SyncMsgs, true).await?;
+        }
+
        alice0
            .set_config(Config::Displayname, Some("Alice Sync"))
            .await?;
+        alice0
+            .evtracker
+            .get_matching(|e| {
+                matches!(
+                    e,
+                    EventType::ConfigSynced {
+                        key: Config::Displayname
+                    }
+                )
+            })
+            .await;
        sync(&alice0, &alice1).await;
        assert_eq!(
            alice1.get_config(Config::Displayname).await?,
            Some("Alice Sync".to_string())
        );
+        alice1
+            .evtracker
+            .get_matching(|e| {
+                matches!(
+                    e,
+                    EventType::ConfigSynced {
+                        key: Config::Displayname
+                    }
+                )
+            })
+            .await;
+
+        alice0.set_config(Config::Displayname, None).await?;
+        alice0
+            .evtracker
+            .get_matching(|e| {
+                matches!(
+                    e,
+                    EventType::ConfigSynced {
+                        key: Config::Displayname
+                    }
+                )
+            })
+            .await;

        Ok(())
    }
--- a/src/configure.rs
+++ b/src/configure.rs
@@ -22,7 +22,7 @@ use percent_encoding::{utf8_percent_encode, NON_ALPHANUMERIC};
 use server_params::{expand_param_vector, ServerParams};
 use tokio::task;

-use crate::config::Config;
+use crate::config::{self, Config};
 use crate::contact::addr_cmp;
 use crate::context::Context;
 use crate::imap::Imap;
@@ -112,12 +112,13 @@ impl Context {
        let mut param = LoginParam::load_candidate_params(self).await?;
        let old_addr = self.get_config(Config::ConfiguredAddr).await?;
        let success = configure(self, &mut param).await;
-        self.set_config(Config::NotifyAboutWrongPw, None).await?;
+        self.set_config_internal(Config::NotifyAboutWrongPw, None)
+            .await?;

        on_configure_completed(self, param, old_addr).await?;

        success?;
-        self.set_config(Config::NotifyAboutWrongPw, Some("1"))
+        self.set_config_internal(Config::NotifyAboutWrongPw, Some("1"))
            .await?;
        Ok(())
    }
@@ -455,7 +456,10 @@ async fn configure(ctx: &Context, param: &mut LoginParam) -> Result<()> {

    imap.configure_folders(ctx, create_mvbox).await?;

-    imap.select_with_uidvalidity(ctx, "INBOX")
+    imap.session
+        .as_mut()
+        .context("no IMAP connection established")?
+        .select_with_uidvalidity(ctx, "INBOX")
        .await
        .context("could not read INBOX status")?;

@@ -473,7 +477,7 @@ async fn configure(ctx: &Context, param: &mut LoginParam) -> Result<()> {

    // the trailing underscore is correct
    param.save_as_configured_params(ctx).await?;
-    ctx.set_config(Config::ConfiguredTimestamp, Some(&time().to_string()))
+    ctx.set_config_internal(Config::ConfiguredTimestamp, Some(&time().to_string()))
        .await?;

    progress!(ctx, 920);
@@ -481,7 +485,7 @@ async fn configure(ctx: &Context, param: &mut LoginParam) -> Result<()> {
    e2ee::ensure_secret_key_exists(ctx).await?;
    info!(ctx, "key generation completed");

-    ctx.set_config_bool(Config::FetchedExistingMsgs, false)
+    ctx.set_config_internal(Config::FetchedExistingMsgs, config::from_bool(false))
        .await?;
    ctx.scheduler.interrupt_inbox().await;

--- a/src/configure/server_params.rs
+++ b/src/configure/server_params.rs
@@ -137,20 +137,11 @@ impl ServerParams {
    }

    fn expand_strict_tls(self) -> Vec<ServerParams> {
-        if self.strict_tls.is_none() {
-            vec![
-                Self {
-                    strict_tls: Some(true), // Strict.
-                    ..self.clone()
-                },
-                Self {
-                    strict_tls: None, // Automatic.
-                    ..self
-                },
-            ]
-        } else {
-            vec![self]
-        }
+        vec![Self {
+            // Strict if not set by the user or provider database.
+            strict_tls: Some(self.strict_tls.unwrap_or(true)),
+            ..self
+        }]
    }
 }

@@ -162,31 +153,10 @@ pub(crate) fn expand_param_vector(
    domain: &str,
 ) -> Vec<ServerParams> {
    v.into_iter()
-        .map(|params| {
-            if params.socket == Socket::Plain {
-                ServerParams {
-                    // Avoid expanding plaintext configuration into configuration with and without
-                    // `strict_tls` if `strict_tls` is set to `None` as `strict_tls` is not used for
-                    // plaintext connections. Always setting it to "enabled", just in case.
-                    strict_tls: Some(true),
-                    ..params
-                }
-            } else {
-                params
-            }
-        })
        // The order of expansion is important.
        //
        // Ports are expanded the last, so they are changed the first.  Username is only changed if
        // default value (address with domain) didn't work for all available hosts and ports.
-        //
-        // Strict TLS must be expanded first, so we try all configurations with strict TLS first
-        // and only then try again without strict TLS. Otherwise we may lock to wrong hostname
-        // without strict TLS when another hostname with strict TLS is available.  For example, if
-        // both smtp.example.net and mail.example.net are running an SMTP server, but both use a
-        // certificate that is only valid for mail.example.net, we want to skip smtp.example.net
-        // and use mail.example.net with strict TLS instead of using smtp.example.net without
-        // strict TLS.
        .flat_map(|params| params.expand_strict_tls().into_iter())
        .flat_map(|params| params.expand_usernames(addr).into_iter())
        .flat_map(|params| params.expand_hostnames(domain).into_iter())
@@ -257,22 +227,6 @@ mod tests {
                    username: "foobar".to_string(),
                    strict_tls: Some(true)
                },
-                ServerParams {
-                    protocol: Protocol::Smtp,
-                    hostname: "example.net".to_string(),
-                    port: 123,
-                    socket: Socket::Ssl,
-                    username: "foobar".to_string(),
-                    strict_tls: None,
-                },
-                ServerParams {
-                    protocol: Protocol::Smtp,
-                    hostname: "example.net".to_string(),
-                    port: 123,
-                    socket: Socket::Starttls,
-                    username: "foobar".to_string(),
-                    strict_tls: None
-                }
            ],
        );

@@ -284,7 +238,7 @@ mod tests {
                port: 123,
                socket: Socket::Plain,
                username: "foobar".to_string(),
-                strict_tls: None,
+                strict_tls: Some(true),
            }],
            "foobar@example.net",
            "example.net",
--- a/src/constants.rs
+++ b/src/constants.rs
@@ -206,6 +206,8 @@ pub(crate) const WORSE_AVATAR_SIZE: u32 = 128;
 pub const BALANCED_IMAGE_SIZE: u32 = 1280;
 pub const WORSE_IMAGE_SIZE: u32 = 640;

+// Key for the folder configuration version (see below).
+pub(crate) const DC_FOLDERS_CONFIGURED_KEY: &str = "folders_configured";
 // this value can be increased if the folder configuration is changed and must be redone on next program start
 pub(crate) const DC_FOLDERS_CONFIGURED_VERSION: i32 = 4;

@@ -214,6 +216,9 @@ pub(crate) const DC_FOLDERS_CONFIGURED_VERSION: i32 = 4;
 // `max_smtp_rcpt_to` in the provider db.
 pub(crate) const DEFAULT_MAX_SMTP_RCPT_TO: usize = 50;

+/// How far the last quota check needs to be in the past to be checked by the background function (in seconds).
+pub(crate) const DC_BACKGROUND_FETCH_QUOTA_CHECK_RATELIMIT: u64 = 12 * 60 * 60; // 12 hours
+
 #[cfg(test)]
 mod tests {
    use num_traits::FromPrimitive;
--- a/src/contact.rs
+++ b/src/contact.rs
@@ -6,7 +6,7 @@ use std::convert::{TryFrom, TryInto};
 use std::fmt;
 use std::ops::Deref;
 use std::path::{Path, PathBuf};
-use std::time::{SystemTime, UNIX_EPOCH};
+use std::time::UNIX_EPOCH;

 use anyhow::{bail, ensure, Context as _, Result};
 use async_channel::{self as channel, Receiver, Sender};
@@ -26,16 +26,17 @@ use crate::constants::{Blocked, Chattype, DC_GCL_ADD_SELF, DC_GCL_VERIFIED_ONLY}
 use crate::context::Context;
 use crate::events::EventType;
 use crate::key::{load_self_public_key, DcKey};
+use crate::log::LogExt;
 use crate::login_param::LoginParam;
 use crate::message::MessageState;
 use crate::mimeparser::AvatarAction;
 use crate::param::{Param, Params};
 use crate::peerstate::Peerstate;
 use crate::sql::{self, params_iter};
-use crate::sync::{self, Sync::*, SyncData};
+use crate::sync::{self, Sync::*};
 use crate::tools::{
    duration_to_str, get_abs_path, improve_single_line_input, strip_rtlo_characters, time,
-    EmailAddress,
+    EmailAddress, SystemTime,
 };
 use crate::{chat, stock_str};

@@ -476,6 +477,15 @@ impl Contact {
    ///
    /// May result in a `#DC_EVENT_CONTACTS_CHANGED` event.
    pub async fn create(context: &Context, name: &str, addr: &str) -> Result<ContactId> {
+        Self::create_ex(context, Sync, name, addr).await
+    }
+
+    pub(crate) async fn create_ex(
+        context: &Context,
+        sync: sync::Sync,
+        name: &str,
+        addr: &str,
+    ) -> Result<ContactId> {
        let name = improve_single_line_input(name);

        let (name, addr) = sanitize_name_and_addr(&name, addr);
@@ -496,6 +506,16 @@ impl Contact {
            set_blocked(context, Nosync, contact_id, false).await?;
        }

+        if sync.into() {
+            chat::sync(
+                context,
+                chat::SyncId::ContactAddr(addr.to_string()),
+                chat::SyncAction::Rename(name.to_string()),
+            )
+            .await
+            .log_err(context)
+            .ok();
+        }
        Ok(contact_id)
    }

@@ -1497,13 +1517,14 @@ WHERE type=? AND id IN (
                true => chat::SyncAction::Block,
                false => chat::SyncAction::Unblock,
            };
-            context
-                .add_sync_item(SyncData::AlterChat {
-                    id: chat::SyncId::ContactAddr(contact.addr.clone()),
-                    action,
-                })
-                .await?;
-            context.send_sync_msg().await?;
+            chat::sync(
+                context,
+                chat::SyncId::ContactAddr(contact.addr.clone()),
+                action,
+            )
+            .await
+            .log_err(context)
+            .ok();
        }
    }

@@ -1516,7 +1537,7 @@ WHERE type=? AND id IN (
 /// as profile images can be set only by receiving messages, this should be always the case, however.
 ///
 /// For contact SELF, the image is not saved in the contact-database but as Config::Selfavatar;
-/// this typically happens if we see message with our own profile image, sent from another device.
+/// this typically happens if we see message with our own profile image.
 pub(crate) async fn set_profile_image(
    context: &Context,
    contact_id: ContactId,
@@ -1529,7 +1550,7 @@ pub(crate) async fn set_profile_image(
            if contact_id == ContactId::SELF {
                if was_encrypted {
                    context
-                        .set_config(Config::Selfavatar, Some(profile_image))
+                        .set_config_ex(Nosync, Config::Selfavatar, Some(profile_image))
                        .await?;
                } else {
                    info!(context, "Do not use unencrypted selfavatar.");
@@ -1542,7 +1563,9 @@ pub(crate) async fn set_profile_image(
        AvatarAction::Delete => {
            if contact_id == ContactId::SELF {
                if was_encrypted {
-                    context.set_config(Config::Selfavatar, None).await?;
+                    context
+                        .set_config_ex(Nosync, Config::Selfavatar, None)
+                        .await?;
                } else {
                    info!(context, "Do not use unencrypted selfavatar deletion.");
                }
@@ -1574,7 +1597,7 @@ pub(crate) async fn set_status(
    if contact_id == ContactId::SELF {
        if encrypted && has_chat_version {
            context
-                .set_config(Config::Selfstatus, Some(&status))
+                .set_config_ex(Nosync, Config::Selfstatus, Some(&status))
                .await?;
        }
    } else {
@@ -1709,6 +1732,12 @@ impl RecentlySeenLoop {
    async fn run(context: Context, interrupt: Receiver<RecentlySeenInterrupt>) {
        type MyHeapElem = (Reverse<i64>, ContactId);

+        let now = SystemTime::now();
+        let now_ts = now
+            .duration_since(SystemTime::UNIX_EPOCH)
+            .unwrap_or_default()
+            .as_secs() as i64;
+
        // Priority contains all recently seen sorted by the timestamp
        // when they become not recently seen.
        //
@@ -1719,7 +1748,7 @@ impl RecentlySeenLoop {
            .query_map(
                "SELECT id, last_seen FROM contacts
                 WHERE last_seen > ?",
-                (time() - SEEN_RECENTLY_SECONDS,),
+                (now_ts - SEEN_RECENTLY_SECONDS,),
                |row| {
                    let contact_id: ContactId = row.get("id")?;
                    let last_seen: i64 = row.get("last_seen")?;
@@ -1734,8 +1763,6 @@ impl RecentlySeenLoop {
            .unwrap_or_default();

        loop {
-            let now = SystemTime::now();
-
            let (until, contact_id) =
                if let Some((Reverse(timestamp), contact_id)) = unseen_queue.peek() {
                    (
@@ -1902,12 +1929,12 @@ mod tests {
        // Search by name.
        let contacts = Contact::get_all(&context.ctx, 0, Some("bob")).await?;
        assert_eq!(contacts.len(), 1);
-        assert_eq!(contacts.get(0), Some(&id));
+        assert_eq!(contacts.first(), Some(&id));

        // Search by address.
        let contacts = Contact::get_all(&context.ctx, 0, Some("user")).await?;
        assert_eq!(contacts.len(), 1);
-        assert_eq!(contacts.get(0), Some(&id));
+        assert_eq!(contacts.first(), Some(&id));

        let contacts = Contact::get_all(&context.ctx, 0, Some("alice")).await?;
        assert_eq!(contacts.len(), 0);
@@ -1934,7 +1961,7 @@ mod tests {
        // Search by display name (same as manually set name).
        let contacts = Contact::get_all(&context.ctx, 0, Some("someone")).await?;
        assert_eq!(contacts.len(), 1);
-        assert_eq!(contacts.get(0), Some(&id));
+        assert_eq!(contacts.first(), Some(&id));

        Ok(())
    }
@@ -2806,4 +2833,33 @@ Hi."#;

        Ok(())
    }
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn test_sync_create() -> Result<()> {
+        let alice0 = &TestContext::new_alice().await;
+        let alice1 = &TestContext::new_alice().await;
+        for a in [alice0, alice1] {
+            a.set_config_bool(Config::SyncMsgs, true).await?;
+        }
+
+        Contact::create(alice0, "Bob", "bob@example.net").await?;
+        test_utils::sync(alice0, alice1).await;
+        let a1b_contact_id =
+            Contact::lookup_id_by_addr(alice1, "bob@example.net", Origin::ManuallyCreated)
+                .await?
+                .unwrap();
+        let a1b_contact = Contact::get_by_id(alice1, a1b_contact_id).await?;
+        assert_eq!(a1b_contact.name, "Bob");
+
+        Contact::create(alice0, "Bob Renamed", "bob@example.net").await?;
+        test_utils::sync(alice0, alice1).await;
+        let id = Contact::lookup_id_by_addr(alice1, "bob@example.net", Origin::ManuallyCreated)
+            .await?
+            .unwrap();
+        assert_eq!(id, a1b_contact_id);
+        let a1b_contact = Contact::get_by_id(alice1, a1b_contact_id).await?;
+        assert_eq!(a1b_contact.name, "Bob Renamed");
+
+        Ok(())
+    }
 }
--- a/src/context.rs
+++ b/src/context.rs
@@ -6,28 +6,34 @@ use std::ops::Deref;
 use std::path::{Path, PathBuf};
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
-use std::time::{Duration, Instant, SystemTime};
+use std::time::Duration;

 use anyhow::{bail, ensure, Context as _, Result};
 use async_channel::{self as channel, Receiver, Sender};
+use pgp::SignedPublicKey;
 use ratelimit::Ratelimit;
 use tokio::sync::{Mutex, Notify, RwLock};

-use crate::chat::{get_chat_cnt, ChatId};
+use crate::aheader::EncryptPreference;
+use crate::chat::{get_chat_cnt, ChatId, ProtectionStatus};
 use crate::config::Config;
-use crate::constants::DC_VERSION_STR;
+use crate::constants::{
+    self, DC_BACKGROUND_FETCH_QUOTA_CHECK_RATELIMIT, DC_CHAT_ID_TRASH, DC_VERSION_STR,
+};
 use crate::contact::Contact;
 use crate::debug_logging::DebugLogging;
 use crate::events::{Event, EventEmitter, EventType, Events};
-use crate::key::{load_self_public_key, DcKey as _};
+use crate::imap::{FolderMeaning, Imap, ServerMetadata};
+use crate::key::{load_self_public_key, load_self_secret_key, DcKey as _};
 use crate::login_param::LoginParam;
-use crate::message::{self, MessageState, MsgId};
+use crate::message::{self, Message, MessageState, MsgId, Viewtype};
+use crate::peerstate::Peerstate;
 use crate::quota::QuotaInfo;
-use crate::scheduler::SchedulerState;
+use crate::scheduler::{convert_folder_meaning, SchedulerState};
 use crate::sql::Sql;
 use crate::stock_str::StockStrings;
 use crate::timesmearing::SmearedTimestamp;
-use crate::tools::{duration_to_str, time};
+use crate::tools::{self, create_id, duration_to_str, time, time_elapsed};

 /// Builder for the [`Context`].
 ///
@@ -224,7 +230,10 @@ pub struct InnerContext {
    /// <https://datatracker.ietf.org/doc/html/rfc2971>
    pub(crate) server_id: RwLock<Option<HashMap<String, String>>>,

-    pub(crate) last_full_folder_scan: Mutex<Option<Instant>>,
+    /// IMAP METADATA.
+    pub(crate) metadata: RwLock<Option<ServerMetadata>>,
+
+    pub(crate) last_full_folder_scan: Mutex<Option<tools::Time>>,

    /// ID for this `Context` in the current process.
    ///
@@ -232,7 +241,7 @@ pub struct InnerContext {
    /// be identified by this ID.
    pub(crate) id: u32,

-    creation_time: SystemTime,
+    creation_time: tools::Time,

    /// The text of the last error logged and emitted as an event.
    /// If the ui wants to display an error after a failure,
@@ -253,7 +262,7 @@ enum RunningState {
    Running { cancel_sender: Sender<()> },

    /// Cancel signal has been sent, waiting for ongoing process to be freed.
-    ShallStop { request: Instant },
+    ShallStop { request: tools::Time },

    /// There is no ongoing process, a new one can be allocated.
    Stopped,
@@ -384,7 +393,8 @@ impl Context {
            resync_request: AtomicBool::new(false),
            new_msgs_notify,
            server_id: RwLock::new(None),
-            creation_time: std::time::SystemTime::now(),
+            metadata: RwLock::new(None),
+            creation_time: tools::Time::now(),
            last_full_folder_scan: Mutex::new(None),
            last_error: std::sync::RwLock::new("".to_string()),
            debug_logging: std::sync::RwLock::new(None),
@@ -398,7 +408,7 @@ impl Context {
    }

    /// Starts the IO scheduler.
-    pub async fn start_io(&mut self) {
+    pub async fn start_io(&self) {
        if !self.is_configured().await.unwrap_or_default() {
            warn!(self, "can not start io on a context that is not configured");
            return;
@@ -436,6 +446,60 @@ impl Context {
        self.scheduler.maybe_network().await;
    }

+    /// Does a background fetch
+    /// pauses the scheduler and does one imap fetch, then unpauses and returns
+    pub async fn background_fetch(&self) -> Result<()> {
+        if !(self.is_configured().await?) {
+            return Ok(());
+        }
+
+        let address = self.get_primary_self_addr().await?;
+        let time_start = tools::Time::now();
+        info!(self, "background_fetch started fetching {address}");
+
+        let _pause_guard = self.scheduler.pause(self.clone()).await?;
+
+        // connection
+        let mut connection = Imap::new_configured(self, channel::bounded(1).1).await?;
+        connection.prepare(self).await?;
+
+        // fetch imap folders
+        for folder_meaning in [FolderMeaning::Inbox, FolderMeaning::Mvbox] {
+            let (_, watch_folder) = convert_folder_meaning(self, folder_meaning).await?;
+            connection
+                .fetch_move_delete(self, &watch_folder, folder_meaning)
+                .await?;
+        }
+
+        // update quota (to send warning if full) - but only check it once in a while
+        let quota_needs_update = {
+            let quota = self.quota.read().await;
+            quota
+                .as_ref()
+                .filter(|quota| {
+                    time_elapsed(&quota.modified)
+                        > Duration::from_secs(DC_BACKGROUND_FETCH_QUOTA_CHECK_RATELIMIT)
+                })
+                .is_none()
+        };
+
+        if quota_needs_update {
+            if let Some(session) = connection.session.as_mut() {
+                if let Err(err) = self.update_recent_quota(session).await {
+                    warn!(self, "Failed to update quota: {err:#}.");
+                }
+            }
+        }
+
+        info!(
+            self,
+            "background_fetch done for {address} took {:?}",
+            time_elapsed(&time_start),
+        );
+
+        Ok(())
+    }
+
    pub(crate) async fn schedule_resync(&self) -> Result<()> {
        self.resync_request.store(true, Ordering::Relaxed);
        self.scheduler.interrupt_inbox().await;
@@ -532,7 +596,7 @@ impl Context {
    pub(crate) async fn free_ongoing(&self) {
        let mut s = self.running_state.write().await;
        if let RunningState::ShallStop { request } = *s {
-            info!(self, "Ongoing stopped in {:?}", request.elapsed());
+            info!(self, "Ongoing stopped in {:?}", time_elapsed(&request));
        }
        *s = RunningState::Stopped;
    }
@@ -547,7 +611,7 @@ impl Context {
                }
                info!(self, "Signaling the ongoing process to stop ASAP.",);
                *s = RunningState::ShallStop {
-                    request: Instant::now(),
+                    request: tools::Time::now(),
                };
            }
            RunningState::ShallStop { .. } | RunningState::Stopped => {
@@ -613,7 +677,7 @@ impl Context {
        let only_fetch_mvbox = self.get_config_int(Config::OnlyFetchMvbox).await?;
        let folders_configured = self
            .sql
-            .get_raw_config_int("folders_configured")
+            .get_raw_config_int(constants::DC_FOLDERS_CONFIGURED_KEY)
            .await?
            .unwrap_or_default();

@@ -653,7 +717,7 @@ impl Context {
        );
        res.insert("journal_mode", journal_mode);
        res.insert("blobdir", self.get_blobdir().display().to_string());
-        res.insert("display_name", displayname.unwrap_or_else(|| unset.into()));
+        res.insert("displayname", displayname.unwrap_or_else(|| unset.into()));
        res.insert(
            "selfavatar",
            self.get_config(Config::Selfavatar)
@@ -669,6 +733,16 @@ impl Context {
            res.insert("imap_server_id", format!("{server_id:?}"));
        }

+        if let Some(metadata) = &*self.metadata.read().await {
+            if let Some(comment) = &metadata.comment {
+                res.insert("imap_server_comment", format!("{comment:?}"));
+            }
+
+            if let Some(admin) = &metadata.admin {
+                res.insert("imap_server_admin", format!("{admin:?}"));
+            }
+        }
+
        res.insert("secondary_addrs", secondary_addrs);
        res.insert(
            "fetch_existing_msgs",
@@ -695,7 +769,10 @@ impl Context {
        res.insert("sentbox_watch", sentbox_watch.to_string());
        res.insert("mvbox_move", mvbox_move.to_string());
        res.insert("only_fetch_mvbox", only_fetch_mvbox.to_string());
-        res.insert("folders_configured", folders_configured.to_string());
+        res.insert(
+            constants::DC_FOLDERS_CONFIGURED_KEY,
+            folders_configured.to_string(),
+        );
        res.insert("configured_inbox_folder", configured_inbox_folder);
        res.insert("configured_sentbox_folder", configured_sentbox_folder);
        res.insert("configured_mvbox_folder", configured_mvbox_folder);
@@ -746,6 +823,12 @@ impl Context {
                .await?
                .to_string(),
        );
+        res.insert(
+            "last_cant_decrypt_outgoing_msgs",
+            self.get_config_int(Config::LastCantDecryptOutgoingMsgs)
+                .await?
+                .to_string(),
+        );
        res.insert(
            "scan_all_folders_debounce_secs",
            self.get_config_int(Config::ScanAllFoldersDebounceSecs)
@@ -789,12 +872,97 @@ impl Context {
                .to_string(),
        );

-        let elapsed = self.creation_time.elapsed();
-        res.insert("uptime", duration_to_str(elapsed.unwrap_or_default()));
+        let elapsed = time_elapsed(&self.creation_time);
+        res.insert("uptime", duration_to_str(elapsed));

        Ok(res)
    }

+    async fn get_self_report(&self) -> Result<String> {
+        let mut res = String::new();
+        res += &format!("core_version {}\n", get_version_str());
+
+        let num_msgs: u32 = self
+            .sql
+            .query_get_value(
+                "SELECT COUNT(*) FROM msgs WHERE hidden=0 AND chat_id!=?",
+                (DC_CHAT_ID_TRASH,),
+            )
+            .await?
+            .unwrap_or_default();
+        res += &format!("num_msgs {}\n", num_msgs);
+
+        let num_chats: u32 = self
+            .sql
+            .query_get_value("SELECT COUNT(*) FROM chats WHERE id>9 AND blocked!=1", ())
+            .await?
+            .unwrap_or_default();
+        res += &format!("num_chats {}\n", num_chats);
+
+        let db_size = tokio::fs::metadata(&self.sql.dbfile).await?.len();
+        res += &format!("db_size_bytes {}\n", db_size);
+
+        let secret_key = &load_self_secret_key(self).await?.primary_key;
+        let key_created = secret_key.created_at().timestamp();
+        res += &format!("key_created {}\n", key_created);
+
+        let self_reporting_id = match self.get_config(Config::SelfReportingId).await? {
+            Some(id) => id,
+            None => {
+                let id = create_id();
+                self.set_config(Config::SelfReportingId, Some(&id)).await?;
+                id
+            }
+        };
+        res += &format!("self_reporting_id {}", self_reporting_id);
+
+        Ok(res)
+    }
+
+    /// Drafts a message with statistics about the usage of Delta Chat.
+    /// The user can inspect the message if they want, and then hit "Send".
+    ///
+    /// On the other end, a bot will receive the message and make it available
+    /// to Delta Chat's developers.
+    pub async fn draft_self_report(&self) -> Result<ChatId> {
+        const SELF_REPORTING_BOT: &str = "self_reporting@testrun.org";
+
+        let contact_id = Contact::create(self, "Statistics bot", SELF_REPORTING_BOT).await?;
+        let chat_id = ChatId::create_for_contact(self, contact_id).await?;
+
+        // We're including the bot's public key in Delta Chat
+        // so that the first message to the bot can directly be encrypted:
+        let public_key = SignedPublicKey::from_base64(
+            "xjMEZbfBlBYJKwYBBAHaRw8BAQdABpLWS2PUIGGo4pslVt4R8sylP5wZihmhf1DTDr3oCM\
+	        PNHDxzZWxmX3JlcG9ydGluZ0B0ZXN0cnVuLm9yZz7CiwQQFggAMwIZAQUCZbfBlAIbAwQLCQgHBhUI\
+	        CQoLAgMWAgEWIQTS2i16sHeYTckGn284K3M5Z4oohAAKCRA4K3M5Z4oohD8dAQCQV7CoH6UP4PD+Nq\
+	        I4kW5tbbqdh2AnDROg60qotmLExAEAxDfd3QHAK9f8b9qQUbLmHIztCLxhEuVbWPBEYeVW0gvOOARl\
+	        t8GUEgorBgEEAZdVAQUBAQdAMBUhYoAAcI625vGZqnM5maPX4sGJ7qvJxPAFILPy6AcDAQgHwngEGB\
+	        YIACAFAmW3wZQCGwwWIQTS2i16sHeYTckGn284K3M5Z4oohAAKCRA4K3M5Z4oohPwCAQCvzk1ObIkj\
+	        2GqsuIfaULlgdnfdZY8LNary425CEfHZDQD5AblXVrlMO1frdlc/Vo9z3pEeCrfYdD7ITD3/OeVoiQ\
+	        4=",
+        )?;
+        let mut peerstate = Peerstate::from_public_key(
+            SELF_REPORTING_BOT,
+            0,
+            EncryptPreference::Mutual,
+            &public_key,
+        );
+        let fingerprint = public_key.fingerprint();
+        peerstate.set_verified(public_key, fingerprint, "".to_string())?;
+        peerstate.save_to_db(&self.sql).await?;
+        chat_id
+            .set_protection(self, ProtectionStatus::Protected, time(), Some(contact_id))
+            .await?;
+
+        let mut msg = Message::new(Viewtype::Text);
+        msg.text = self.get_self_report().await?;
+
+        chat_id.set_draft(self, Some(&mut msg)).await?;
+
+        Ok(chat_id)
+    }
+
    /// Get a list of fresh, unmuted messages in unblocked chats.
    ///
    /// The list starts with the most recent message
@@ -1065,9 +1233,10 @@ mod tests {
    use crate::constants::Chattype;
    use crate::contact::ContactId;
    use crate::message::{Message, Viewtype};
+    use crate::mimeparser::SystemMessage;
    use crate::receive_imf::receive_imf;
-    use crate::test_utils::TestContext;
-    use crate::tools::create_outgoing_rfc724_mid;
+    use crate::test_utils::{get_chat_msg, TestContext};
+    use crate::tools::{create_outgoing_rfc724_mid, SystemTime};

    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
    async fn test_wrong_db() -> Result<()> {
@@ -1305,6 +1474,7 @@ mod tests {
            "mail_security",
            "notify_about_wrong_pw",
            "save_mime_headers",
+            "self_reporting_id",
            "selfstatus",
            "send_server",
            "send_user",
@@ -1370,7 +1540,7 @@ mod tests {
        assert_eq!(res.len(), 2);

        // Message added later is returned first.
-        assert_eq!(res.get(0), Some(&msg2.id));
+        assert_eq!(res.first(), Some(&msg2.id));
        assert_eq!(res.get(1), Some(&msg1.id));

        // Global search with longer text does not find any message.
@@ -1587,7 +1757,7 @@ mod tests {

        let bob_next_msg_ids = bob.get_next_msgs().await?;
        assert_eq!(bob_next_msg_ids.len(), 1);
-        assert_eq!(bob_next_msg_ids.get(0), Some(&received_msg.id));
+        assert_eq!(bob_next_msg_ids.first(), Some(&received_msg.id));

        bob.set_config_u32(Config::LastMsgId, received_msg.id.to_u32())
            .await?;
@@ -1596,7 +1766,7 @@ mod tests {
        // Next messages include self-sent messages.
        let alice_next_msg_ids = alice.get_next_msgs().await?;
        assert_eq!(alice_next_msg_ids.len(), 1);
-        assert_eq!(alice_next_msg_ids.get(0), Some(&sent_msg.sender_msg_id));
+        assert_eq!(alice_next_msg_ids.first(), Some(&sent_msg.sender_msg_id));

        alice
            .set_config_u32(Config::LastMsgId, sent_msg.sender_msg_id.to_u32())
@@ -1605,4 +1775,24 @@ mod tests {

        Ok(())
    }
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn test_draft_self_report() -> Result<()> {
+        let alice = TestContext::new_alice().await;
+
+        let chat_id = alice.draft_self_report().await?;
+        let msg = get_chat_msg(&alice, chat_id, 0, 1).await;
+        assert_eq!(msg.get_info_type(), SystemMessage::ChatProtectionEnabled);
+
+        let chat = Chat::load_from_db(&alice, chat_id).await?;
+        assert!(chat.is_protected());
+
+        let mut draft = chat_id.get_draft(&alice).await?.unwrap();
+        assert!(draft.text.starts_with("core_version"));
+
+        // Test that sending into the protected chat works:
+        let _sent = alice.send_msg(chat_id, &mut draft).await;
+
+        Ok(())
+    }
 }
--- a/src/dehtml.rs
+++ b/src/dehtml.rs
@@ -181,7 +181,12 @@ fn dehtml_text_cb(event: &BytesText, dehtml: &mut Dehtml) {
    if dehtml.get_add_text() == AddText::YesPreserveLineEnds
        || dehtml.get_add_text() == AddText::YesRemoveLineEnds
    {
-        let last_added = escaper::decode_html_buf_sloppy(event as &[_]).unwrap_or_default();
+        let event = event as &[_];
+        let event_str = std::str::from_utf8(event).unwrap_or_default();
+        let mut last_added = escaper::decode_html_buf_sloppy(event).unwrap_or_default();
+        if event_str.starts_with(&last_added) {
+            last_added = event_str.to_string();
+        }

        if dehtml.get_add_text() == AddText::YesRemoveLineEnds {
            // Replace all line ends with spaces.
@@ -527,6 +532,6 @@ mod tests {
    fn test_spaces() {
        let input = include_str!("../test-data/spaces.html");
        let txt = dehtml(input).unwrap();
-        assert_eq!(txt.text, "Welcome back to Strolling!\n\nHey there,\n\nWelcome back! Use this link to securely sign in to your Strolling account:\n\nSign in to Strolling\n\nFor your security, the link will expire in 24 hours time.\n\nSee you soon!\n\nYou can also copy\n\nhttps://strolling.rosano.ca/members/?token=XXX\n\nIf you did not make this request, you can safely ignore this email.\n\nThis message was sent from [strolling.rosano.ca](https://strolling.rosano.ca/) to [alice@example.org](mailto:alice@example.org)");
+        assert_eq!(txt.text, "Welcome back to Strolling!\n\nHey there,\n\nWelcome back! Use this link to securely sign in to your Strolling account:\n\nSign in to Strolling\n\nFor your security, the link will expire in 24 hours time.\n\nSee you soon!\n\nYou can also copy & paste this URL into your browser:\n\nhttps://strolling.rosano.ca/members/?token=XXX&action=signin&r=https%3A%2F%2Fstrolling.rosano.ca%2F\n\nIf you did not make this request, you can safely ignore this email.\n\nThis message was sent from [strolling.rosano.ca](https://strolling.rosano.ca/) to [alice@example.org](mailto:alice@example.org)");
    }
 }
--- a/src/download.rs
+++ b/src/download.rs
@@ -136,39 +136,36 @@ pub(crate) async fn download_msg(context: &Context, msg_id: MsgId, imap: &mut Im
    let row = context
        .sql
        .query_row_optional(
-            "SELECT uid, folder FROM imap WHERE rfc724_mid=? AND target!=''",
+            "SELECT uid, folder, uidvalidity FROM imap WHERE rfc724_mid=? AND target!=''",
            (&msg.rfc724_mid,),
            |row| {
                let server_uid: u32 = row.get(0)?;
                let server_folder: String = row.get(1)?;
-                Ok((server_uid, server_folder))
+                let uidvalidity: u32 = row.get(2)?;
+                Ok((server_uid, server_folder, uidvalidity))
            },
        )
        .await?;

-    if let Some((server_uid, server_folder)) = row {
-        match imap
-            .fetch_single_msg(context, &server_folder, server_uid, msg.rfc724_mid.clone())
-            .await
-        {
-            ImapActionResult::RetryLater | ImapActionResult::Failed => {
-                msg.id
-                    .update_download_state(context, DownloadState::Failure)
-                    .await?;
-                Err(anyhow!("Call download_full() again to try over."))
-            }
-            ImapActionResult::Success => {
-                // update_download_state() not needed as receive_imf() already
-                // set the state and emitted the event.
-                Ok(())
-            }
-        }
-    } else {
+    let Some((server_uid, server_folder, uidvalidity)) = row else {
        // No IMAP record found, we don't know the UID and folder.
-        msg.id
-            .update_download_state(context, DownloadState::Failure)
-            .await?;
-        Err(anyhow!("Call download_full() again to try over."))
+        return Err(anyhow!("Call download_full() again to try over."));
+    };
+
+    match imap
+        .fetch_single_msg(
+            context,
+            &server_folder,
+            uidvalidity,
+            server_uid,
+            msg.rfc724_mid.clone(),
+        )
+        .await
+    {
+        ImapActionResult::RetryLater | ImapActionResult::Failed => {
+            Err(anyhow!("Call download_full() again to try over."))
+        }
+        ImapActionResult::Success => Ok(()),
    }
 }

@@ -181,6 +178,7 @@ impl Imap {
        &mut self,
        context: &Context,
        folder: &str,
+        uidvalidity: u32,
        uid: u32,
        rfc724_mid: String,
    ) -> ImapActionResult {
@@ -196,8 +194,19 @@ impl Imap {

        let mut uid_message_ids: BTreeMap<u32, String> = BTreeMap::new();
        uid_message_ids.insert(uid, rfc724_mid);
-        let (last_uid, _received) = match self
-            .fetch_many_msgs(context, folder, vec![uid], &uid_message_ids, false, false)
+        let Some(session) = self.session.as_mut() else {
+            return ImapActionResult::Failed;
+        };
+        let (last_uid, _received) = match session
+            .fetch_many_msgs(
+                context,
+                folder,
+                uidvalidity,
+                vec![uid],
+                &uid_message_ids,
+                false,
+                false,
+            )
            .await
        {
            Ok(res) => res,
@@ -257,7 +266,7 @@ mod tests {
    use crate::chat::{get_chat_msgs, send_msg};
    use crate::ephemeral::Timer;
    use crate::message::Viewtype;
-    use crate::receive_imf::receive_imf_inner;
+    use crate::receive_imf::receive_imf_from_inbox;
    use crate::test_utils::TestContext;

    #[test]
@@ -338,7 +347,7 @@ mod tests {
             Date: Sun, 22 Mar 2020 22:37:57 +0000\
             Content-Type: text/plain";

-        receive_imf_inner(
+        receive_imf_from_inbox(
            &t,
            "Mr.12345678901@example.com",
            header.as_bytes(),
@@ -354,7 +363,7 @@ mod tests {
            .get_text()
            .contains(&stock_str::partial_download_msg_body(&t, 100000).await));

-        receive_imf_inner(
+        receive_imf_from_inbox(
            &t,
            "Mr.12345678901@example.com",
            format!("{header}\n\n100k text...").as_bytes(),
@@ -383,7 +392,7 @@ mod tests {
            .await?;

        // download message from bob partially, this must not change the ephemeral timer
-        receive_imf_inner(
+        receive_imf_from_inbox(
            &t,
            "first@example.org",
            b"From: Bob <bob@example.org>\n\
@@ -426,7 +435,7 @@ mod tests {
        let sent2_rfc724_mid = sent2.load_from_db().await.rfc724_mid;

        // not downloading the status update results in an placeholder
-        receive_imf_inner(
+        receive_imf_from_inbox(
            &bob,
            &sent2_rfc724_mid,
            sent2.payload().as_bytes(),
@@ -442,7 +451,7 @@ mod tests {

        // downloading the status update afterwards expands to nothing and moves the placeholder to trash-chat
        // (usually status updates are too small for not being downloaded directly)
-        receive_imf_inner(
+        receive_imf_from_inbox(
            &bob,
            &sent2_rfc724_mid,
            sent2.payload().as_bytes(),
@@ -493,7 +502,7 @@ mod tests {
            ";

        // not downloading the mdn results in an placeholder
-        receive_imf_inner(
+        receive_imf_from_inbox(
            &bob,
            "bar@example.org",
            raw,
@@ -509,7 +518,7 @@ mod tests {

        // downloading the mdn afterwards expands to nothing and deletes the placeholder directly
        // (usually mdn are too small for not being downloaded directly)
-        receive_imf_inner(&bob, "bar@example.org", raw, false, None, false).await?;
+        receive_imf_from_inbox(&bob, "bar@example.org", raw, false, None, false).await?;
        assert_eq!(get_chat_msgs(&bob, chat_id).await?.len(), 0);
        assert!(Message::load_from_db(&bob, msg.id)
            .await?
--- a/src/e2ee.rs
+++ b/src/e2ee.rs
@@ -52,7 +52,7 @@ impl EncryptHelper {
        &self,
        context: &Context,
        e2ee_guaranteed: bool,
-        peerstates: &[(Option<Peerstate>, &str)],
+        peerstates: &[(Option<Peerstate>, String)],
    ) -> Result<bool> {
        let mut prefer_encrypt_count = if self.prefer_encrypt == EncryptPreference::Mutual {
            1
@@ -94,7 +94,7 @@ impl EncryptHelper {
        context: &Context,
        verified: bool,
        mail_to_encrypt: lettre_email::PartBuilder,
-        peerstates: Vec<(Option<Peerstate>, &str)>,
+        peerstates: Vec<(Option<Peerstate>, String)>,
    ) -> Result<String> {
        let mut keyring: Vec<SignedPublicKey> = Vec::new();

@@ -117,7 +117,7 @@ impl EncryptHelper {
        // Encrypt to secondary verified keys
        // if we also encrypt to the introducer ("verifier") of the key.
        if verified {
-            for (peerstate, _addr) in peerstates {
+            for (peerstate, _addr) in &peerstates {
                if let Some(peerstate) = peerstate {
                    if let (Some(key), Some(verifier)) = (
                        peerstate.secondary_verified_key.as_ref(),
@@ -293,7 +293,7 @@ Sent with my Delta Chat Messenger: https://delta.chat";
        Ok(())
    }

-    fn new_peerstates(prefer_encrypt: EncryptPreference) -> Vec<(Option<Peerstate>, &'static str)> {
+    fn new_peerstates(prefer_encrypt: EncryptPreference) -> Vec<(Option<Peerstate>, String)> {
        let addr = "bob@foo.bar";
        let pub_key = bob_keypair().public;
        let peerstate = Peerstate {
@@ -315,7 +315,7 @@ Sent with my Delta Chat Messenger: https://delta.chat";
            backward_verified_key_id: None,
            fingerprint_changed: false,
        };
-        vec![(Some(peerstate), addr)]
+        vec![(Some(peerstate), addr.to_string())]
    }

    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
@@ -340,7 +340,7 @@ Sent with my Delta Chat Messenger: https://delta.chat";
        assert!(encrypt_helper.should_encrypt(&t, false, &ps).unwrap());

        // test with missing peerstate
-        let ps = vec![(None, "bob@foo.bar")];
+        let ps = vec![(None, "bob@foo.bar".to_string())];
        assert!(encrypt_helper.should_encrypt(&t, true, &ps).is_err());
        assert!(!encrypt_helper.should_encrypt(&t, false, &ps).unwrap());
    }
--- a/src/ephemeral.rs
+++ b/src/ephemeral.rs
@@ -67,7 +67,7 @@ use std::collections::BTreeSet;
 use std::convert::{TryFrom, TryInto};
 use std::num::ParseIntError;
 use std::str::FromStr;
-use std::time::{Duration, SystemTime, UNIX_EPOCH};
+use std::time::{Duration, UNIX_EPOCH};

 use anyhow::{ensure, Result};
 use async_channel::Receiver;
@@ -85,7 +85,7 @@ use crate::message::{Message, MessageState, MsgId, Viewtype};
 use crate::mimeparser::SystemMessage;
 use crate::sql::{self, params_iter};
 use crate::stock_str;
-use crate::tools::{duration_to_str, time};
+use crate::tools::{duration_to_str, time, SystemTime};

 /// Ephemeral timer value.
 #[derive(Debug, PartialEq, Eq, Copy, Clone, Serialize, Deserialize)]
@@ -590,7 +590,11 @@ pub(crate) async fn delete_expired_imap_messages(context: &Context) -> Result<()
        match context.get_config_delete_server_after().await? {
            None => (0, 0),
            Some(delete_server_after) => (
-                now - delete_server_after,
+                match delete_server_after {
+                    // Guarantee immediate deletion.
+                    0 => i64::MAX,
+                    _ => now - delete_server_after,
+                },
                now - max(delete_server_after, MIN_DELETE_SERVER_AFTER),
            ),
        };
@@ -1127,6 +1131,7 @@ mod tests {
            (1030, now - 19 * HOUR, 0),
            (2000, now - 18 * HOUR, now - HOUR),
            (2020, now - 17 * HOUR, now + HOUR),
+            (3000, now + HOUR, 0),
        ] {
            let message_id = id.to_string();
            t.sql
@@ -1212,6 +1217,10 @@ mod tests {
            0
        );

+        t.set_config(Config::DeleteServerAfter, Some("1")).await?;
+        delete_expired_imap_messages(&t).await?;
+        test_marked_for_deletion(&t, 3000).await?;
+
        Ok(())
    }

--- a/src/events/payload.rs
+++ b/src/events/payload.rs
@@ -4,6 +4,7 @@ use serde::{Deserialize, Serialize};
 use std::path::PathBuf;

 use crate::chat::ChatId;
+use crate::config::Config;
 use crate::contact::ContactId;
 use crate::ephemeral::Timer as EphemeralTimer;
 use crate::message::MsgId;
@@ -261,8 +262,17 @@ pub enum EventType {
    ConnectivityChanged,

    /// The user's avatar changed.
+    /// Deprecated by `ConfigSynced`.
    SelfavatarChanged,

+    /// A multi-device synced config value changed. Maybe the app needs to refresh smth. For
+    /// uniformity this is emitted on the source device too. The value isn't here, otherwise it
+    /// would be logged which might not be good for privacy.
+    ConfigSynced {
+        /// Configuration key.
+        key: Config,
+    },
+
    /// Webxdc status update received.
    WebxdcStatusUpdate {
        /// Message ID.
@@ -277,4 +287,11 @@ pub enum EventType {
        /// ID of the deleted message.
        msg_id: MsgId,
    },
+
+    /// Tells that the Background fetch was completed (or timed out).
+    /// This event acts as a marker, when you reach this event you can be sure
+    /// that all events emitted during the background fetch were processed.
+    ///
+    /// This event is only emitted by the account manager
+    AccountsBackgroundFetchDone,
 }
--- a/src/headerdef.rs
+++ b/src/headerdef.rs
@@ -2,7 +2,7 @@

 use mailparse::{MailHeader, MailHeaderMap};

-#[derive(Debug, Display, Clone, PartialEq, Eq, EnumVariantNames, IntoStaticStr)]
+#[derive(Debug, Display, Clone, PartialEq, Eq, IntoStaticStr)]
 #[strum(serialize_all = "kebab_case")]
 #[allow(missing_docs)]
 pub enum HeaderDef {
--- a/src/imap.rs
+++ b/src/imap.rs
@@ -4,7 +4,6 @@
 //! to implement connect, fetch, delete functionality with standard IMAP servers.

 use std::{
-    cmp,
    cmp::max,
    collections::{BTreeMap, BTreeSet, HashMap},
    iter::Peekable,
@@ -15,16 +14,15 @@ use std::{
 use anyhow::{bail, format_err, Context as _, Result};
 use async_channel::Receiver;
 use async_imap::types::{Fetch, Flag, Name, NameAttribute, UnsolicitedResponse};
-use futures::{StreamExt, TryStreamExt};
+use futures::{FutureExt as _, StreamExt, TryStreamExt};
+use futures_lite::FutureExt;
 use num_traits::FromPrimitive;
 use ratelimit::Ratelimit;
 use tokio::sync::RwLock;

 use crate::chat::{self, ChatId, ChatIdBlocked};
 use crate::config::Config;
-use crate::constants::{
-    Blocked, Chattype, ShowEmails, DC_FETCH_EXISTING_MSGS_COUNT, DC_FOLDERS_CONFIGURED_VERSION,
-};
+use crate::constants::{self, Blocked, Chattype, ShowEmails};
 use crate::contact::{normalize_name, Contact, ContactAddress, ContactId, Modifier, Origin};
 use crate::context::Context;
 use crate::events::EventType;
@@ -54,8 +52,6 @@ use client::Client;
 use mailparse::SingleInfo;
 use session::Session;

-use self::select_folder::NewlySelected;
-
 pub(crate) const GENERATED_PREFIX: &str = "GEN_";

 #[derive(Debug, Display, Clone, Copy, PartialEq, Eq)]
@@ -65,20 +61,6 @@ pub enum ImapActionResult {
    Success,
 }

-/// Prefetch:
-/// - Message-ID to check if we already have the message.
-/// - In-Reply-To and References to check if message is a reply to chat message.
-/// - Chat-Version to check if a message is a chat message
-/// - Autocrypt-Setup-Message to check if a message is an autocrypt setup message,
-///   not necessarily sent by Delta Chat.
-const PREFETCH_FLAGS: &str = "(UID INTERNALDATE RFC822.SIZE BODY.PEEK[HEADER.FIELDS (\
-                              MESSAGE-ID \
-                              X-MICROSOFT-ORIGINAL-MESSAGE-ID \
-                              FROM \
-                              IN-REPLY-TO REFERENCES \
-                              CHAT-VERSION \
-                              AUTOCRYPT-SETUP-MESSAGE\
-                              )])";
 const RFC724MID_UID: &str = "(UID BODY.PEEK[HEADER.FIELDS (\
                             MESSAGE-ID \
                             X-MICROSOFT-ORIGINAL-MESSAGE-ID\
@@ -95,16 +77,11 @@ pub struct Imap {

    pub(crate) connectivity: ConnectivityStore,

-    /// Rate limit for IMAP connection usage attempts.
+    /// Rate limit for IMAP connection attempts.
    ///
-    /// Rate limit is checked before connecting
-    /// and updated right before login attempt.
-    /// It does not limit the number of connection attempts
-    /// if the network is bad as only successful connections are counted.
-    ///
-    /// Main purpose of this rate limit is
-    /// to prevent busy loop in case
-    /// connection gets dropped over and over due to IMAP bug,
+    /// This rate limit prevents busy loop
+    /// in case the server refuses connections
+    /// or in case connection gets dropped over and over due to IMAP bug,
    /// e.g. the server returning invalid response to SELECT command
    /// immediately after logging in or returning an error in response to LOGIN command
    /// due to internal server error.
@@ -117,6 +94,17 @@ struct OAuth2 {
    access_token: String,
 }

+#[derive(Debug)]
+pub(crate) struct ServerMetadata {
+    /// IMAP METADATA `/shared/comment` as defined in
+    /// <https://www.rfc-editor.org/rfc/rfc5464#section-6.2.1>.
+    pub comment: Option<String>,
+
+    /// IMAP METADATA `/shared/admin` as defined in
+    /// <https://www.rfc-editor.org/rfc/rfc5464#section-6.2.2>.
+    pub admin: Option<String>,
+}
+
 impl async_imap::Authenticator for OAuth2 {
    type Response = String;

@@ -270,7 +258,7 @@ impl Imap {
            session: None,
            login_failed_once: false,
            connectivity: Default::default(),
-            // 1 login per minute + a burst of 2.
+            // 1 connection per minute + a burst of 2.
            ratelimit: RwLock::new(Ratelimit::new(Duration::new(120, 0), 2.0)),
        };

@@ -319,13 +307,6 @@ impl Imap {
            return Ok(());
        }

-        self.connectivity.set_connecting(context).await;
-
-        // Check rate limit before trying to connect
-        // to avoid connecting and not using the connection
-        // in case we are currently ratelimited.
-        // Otherwise connection may become unusable due to NAT forgetting about it
-        // before we attempt to actually login.
        let ratelimit_duration = self.ratelimit.read().await.until_can_send();
        if !ratelimit_duration.is_zero() {
            warn!(
@@ -333,10 +314,23 @@ impl Imap {
                "IMAP got rate limited, waiting for {} until can connect",
                duration_to_str(ratelimit_duration),
            );
-            tokio::time::sleep(ratelimit_duration).await;
+            let interrupted = async {
+                tokio::time::sleep(ratelimit_duration).await;
+                false
+            }
+            .race(self.idle_interrupt_receiver.recv().map(|_| true))
+            .await;
+            if interrupted {
+                info!(
+                    context,
+                    "Connecting to IMAP without waiting for ratelimit due to interrupt."
+                );
+            }
        }

        info!(context, "Connecting to IMAP server");
+        self.connectivity.set_connecting(context).await;
+        self.ratelimit.write().await.send();
        let connection_res: Result<Client> = if self.config.lp.security == Socket::Starttls
            || self.config.lp.security == Socket::Plain
        {
@@ -387,7 +381,6 @@ impl Imap {
            }
        };
        let client = connection_res?;
-        self.ratelimit.write().await.send();

        let config = &self.config;
        let imap_user: &str = config.lp.user.as_ref();
@@ -439,7 +432,10 @@ impl Imap {
                    && err.to_string().to_lowercase().contains("authentication")
                    && context.get_config_bool(Config::NotifyAboutWrongPw).await?
                {
-                    if let Err(e) = context.set_config(Config::NotifyAboutWrongPw, None).await {
+                    if let Err(e) = context
+                        .set_config_internal(Config::NotifyAboutWrongPw, None)
+                        .await
+                    {
                        warn!(context, "{:#}", e);
                    }
                    drop(lock);
@@ -523,211 +519,6 @@ impl Imap {
        Ok(())
    }

-    /// Synchronizes UIDs in the database with UIDs on the server.
-    ///
-    /// It is assumed that no operations are taking place on the same
-    /// folder at the moment. Make sure to run it in the same
-    /// thread/task as other network operations on this folder to
-    /// avoid race conditions.
-    pub(crate) async fn resync_folder_uids(
-        &mut self,
-        context: &Context,
-        folder: &str,
-        folder_meaning: FolderMeaning,
-    ) -> Result<()> {
-        // Collect pairs of UID and Message-ID.
-        let mut msgs = BTreeMap::new();
-
-        let session = self
-            .session
-            .as_mut()
-            .context("IMAP No connection established")?;
-
-        session.select_folder(context, Some(folder)).await?;
-
-        let mut list = session
-            .uid_fetch("1:*", RFC724MID_UID)
-            .await
-            .with_context(|| format!("can't resync folder {folder}"))?;
-        while let Some(fetch) = list.try_next().await? {
-            let headers = match get_fetch_headers(&fetch) {
-                Ok(headers) => headers,
-                Err(err) => {
-                    warn!(context, "Failed to parse FETCH headers: {}", err);
-                    continue;
-                }
-            };
-            let message_id = prefetch_get_message_id(&headers);
-
-            if let (Some(uid), Some(rfc724_mid)) = (fetch.uid, message_id) {
-                msgs.insert(
-                    uid,
-                    (
-                        rfc724_mid,
-                        target_folder(context, folder, folder_meaning, &headers).await?,
-                    ),
-                );
-            }
-        }
-
-        info!(
-            context,
-            "Resync: collected {} message IDs in folder {}",
-            msgs.len(),
-            folder,
-        );
-
-        let uid_validity = get_uidvalidity(context, folder).await?;
-
-        // Write collected UIDs to SQLite database.
-        context
-            .sql
-            .transaction(move |transaction| {
-                transaction.execute("DELETE FROM imap WHERE folder=?", (folder,))?;
-                for (uid, (rfc724_mid, target)) in &msgs {
-                    // This may detect previously undetected moved
-                    // messages, so we update server_folder too.
-                    transaction.execute(
-                        "INSERT INTO imap (rfc724_mid, folder, uid, uidvalidity, target)
-                         VALUES           (?1,         ?2,     ?3,  ?4,          ?5)
-                         ON CONFLICT(folder, uid, uidvalidity)
-                         DO UPDATE SET rfc724_mid=excluded.rfc724_mid,
-                                       target=excluded.target",
-                        (rfc724_mid, folder, uid, uid_validity, target),
-                    )?;
-                }
-                Ok(())
-            })
-            .await?;
-        Ok(())
-    }
-
-    /// Selects a folder and takes care of UIDVALIDITY changes.
-    ///
-    /// When selecting a folder for the first time, sets the uid_next to the current
-    /// mailbox.uid_next so that no old emails are fetched.
-    ///
-    /// Returns Result<new_emails> (i.e. whether new emails arrived),
-    /// if in doubt, returns new_emails=true so emails are fetched.
-    pub(crate) async fn select_with_uidvalidity(
-        &mut self,
-        context: &Context,
-        folder: &str,
-    ) -> Result<bool> {
-        let session = self.session.as_mut().context("no session")?;
-        let newly_selected = session
-            .select_or_create_folder(context, folder)
-            .await
-            .with_context(|| format!("failed to select or create folder {folder}"))?;
-        let mailbox = session
-            .selected_mailbox
-            .as_mut()
-            .with_context(|| format!("No mailbox selected, folder: {folder}"))?;
-
-        let old_uid_validity = get_uidvalidity(context, folder)
-            .await
-            .with_context(|| format!("failed to get old UID validity for folder {folder}"))?;
-        let old_uid_next = get_uid_next(context, folder)
-            .await
-            .with_context(|| format!("failed to get old UID NEXT for folder {folder}"))?;
-
-        let new_uid_validity = mailbox
-            .uid_validity
-            .with_context(|| format!("No UIDVALIDITY for folder {folder}"))?;
-        let new_uid_next = if let Some(uid_next) = mailbox.uid_next {
-            Some(uid_next)
-        } else {
-            warn!(
-                context,
-                "SELECT response for IMAP folder {folder:?} has no UIDNEXT, fall back to STATUS command."
-            );
-
-            // RFC 3501 says STATUS command SHOULD NOT be used
-            // on the currently selected mailbox because the same
-            // information can be obtained by other means,
-            // such as reading SELECT response.
-            //
-            // However, it also says that UIDNEXT is REQUIRED
-            // in the SELECT response and if we are here,
-            // it is actually not returned.
-            //
-            // In particular, Winmail Pro Mail Server 5.1.0616
-            // never returns UIDNEXT in SELECT response,
-            // but responds to "STATUS INBOX (UIDNEXT)" command.
-            let status = session
-                .inner
-                .status(folder, "(UIDNEXT)")
-                .await
-                .with_context(|| format!("STATUS (UIDNEXT) error for {folder:?}"))?;
-
-            if status.uid_next.is_none() {
-                // This happens with mail.163.com as of 2023-11-26.
-                // It does not return UIDNEXT on SELECT and returns invalid
-                // `* STATUS "INBOX" ()` response on explicit request for UIDNEXT.
-                warn!(context, "STATUS {folder} (UIDNEXT) did not return UIDNEXT.");
-            }
-            status.uid_next
-        };
-        mailbox.uid_next = new_uid_next;
-
-        if new_uid_validity == old_uid_validity {
-            let new_emails = if newly_selected == NewlySelected::No {
-                // The folder was not newly selected i.e. no SELECT command was run. This means that mailbox.uid_next
-                // was not updated and may contain an incorrect value. So, just return true so that
-                // the caller tries to fetch new messages (we could of course run a SELECT command now, but trying to fetch
-                // new messages is only one command, just as a SELECT command)
-                true
-            } else if let Some(new_uid_next) = new_uid_next {
-                if new_uid_next < old_uid_next {
-                    warn!(
-                        context,
-                        "The server illegally decreased the uid_next of folder {folder:?} from {old_uid_next} to {new_uid_next} without changing validity ({new_uid_validity}), resyncing UIDs...",
-                    );
-                    set_uid_next(context, folder, new_uid_next).await?;
-                    context.schedule_resync().await?;
-                }
-                new_uid_next != old_uid_next // If UIDNEXT changed, there are new emails
-            } else {
-                // We have no UIDNEXT and if in doubt, return true.
-                true
-            };
-
-            return Ok(new_emails);
-        }
-
-        // UIDVALIDITY is modified, reset highest seen MODSEQ.
-        set_modseq(context, folder, 0).await?;
-
-        // ==============  uid_validity has changed or is being set the first time.  ==============
-
-        let new_uid_next = new_uid_next.unwrap_or_default();
-        set_uid_next(context, folder, new_uid_next).await?;
-        set_uidvalidity(context, folder, new_uid_validity).await?;
-
-        // Collect garbage entries in `imap` table.
-        context
-            .sql
-            .execute(
-                "DELETE FROM imap WHERE folder=? AND uidvalidity!=?",
-                (&folder, new_uid_validity),
-            )
-            .await?;
-
-        if old_uid_validity != 0 || old_uid_next != 0 {
-            context.schedule_resync().await?;
-        }
-        info!(
-            context,
-            "uid/validity change folder {}: new {}/{} previous {}/{}.",
-            folder,
-            new_uid_next,
-            new_uid_validity,
-            old_uid_next,
-            old_uid_validity,
-        );
-        Ok(false)
-    }
-
    /// Fetches new messages.
    ///
    /// Returns true if at least one message was fetched.
@@ -743,7 +534,8 @@ impl Imap {
            return Ok(false);
        }

-        let new_emails = self
+        let session = self.session.as_mut().context("No IMAP session")?;
+        let new_emails = session
            .select_with_uidvalidity(context, folder)
            .await
            .with_context(|| format!("Failed to select folder {folder:?}"))?;
@@ -757,11 +549,12 @@ impl Imap {
        let old_uid_next = get_uid_next(context, folder).await?;

        let msgs = if fetch_existing_msgs {
-            self.prefetch_existing_msgs()
+            session
+                .prefetch_existing_msgs()
                .await
                .context("prefetch_existing_msgs")?
        } else {
-            self.prefetch(old_uid_next).await.context("prefetch")?
+            session.prefetch(old_uid_next).await.context("prefetch")?
        };
        let read_cnt = msgs.len();

@@ -769,6 +562,7 @@ impl Imap {
        let mut uids_fetch = Vec::<(_, bool /* partially? */)>::with_capacity(msgs.len() + 1);
        let mut uid_message_ids = BTreeMap::new();
        let mut largest_uid_skipped = None;
+        let delete_target = context.get_delete_msgs_target().await?;

        // Store the info about IMAP messages in the database.
        for (uid, ref fetch_response) in msgs {
@@ -794,8 +588,24 @@ impl Imap {
            // Such move to the same folder results in the messages
            // getting a new UID, so the messages will be detected as new
            // in the `INBOX.DeltaChat` folder again.
+            let _target;
            let target = if let Some(message_id) = &message_id {
-                if context
+                let is_dup = if let Some((_, ts_sent_old)) =
+                    message::rfc724_mid_exists(context, message_id).await?
+                {
+                    let is_chat_msg = headers.get_header_value(HeaderDef::ChatVersion).is_some();
+                    let ts_sent = headers
+                        .get_header_value(HeaderDef::Date)
+                        .and_then(|v| mailparse::dateparse(&v).ok())
+                        .unwrap_or_default();
+                    is_dup_msg(is_chat_msg, ts_sent, ts_sent_old)
+                } else {
+                    false
+                };
+                if is_dup {
+                    info!(context, "Deleting duplicate message {message_id}.");
+                    &delete_target
+                } else if context
                    .sql
                    .exists(
                        "SELECT COUNT (*) FROM imap WHERE rfc724_mid=?",
@@ -807,9 +617,10 @@ impl Imap {
                        context,
                        "Not moving the message {} that we have seen before.", &message_id
                    );
-                    folder.to_string()
+                    folder
                } else {
-                    target_folder(context, folder, folder_meaning, &headers).await?
+                    _target = target_folder(context, folder, folder_meaning, &headers).await?;
+                    &_target
                }
            } else {
                // Do not move the messages without Message-ID.
@@ -819,7 +630,7 @@ impl Imap {
                    context,
                    "Not moving the message that does not have a Message-ID."
                );
-                folder.to_string()
+                folder
            };

            // Generate a fake Message-ID to identify the message in the database
@@ -834,7 +645,7 @@ impl Imap {
                       ON CONFLICT(folder, uid, uidvalidity)
                       DO UPDATE SET rfc724_mid=excluded.rfc724_mid,
                                     target=excluded.target",
-                    (&message_id, &folder, uid, uid_validity, &target),
+                    (&message_id, &folder, uid, uid_validity, target),
                )
                .await?;

@@ -884,9 +695,13 @@ impl Imap {
        for (uid, fp) in uids_fetch {
            if fp != fetch_partially {
                let (largest_uid_fetched_in_batch, received_msgs_in_batch) = self
+                    .session
+                    .as_mut()
+                    .context("No IMAP session")?
                    .fetch_many_msgs(
                        context,
                        folder,
+                        uid_validity,
                        uids_fetch_in_batch.split_off(0),
                        &uid_message_ids,
                        fetch_partially,
@@ -953,13 +768,14 @@ impl Imap {
        }
        self.prepare(context).await.context("could not connect")?;

-        add_all_recipients_as_contacts(context, self, Config::ConfiguredSentboxFolder)
+        let session = self.session.as_mut().context("No IMAP session")?;
+        add_all_recipients_as_contacts(context, session, Config::ConfiguredSentboxFolder)
            .await
            .context("failed to get recipients from the sentbox")?;
-        add_all_recipients_as_contacts(context, self, Config::ConfiguredMvboxFolder)
+        add_all_recipients_as_contacts(context, session, Config::ConfiguredMvboxFolder)
            .await
-            .context("failed to ge recipients from the movebox")?;
-        add_all_recipients_as_contacts(context, self, Config::ConfiguredInboxFolder)
+            .context("failed to get recipients from the movebox")?;
+        add_all_recipients_as_contacts(context, session, Config::ConfiguredInboxFolder)
            .await
            .context("failed to get recipients from the inbox")?;

@@ -988,11 +804,11 @@ impl Imap {
        info!(context, "Done fetching existing messages.");
        Ok(())
    }
+}

+impl Session {
    /// Synchronizes UIDs for all folders.
    pub(crate) async fn resync_folders(&mut self, context: &Context) -> Result<()> {
-        self.prepare(context).await?;
-
        let all_folders = self
            .list_folders()
            .await
@@ -1006,9 +822,81 @@ impl Imap {
        }
        Ok(())
    }
-}

-impl Session {
+    /// Synchronizes UIDs in the database with UIDs on the server.
+    ///
+    /// It is assumed that no operations are taking place on the same
+    /// folder at the moment. Make sure to run it in the same
+    /// thread/task as other network operations on this folder to
+    /// avoid race conditions.
+    pub(crate) async fn resync_folder_uids(
+        &mut self,
+        context: &Context,
+        folder: &str,
+        folder_meaning: FolderMeaning,
+    ) -> Result<()> {
+        // Collect pairs of UID and Message-ID.
+        let mut msgs = BTreeMap::new();
+
+        self.select_folder(context, Some(folder)).await?;
+
+        let mut list = self
+            .uid_fetch("1:*", RFC724MID_UID)
+            .await
+            .with_context(|| format!("can't resync folder {folder}"))?;
+        while let Some(fetch) = list.try_next().await? {
+            let headers = match get_fetch_headers(&fetch) {
+                Ok(headers) => headers,
+                Err(err) => {
+                    warn!(context, "Failed to parse FETCH headers: {}", err);
+                    continue;
+                }
+            };
+            let message_id = prefetch_get_message_id(&headers);
+
+            if let (Some(uid), Some(rfc724_mid)) = (fetch.uid, message_id) {
+                msgs.insert(
+                    uid,
+                    (
+                        rfc724_mid,
+                        target_folder(context, folder, folder_meaning, &headers).await?,
+                    ),
+                );
+            }
+        }
+
+        info!(
+            context,
+            "Resync: collected {} message IDs in folder {}",
+            msgs.len(),
+            folder,
+        );
+
+        let uid_validity = get_uidvalidity(context, folder).await?;
+
+        // Write collected UIDs to SQLite database.
+        context
+            .sql
+            .transaction(move |transaction| {
+                transaction.execute("DELETE FROM imap WHERE folder=?", (folder,))?;
+                for (uid, (rfc724_mid, target)) in &msgs {
+                    // This may detect previously undetected moved
+                    // messages, so we update server_folder too.
+                    transaction.execute(
+                        "INSERT INTO imap (rfc724_mid, folder, uid, uidvalidity, target)
+                         VALUES           (?1,         ?2,     ?3,  ?4,          ?5)
+                         ON CONFLICT(folder, uid, uidvalidity)
+                         DO UPDATE SET rfc724_mid=excluded.rfc724_mid,
+                                       target=excluded.target",
+                        (rfc724_mid, folder, uid, uid_validity, target),
+                    )?;
+                }
+                Ok(())
+            })
+            .await?;
+        Ok(())
+    }
+
    /// Deletes batch of messages identified by their UID from the currently
    /// selected folder.
    async fn delete_message_batch(
@@ -1232,17 +1120,10 @@ impl Session {

        Ok(())
    }
-}

-impl Imap {
    /// Synchronizes `\Seen` flags using `CONDSTORE` extension.
    pub(crate) async fn sync_seen_flags(&mut self, context: &Context, folder: &str) -> Result<()> {
-        let session = self
-            .session
-            .as_mut()
-            .with_context(|| format!("No IMAP connection established, folder: {folder}"))?;
-
-        if !session.can_condstore() {
+        if !self.can_condstore() {
            info!(
                context,
                "Server does not support CONDSTORE, skipping flag synchronization."
@@ -1250,12 +1131,11 @@ impl Imap {
            return Ok(());
        }

-        session
-            .select_folder(context, Some(folder))
+        self.select_folder(context, Some(folder))
            .await
            .context("failed to select folder")?;

-        let mailbox = session
+        let mailbox = self
            .selected_mailbox
            .as_ref()
            .with_context(|| format!("No mailbox selected, folder: {folder}"))?;
@@ -1277,7 +1157,7 @@ impl Imap {
        let mut highest_modseq = get_modseq(context, folder)
            .await
            .with_context(|| format!("failed to get MODSEQ for folder {folder}"))?;
-        let mut list = session
+        let mut list = self
            .uid_fetch("1:*", format!("(FLAGS) (CHANGEDSINCE {highest_modseq})"))
            .await
            .context("failed to fetch flags")?;
@@ -1326,12 +1206,7 @@ impl Imap {

    /// Gets the from, to and bcc addresses from all existing outgoing emails.
    pub async fn get_all_recipients(&mut self, context: &Context) -> Result<Vec<SingleInfo>> {
-        let session = self
-            .session
-            .as_mut()
-            .context("IMAP No Connection established")?;
-
-        let mut uids: Vec<_> = session
+        let mut uids: Vec<_> = self
            .uid_search(get_imap_self_sent_search_command(context).await?)
            .await?
            .into_iter()
@@ -1340,7 +1215,7 @@ impl Imap {

        let mut result = Vec::new();
        for (_, uid_set) in build_sequence_sets(&uids)? {
-            let mut list = session
+            let mut list = self
                .uid_fetch(uid_set, "(UID BODY.PEEK[HEADER.FIELDS (FROM TO CC BCC)])")
                .await
                .context("IMAP Could not fetch")?;
@@ -1364,77 +1239,17 @@ impl Imap {
        Ok(result)
    }

-    /// Prefetch all messages greater than or equal to `uid_next`. Returns a list of fetch results
-    /// in the order of ascending delivery time to the server (INTERNALDATE).
-    async fn prefetch(&mut self, uid_next: u32) -> Result<Vec<(u32, async_imap::types::Fetch)>> {
-        let session = self
-            .session
-            .as_mut()
-            .context("no IMAP connection established")?;
-
-        // fetch messages with larger UID than the last one seen
-        let set = format!("{uid_next}:*");
-        let mut list = session
-            .uid_fetch(set, PREFETCH_FLAGS)
-            .await
-            .context("IMAP could not fetch")?;
-
-        let mut msgs = BTreeMap::new();
-        while let Some(msg) = list.try_next().await? {
-            if let Some(msg_uid) = msg.uid {
-                // If the mailbox is not empty, results always include
-                // at least one UID, even if last_seen_uid+1 is past
-                // the last UID in the mailbox.  It happens because
-                // uid:* is interpreted the same way as *:uid.
-                // See <https://tools.ietf.org/html/rfc3501#page-61> for
-                // standard reference. Therefore, sometimes we receive
-                // already seen messages and have to filter them out.
-                if msg_uid >= uid_next {
-                    msgs.insert((msg.internal_date(), msg_uid), msg);
-                }
-            }
-        }
-
-        Ok(msgs.into_iter().map(|((_, uid), msg)| (uid, msg)).collect())
-    }
-
-    /// Like fetch_after(), but not for new messages but existing ones (the DC_FETCH_EXISTING_MSGS_COUNT newest messages)
-    async fn prefetch_existing_msgs(&mut self) -> Result<Vec<(u32, async_imap::types::Fetch)>> {
-        let session = self.session.as_mut().context("no IMAP session")?;
-        let exists: i64 = {
-            let mailbox = session.selected_mailbox.as_ref().context("no mailbox")?;
-            mailbox.exists.into()
-        };
-
-        // Fetch last DC_FETCH_EXISTING_MSGS_COUNT (100) messages.
-        // Sequence numbers are sequential. If there are 1000 messages in the inbox,
-        // we can fetch the sequence numbers 900-1000 and get the last 100 messages.
-        let first = cmp::max(1, exists - DC_FETCH_EXISTING_MSGS_COUNT + 1);
-        let set = format!("{first}:{exists}");
-        let mut list = session
-            .fetch(&set, PREFETCH_FLAGS)
-            .await
-            .context("IMAP Could not fetch")?;
-
-        let mut msgs = BTreeMap::new();
-        while let Some(msg) = list.try_next().await? {
-            if let Some(msg_uid) = msg.uid {
-                msgs.insert((msg.internal_date(), msg_uid), msg);
-            }
-        }
-
-        Ok(msgs.into_iter().map(|((_, uid), msg)| (uid, msg)).collect())
-    }
-
    /// Fetches a list of messages by server UID.
    ///
    /// Returns the last UID fetched successfully and the info about each downloaded message.
    /// If the message is incorrect or there is a failure to write a message to the database,
    /// it is skipped and the error is logged.
+    #[allow(clippy::too_many_arguments)]
    pub(crate) async fn fetch_many_msgs(
        &mut self,
        context: &Context,
        folder: &str,
+        uidvalidity: u32,
        request_uids: Vec<u32>,
        uid_message_ids: &BTreeMap<u32, String>,
        fetch_partially: bool,
@@ -1447,7 +1262,6 @@ impl Imap {
            return Ok((last_uid, received_msgs));
        }

-        let session = self.session.as_mut().context("no IMAP session")?;
        for (request_uids, set) in build_sequence_sets(&request_uids)? {
            info!(
                context,
@@ -1455,7 +1269,7 @@ impl Imap {
                if fetch_partially { "partial" } else { "full" },
                set
            );
-            let mut fetch_responses = session
+            let mut fetch_responses = self
                .uid_fetch(
                    &set,
                    if fetch_partially {
@@ -1568,6 +1382,9 @@ impl Imap {
                );
                match receive_imf_inner(
                    context,
+                    folder,
+                    uidvalidity,
+                    request_uid,
                    rfc724_mid,
                    body,
                    is_seen,
@@ -1611,6 +1428,49 @@ impl Imap {

        Ok((last_uid, received_msgs))
    }
+
+    /// Retrieves server metadata if it is supported.
+    ///
+    /// We get [`/shared/comment`](https://www.rfc-editor.org/rfc/rfc5464#section-6.2.1)
+    /// and [`/shared/admin`](https://www.rfc-editor.org/rfc/rfc5464#section-6.2.2)
+    /// metadata.
+    pub(crate) async fn fetch_metadata(&mut self, context: &Context) -> Result<()> {
+        if !self.can_metadata() {
+            return Ok(());
+        }
+
+        let mut lock = context.metadata.write().await;
+        if (*lock).is_some() {
+            return Ok(());
+        }
+
+        info!(
+            context,
+            "Server supports metadata, retrieving server comment and admin contact."
+        );
+
+        let mut comment = None;
+        let mut admin = None;
+
+        let mailbox = "";
+        let options = "";
+        let metadata = self
+            .get_metadata(mailbox, options, "(/shared/comment /shared/admin)")
+            .await?;
+        for m in metadata {
+            match m.entry.as_ref() {
+                "/shared/comment" => {
+                    comment = m.value;
+                }
+                "/shared/admin" => {
+                    admin = m.value;
+                }
+                _ => {}
+            }
+        }
+        *lock = Some(ServerMetadata { comment, admin });
+        Ok(())
+    }
 }

 impl Session {
@@ -1684,18 +1544,24 @@ impl Imap {
        context: &Context,
        create_mvbox: bool,
    ) -> Result<()> {
-        let folders_configured = context.sql.get_raw_config_int("folders_configured").await?;
-        if folders_configured.unwrap_or_default() >= DC_FOLDERS_CONFIGURED_VERSION {
+        let folders_configured = context
+            .sql
+            .get_raw_config_int(constants::DC_FOLDERS_CONFIGURED_KEY)
+            .await?;
+        if folders_configured.unwrap_or_default() >= constants::DC_FOLDERS_CONFIGURED_VERSION {
            return Ok(());
        }
-
+        if let Err(err) = self.connect(context).await {
+            self.connectivity.set_err(context, &err).await;
+            return Err(err);
+        }
        self.configure_folders(context, create_mvbox).await
    }

    /// Attempts to configure mvbox.
    ///
    /// Tries to find any folder in the given list of `folders`. If none is found, tries to create
-    /// any of them in the same order. This method does not use LIST command to ensure that
+    /// `folders[0]`. This method does not use LIST command to ensure that
    /// configuration works even if mailbox lookup is forbidden via Access Control List (see
    /// <https://datatracker.ietf.org/doc/html/rfc4314>).
    ///
@@ -1724,24 +1590,28 @@ impl Imap {
                    "MVBOX-folder {:?} successfully selected, using it.", &folder
                );
                session.close().await?;
+                // Before moving emails to the mvbox we need to remember its UIDVALIDITY, otherwise
+                // emails moved before that wouldn't be fetched but considered "old" instead.
+                session.select_with_uidvalidity(context, folder).await?;
                return Ok(Some(folder));
            }
        }

-        if create_mvbox {
-            for folder in folders {
-                match session.create(&folder).await {
-                    Ok(_) => {
-                        info!(context, "MVBOX-folder {} created.", &folder);
-                        return Ok(Some(folder));
-                    }
-                    Err(err) => {
-                        warn!(context, "Cannot create MVBOX-folder {:?}: {}", &folder, err);
-                    }
-                }
+        if !create_mvbox {
+            return Ok(None);
+        }
+        let Some(folder) = folders.first() else {
+            return Ok(None);
+        };
+        match session.select_with_uidvalidity(context, folder).await {
+            Ok(_) => {
+                info!(context, "MVBOX-folder {} created.", folder);
+                return Ok(Some(folder));
+            }
+            Err(err) => {
+                warn!(context, "Cannot create MVBOX-folder {:?}: {}", folder, err);
            }
        }
-
        Ok(None)
    }

@@ -1793,20 +1663,23 @@ impl Imap {
            .context("failed to configure mvbox")?;

        context
-            .set_config(Config::ConfiguredInboxFolder, Some("INBOX"))
+            .set_config_internal(Config::ConfiguredInboxFolder, Some("INBOX"))
            .await?;
        if let Some(mvbox_folder) = mvbox_folder {
            info!(context, "Setting MVBOX FOLDER TO {}", &mvbox_folder);
            context
-                .set_config(Config::ConfiguredMvboxFolder, Some(mvbox_folder))
+                .set_config_internal(Config::ConfiguredMvboxFolder, Some(mvbox_folder))
                .await?;
        }
        for (config, name) in folder_configs {
-            context.set_config(config, Some(&name)).await?;
+            context.set_config_internal(config, Some(&name)).await?;
        }
        context
            .sql
-            .set_raw_config_int("folders_configured", DC_FOLDERS_CONFIGURED_VERSION)
+            .set_raw_config_int(
+                constants::DC_FOLDERS_CONFIGURED_KEY,
+                constants::DC_FOLDERS_CONFIGURED_VERSION,
+            )
            .await?;

        info!(context, "FINISHED configuring IMAP-folders.");
@@ -1824,13 +1697,14 @@ impl Session {
        use async_imap::imap_proto::ResponseCode;
        use UnsolicitedResponse::*;

+        let folder = self.selected_folder.as_deref().unwrap_or_default();
        let mut unsolicited_exists = false;
        while let Ok(response) = self.unsolicited_responses.try_recv() {
            match response {
                Exists(_) => {
                    info!(
                        context,
-                        "Need to fetch again, got unsolicited EXISTS {:?}", response
+                        "Need to refetch {folder:?}, got unsolicited EXISTS {response:?}"
                    );
                    unsolicited_exists = true;
                }
@@ -1849,7 +1723,7 @@ impl Session {
                    ) => {}

                _ => {
-                    info!(context, "got unsolicited response {:?}", response)
+                    info!(context, "{folder:?}: got unsolicited response {response:?}")
                }
            }
        }
@@ -2088,6 +1962,26 @@ fn get_folder_meaning_by_name(folder_name: &str) -> FolderMeaning {
        "草稿",
        "임시보관함",
    ];
+    const TRASH_NAMES: &[&str] = &[
+        "Trash",
+        "Bin",
+        "Caixote do lixo",
+        "Cestino",
+        "Corbeille",
+        "Papelera",
+        "Papierkorb",
+        "Papirkurv",
+        "Papperskorgen",
+        "Prullenbak",
+        "Rubujo",
+        "Κάδος απορριμμάτων",
+        "Корзина",
+        "Кошик",
+        "ゴミ箱",
+        "垃圾桶",
+        "已删除邮件",
+        "휴지통",
+    ];
    let lower = folder_name.to_lowercase();

    if SENT_NAMES.iter().any(|s| s.to_lowercase() == lower) {
@@ -2096,6 +1990,8 @@ fn get_folder_meaning_by_name(folder_name: &str) -> FolderMeaning {
        FolderMeaning::Spam
    } else if DRAFT_NAMES.iter().any(|s| s.to_lowercase() == lower) {
        FolderMeaning::Drafts
+    } else if TRASH_NAMES.iter().any(|s| s.to_lowercase() == lower) {
+        FolderMeaning::Trash
    } else {
        FolderMeaning::Unknown
    }
@@ -2247,6 +2143,15 @@ pub(crate) async fn prefetch_should_download(
    Ok(should_download)
 }

+/// Returns whether a message is a duplicate (resent message).
+pub(crate) fn is_dup_msg(is_chat_msg: bool, ts_sent: i64, ts_sent_old: i64) -> bool {
+    // If the existing message has timestamp_sent == 0, that means we don't know its actual sent
+    // timestamp, so don't delete the new message. E.g. outgoing messages have zero timestamp_sent
+    // because they are stored to the db before sending. Also consider as duplicates only messages
+    // with greater timestamp to avoid deleting both messages in a multi-device setting.
+    is_chat_msg && ts_sent_old != 0 && ts_sent > ts_sent_old
+}
+
 /// Marks messages in `msgs` table as seen, searching for them by UID.
 ///
 /// Returns updated chat ID if any message was marked as seen.
@@ -2506,7 +2411,7 @@ impl std::fmt::Display for UidRange {
 }
 async fn add_all_recipients_as_contacts(
    context: &Context,
-    imap: &mut Imap,
+    session: &mut Session,
    folder: Config,
 ) -> Result<()> {
    let mailbox = if let Some(m) = context.get_config(folder).await? {
@@ -2518,11 +2423,12 @@ async fn add_all_recipients_as_contacts(
        );
        return Ok(());
    };
-    imap.select_with_uidvalidity(context, &mailbox)
+    session
+        .select_with_uidvalidity(context, &mailbox)
        .await
        .with_context(|| format!("could not select {mailbox}"))?;

-    let recipients = imap
+    let recipients = session
        .get_all_recipients(context)
        .await
        .context("could not get recipients")?;
@@ -2589,6 +2495,7 @@ mod tests {
        );
        assert_eq!(get_folder_meaning_by_name("xxx"), FolderMeaning::Unknown);
        assert_eq!(get_folder_meaning_by_name("SPAM"), FolderMeaning::Spam);
+        assert_eq!(get_folder_meaning_by_name("Trash"), FolderMeaning::Trash);
    }

    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
--- a/src/imap/capabilities.rs
+++ b/src/imap/capabilities.rs
@@ -21,6 +21,10 @@ pub(crate) struct Capabilities {
    /// <https://tools.ietf.org/html/rfc7162>
    pub can_condstore: bool,

+    /// True if the server has METADATA capability as defined in
+    /// <https://tools.ietf.org/html/rfc5464>
+    pub can_metadata: bool,
+
    /// Server ID if the server supports ID capability.
    pub server_id: Option<HashMap<String, String>>,
 }
--- a/src/imap/client.rs
+++ b/src/imap/client.rs
@@ -59,6 +59,7 @@ async fn determine_capabilities(
        can_move: caps.has_str("MOVE"),
        can_check_quota: caps.has_str("QUOTA"),
        can_condstore: caps.has_str("CONDSTORE"),
+        can_metadata: caps.has_str("METADATA"),
        server_id,
    };
    Ok(capabilities)
--- a/src/imap/idle.rs
+++ b/src/imap/idle.rs
@@ -1,4 +1,4 @@
-use std::time::{Duration, SystemTime};
+use std::time::Duration;

 use anyhow::{bail, Context as _, Result};
 use async_channel::Receiver;
@@ -11,6 +11,7 @@ use crate::config::Config;
 use crate::context::Context;
 use crate::imap::{client::IMAP_TIMEOUT, FolderMeaning};
 use crate::log::LogExt;
+use crate::tools::{self, time_elapsed};

 /// Timeout after which IDLE is finished
 /// if there are no responses from the server.
@@ -100,22 +101,15 @@ impl Imap {
    pub(crate) async fn fake_idle(
        &mut self,
        context: &Context,
-        watch_folder: Option<String>,
+        watch_folder: String,
        folder_meaning: FolderMeaning,
    ) {
        // Idle using polling. This is also needed if we're not yet configured -
        // in this case, we're waiting for a configure job (and an interrupt).

-        let fake_idle_start_time = SystemTime::now();
+        let fake_idle_start_time = tools::Time::now();

        // Do not poll, just wait for an interrupt when no folder is passed in.
-        let watch_folder = if let Some(watch_folder) = watch_folder {
-            watch_folder
-        } else {
-            info!(context, "IMAP-fake-IDLE: no folder, waiting for interrupt");
-            self.idle_interrupt_receiver.recv().await.ok();
-            return;
-        };
        info!(context, "IMAP-fake-IDLEing folder={:?}", watch_folder);

        const TIMEOUT_INIT_MS: u64 = 60_000;
@@ -196,11 +190,7 @@ impl Imap {
        info!(
            context,
            "IMAP-fake-IDLE done after {:.4}s",
-            SystemTime::now()
-                .duration_since(fake_idle_start_time)
-                .unwrap_or_default()
-                .as_millis() as f64
-                / 1000.,
+            time_elapsed(&fake_idle_start_time).as_millis() as f64 / 1000.,
        );
    }
 }
--- a/src/imap/scan_folders.rs
+++ b/src/imap/scan_folders.rs
@@ -1,12 +1,12 @@
-use std::{collections::BTreeMap, time::Instant};
+use std::collections::BTreeMap;

 use anyhow::{Context as _, Result};
-use futures::TryStreamExt;

 use super::{get_folder_meaning_by_attrs, get_folder_meaning_by_name};
 use crate::config::Config;
 use crate::imap::Imap;
 use crate::log::LogExt;
+use crate::tools::{self, time_elapsed};
 use crate::{context::Context, imap::FolderMeaning};

 impl Imap {
@@ -15,7 +15,7 @@ impl Imap {
        // First of all, debounce to once per minute:
        let mut last_scan = context.last_full_folder_scan.lock().await;
        if let Some(last_scan) = *last_scan {
-            let elapsed_secs = last_scan.elapsed().as_secs();
+            let elapsed_secs = time_elapsed(&last_scan).as_secs();
            let debounce_secs = context
                .get_config_u64(Config::ScanAllFoldersDebounceSecs)
                .await?;
@@ -27,7 +27,8 @@ impl Imap {
        info!(context, "Starting full folder scan");

        self.prepare(context).await?;
-        let folders = self.list_folders().await?;
+        let session = self.session.as_mut().context("No IMAP session")?;
+        let folders = session.list_folders().await?;
        let watched_folders = get_watched_folders(context).await?;

        let mut folder_configs = BTreeMap::new();
@@ -89,25 +90,13 @@ impl Imap {
            Config::ConfiguredTrashFolder,
        ] {
            context
-                .set_config(conf, folder_configs.get(&conf).map(|s| s.as_str()))
+                .set_config_internal(conf, folder_configs.get(&conf).map(|s| s.as_str()))
                .await?;
        }

-        last_scan.replace(Instant::now());
+        last_scan.replace(tools::Time::now());
        Ok(true)
    }
-
-    /// Returns the names of all folders on the IMAP server.
-    pub async fn list_folders(self: &mut Imap) -> Result<Vec<async_imap::types::Name>> {
-        let session = self.session.as_mut();
-        let session = session.context("No IMAP connection")?;
-        let list = session
-            .list(Some(""), Some("*"))
-            .await?
-            .try_collect()
-            .await?;
-        Ok(list)
-    }
 }

 pub(crate) async fn get_watched_folder_configs(context: &Context) -> Result<Vec<Config>> {
--- a/src/imap/select_folder.rs
+++ b/src/imap/select_folder.rs
@@ -3,6 +3,7 @@
 use anyhow::Context as _;

 use super::session::Session as ImapSession;
+use super::{get_uid_next, get_uidvalidity, set_modseq, set_uid_next, set_uidvalidity};
 use crate::context::Context;

 type Result<T> = std::result::Result<T, Error>;
@@ -112,16 +113,146 @@ impl ImapSession {
            Err(err) => match err {
                Error::NoFolder(..) => {
                    info!(context, "Failed to select folder {} because it does not exist, trying to create it.", folder);
-                    self.create(folder).await.with_context(|| {
-                        format!("Couldn't select folder ('{err}'), then create() failed")
-                    })?;
-
-                    Ok(self.select_folder(context, Some(folder)).await.with_context(|| format!("failed to select newely created folder {folder}"))?)
+                    let create_res = self.create(folder).await;
+                    if let Err(ref err) = create_res {
+                        info!(context, "Couldn't select folder, then create() failed: {err:#}.");
+                        // Need to recheck, could have been created in parallel.
+                    }
+                    let select_res = self.select_folder(context, Some(folder)).await.with_context(|| format!("failed to select newely created folder {folder}"));
+                    if select_res.is_err() {
+                        create_res?;
+                    }
+                    select_res
                }
                _ => Err(err).with_context(|| format!("failed to select folder {folder} with error other than NO, not trying to create it")),
            },
        }
    }
+
+    /// Selects a folder and takes care of UIDVALIDITY changes.
+    ///
+    /// When selecting a folder for the first time, sets the uid_next to the current
+    /// mailbox.uid_next so that no old emails are fetched.
+    ///
+    /// Returns Result<new_emails> (i.e. whether new emails arrived),
+    /// if in doubt, returns new_emails=true so emails are fetched.
+    pub(crate) async fn select_with_uidvalidity(
+        &mut self,
+        context: &Context,
+        folder: &str,
+    ) -> Result<bool> {
+        let newly_selected = self
+            .select_or_create_folder(context, folder)
+            .await
+            .with_context(|| format!("failed to select or create folder {folder}"))?;
+        let mailbox = self
+            .selected_mailbox
+            .as_mut()
+            .with_context(|| format!("No mailbox selected, folder: {folder}"))?;
+
+        let old_uid_validity = get_uidvalidity(context, folder)
+            .await
+            .with_context(|| format!("failed to get old UID validity for folder {folder}"))?;
+        let old_uid_next = get_uid_next(context, folder)
+            .await
+            .with_context(|| format!("failed to get old UID NEXT for folder {folder}"))?;
+
+        let new_uid_validity = mailbox
+            .uid_validity
+            .with_context(|| format!("No UIDVALIDITY for folder {folder}"))?;
+        let new_uid_next = if let Some(uid_next) = mailbox.uid_next {
+            Some(uid_next)
+        } else {
+            warn!(
+                context,
+                "SELECT response for IMAP folder {folder:?} has no UIDNEXT, fall back to STATUS command."
+            );
+
+            // RFC 3501 says STATUS command SHOULD NOT be used
+            // on the currently selected mailbox because the same
+            // information can be obtained by other means,
+            // such as reading SELECT response.
+            //
+            // However, it also says that UIDNEXT is REQUIRED
+            // in the SELECT response and if we are here,
+            // it is actually not returned.
+            //
+            // In particular, Winmail Pro Mail Server 5.1.0616
+            // never returns UIDNEXT in SELECT response,
+            // but responds to "STATUS INBOX (UIDNEXT)" command.
+            let status = self
+                .inner
+                .status(folder, "(UIDNEXT)")
+                .await
+                .with_context(|| format!("STATUS (UIDNEXT) error for {folder:?}"))?;
+
+            if status.uid_next.is_none() {
+                // This happens with mail.163.com as of 2023-11-26.
+                // It does not return UIDNEXT on SELECT and returns invalid
+                // `* STATUS "INBOX" ()` response on explicit request for UIDNEXT.
+                warn!(context, "STATUS {folder} (UIDNEXT) did not return UIDNEXT.");
+            }
+            status.uid_next
+        };
+        mailbox.uid_next = new_uid_next;
+
+        if new_uid_validity == old_uid_validity {
+            let new_emails = if newly_selected == NewlySelected::No {
+                // The folder was not newly selected i.e. no SELECT command was run. This means that mailbox.uid_next
+                // was not updated and may contain an incorrect value. So, just return true so that
+                // the caller tries to fetch new messages (we could of course run a SELECT command now, but trying to fetch
+                // new messages is only one command, just as a SELECT command)
+                true
+            } else if let Some(new_uid_next) = new_uid_next {
+                if new_uid_next < old_uid_next {
+                    warn!(
+                        context,
+                        "The server illegally decreased the uid_next of folder {folder:?} from {old_uid_next} to {new_uid_next} without changing validity ({new_uid_validity}), resyncing UIDs...",
+                    );
+                    set_uid_next(context, folder, new_uid_next).await?;
+                    context.schedule_resync().await?;
+                }
+                new_uid_next != old_uid_next // If UIDNEXT changed, there are new emails
+            } else {
+                // We have no UIDNEXT and if in doubt, return true.
+                true
+            };
+
+            return Ok(new_emails);
+        }
+
+        // UIDVALIDITY is modified, reset highest seen MODSEQ.
+        set_modseq(context, folder, 0).await?;
+
+        // ==============  uid_validity has changed or is being set the first time.  ==============
+
+        let new_uid_next = new_uid_next.unwrap_or_default();
+        set_uid_next(context, folder, new_uid_next).await?;
+        set_uidvalidity(context, folder, new_uid_validity).await?;
+
+        // Collect garbage entries in `imap` table.
+        context
+            .sql
+            .execute(
+                "DELETE FROM imap WHERE folder=? AND uidvalidity!=?",
+                (&folder, new_uid_validity),
+            )
+            .await?;
+
+        if old_uid_validity != 0 || old_uid_next != 0 {
+            context.schedule_resync().await?;
+        }
+        info!(
+            context,
+            "uid/validity change folder {}: new {}/{} previous {}/{}.",
+            folder,
+            new_uid_next,
+            new_uid_validity,
+            old_uid_next,
+            old_uid_validity,
+        );
+        Ok(false)
+    }
 }

 #[derive(PartialEq, Debug, Copy, Clone, Eq)]
--- a/src/imap/session.rs
+++ b/src/imap/session.rs
@@ -1,11 +1,32 @@
+use std::cmp;
+use std::collections::BTreeMap;
 use std::ops::{Deref, DerefMut};

+use anyhow::{Context as _, Result};
 use async_imap::types::Mailbox;
 use async_imap::Session as ImapSession;
+use futures::TryStreamExt;

+use crate::constants::DC_FETCH_EXISTING_MSGS_COUNT;
 use crate::imap::capabilities::Capabilities;
 use crate::net::session::SessionStream;

+/// Prefetch:
+/// - Message-ID to check if we already have the message.
+/// - In-Reply-To and References to check if message is a reply to chat message.
+/// - Chat-Version to check if a message is a chat message
+/// - Autocrypt-Setup-Message to check if a message is an autocrypt setup message,
+///   not necessarily sent by Delta Chat.
+const PREFETCH_FLAGS: &str = "(UID INTERNALDATE RFC822.SIZE BODY.PEEK[HEADER.FIELDS (\
+                              MESSAGE-ID \
+                              DATE \
+                              X-MICROSOFT-ORIGINAL-MESSAGE-ID \
+                              FROM \
+                              IN-REPLY-TO REFERENCES \
+                              CHAT-VERSION \
+                              AUTOCRYPT-SETUP-MESSAGE\
+                              )])";
+
 #[derive(Debug)]
 pub(crate) struct Session {
    pub(super) inner: ImapSession<Box<dyn SessionStream>>,
@@ -64,4 +85,75 @@ impl Session {
    pub fn can_condstore(&self) -> bool {
        self.capabilities.can_condstore
    }
+
+    pub fn can_metadata(&self) -> bool {
+        self.capabilities.can_metadata
+    }
+
+    /// Returns the names of all folders on the IMAP server.
+    pub async fn list_folders(&mut self) -> Result<Vec<async_imap::types::Name>> {
+        let list = self.list(Some(""), Some("*")).await?.try_collect().await?;
+        Ok(list)
+    }
+
+    /// Prefetch all messages greater than or equal to `uid_next`. Returns a list of fetch results
+    /// in the order of ascending delivery time to the server (INTERNALDATE).
+    pub(crate) async fn prefetch(
+        &mut self,
+        uid_next: u32,
+    ) -> Result<Vec<(u32, async_imap::types::Fetch)>> {
+        // fetch messages with larger UID than the last one seen
+        let set = format!("{uid_next}:*");
+        let mut list = self
+            .uid_fetch(set, PREFETCH_FLAGS)
+            .await
+            .context("IMAP could not fetch")?;
+
+        let mut msgs = BTreeMap::new();
+        while let Some(msg) = list.try_next().await? {
+            if let Some(msg_uid) = msg.uid {
+                // If the mailbox is not empty, results always include
+                // at least one UID, even if last_seen_uid+1 is past
+                // the last UID in the mailbox.  It happens because
+                // uid:* is interpreted the same way as *:uid.
+                // See <https://tools.ietf.org/html/rfc3501#page-61> for
+                // standard reference. Therefore, sometimes we receive
+                // already seen messages and have to filter them out.
+                if msg_uid >= uid_next {
+                    msgs.insert((msg.internal_date(), msg_uid), msg);
+                }
+            }
+        }
+
+        Ok(msgs.into_iter().map(|((_, uid), msg)| (uid, msg)).collect())
+    }
+
+    /// Like prefetch(), but not for new messages but existing ones (the DC_FETCH_EXISTING_MSGS_COUNT newest messages)
+    pub(crate) async fn prefetch_existing_msgs(
+        &mut self,
+    ) -> Result<Vec<(u32, async_imap::types::Fetch)>> {
+        let exists: i64 = {
+            let mailbox = self.selected_mailbox.as_ref().context("no mailbox")?;
+            mailbox.exists.into()
+        };
+
+        // Fetch last DC_FETCH_EXISTING_MSGS_COUNT (100) messages.
+        // Sequence numbers are sequential. If there are 1000 messages in the inbox,
+        // we can fetch the sequence numbers 900-1000 and get the last 100 messages.
+        let first = cmp::max(1, exists - DC_FETCH_EXISTING_MSGS_COUNT + 1);
+        let set = format!("{first}:{exists}");
+        let mut list = self
+            .fetch(&set, PREFETCH_FLAGS)
+            .await
+            .context("IMAP Could not fetch")?;
+
+        let mut msgs = BTreeMap::new();
+        while let Some(msg) = list.try_next().await? {
+            if let Some(msg_uid) = msg.uid {
+                msgs.insert((msg.internal_date(), msg_uid), msg);
+            }
+        }
+
+        Ok(msgs.into_iter().map(|((_, uid), msg)| (uid, msg)).collect())
+    }
 }
--- a/src/imex.rs
+++ b/src/imex.rs
@@ -389,11 +389,11 @@ async fn imex_inner(

    if what == ImexMode::ExportBackup || what == ImexMode::ExportSelfKeys {
        // before we export anything, make sure the private key exists
-        if e2ee::ensure_secret_key_exists(context).await.is_err() {
-            bail!("Cannot create private key or private key not available.");
-        } else {
-            create_folder(context, &path).await?;
-        }
+        e2ee::ensure_secret_key_exists(context)
+            .await
+            .context("Cannot create private key or private key not available")?;
+
+        create_folder(context, &path).await?;
    }

    match what {
@@ -534,7 +534,7 @@ async fn export_backup(context: &Context, dir: &Path, passphrase: String) -> Res
    let _d1 = DeleteOnDrop(temp_db_path.clone());
    let _d2 = DeleteOnDrop(temp_path.clone());

-    export_database(context, &temp_db_path, passphrase)
+    export_database(context, &temp_db_path, passphrase, now)
        .await
        .context("could not export database")?;

@@ -770,19 +770,27 @@ where
 /// overwritten.
 ///
 /// This also verifies that IO is not running during the export.
-async fn export_database(context: &Context, dest: &Path, passphrase: String) -> Result<()> {
+async fn export_database(
+    context: &Context,
+    dest: &Path,
+    passphrase: String,
+    timestamp: i64,
+) -> Result<()> {
    ensure!(
        !context.scheduler.is_running().await,
        "cannot export backup, IO is running"
    );
-    let now = time().try_into().context("32-bit UNIX time overflow")?;
+    let timestamp = timestamp.try_into().context("32-bit UNIX time overflow")?;

    // TODO: Maybe introduce camino crate for UTF-8 paths where we need them.
    let dest = dest
        .to_str()
        .with_context(|| format!("path {} is not valid unicode", dest.display()))?;

-    context.sql.set_raw_config_int("backup_time", now).await?;
+    context
+        .sql
+        .set_raw_config_int("backup_time", timestamp)
+        .await?;
    sql::housekeeping(context).await.log_err(context).ok();
    context
        .sql
--- a/src/imex/transfer.rs
+++ b/src/imex/transfer.rs
@@ -52,6 +52,7 @@ use crate::context::Context;
 use crate::message::{Message, Viewtype};
 use crate::qr::{self, Qr};
 use crate::stock_str::backup_transfer_msg_body;
+use crate::tools::time;
 use crate::{e2ee, EventType};

 use super::{export_database, DBFILE_BACKUP_NAME};
@@ -158,7 +159,7 @@ impl BackupProvider {
        // Generate the token up front: we also use it to encrypt the database.
        let token = AuthToken::generate();
        context.emit_event(SendProgress::Started.into());
-        export_database(context, dbfile, token.to_string())
+        export_database(context, dbfile, token.to_string(), time())
            .await
            .context("Database export failed")?;
        context.emit_event(SendProgress::DatabaseExported.into());
@@ -638,7 +639,7 @@ mod tests {
        let self_chat = ctx1.get_self_chat().await;
        let msgs = get_chat_msgs(&ctx1, self_chat.id).await.unwrap();
        assert_eq!(msgs.len(), 2);
-        let msgid = match msgs.get(0).unwrap() {
+        let msgid = match msgs.first().unwrap() {
            ChatItem::Message { msg_id } => msg_id,
            _ => panic!("wrong chat item"),
        };
--- a/src/key.rs
+++ b/src/key.rs
@@ -18,7 +18,7 @@ use crate::constants::KeyGenType;
 use crate::context::Context;
 use crate::log::LogExt;
 use crate::pgp::KeyPair;
-use crate::tools::EmailAddress;
+use crate::tools::{self, time_elapsed, EmailAddress};

 /// Convenience trait for working with keys.
 ///
@@ -79,7 +79,7 @@ pub(crate) trait DcKey: Serialize + Deserializable + KeyTrait + Clone {
 }

 pub(crate) async fn load_self_public_key(context: &Context) -> Result<SignedPublicKey> {
-    match context
+    let public_key = context
        .sql
        .query_row_optional(
            "SELECT public_key
@@ -91,8 +91,8 @@ pub(crate) async fn load_self_public_key(context: &Context) -> Result<SignedPubl
                Ok(bytes)
            },
        )
-        .await?
-    {
+        .await?;
+    match public_key {
        Some(bytes) => SignedPublicKey::from_slice(&bytes),
        None => {
            let keypair = generate_keypair(context).await?;
@@ -102,7 +102,7 @@ pub(crate) async fn load_self_public_key(context: &Context) -> Result<SignedPubl
 }

 pub(crate) async fn load_self_secret_key(context: &Context) -> Result<SignedSecretKey> {
-    match context
+    let private_key = context
        .sql
        .query_row_optional(
            "SELECT private_key
@@ -114,8 +114,8 @@ pub(crate) async fn load_self_secret_key(context: &Context) -> Result<SignedSecr
                Ok(bytes)
            },
        )
-        .await?
-    {
+        .await?;
+    match private_key {
        Some(bytes) => SignedSecretKey::from_slice(&bytes),
        None => {
            let keypair = generate_keypair(context).await?;
@@ -204,7 +204,7 @@ async fn generate_keypair(context: &Context) -> Result<KeyPair> {
    match load_keypair(context, &addr).await? {
        Some(key_pair) => Ok(key_pair),
        None => {
-            let start = std::time::SystemTime::now();
+            let start = tools::Time::now();
            let keytype = KeyGenType::from_i32(context.get_config_int(Config::KeyGenType).await?)
                .unwrap_or_default();
            info!(context, "Generating keypair with type {}", keytype);
@@ -216,7 +216,7 @@ async fn generate_keypair(context: &Context) -> Result<KeyPair> {
            info!(
                context,
                "Keypair generated in {:.3}s.",
-                start.elapsed().unwrap_or_default().as_secs()
+                time_elapsed(&start).as_secs(),
            );
            Ok(keypair)
        }
@@ -255,7 +255,7 @@ pub(crate) async fn load_keypair(

 /// Use of a key pair for encryption or decryption.
 ///
-/// This is used by [store_self_keypair] to know what kind of key is
+/// This is used by `store_self_keypair` to know what kind of key is
 /// being saved.
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub enum KeyPairUse {
@@ -277,7 +277,7 @@ pub enum KeyPairUse {
 /// same key again overwrites it.
 ///
 /// [Config::ConfiguredAddr]: crate::config::Config::ConfiguredAddr
-pub async fn store_self_keypair(
+pub(crate) async fn store_self_keypair(
    context: &Context,
    keypair: &KeyPair,
    default: KeyPairUse,
@@ -294,11 +294,17 @@ pub async fn store_self_keypair(
                KeyPairUse::ReadOnly => false,
            };

+            // `addr` and `is_default` written for compatibility with older versions,
+            // until new cores are rolled out everywhere.
+            // otherwise "add second device" or "backup" may break.
+            // moreover, this allows downgrades to the previous version.
+            // writing of `addr` and `is_default` can be removed ~ 2024-08
+            let addr = keypair.addr.to_string();
            transaction
                .execute(
-                    "INSERT OR REPLACE INTO keypairs (public_key, private_key)
-                     VALUES (?,?)",
-                    (&public_key, &secret_key),
+                    "INSERT OR REPLACE INTO keypairs (public_key, private_key, addr, is_default)
+                     VALUES (?,?,?,?)",
+                    (&public_key, &secret_key, addr, is_default),
                )
                .context("Failed to insert keypair")?;

--- a/src/location.rs
+++ b/src/location.rs
@@ -139,8 +139,9 @@ impl Kml {
                match chrono::NaiveDateTime::parse_from_str(&val, "%Y-%m-%dT%H:%M:%SZ") {
                    Ok(res) => {
                        self.curr.timestamp = res.timestamp();
-                        if self.curr.timestamp > time() {
-                            self.curr.timestamp = time();
+                        let now = time();
+                        if self.curr.timestamp > now {
+                            self.curr.timestamp = now;
                        }
                    }
                    Err(_err) => {
@@ -333,12 +334,13 @@ pub async fn set(context: &Context, latitude: f64, longitude: f64, accuracy: f64
        return Ok(true);
    }
    let mut continue_streaming = false;
+    let now = time();

    let chats = context
        .sql
        .query_map(
            "SELECT id FROM chats WHERE locations_send_until>?;",
-            (time(),),
+            (now,),
            |row| row.get::<_, i32>(0),
            |chats| {
                chats
@@ -356,7 +358,7 @@ pub async fn set(context: &Context, latitude: f64, longitude: f64, accuracy: f64
                    latitude,
                    longitude,
                    accuracy,
-                    time(),
+                    now,
                    chat_id,
                    ContactId::SELF,
                )).await.context("Failed to store location")?;
@@ -954,7 +956,7 @@ Content-Disposition: attachment; filename="location.kml"
        assert!(msg.chat_id == bob_chat_id);
        assert_eq!(msg.msg_ids.len(), 1);

-        let bob_msg = Message::load_from_db(&bob, *msg.msg_ids.get(0).unwrap()).await?;
+        let bob_msg = Message::load_from_db(&bob, *msg.msg_ids.first().unwrap()).await?;
        assert_eq!(bob_msg.chat_id, bob_chat_id);
        assert_eq!(bob_msg.viewtype, Viewtype::Image);

--- a/src/login_param.rs
+++ b/src/login_param.rs
@@ -14,8 +14,22 @@ use crate::socks::Socks5Config;
 #[repr(u32)]
 #[strum(serialize_all = "snake_case")]
 pub enum CertificateChecks {
-    /// Same as AcceptInvalidCertificates unless overridden by
-    /// `strict_tls` setting in provider database.
+    /// Same as AcceptInvalidCertificates if stored in the database
+    /// as `configured_{imap,smtp}_certificate_checks`.
+    ///
+    /// Previous Delta Chat versions stored this in `configured_*`
+    /// if Automatic configuration
+    /// was selected, configuration with strict TLS checks failed
+    /// and configuration without strict TLS checks succeeded.
+    ///
+    /// Currently Delta Chat stores only
+    /// `Strict` or `AcceptInvalidCertificates` variants
+    /// in `configured_*` settings.
+    ///
+    /// `Automatic` in `{imap,smtp}_certificate_checks`
+    /// means that provider database setting should be taken.
+    /// If there is no provider database setting for certificate checks,
+    /// `Automatic` is the same as `Strict`.
    Automatic = 0,

    Strict = 1,
--- a/src/message.rs
+++ b/src/message.rs
@@ -757,7 +757,7 @@ impl Message {
        self.param.get_int(Param::GuaranteeE2ee).unwrap_or_default() != 0
    }

-    /// Returns true if message is Auto-Submitted.
+    /// Returns true if message is auto-generated.
    pub fn is_bot(&self) -> bool {
        self.param.get_bool(Param::Bot).unwrap_or_default()
    }
@@ -1130,7 +1130,7 @@ impl Message {
    /// `References` header is not taken into account.
    pub async fn parent(&self, context: &Context) -> Result<Option<Message>> {
        if let Some(in_reply_to) = &self.in_reply_to {
-            if let Some(msg_id) = rfc724_mid_exists(context, in_reply_to).await? {
+            if let Some((msg_id, _ts_sent)) = rfc724_mid_exists(context, in_reply_to).await? {
                let msg = Message::load_from_db(context, msg_id).await?;
                return if msg.chat_id.is_trash() {
                    // If message is already moved to trash chat, pretend it does not exist.
@@ -1522,7 +1522,9 @@ pub async fn delete_msgs(context: &Context, msg_ids: &[MsgId]) -> Result<()> {

    if !msg_ids.is_empty() {
        // Run housekeeping to delete unused blobs.
-        context.set_config(Config::LastHousekeeping, None).await?;
+        context
+            .set_config_internal(Config::LastHousekeeping, None)
+            .await?;
    }

    // Interrupt Inbox loop to start message deletion and run housekeeping.
@@ -1550,7 +1552,7 @@ pub async fn markseen_msgs(context: &Context, msg_ids: Vec<MsgId>) -> Result<()>
    let old_last_msg_id = MsgId::new(context.get_config_u32(Config::LastMsgId).await?);
    let last_msg_id = msg_ids.iter().fold(&old_last_msg_id, std::cmp::max);
    context
-        .set_config_u32(Config::LastMsgId, last_msg_id.to_u32())
+        .set_config_internal(Config::LastMsgId, Some(&last_msg_id.to_u32().to_string()))
        .await?;

    let msgs = context
@@ -1816,18 +1818,23 @@ pub async fn estimate_deletion_cnt(
    Ok(cnt)
 }

+/// See [`rfc724_mid_exists_and()`].
 pub(crate) async fn rfc724_mid_exists(
    context: &Context,
    rfc724_mid: &str,
-) -> Result<Option<MsgId>> {
+) -> Result<Option<(MsgId, i64)>> {
    rfc724_mid_exists_and(context, rfc724_mid, "1").await
 }

+/// Returns [MsgId] and "sent" timestamp of the message with given `rfc724_mid` (Message-ID header)
+/// if it exists in the db.
+///
+/// @param cond SQL subexpression for filtering messages.
 pub(crate) async fn rfc724_mid_exists_and(
    context: &Context,
    rfc724_mid: &str,
    cond: &str,
-) -> Result<Option<MsgId>> {
+) -> Result<Option<(MsgId, i64)>> {
    let rfc724_mid = rfc724_mid.trim_start_matches('<').trim_end_matches('>');
    if rfc724_mid.is_empty() {
        warn!(context, "Empty rfc724_mid passed to rfc724_mid_exists");
@@ -1837,12 +1844,13 @@ pub(crate) async fn rfc724_mid_exists_and(
    let res = context
        .sql
        .query_row_optional(
-            &("SELECT id FROM msgs WHERE rfc724_mid=? AND ".to_string() + cond),
+            &("SELECT id, timestamp_sent FROM msgs WHERE rfc724_mid=? AND ".to_string() + cond),
            (rfc724_mid,),
            |row| {
                let msg_id: MsgId = row.get(0)?;
+                let timestamp_sent: i64 = row.get(1)?;

-                Ok(msg_id)
+                Ok((msg_id, timestamp_sent))
            },
        )
        .await?;
@@ -1858,7 +1866,7 @@ pub(crate) async fn get_latest_by_rfc724_mids(
    mids: &[String],
 ) -> Result<Option<Message>> {
    for id in mids.iter().rev() {
-        if let Some(msg_id) = rfc724_mid_exists(context, id).await? {
+        if let Some((msg_id, _)) = rfc724_mid_exists(context, id).await? {
            let msg = Message::load_from_db(context, msg_id).await?;
            if msg.chat_id != DC_CHAT_ID_TRASH {
                return Ok(Some(msg));
--- a/src/mimefactory.rs
+++ b/src/mimefactory.rs
@@ -277,7 +277,7 @@ impl<'a> MimeFactory<'a> {
    async fn peerstates_for_recipients(
        &self,
        context: &Context,
-    ) -> Result<Vec<(Option<Peerstate>, &str)>> {
+    ) -> Result<Vec<(Option<Peerstate>, String)>> {
        let self_addr = context.get_primary_self_addr().await?;

        let mut res = Vec::new();
@@ -286,7 +286,7 @@ impl<'a> MimeFactory<'a> {
            .iter()
            .filter(|(_, addr)| addr != &self_addr)
        {
-            res.push((Peerstate::from_addr(context, addr).await?, addr.as_str()));
+            res.push((Peerstate::from_addr(context, addr).await?, addr.clone()));
        }

        Ok(res)
@@ -338,20 +338,13 @@ impl<'a> MimeFactory<'a> {
    fn should_force_plaintext(&self) -> bool {
        match &self.loaded {
            Loaded::Message { chat } => {
-                if chat.is_protected() {
-                    false
-                } else if chat.typ == Chattype::Broadcast {
-                    // encryption may disclose recipients;
-                    // this is probably a worse issue than not opportunistically (!) encrypting
-                    true
-                } else {
-                    self.msg
-                        .param
-                        .get_bool(Param::ForcePlaintext)
-                        .unwrap_or_default()
-                }
+                self.msg
+                    .param
+                    .get_bool(Param::ForcePlaintext)
+                    .unwrap_or_default()
+                    || chat.typ == Chattype::Broadcast
            }
-            Loaded::Mdn { .. } => true,
+            Loaded::Mdn { .. } => false,
        }
    }

@@ -917,6 +910,16 @@ impl<'a> MimeFactory<'a> {
        Ok(Some(part))
    }

+    fn add_message_text(&self, part: PartBuilder, mut text: String) -> PartBuilder {
+        // This is needed to protect from ESPs (such as gmx.at) doing their own Quoted-Printable
+        // encoding and thus breaking messages and signatures. It's unlikely that the reader uses a
+        // MUA not supporting Quoted-Printable encoding. And RFC 2646 "4.6" also recommends it for
+        // encrypted messages.
+        let part = part.header(("Content-Transfer-Encoding", "quoted-printable"));
+        text = quoted_printable::encode_to_str(text);
+        part.body(text)
+    }
+
    #[allow(clippy::cognitive_complexity)]
    async fn render_message(
        &mut self,
@@ -930,7 +933,6 @@ impl<'a> MimeFactory<'a> {
        };
        let command = self.msg.param.get_cmd();
        let mut placeholdertext = None;
-        let mut meta_part = None;

        let send_verified_headers = match chat.typ {
            Chattype::Single => true,
@@ -1085,6 +1087,13 @@ impl<'a> MimeFactory<'a> {
                        ));
                    }

+                    let fingerprint = msg.param.get(Param::Arg3).unwrap_or_default();
+                    if !fingerprint.is_empty() {
+                        headers.protected.push(Header::new(
+                            "Secure-Join-Fingerprint".into(),
+                            fingerprint.into(),
+                        ));
+                    }
                    if let Some(id) = msg.param.get(Param::Arg4) {
                        headers
                            .protected
@@ -1109,17 +1118,13 @@ impl<'a> MimeFactory<'a> {

        if let Some(grpimage) = grpimage {
            info!(context, "setting group image '{}'", grpimage);
-            let mut meta = Message {
-                viewtype: Viewtype::Image,
-                ..Default::default()
-            };
-            meta.param.set(Param::File, grpimage);
-
-            let (mail, filename_as_sent) = build_body_file(context, &meta, "group-image").await?;
-            meta_part = Some(mail);
-            headers
-                .protected
-                .push(Header::new("Chat-Group-Avatar".into(), filename_as_sent));
+            let avatar = build_avatar_file(context, grpimage)
+                .await
+                .context("Cannot attach group image")?;
+            headers.hidden.push(Header::new(
+                "Chat-Group-Avatar".into(),
+                format!("base64:{avatar}"),
+            ));
        }

        if self.msg.viewtype == Viewtype::Sticker {
@@ -1207,13 +1212,11 @@ impl<'a> MimeFactory<'a> {
            footer
        );

-        // Message is sent as text/plain, with charset = utf-8
-        let mut main_part = PartBuilder::new()
-            .header((
-                "Content-Type".to_string(),
-                "text/plain; charset=utf-8; format=flowed; delsp=no".to_string(),
-            ))
-            .body(message_text);
+        let mut main_part = PartBuilder::new().header((
+            "Content-Type",
+            "text/plain; charset=utf-8; format=flowed; delsp=no",
+        ));
+        main_part = self.add_message_text(main_part, message_text);

        if is_reaction {
            main_part = main_part.header(("Content-Disposition", "reaction"));
@@ -1245,10 +1248,6 @@ impl<'a> MimeFactory<'a> {
            parts.push(file_part);
        }

-        if let Some(meta_part) = meta_part {
-            parts.push(meta_part);
-        }
-
        if let Some(msg_kml_part) = self.get_message_kml_part() {
            parts.push(msg_kml_part);
        }
@@ -1280,7 +1279,7 @@ impl<'a> MimeFactory<'a> {

        if self.attach_selfavatar {
            match context.get_config(Config::Selfavatar).await? {
-                Some(path) => match build_selfavatar_file(context, &path).await {
+                Some(path) => match build_avatar_file(context, &path).await {
                    Ok(avatar) => headers.hidden.push(Header::new(
                        "Chat-User-Avatar".into(),
                        format!("base64:{avatar}"),
@@ -1340,15 +1339,12 @@ impl<'a> MimeFactory<'a> {
        };
        let p2 = stock_str::read_rcpt_mail_body(context, &p1).await;
        let message_text = format!("{}\r\n", format_flowed(&p2));
-        message = message.child(
-            PartBuilder::new()
-                .header((
-                    "Content-Type".to_string(),
-                    "text/plain; charset=utf-8; format=flowed; delsp=no".to_string(),
-                ))
-                .body(message_text)
-                .build(),
-        );
+        let text_part = PartBuilder::new().header((
+            "Content-Type".to_string(),
+            "text/plain; charset=utf-8; format=flowed; delsp=no".to_string(),
+        ));
+        let text_part = self.add_message_text(text_part, message_text);
+        message = message.child(text_part.build());

        // second body part: machine-readable, always REQUIRED by RFC 6522
        let message_text2 = format!(
@@ -1492,8 +1488,11 @@ async fn build_body_file(
    Ok((mail, filename_to_send))
 }

-async fn build_selfavatar_file(context: &Context, path: &str) -> Result<String> {
-    let blob = BlobObject::from_path(context, path.as_ref())?;
+async fn build_avatar_file(context: &Context, path: &str) -> Result<String> {
+    let blob = match path.starts_with("$BLOBDIR/") {
+        true => BlobObject::from_name(context, path.to_string())?,
+        false => BlobObject::from_path(context, path.as_ref())?,
+    };
    let body = fs::read(blob.to_abs_path()).await?;
    let encoded_body = wrapped_base64_encode(&body);
    Ok(encoded_body)
@@ -1564,6 +1563,7 @@ mod tests {
    use crate::mimeparser::MimeMessage;
    use crate::receive_imf::receive_imf;
    use crate::test_utils::{get_chat_msg, TestContext, TestContextManager};
+
    #[test]
    fn test_render_email_address() {
        let display_name = "ä space";
@@ -1819,6 +1819,37 @@ mod tests {
        assert_eq!("Re: Hello, Bob", mf.subject_str(&t).await.unwrap());
    }

+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn test_mdn_create_encrypted() -> Result<()> {
+        let mut tcm = TestContextManager::new();
+        let alice = tcm.alice().await;
+        let bob = tcm.bob().await;
+        bob.set_config_bool(Config::MdnsEnabled, true).await?;
+
+        let mut msg = Message::new(Viewtype::Text);
+        msg.param.set_int(Param::SkipAutocrypt, 1);
+        let chat_alice = alice.create_chat(&bob).await.id;
+        let sent = alice.send_msg(chat_alice, &mut msg).await;
+
+        let rcvd = bob.recv_msg(&sent).await;
+        message::markseen_msgs(&bob, vec![rcvd.id]).await?;
+        let mimefactory = MimeFactory::from_mdn(&bob, &rcvd, vec![]).await?;
+        let rendered_msg = mimefactory.render(&bob).await?;
+
+        assert!(!rendered_msg.is_encrypted);
+
+        let rcvd = tcm.send_recv(&alice, &bob, "Heyho").await;
+        message::markseen_msgs(&bob, vec![rcvd.id]).await?;
+
+        let mimefactory = MimeFactory::from_mdn(&bob, &rcvd, vec![]).await?;
+        let rendered_msg = mimefactory.render(&bob).await?;
+
+        // When encrypted, the MDN should be encrypted as well
+        assert!(rendered_msg.is_encrypted);
+
+        Ok(())
+    }
+
    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
    async fn test_subject_in_group() -> Result<()> {
        async fn send_msg_get_subject(
@@ -2159,6 +2190,7 @@ mod tests {
        assert_eq!(inner.match_indices("Message-ID:").count(), 1);
        assert_eq!(inner.match_indices("Chat-User-Avatar:").count(), 1);
        assert_eq!(inner.match_indices("Subject:").count(), 0);
+        assert_eq!(inner.match_indices("quoted-printable").count(), 1);

        assert_eq!(body.match_indices("this is the text!").count(), 1);

@@ -2179,6 +2211,7 @@ mod tests {
        assert_eq!(inner.match_indices("Message-ID:").count(), 1);
        assert_eq!(inner.match_indices("Chat-User-Avatar:").count(), 0);
        assert_eq!(inner.match_indices("Subject:").count(), 0);
+        assert_eq!(inner.match_indices("quoted-printable").count(), 1);

        assert_eq!(body.match_indices("this is the text!").count(), 1);

@@ -2235,6 +2268,7 @@ mod tests {
        assert_eq!(part.match_indices("Message-ID:").count(), 1);
        assert_eq!(part.match_indices("Chat-User-Avatar:").count(), 1);
        assert_eq!(part.match_indices("Subject:").count(), 0);
+        assert_eq!(part.match_indices("quoted-printable").count(), 1);

        let body = payload.next().unwrap();
        assert_eq!(body.match_indices("this is the text!").count(), 1);
@@ -2282,6 +2316,7 @@ mod tests {
        assert_eq!(part.match_indices("Message-ID:").count(), 1);
        assert_eq!(part.match_indices("Chat-User-Avatar:").count(), 0);
        assert_eq!(part.match_indices("Subject:").count(), 0);
+        assert_eq!(part.match_indices("quoted-printable").count(), 1);

        let body = payload.next().unwrap();
        assert_eq!(body.match_indices("this is the text!").count(), 1);
--- a/src/mimeparser.rs
+++ b/src/mimeparser.rs
@@ -8,7 +8,6 @@ use std::pin::Pin;
 use std::str;

 use anyhow::{bail, Context as _, Result};
-use base64::Engine as _;
 use deltachat_derive::{FromSql, ToSql};
 use format_flowed::unformat_flowed;
 use lettre_email::mime::{self, Mime};
@@ -69,6 +68,8 @@ pub(crate) struct MimeMessage {
    /// Whether the From address was repeated in the signed part
    /// (and we know that the signer intended to send from this address)
    pub from_is_signed: bool,
+    /// Whether the message is incoming or outgoing (self-sent).
+    pub incoming: bool,
    /// The List-Post address is only set for mailing lists. Users can send
    /// messages to this address to post them to the list.
    pub list_post: Option<String>,
@@ -82,9 +83,10 @@ pub(crate) struct MimeMessage {
    /// If a message is not encrypted or the signature is not valid,
    /// this set is empty.
    pub signatures: HashSet<Fingerprint>,
-    /// The set of mail recipient addresses for which gossip headers were applied, regardless of
-    /// whether they modified any peerstates.
-    pub gossiped_addr: HashSet<String>,
+    /// The mail recipient addresses for which gossip headers were applied
+    /// and their respective gossiped keys,
+    /// regardless of whether they modified any peerstates.
+    pub gossiped_keys: HashMap<String, SignedPublicKey>,

    /// True if the message is a forwarded message.
    pub is_forwarded: bool,
@@ -117,8 +119,8 @@ pub(crate) struct MimeMessage {
    /// Hop info for debugging.
    pub(crate) hop_info: String,

-    /// Whether the contact sending this should be marked as bot.
-    pub(crate) is_bot: bool,
+    /// Whether the contact sending this should be marked as bot or non-bot.
+    pub(crate) is_bot: Option<bool>,

    /// When the message was received, in secs since epoch.
    pub(crate) timestamp_rcvd: i64,
@@ -176,6 +178,10 @@ pub enum SystemMessage {
    /// "%1$s sent a message from another device."
    ChatProtectionDisabled = 12,

+    /// Message can't be sent because of `Invalid unencrypted mail to <>`
+    /// which is sent by chatmail servers.
+    InvalidUnencryptedMail = 13,
+
    /// Self-sent-message that contains only json used for multi-device-sync;
    /// if possible, we attach that to other messages as for locations.
    MultiDeviceSync = 20,
@@ -203,11 +209,12 @@ impl MimeMessage {
    ) -> Result<Self> {
        let mail = mailparse::parse_mail(body)?;

-        let message_time = mail
+        let timestamp_rcvd = smeared_time(context);
+        let timestamp_sent = mail
            .headers
            .get_header_value(HeaderDef::Date)
            .and_then(|v| mailparse::dateparse(&v).ok())
-            .unwrap_or_default();
+            .map_or(timestamp_rcvd, |value| min(value, timestamp_rcvd + 60));
        let mut hop_info = parse_receive_headers(&mail.get_headers());

        let mut headers = Default::default();
@@ -258,8 +265,10 @@ impl MimeMessage {
                for field in &part.headers {
                    let key = field.get_key().to_lowercase();

-                    // For now only Chat-User-Avatar can be hidden.
-                    if !headers.contains_key(&key) && key == "chat-user-avatar" {
+                    // For now only avatar headers can be hidden.
+                    if !headers.contains_key(&key)
+                        && (key == "chat-user-avatar" || key == "chat-group-avatar")
+                    {
                        headers.insert(key.to_string(), field.get_value());
                    }
                }
@@ -274,11 +283,11 @@ impl MimeMessage {
        let private_keyring = load_self_secret_keyring(context).await?;

        let mut decryption_info =
-            prepare_decryption(context, &mail, &from.addr, message_time).await?;
+            prepare_decryption(context, &mail, &from.addr, timestamp_sent).await?;

        // Memory location for a possible decrypted message.
        let mut mail_raw = Vec::new();
-        let mut gossiped_addr = Default::default();
+        let mut gossiped_keys = Default::default();
        let mut from_is_signed = false;
        hop_info += "\n\n";
        hop_info += &decryption_info.dkim_results.to_string();
@@ -318,9 +327,9 @@ impl MimeMessage {
                // but only if the mail was correctly signed. Probably it's ok to not require
                // encryption here, but let's follow the standard.
                let gossip_headers = mail.headers.get_all_values("Autocrypt-Gossip");
-                gossiped_addr = update_gossip_peerstates(
+                gossiped_keys = update_gossip_peerstates(
                    context,
-                    message_time,
+                    timestamp_sent,
                    &from.addr,
                    &recipients,
                    gossip_headers,
@@ -371,12 +380,12 @@ impl MimeMessage {

            // If it is not a read receipt, degrade encryption.
            if let (Some(peerstate), Ok(mail)) = (&mut decryption_info.peerstate, mail) {
-                if message_time > peerstate.last_seen_autocrypt
+                if timestamp_sent > peerstate.last_seen_autocrypt
                    && mail.ctype.mimetype != "multipart/report"
                // Disallowing keychanges is disabled for now:
                // && decryption_info.dkim_results.allow_keychange
                {
-                    peerstate.degrade_encryption(message_time);
+                    peerstate.degrade_encryption(timestamp_sent);
                }
            }
        }
@@ -390,15 +399,7 @@ impl MimeMessage {
            }
        }

-        // Auto-submitted is also set by holiday-notices so we also check `chat-version`
-        let is_bot = headers.contains_key("auto-submitted") && headers.contains_key("chat-version");
-
-        let timestamp_rcvd = smeared_time(context);
-        let timestamp_sent = headers
-            .get(HeaderDef::Date.get_headername())
-            .and_then(|value| mailparse::dateparse(value).ok())
-            .map_or(timestamp_rcvd, |value| min(value, timestamp_rcvd + 60));
-
+        let incoming = !context.is_self_addr(&from.addr).await?;
        let mut parser = MimeMessage {
            parts: Vec::new(),
            headers,
@@ -406,13 +407,14 @@ impl MimeMessage {
            list_post,
            from,
            from_is_signed,
+            incoming,
            chat_disposition_notification_to,
            decryption_info,
            decrypting_failed: mail.is_err(),

            // only non-empty if it was a valid autocrypt message
            signatures,
-            gossiped_addr,
+            gossiped_keys,
            is_forwarded: false,
            mdn_reports: Vec::new(),
            is_system_message: SystemMessage::Unknown,
@@ -427,7 +429,7 @@ impl MimeMessage {
            is_mime_modified: false,
            decoded_data: Vec::new(),
            hop_info,
-            is_bot,
+            is_bot: None,
            timestamp_rcvd,
            timestamp_sent,
        };
@@ -460,6 +462,13 @@ impl MimeMessage {
            },
        };

+        if parser.mdn_reports.is_empty() {
+            // "Auto-Submitted" is also set by holiday-notices so we also check "chat-version".
+            let is_bot = parser.headers.get("auto-submitted")
+                == Some(&"auto-generated".to_string())
+                && parser.headers.contains_key("chat-version");
+            parser.is_bot = Some(is_bot);
+        }
        parser.maybe_remove_bad_parts();
        parser.maybe_remove_inline_mailinglist_footer();
        parser.heuristically_parse_ndn(context).await;
@@ -698,7 +707,7 @@ impl MimeMessage {
            self.do_add_single_part(part);
        }

-        if self.headers.contains_key("auto-submitted") {
+        if self.is_bot == Some(true) {
            for part in &mut self.parts {
                part.param.set(Param::Bot, "1");
            }
@@ -714,37 +723,20 @@ impl MimeMessage {
    ) -> Option<AvatarAction> {
        if header_value == "0" {
            Some(AvatarAction::Delete)
-        } else if let Some(avatar) = header_value
+        } else if let Some(base64) = header_value
            .split_ascii_whitespace()
            .collect::<String>()
            .strip_prefix("base64:")
-            .map(|x| base64::engine::general_purpose::STANDARD.decode(x))
        {
-            // Avatar sent directly in the header as base64.
-            if let Ok(decoded_data) = avatar {
-                let extension = if let Ok(format) = image::guess_format(&decoded_data) {
-                    if let Some(ext) = format.extensions_str().first() {
-                        format!(".{ext}")
-                    } else {
-                        String::new()
-                    }
-                } else {
-                    String::new()
-                };
-                match BlobObject::create(context, &format!("avatar{extension}"), &decoded_data)
-                    .await
-                {
-                    Ok(blob) => Some(AvatarAction::Change(blob.as_name().to_string())),
-                    Err(err) => {
-                        warn!(
-                            context,
-                            "Could not save decoded avatar to blob file: {:#}", err
-                        );
-                        None
-                    }
+            match BlobObject::store_from_base64(context, base64, "avatar").await {
+                Ok(path) => Some(AvatarAction::Change(path)),
+                Err(err) => {
+                    warn!(
+                        context,
+                        "Could not decode and save avatar to blob file: {:#}", err,
+                    );
+                    None
                }
-            } else {
-                None
            }
        } else {
            // Avatar sent in attachment, as previous versions of Delta Chat did.
@@ -914,7 +906,7 @@ impl MimeMessage {
                skip the rest.  (see
                <https://k9mail.app/2016/11/24/OpenPGP-Considerations-Part-I.html>
                for background information why we use encrypted+signed) */
-                if let Some(first) = mail.subparts.get(0) {
+                if let Some(first) = mail.subparts.first() {
                    any_part_added = self
                        .parse_mime_recursive(context, first, is_related)
                        .await?;
@@ -970,10 +962,13 @@ impl MimeMessage {
                            }
                        }
                        Some(_) => {
-                            if let Some(first) = mail.subparts.get(0) {
-                                any_part_added = self
-                                    .parse_mime_recursive(context, first, is_related)
-                                    .await?;
+                            for cur_data in &mail.subparts {
+                                if self
+                                    .parse_mime_recursive(context, cur_data, is_related)
+                                    .await?
+                                {
+                                    any_part_added = true;
+                                }
                            }
                        }
                    }
@@ -1717,9 +1712,9 @@ async fn update_gossip_peerstates(
    from: &str,
    recipients: &[SingleInfo],
    gossip_headers: Vec<String>,
-) -> Result<HashSet<String>> {
+) -> Result<HashMap<String, SignedPublicKey>> {
    // XXX split the parsing from the modification part
-    let mut gossiped_addr: HashSet<String> = Default::default();
+    let mut gossiped_keys: HashMap<String, SignedPublicKey> = Default::default();

    for value in &gossip_headers {
        let header = match value.parse::<Aheader>() {
@@ -1763,10 +1758,10 @@ async fn update_gossip_peerstates(
            .handle_fingerprint_change(context, message_time)
            .await?;

-        gossiped_addr.insert(header.addr.to_lowercase());
+        gossiped_keys.insert(header.addr.to_lowercase(), header.public_key);
    }

-    Ok(gossiped_addr)
+    Ok(gossiped_keys)
 }

 /// Message Disposition Notification (RFC 8098)
@@ -2225,6 +2220,7 @@ mod tests {
        message::{Message, MessageState, MessengerMessage},
        receive_imf::receive_imf,
        test_utils::TestContext,
+        tools::time,
    };

    impl AvatarAction {
@@ -2733,6 +2729,7 @@ Chat-Version: 1.0\n\
 Message-ID: <bar@example.org>\n\
 To: Alice <alice@example.org>\n\
 From: Bob <bob@example.org>\n\
+Auto-Submitted: auto-replied\n\
 Content-Type: multipart/report; report-type=disposition-notification;\n\t\
 boundary=\"kJBbU58X1xeWNHgBtTbMk80M5qnV4N\"\n\
 \n\
@@ -2768,6 +2765,7 @@ Disposition: manual-action/MDN-sent-automatically; displayed\n\

        assert_eq!(message.parts.len(), 1);
        assert_eq!(message.mdn_reports.len(), 1);
+        assert_eq!(message.is_bot, None);
    }

    /// Test parsing multiple MDNs combined in a single message.
@@ -3819,4 +3817,56 @@ Content-Disposition: reaction\n\

        Ok(())
    }
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn test_tlsrpt() -> Result<()> {
+        let context = TestContext::new_alice().await;
+        let raw = include_bytes!("../test-data/message/tlsrpt.eml");
+
+        let msg = MimeMessage::from_bytes(&context.ctx, &raw[..], None)
+            .await
+            .unwrap();
+        assert_eq!(msg.parts.len(), 1);
+
+        assert_eq!(msg.parts[0].typ, Viewtype::File);
+        assert_eq!(msg.parts[0].msg, "Report Domain: nine.testrun.org Submitter: google.com Report-ID: <2024.01.20T00.00.00Z+nine.testrun.org@google.com> – This is an aggregate TLS report from google.com");
+
+        Ok(())
+    }
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn test_time_in_future() -> Result<()> {
+        let alice = TestContext::new_alice().await;
+
+        let beginning_time = time();
+
+        // Receive a message with a date far in the future (year 3004)
+        // I'm just going to assume that no one uses this code after the year 3000
+        let mime_message = MimeMessage::from_bytes(
+            &alice,
+            b"To: alice@example.org\n\
+              From: bob@example.net\n\
+              Date: Today, 29 February 3004 00:00:10 -800\n\
+              Message-ID: 56789@example.net\n\
+              Subject: Meeting\n\
+              Mime-Version: 1.0 (1.0)\n\
+              Content-Type: text/plain; charset=utf-8\n\
+              \n\
+              Hi",
+            None,
+        )
+        .await?;
+
+        // We do allow the time to be in the future a bit (because of unsynchronized clocks),
+        // but only 60 seconds:
+        assert!(mime_message.decryption_info.message_time <= time() + 60);
+        assert!(mime_message.decryption_info.message_time >= beginning_time + 60);
+        assert_eq!(
+            mime_message.decryption_info.message_time,
+            mime_message.timestamp_sent
+        );
+        assert!(mime_message.timestamp_rcvd <= time());
+
+        Ok(())
+    }
 }
--- a/src/param.rs
+++ b/src/param.rs
@@ -65,7 +65,7 @@ pub enum Param {
    /// For Messages: the message is a reaction.
    Reaction = b'x',

-    /// For Messages: a message with Auto-Submitted header ("bot").
+    /// For Messages: a message with "Auto-Submitted: auto-generated" header ("bot").
    Bot = b'b',

    /// For Messages: unset or 0=not forwarded,
@@ -84,6 +84,9 @@ pub enum Param {
    /// For Messages
    Arg2 = b'F',

+    /// `Secure-Join-Fingerprint` header for `{vc,vg}-request-with-auth` messages.
+    Arg3 = b'G',
+
    /// For Messages
    Arg4 = b'H',

--- a/src/peerstate.rs
+++ b/src/peerstate.rs
@@ -97,13 +97,28 @@ pub struct Peerstate {
 impl Peerstate {
    /// Creates a peerstate from the `Autocrypt` header.
    pub fn from_header(header: &Aheader, message_time: i64) -> Self {
+        Self::from_public_key(
+            &header.addr,
+            message_time,
+            header.prefer_encrypt,
+            &header.public_key,
+        )
+    }
+
+    /// Creates a peerstate from the given public key.
+    pub fn from_public_key(
+        addr: &str,
+        last_seen: i64,
+        prefer_encrypt: EncryptPreference,
+        public_key: &SignedPublicKey,
+    ) -> Self {
        Peerstate {
-            addr: header.addr.clone(),
-            last_seen: message_time,
-            last_seen_autocrypt: message_time,
-            prefer_encrypt: header.prefer_encrypt,
-            public_key: Some(header.public_key.clone()),
-            public_key_fingerprint: Some(header.public_key.fingerprint()),
+            addr: addr.to_string(),
+            last_seen,
+            last_seen_autocrypt: last_seen,
+            prefer_encrypt,
+            public_key: Some(public_key.clone()),
+            public_key_fingerprint: Some(public_key.fingerprint()),
            gossip_key: None,
            gossip_key_fingerprint: None,
            gossip_timestamp: 0,
@@ -322,7 +337,7 @@ impl Peerstate {
            return;
        }

-        if message_time > self.last_seen {
+        if message_time >= self.last_seen {
            self.last_seen = message_time;
            self.last_seen_autocrypt = message_time;
            if (header.prefer_encrypt == EncryptPreference::Mutual
@@ -345,7 +360,7 @@ impl Peerstate {
            return;
        }

-        if message_time > self.gossip_timestamp {
+        if message_time >= self.gossip_timestamp {
            self.gossip_timestamp = message_time;
            if self.gossip_key.as_ref() != Some(&gossip_header.public_key) {
                self.gossip_key = Some(gossip_header.public_key.clone());
@@ -457,59 +472,44 @@ impl Peerstate {
        Ok(backward_verified)
    }

-    /// Set this peerstate to verified
-    /// Make sure to call `self.save_to_db` to save these changes
+    /// Set this peerstate to verified;
+    /// make sure to call `self.save_to_db` to save these changes.
+    ///
    /// Params:
-    /// verifier:
+    ///
+    /// * key: The new verified key.
+    /// * fingerprint: Only set to verified if the key's fingerprint matches this.
+    /// * verifier:
    ///   The address which introduces the given contact.
    ///   If we are verifying the contact, use that contacts address.
    pub fn set_verified(
        &mut self,
-        which_key: PeerstateKeyType,
+        key: SignedPublicKey,
        fingerprint: Fingerprint,
        verifier: String,
    ) -> Result<()> {
-        match which_key {
-            PeerstateKeyType::PublicKey => {
-                if self.public_key_fingerprint.is_some()
-                    && self.public_key_fingerprint.as_ref().unwrap() == &fingerprint
-                {
-                    self.verified_key = self.public_key.clone();
-                    self.verified_key_fingerprint = Some(fingerprint);
-                    self.verifier = Some(verifier);
-                    Ok(())
-                } else {
-                    Err(Error::msg(format!(
-                        "{fingerprint} is not peer's public key fingerprint",
-                    )))
-                }
-            }
-            PeerstateKeyType::GossipKey => {
-                if self.gossip_key_fingerprint.is_some()
-                    && self.gossip_key_fingerprint.as_ref().unwrap() == &fingerprint
-                {
-                    self.verified_key = self.gossip_key.clone();
-                    self.verified_key_fingerprint = Some(fingerprint);
-                    self.verifier = Some(verifier);
-                    Ok(())
-                } else {
-                    Err(Error::msg(format!(
-                        "{fingerprint} is not peer's gossip key fingerprint",
-                    )))
-                }
-            }
+        if key.fingerprint() == fingerprint {
+            self.verified_key = Some(key);
+            self.verified_key_fingerprint = Some(fingerprint);
+            self.verifier = Some(verifier);
+            Ok(())
+        } else {
+            Err(Error::msg(format!(
+                "{fingerprint} is not peer's key fingerprint",
+            )))
        }
    }

-    /// Sets current gossiped key as the secondary verified key.
+    /// Sets the gossiped key as the secondary verified key.
    ///
    /// If gossiped key is the same as the current verified key,
    /// do nothing to avoid overwriting secondary verified key
    /// which may be different.
-    pub fn set_secondary_verified_key_from_gossip(&mut self, verifier: String) {
-        if self.gossip_key_fingerprint != self.verified_key_fingerprint {
-            self.secondary_verified_key = self.gossip_key.clone();
-            self.secondary_verified_key_fingerprint = self.gossip_key_fingerprint.clone();
+    pub fn set_secondary_verified_key(&mut self, gossip_key: SignedPublicKey, verifier: String) {
+        let fingerprint = gossip_key.fingerprint();
+        if self.verified_key_fingerprint.as_ref() != Some(&fingerprint) {
+            self.secondary_verified_key = Some(gossip_key);
+            self.secondary_verified_key_fingerprint = Some(fingerprint);
            self.secondary_verifier = Some(verifier);
        }
    }
@@ -995,7 +995,7 @@ mod tests {
        assert_eq!(peerstate.prefer_encrypt, EncryptPreference::Reset);

        // Same header will be applied in the future.
-        peerstate.apply_header(&header, 400);
+        peerstate.apply_header(&header, 300);
        assert_eq!(peerstate.prefer_encrypt, EncryptPreference::Mutual);
    }
 }
--- a/src/pgp.rs
+++ b/src/pgp.rs
@@ -4,7 +4,7 @@ use std::collections::{BTreeMap, HashSet};
 use std::io;
 use std::io::Cursor;

-use anyhow::{bail, format_err, Context as _, Result};
+use anyhow::{bail, Context as _, Result};
 use pgp::armor::BlockType;
 use pgp::composed::{
    Deserializable, KeyType as PgpKeyType, Message, SecretKeyParamsBuilder, SignedPublicKey,
@@ -138,8 +138,11 @@ pub struct KeyPair {
 }

 /// Create a new key pair.
+///
+/// Both secret and public key consist of signing primary key and encryption subkey
+/// as [described in the Autocrypt standard](https://autocrypt.org/level1.html#openpgp-based-key-data).
 pub(crate) fn create_keypair(addr: EmailAddress, keygen_type: KeyGenType) -> Result<KeyPair> {
-    let (secret_key_type, public_key_type) = match keygen_type {
+    let (signing_key_type, encryption_key_type) = match keygen_type {
        KeyGenType::Rsa2048 => (PgpKeyType::Rsa(2048), PgpKeyType::Rsa(2048)),
        KeyGenType::Rsa4096 => (PgpKeyType::Rsa(4096), PgpKeyType::Rsa(4096)),
        KeyGenType::Ed25519 | KeyGenType::Default => (PgpKeyType::EdDSA, PgpKeyType::ECDH),
@@ -147,8 +150,8 @@ pub(crate) fn create_keypair(addr: EmailAddress, keygen_type: KeyGenType) -> Res

    let user_id = format!("<{addr}>");
    let key_params = SecretKeyParamsBuilder::default()
-        .key_type(secret_key_type)
-        .can_create_certificates(true)
+        .key_type(signing_key_type)
+        .can_certify(true)
        .can_sign(true)
        .primary_user_id(user_id)
        .passphrase(None)
@@ -170,41 +173,36 @@ pub(crate) fn create_keypair(addr: EmailAddress, keygen_type: KeyGenType) -> Res
        ])
        .subkey(
            SubkeyParamsBuilder::default()
-                .key_type(public_key_type)
+                .key_type(encryption_key_type)
                .can_encrypt(true)
                .passphrase(None)
                .build()
-                .map_err(|e| format_err!("{}", e))
                .context("failed to build subkey parameters")?,
        )
        .build()
-        .map_err(|e| format_err!("{}", e))
-        .context("invalid key params")?;
-    let key = key_params.generate().context("invalid params")?;
-    let private_key = key
+        .context("failed to build key parameters")?;
+
+    let secret_key = key_params
+        .generate()
+        .context("failed to generate the key")?
        .sign(|| "".into())
-        .map_err(|e| format_err!("{}", e))
        .context("failed to sign secret key")?;
-
-    let public_key = private_key.public_key();
-    let public_key = public_key
-        .sign(&private_key, || "".into())
-        .map_err(|e| format_err!("{}", e))
-        .context("failed to sign public key")?;
-
-    private_key
+    secret_key
        .verify()
-        .map_err(|e| format_err!("{}", e))
-        .context("invalid private key generated")?;
+        .context("invalid secret key generated")?;
+
+    let public_key = secret_key
+        .public_key()
+        .sign(&secret_key, || "".into())
+        .context("failed to sign public key")?;
    public_key
        .verify()
-        .map_err(|e| format_err!("{}", e))
        .context("invalid public key generated")?;

    Ok(KeyPair {
        addr,
        public: public_key,
-        secret: private_key,
+        secret: secret_key,
    })
 }

--- a/src/provider.rs
+++ b/src/provider.rs
@@ -215,8 +215,18 @@ pub async fn get_provider_info(

 /// Finds a provider in offline database based on domain.
 pub fn get_provider_by_domain(domain: &str) -> Option<&'static Provider> {
-    if let Some(provider) = PROVIDER_DATA.get(domain.to_lowercase().as_str()) {
-        return Some(*provider);
+    let domain = domain.to_lowercase();
+    for (pattern, provider) in PROVIDER_DATA {
+        if let Some(suffix) = pattern.strip_prefix('*') {
+            // Wildcard domain pattern.
+            //
+            // For example, `suffix` is ".hermes.radio" for "*.hermes.radio" pattern.
+            if domain.ends_with(suffix) {
+                return Some(provider);
+            }
+        } else if pattern == domain {
+            return Some(provider);
+        }
    }

    None
@@ -226,33 +236,42 @@ pub fn get_provider_by_domain(domain: &str) -> Option<&'static Provider> {
 ///
 /// For security reasons, only Gmail can be configured this way.
 pub async fn get_provider_by_mx(context: &Context, domain: &str) -> Option<&'static Provider> {
-    if let Ok(resolver) = get_resolver() {
-        let mut fqdn: String = domain.to_string();
-        if !fqdn.ends_with('.') {
-            fqdn.push('.');
+    let Ok(resolver) = get_resolver() else {
+        warn!(context, "Cannot get a resolver to check MX records.");
+        return None;
+    };
+
+    let mut fqdn: String = domain.to_string();
+    if !fqdn.ends_with('.') {
+        fqdn.push('.');
+    }
+
+    let Ok(mx_domains) = resolver.mx_lookup(fqdn).await else {
+        warn!(context, "Cannot resolve MX records for {domain:?}.");
+        return None;
+    };
+
+    for (provider_domain_pattern, provider) in PROVIDER_DATA {
+        if provider.id != "gmail" {
+            // MX lookup is limited to Gmail for security reasons
+            continue;
        }

-        if let Ok(mx_domains) = resolver.mx_lookup(fqdn).await {
-            for (provider_domain, provider) in &*PROVIDER_DATA {
-                if provider.id != "gmail" {
-                    // MX lookup is limited to Gmail for security reasons
-                    continue;
-                }
+        if provider_domain_pattern.starts_with('*') {
+            // Skip wildcard patterns.
+            continue;
+        }

-                let provider_fqdn = provider_domain.to_string() + ".";
-                let provider_fqdn_dot = ".".to_string() + &provider_fqdn;
+        let provider_fqdn = provider_domain_pattern.to_string() + ".";
+        let provider_fqdn_dot = ".".to_string() + &provider_fqdn;

-                for mx_domain in mx_domains.iter() {
-                    let mx_domain = mx_domain.exchange().to_lowercase().to_utf8();
+        for mx_domain in mx_domains.iter() {
+            let mx_domain = mx_domain.exchange().to_lowercase().to_utf8();

-                    if mx_domain == provider_fqdn || mx_domain.ends_with(&provider_fqdn_dot) {
-                        return Some(provider);
-                    }
-                }
+            if mx_domain == provider_fqdn || mx_domain.ends_with(&provider_fqdn_dot) {
+                return Some(provider);
            }
        }
-    } else {
-        warn!(context, "cannot get a resolver to check MX records.");
    }

    None
--- a/src/provider/data.rs
+++ b/src/provider/data.rs
@@ -593,7 +593,7 @@ static P_GMX_NET: Provider = Provider {
    oauth2_authorizer: None,
 };

-// hermes.radio.md: ac.hermes.radio, ac1.hermes.radio, ac2.hermes.radio, ac3.hermes.radio, ac4.hermes.radio, ac5.hermes.radio, ac6.hermes.radio, ac7.hermes.radio, ac8.hermes.radio, ac9.hermes.radio, ac10.hermes.radio, ac11.hermes.radio, ac12.hermes.radio, ac13.hermes.radio, ac14.hermes.radio, ac15.hermes.radio, ka.hermes.radio, ka1.hermes.radio, ka2.hermes.radio, ka3.hermes.radio, ka4.hermes.radio, ka5.hermes.radio, ka6.hermes.radio, ka7.hermes.radio, ka8.hermes.radio, ka9.hermes.radio, ka10.hermes.radio, ka11.hermes.radio, ka12.hermes.radio, ka13.hermes.radio, ka14.hermes.radio, ka15.hermes.radio, ec.hermes.radio, ec1.hermes.radio, ec2.hermes.radio, ec3.hermes.radio, ec4.hermes.radio, ec5.hermes.radio, ec6.hermes.radio, ec7.hermes.radio, ec8.hermes.radio, ec9.hermes.radio, ec10.hermes.radio, ec11.hermes.radio, ec12.hermes.radio, ec13.hermes.radio, ec14.hermes.radio, ec15.hermes.radio, hermes.radio
+// hermes.radio.md: *.hermes.radio, *.aco-connexion.org
 static P_HERMES_RADIO: Provider = Provider {
    id: "hermes.radio",
    status: Status::Ok,
@@ -1608,375 +1608,326 @@ static P_ZOHO: Provider = Provider {
    oauth2_authorizer: None,
 };

-pub(crate) static PROVIDER_DATA: Lazy<HashMap<&'static str, &'static Provider>> = Lazy::new(|| {
-    HashMap::from([
-        ("163.com", &P_163),
-        ("aktivix.org", &P_AKTIVIX_ORG),
-        ("aol.com", &P_AOL),
-        ("arcor.de", &P_ARCOR_DE),
-        ("autistici.org", &P_AUTISTICI_ORG),
-        ("delta.blinzeln.de", &P_BLINDZELN_ORG),
-        ("delta.blindzeln.org", &P_BLINDZELN_ORG),
-        ("bluewin.ch", &P_BLUEWIN_CH),
-        ("buzon.uy", &P_BUZON_UY),
-        ("c1.testrun.org", &P_C1_TESTRUN_ORG),
-        ("c2.testrun.org", &P_C2_TESTRUN_ORG),
-        ("c3.testrun.org", &P_C3_TESTRUN_ORG),
-        ("chello.at", &P_CHELLO_AT),
-        ("xfinity.com", &P_COMCAST),
-        ("comcast.net", &P_COMCAST),
-        ("dismail.de", &P_DISMAIL_DE),
-        ("disroot.org", &P_DISROOT),
-        ("e.email", &P_E_EMAIL),
-        ("espiv.net", &P_ESPIV_NET),
-        ("example.com", &P_EXAMPLE_COM),
-        ("example.org", &P_EXAMPLE_COM),
-        ("example.net", &P_EXAMPLE_COM),
-        ("123mail.org", &P_FASTMAIL),
-        ("150mail.com", &P_FASTMAIL),
-        ("150ml.com", &P_FASTMAIL),
-        ("16mail.com", &P_FASTMAIL),
-        ("2-mail.com", &P_FASTMAIL),
-        ("4email.net", &P_FASTMAIL),
-        ("50mail.com", &P_FASTMAIL),
-        ("airpost.net", &P_FASTMAIL),
-        ("allmail.net", &P_FASTMAIL),
-        ("bestmail.us", &P_FASTMAIL),
-        ("cluemail.com", &P_FASTMAIL),
-        ("elitemail.org", &P_FASTMAIL),
-        ("emailcorner.net", &P_FASTMAIL),
-        ("emailengine.net", &P_FASTMAIL),
-        ("emailengine.org", &P_FASTMAIL),
-        ("emailgroups.net", &P_FASTMAIL),
-        ("emailplus.org", &P_FASTMAIL),
-        ("emailuser.net", &P_FASTMAIL),
-        ("eml.cc", &P_FASTMAIL),
-        ("f-m.fm", &P_FASTMAIL),
-        ("fast-email.com", &P_FASTMAIL),
-        ("fast-mail.org", &P_FASTMAIL),
-        ("fastem.com", &P_FASTMAIL),
-        ("fastemail.us", &P_FASTMAIL),
-        ("fastemailer.com", &P_FASTMAIL),
-        ("fastest.cc", &P_FASTMAIL),
-        ("fastimap.com", &P_FASTMAIL),
-        ("fastmail.cn", &P_FASTMAIL),
-        ("fastmail.co.uk", &P_FASTMAIL),
-        ("fastmail.com", &P_FASTMAIL),
-        ("fastmail.com.au", &P_FASTMAIL),
-        ("fastmail.de", &P_FASTMAIL),
-        ("fastmail.es", &P_FASTMAIL),
-        ("fastmail.fm", &P_FASTMAIL),
-        ("fastmail.fr", &P_FASTMAIL),
-        ("fastmail.im", &P_FASTMAIL),
-        ("fastmail.in", &P_FASTMAIL),
-        ("fastmail.jp", &P_FASTMAIL),
-        ("fastmail.mx", &P_FASTMAIL),
-        ("fastmail.net", &P_FASTMAIL),
-        ("fastmail.nl", &P_FASTMAIL),
-        ("fastmail.org", &P_FASTMAIL),
-        ("fastmail.se", &P_FASTMAIL),
-        ("fastmail.to", &P_FASTMAIL),
-        ("fastmail.tw", &P_FASTMAIL),
-        ("fastmail.uk", &P_FASTMAIL),
-        ("fastmail.us", &P_FASTMAIL),
-        ("fastmailbox.net", &P_FASTMAIL),
-        ("fastmessaging.com", &P_FASTMAIL),
-        ("fea.st", &P_FASTMAIL),
-        ("fmail.co.uk", &P_FASTMAIL),
-        ("fmailbox.com", &P_FASTMAIL),
-        ("fmgirl.com", &P_FASTMAIL),
-        ("fmguy.com", &P_FASTMAIL),
-        ("ftml.net", &P_FASTMAIL),
-        ("h-mail.us", &P_FASTMAIL),
-        ("hailmail.net", &P_FASTMAIL),
-        ("imap-mail.com", &P_FASTMAIL),
-        ("imap.cc", &P_FASTMAIL),
-        ("imapmail.org", &P_FASTMAIL),
-        ("inoutbox.com", &P_FASTMAIL),
-        ("internet-e-mail.com", &P_FASTMAIL),
-        ("internet-mail.org", &P_FASTMAIL),
-        ("internetemails.net", &P_FASTMAIL),
-        ("internetmailing.net", &P_FASTMAIL),
-        ("jetemail.net", &P_FASTMAIL),
-        ("justemail.net", &P_FASTMAIL),
-        ("letterboxes.org", &P_FASTMAIL),
-        ("mail-central.com", &P_FASTMAIL),
-        ("mail-page.com", &P_FASTMAIL),
-        ("mailandftp.com", &P_FASTMAIL),
-        ("mailas.com", &P_FASTMAIL),
-        ("mailbolt.com", &P_FASTMAIL),
-        ("mailc.net", &P_FASTMAIL),
-        ("mailcan.com", &P_FASTMAIL),
-        ("mailforce.net", &P_FASTMAIL),
-        ("mailftp.com", &P_FASTMAIL),
-        ("mailhaven.com", &P_FASTMAIL),
-        ("mailingaddress.org", &P_FASTMAIL),
-        ("mailite.com", &P_FASTMAIL),
-        ("mailmight.com", &P_FASTMAIL),
-        ("mailnew.com", &P_FASTMAIL),
-        ("mailsent.net", &P_FASTMAIL),
-        ("mailservice.ms", &P_FASTMAIL),
-        ("mailup.net", &P_FASTMAIL),
-        ("mailworks.org", &P_FASTMAIL),
-        ("ml1.net", &P_FASTMAIL),
-        ("mm.st", &P_FASTMAIL),
-        ("myfastmail.com", &P_FASTMAIL),
-        ("mymacmail.com", &P_FASTMAIL),
-        ("nospammail.net", &P_FASTMAIL),
-        ("ownmail.net", &P_FASTMAIL),
-        ("petml.com", &P_FASTMAIL),
-        ("postinbox.com", &P_FASTMAIL),
-        ("postpro.net", &P_FASTMAIL),
-        ("proinbox.com", &P_FASTMAIL),
-        ("promessage.com", &P_FASTMAIL),
-        ("realemail.net", &P_FASTMAIL),
-        ("reallyfast.biz", &P_FASTMAIL),
-        ("reallyfast.info", &P_FASTMAIL),
-        ("rushpost.com", &P_FASTMAIL),
-        ("sent.as", &P_FASTMAIL),
-        ("sent.at", &P_FASTMAIL),
-        ("sent.com", &P_FASTMAIL),
-        ("speedpost.net", &P_FASTMAIL),
-        ("speedymail.org", &P_FASTMAIL),
-        ("ssl-mail.com", &P_FASTMAIL),
-        ("swift-mail.com", &P_FASTMAIL),
-        ("the-fastest.net", &P_FASTMAIL),
-        ("the-quickest.com", &P_FASTMAIL),
-        ("theinternetemail.com", &P_FASTMAIL),
-        ("veryfast.biz", &P_FASTMAIL),
-        ("veryspeedy.net", &P_FASTMAIL),
-        ("warpmail.net", &P_FASTMAIL),
-        ("xsmail.com", &P_FASTMAIL),
-        ("yepmail.net", &P_FASTMAIL),
-        ("your-mail.com", &P_FASTMAIL),
-        ("firemail.at", &P_FIREMAIL_DE),
-        ("firemail.de", &P_FIREMAIL_DE),
-        ("five.chat", &P_FIVE_CHAT),
-        ("freenet.de", &P_FREENET_DE),
-        ("gmail.com", &P_GMAIL),
-        ("googlemail.com", &P_GMAIL),
-        ("google.com", &P_GMAIL),
-        ("gmx.net", &P_GMX_NET),
-        ("gmx.de", &P_GMX_NET),
-        ("gmx.at", &P_GMX_NET),
-        ("gmx.ch", &P_GMX_NET),
-        ("gmx.org", &P_GMX_NET),
-        ("gmx.eu", &P_GMX_NET),
-        ("gmx.info", &P_GMX_NET),
-        ("gmx.biz", &P_GMX_NET),
-        ("gmx.com", &P_GMX_NET),
-        ("ac.hermes.radio", &P_HERMES_RADIO),
-        ("ac1.hermes.radio", &P_HERMES_RADIO),
-        ("ac2.hermes.radio", &P_HERMES_RADIO),
-        ("ac3.hermes.radio", &P_HERMES_RADIO),
-        ("ac4.hermes.radio", &P_HERMES_RADIO),
-        ("ac5.hermes.radio", &P_HERMES_RADIO),
-        ("ac6.hermes.radio", &P_HERMES_RADIO),
-        ("ac7.hermes.radio", &P_HERMES_RADIO),
-        ("ac8.hermes.radio", &P_HERMES_RADIO),
-        ("ac9.hermes.radio", &P_HERMES_RADIO),
-        ("ac10.hermes.radio", &P_HERMES_RADIO),
-        ("ac11.hermes.radio", &P_HERMES_RADIO),
-        ("ac12.hermes.radio", &P_HERMES_RADIO),
-        ("ac13.hermes.radio", &P_HERMES_RADIO),
-        ("ac14.hermes.radio", &P_HERMES_RADIO),
-        ("ac15.hermes.radio", &P_HERMES_RADIO),
-        ("ka.hermes.radio", &P_HERMES_RADIO),
-        ("ka1.hermes.radio", &P_HERMES_RADIO),
-        ("ka2.hermes.radio", &P_HERMES_RADIO),
-        ("ka3.hermes.radio", &P_HERMES_RADIO),
-        ("ka4.hermes.radio", &P_HERMES_RADIO),
-        ("ka5.hermes.radio", &P_HERMES_RADIO),
-        ("ka6.hermes.radio", &P_HERMES_RADIO),
-        ("ka7.hermes.radio", &P_HERMES_RADIO),
-        ("ka8.hermes.radio", &P_HERMES_RADIO),
-        ("ka9.hermes.radio", &P_HERMES_RADIO),
-        ("ka10.hermes.radio", &P_HERMES_RADIO),
-        ("ka11.hermes.radio", &P_HERMES_RADIO),
-        ("ka12.hermes.radio", &P_HERMES_RADIO),
-        ("ka13.hermes.radio", &P_HERMES_RADIO),
-        ("ka14.hermes.radio", &P_HERMES_RADIO),
-        ("ka15.hermes.radio", &P_HERMES_RADIO),
-        ("ec.hermes.radio", &P_HERMES_RADIO),
-        ("ec1.hermes.radio", &P_HERMES_RADIO),
-        ("ec2.hermes.radio", &P_HERMES_RADIO),
-        ("ec3.hermes.radio", &P_HERMES_RADIO),
-        ("ec4.hermes.radio", &P_HERMES_RADIO),
-        ("ec5.hermes.radio", &P_HERMES_RADIO),
-        ("ec6.hermes.radio", &P_HERMES_RADIO),
-        ("ec7.hermes.radio", &P_HERMES_RADIO),
-        ("ec8.hermes.radio", &P_HERMES_RADIO),
-        ("ec9.hermes.radio", &P_HERMES_RADIO),
-        ("ec10.hermes.radio", &P_HERMES_RADIO),
-        ("ec11.hermes.radio", &P_HERMES_RADIO),
-        ("ec12.hermes.radio", &P_HERMES_RADIO),
-        ("ec13.hermes.radio", &P_HERMES_RADIO),
-        ("ec14.hermes.radio", &P_HERMES_RADIO),
-        ("ec15.hermes.radio", &P_HERMES_RADIO),
-        ("hermes.radio", &P_HERMES_RADIO),
-        ("hey.com", &P_HEY_COM),
-        ("i.ua", &P_I_UA),
-        ("i3.net", &P_I3_NET),
-        ("icloud.com", &P_ICLOUD),
-        ("me.com", &P_ICLOUD),
-        ("mac.com", &P_ICLOUD),
-        ("ik.me", &P_INFOMANIAK_COM),
-        ("kolst.com", &P_KOLST_COM),
-        ("kontent.com", &P_KONTENT_COM),
-        ("mail.de", &P_MAIL_DE),
-        ("mail.ru", &P_MAIL_RU),
-        ("inbox.ru", &P_MAIL_RU),
-        ("internet.ru", &P_MAIL_RU),
-        ("bk.ru", &P_MAIL_RU),
-        ("list.ru", &P_MAIL_RU),
-        ("mail2tor.com", &P_MAIL2TOR),
-        ("mailbox.org", &P_MAILBOX_ORG),
-        ("secure.mailbox.org", &P_MAILBOX_ORG),
-        ("mailo.com", &P_MAILO_COM),
-        ("nauta.cu", &P_NAUTA_CU),
-        ("naver.com", &P_NAVER),
-        ("nine.testrun.org", &P_NINE_TESTRUN_ORG),
-        ("nubo.coop", &P_NUBO_COOP),
-        ("hotmail.com", &P_OUTLOOK_COM),
-        ("outlook.com", &P_OUTLOOK_COM),
-        ("office365.com", &P_OUTLOOK_COM),
-        ("outlook.com.tr", &P_OUTLOOK_COM),
-        ("live.com", &P_OUTLOOK_COM),
-        ("outlook.de", &P_OUTLOOK_COM),
-        ("ouvaton.org", &P_OUVATON_COOP),
-        ("posteo.de", &P_POSTEO),
-        ("posteo.af", &P_POSTEO),
-        ("posteo.at", &P_POSTEO),
-        ("posteo.be", &P_POSTEO),
-        ("posteo.ca", &P_POSTEO),
-        ("posteo.ch", &P_POSTEO),
-        ("posteo.cl", &P_POSTEO),
-        ("posteo.co", &P_POSTEO),
-        ("posteo.co.uk", &P_POSTEO),
-        ("posteo.com.br", &P_POSTEO),
-        ("posteo.cr", &P_POSTEO),
-        ("posteo.cz", &P_POSTEO),
-        ("posteo.dk", &P_POSTEO),
-        ("posteo.ee", &P_POSTEO),
-        ("posteo.es", &P_POSTEO),
-        ("posteo.eu", &P_POSTEO),
-        ("posteo.fi", &P_POSTEO),
-        ("posteo.gl", &P_POSTEO),
-        ("posteo.gr", &P_POSTEO),
-        ("posteo.hn", &P_POSTEO),
-        ("posteo.hr", &P_POSTEO),
-        ("posteo.hu", &P_POSTEO),
-        ("posteo.ie", &P_POSTEO),
-        ("posteo.in", &P_POSTEO),
-        ("posteo.is", &P_POSTEO),
-        ("posteo.it", &P_POSTEO),
-        ("posteo.jp", &P_POSTEO),
-        ("posteo.la", &P_POSTEO),
-        ("posteo.li", &P_POSTEO),
-        ("posteo.lt", &P_POSTEO),
-        ("posteo.lu", &P_POSTEO),
-        ("posteo.me", &P_POSTEO),
-        ("posteo.mx", &P_POSTEO),
-        ("posteo.my", &P_POSTEO),
-        ("posteo.net", &P_POSTEO),
-        ("posteo.nl", &P_POSTEO),
-        ("posteo.no", &P_POSTEO),
-        ("posteo.nz", &P_POSTEO),
-        ("posteo.org", &P_POSTEO),
-        ("posteo.pe", &P_POSTEO),
-        ("posteo.pl", &P_POSTEO),
-        ("posteo.pm", &P_POSTEO),
-        ("posteo.pt", &P_POSTEO),
-        ("posteo.ro", &P_POSTEO),
-        ("posteo.ru", &P_POSTEO),
-        ("posteo.se", &P_POSTEO),
-        ("posteo.sg", &P_POSTEO),
-        ("posteo.si", &P_POSTEO),
-        ("posteo.tn", &P_POSTEO),
-        ("posteo.uk", &P_POSTEO),
-        ("posteo.us", &P_POSTEO),
-        ("protonmail.com", &P_PROTONMAIL),
-        ("protonmail.ch", &P_PROTONMAIL),
-        ("pm.me", &P_PROTONMAIL),
-        ("qq.com", &P_QQ),
-        ("foxmail.com", &P_QQ),
-        ("riseup.net", &P_RISEUP_NET),
-        ("rogers.com", &P_ROGERS_COM),
-        ("sonic.net", &P_SONIC),
-        ("systemausfall.org", &P_SYSTEMAUSFALL_ORG),
-        ("solidaris.me", &P_SYSTEMAUSFALL_ORG),
-        ("systemli.org", &P_SYSTEMLI_ORG),
-        ("t-online.de", &P_T_ONLINE),
-        ("magenta.de", &P_T_ONLINE),
-        ("testrun.org", &P_TESTRUN),
-        ("tiscali.it", &P_TISCALI_IT),
-        ("tutanota.com", &P_TUTANOTA),
-        ("tutanota.de", &P_TUTANOTA),
-        ("tutamail.com", &P_TUTANOTA),
-        ("tuta.io", &P_TUTANOTA),
-        ("keemail.me", &P_TUTANOTA),
-        ("ukr.net", &P_UKR_NET),
-        ("undernet.uy", &P_UNDERNET_UY),
-        ("vfemail.net", &P_VFEMAIL),
-        ("vivaldi.net", &P_VIVALDI),
-        ("vodafone.de", &P_VODAFONE_DE),
-        ("vodafonemail.de", &P_VODAFONE_DE),
-        ("web.de", &P_WEB_DE),
-        ("email.de", &P_WEB_DE),
-        ("flirt.ms", &P_WEB_DE),
-        ("hallo.ms", &P_WEB_DE),
-        ("kuss.ms", &P_WEB_DE),
-        ("love.ms", &P_WEB_DE),
-        ("magic.ms", &P_WEB_DE),
-        ("singles.ms", &P_WEB_DE),
-        ("cool.ms", &P_WEB_DE),
-        ("kanzler.ms", &P_WEB_DE),
-        ("okay.ms", &P_WEB_DE),
-        ("party.ms", &P_WEB_DE),
-        ("pop.ms", &P_WEB_DE),
-        ("stars.ms", &P_WEB_DE),
-        ("techno.ms", &P_WEB_DE),
-        ("clever.ms", &P_WEB_DE),
-        ("deutschland.ms", &P_WEB_DE),
-        ("genial.ms", &P_WEB_DE),
-        ("ich.ms", &P_WEB_DE),
-        ("online.ms", &P_WEB_DE),
-        ("smart.ms", &P_WEB_DE),
-        ("wichtig.ms", &P_WEB_DE),
-        ("action.ms", &P_WEB_DE),
-        ("fussball.ms", &P_WEB_DE),
-        ("joker.ms", &P_WEB_DE),
-        ("planet.ms", &P_WEB_DE),
-        ("power.ms", &P_WEB_DE),
-        ("yahoo.com", &P_YAHOO),
-        ("yahoo.de", &P_YAHOO),
-        ("yahoo.it", &P_YAHOO),
-        ("yahoo.fr", &P_YAHOO),
-        ("yahoo.es", &P_YAHOO),
-        ("yahoo.se", &P_YAHOO),
-        ("yahoo.co.uk", &P_YAHOO),
-        ("yahoo.co.nz", &P_YAHOO),
-        ("yahoo.com.au", &P_YAHOO),
-        ("yahoo.com.ar", &P_YAHOO),
-        ("yahoo.com.br", &P_YAHOO),
-        ("yahoo.com.mx", &P_YAHOO),
-        ("ymail.com", &P_YAHOO),
-        ("rocketmail.com", &P_YAHOO),
-        ("yahoodns.net", &P_YAHOO),
-        ("yandex.com", &P_YANDEX_RU),
-        ("yandex.by", &P_YANDEX_RU),
-        ("yandex.kz", &P_YANDEX_RU),
-        ("yandex.ru", &P_YANDEX_RU),
-        ("yandex.ua", &P_YANDEX_RU),
-        ("ya.ru", &P_YANDEX_RU),
-        ("narod.ru", &P_YANDEX_RU),
-        ("yggmail", &P_YGGMAIL),
-        ("ziggo.nl", &P_ZIGGO_NL),
-        ("zohomail.eu", &P_ZOHO),
-        ("zohomail.com", &P_ZOHO),
-        ("zoho.com", &P_ZOHO),
-    ])
-});
+pub(crate) static PROVIDER_DATA: [(&str, &Provider); 318] = [
+    ("163.com", &P_163),
+    ("aktivix.org", &P_AKTIVIX_ORG),
+    ("aol.com", &P_AOL),
+    ("arcor.de", &P_ARCOR_DE),
+    ("autistici.org", &P_AUTISTICI_ORG),
+    ("delta.blinzeln.de", &P_BLINDZELN_ORG),
+    ("delta.blindzeln.org", &P_BLINDZELN_ORG),
+    ("bluewin.ch", &P_BLUEWIN_CH),
+    ("buzon.uy", &P_BUZON_UY),
+    ("c1.testrun.org", &P_C1_TESTRUN_ORG),
+    ("c2.testrun.org", &P_C2_TESTRUN_ORG),
+    ("c3.testrun.org", &P_C3_TESTRUN_ORG),
+    ("chello.at", &P_CHELLO_AT),
+    ("xfinity.com", &P_COMCAST),
+    ("comcast.net", &P_COMCAST),
+    ("dismail.de", &P_DISMAIL_DE),
+    ("disroot.org", &P_DISROOT),
+    ("e.email", &P_E_EMAIL),
+    ("espiv.net", &P_ESPIV_NET),
+    ("example.com", &P_EXAMPLE_COM),
+    ("example.org", &P_EXAMPLE_COM),
+    ("example.net", &P_EXAMPLE_COM),
+    ("123mail.org", &P_FASTMAIL),
+    ("150mail.com", &P_FASTMAIL),
+    ("150ml.com", &P_FASTMAIL),
+    ("16mail.com", &P_FASTMAIL),
+    ("2-mail.com", &P_FASTMAIL),
+    ("4email.net", &P_FASTMAIL),
+    ("50mail.com", &P_FASTMAIL),
+    ("airpost.net", &P_FASTMAIL),
+    ("allmail.net", &P_FASTMAIL),
+    ("bestmail.us", &P_FASTMAIL),
+    ("cluemail.com", &P_FASTMAIL),
+    ("elitemail.org", &P_FASTMAIL),
+    ("emailcorner.net", &P_FASTMAIL),
+    ("emailengine.net", &P_FASTMAIL),
+    ("emailengine.org", &P_FASTMAIL),
+    ("emailgroups.net", &P_FASTMAIL),
+    ("emailplus.org", &P_FASTMAIL),
+    ("emailuser.net", &P_FASTMAIL),
+    ("eml.cc", &P_FASTMAIL),
+    ("f-m.fm", &P_FASTMAIL),
+    ("fast-email.com", &P_FASTMAIL),
+    ("fast-mail.org", &P_FASTMAIL),
+    ("fastem.com", &P_FASTMAIL),
+    ("fastemail.us", &P_FASTMAIL),
+    ("fastemailer.com", &P_FASTMAIL),
+    ("fastest.cc", &P_FASTMAIL),
+    ("fastimap.com", &P_FASTMAIL),
+    ("fastmail.cn", &P_FASTMAIL),
+    ("fastmail.co.uk", &P_FASTMAIL),
+    ("fastmail.com", &P_FASTMAIL),
+    ("fastmail.com.au", &P_FASTMAIL),
+    ("fastmail.de", &P_FASTMAIL),
+    ("fastmail.es", &P_FASTMAIL),
+    ("fastmail.fm", &P_FASTMAIL),
+    ("fastmail.fr", &P_FASTMAIL),
+    ("fastmail.im", &P_FASTMAIL),
+    ("fastmail.in", &P_FASTMAIL),
+    ("fastmail.jp", &P_FASTMAIL),
+    ("fastmail.mx", &P_FASTMAIL),
+    ("fastmail.net", &P_FASTMAIL),
+    ("fastmail.nl", &P_FASTMAIL),
+    ("fastmail.org", &P_FASTMAIL),
+    ("fastmail.se", &P_FASTMAIL),
+    ("fastmail.to", &P_FASTMAIL),
+    ("fastmail.tw", &P_FASTMAIL),
+    ("fastmail.uk", &P_FASTMAIL),
+    ("fastmail.us", &P_FASTMAIL),
+    ("fastmailbox.net", &P_FASTMAIL),
+    ("fastmessaging.com", &P_FASTMAIL),
+    ("fea.st", &P_FASTMAIL),
+    ("fmail.co.uk", &P_FASTMAIL),
+    ("fmailbox.com", &P_FASTMAIL),
+    ("fmgirl.com", &P_FASTMAIL),
+    ("fmguy.com", &P_FASTMAIL),
+    ("ftml.net", &P_FASTMAIL),
+    ("h-mail.us", &P_FASTMAIL),
+    ("hailmail.net", &P_FASTMAIL),
+    ("imap-mail.com", &P_FASTMAIL),
+    ("imap.cc", &P_FASTMAIL),
+    ("imapmail.org", &P_FASTMAIL),
+    ("inoutbox.com", &P_FASTMAIL),
+    ("internet-e-mail.com", &P_FASTMAIL),
+    ("internet-mail.org", &P_FASTMAIL),
+    ("internetemails.net", &P_FASTMAIL),
+    ("internetmailing.net", &P_FASTMAIL),
+    ("jetemail.net", &P_FASTMAIL),
+    ("justemail.net", &P_FASTMAIL),
+    ("letterboxes.org", &P_FASTMAIL),
+    ("mail-central.com", &P_FASTMAIL),
+    ("mail-page.com", &P_FASTMAIL),
+    ("mailandftp.com", &P_FASTMAIL),
+    ("mailas.com", &P_FASTMAIL),
+    ("mailbolt.com", &P_FASTMAIL),
+    ("mailc.net", &P_FASTMAIL),
+    ("mailcan.com", &P_FASTMAIL),
+    ("mailforce.net", &P_FASTMAIL),
+    ("mailftp.com", &P_FASTMAIL),
+    ("mailhaven.com", &P_FASTMAIL),
+    ("mailingaddress.org", &P_FASTMAIL),
+    ("mailite.com", &P_FASTMAIL),
+    ("mailmight.com", &P_FASTMAIL),
+    ("mailnew.com", &P_FASTMAIL),
+    ("mailsent.net", &P_FASTMAIL),
+    ("mailservice.ms", &P_FASTMAIL),
+    ("mailup.net", &P_FASTMAIL),
+    ("mailworks.org", &P_FASTMAIL),
+    ("ml1.net", &P_FASTMAIL),
+    ("mm.st", &P_FASTMAIL),
+    ("myfastmail.com", &P_FASTMAIL),
+    ("mymacmail.com", &P_FASTMAIL),
+    ("nospammail.net", &P_FASTMAIL),
+    ("ownmail.net", &P_FASTMAIL),
+    ("petml.com", &P_FASTMAIL),
+    ("postinbox.com", &P_FASTMAIL),
+    ("postpro.net", &P_FASTMAIL),
+    ("proinbox.com", &P_FASTMAIL),
+    ("promessage.com", &P_FASTMAIL),
+    ("realemail.net", &P_FASTMAIL),
+    ("reallyfast.biz", &P_FASTMAIL),
+    ("reallyfast.info", &P_FASTMAIL),
+    ("rushpost.com", &P_FASTMAIL),
+    ("sent.as", &P_FASTMAIL),
+    ("sent.at", &P_FASTMAIL),
+    ("sent.com", &P_FASTMAIL),
+    ("speedpost.net", &P_FASTMAIL),
+    ("speedymail.org", &P_FASTMAIL),
+    ("ssl-mail.com", &P_FASTMAIL),
+    ("swift-mail.com", &P_FASTMAIL),
+    ("the-fastest.net", &P_FASTMAIL),
+    ("the-quickest.com", &P_FASTMAIL),
+    ("theinternetemail.com", &P_FASTMAIL),
+    ("veryfast.biz", &P_FASTMAIL),
+    ("veryspeedy.net", &P_FASTMAIL),
+    ("warpmail.net", &P_FASTMAIL),
+    ("xsmail.com", &P_FASTMAIL),
+    ("yepmail.net", &P_FASTMAIL),
+    ("your-mail.com", &P_FASTMAIL),
+    ("firemail.at", &P_FIREMAIL_DE),
+    ("firemail.de", &P_FIREMAIL_DE),
+    ("five.chat", &P_FIVE_CHAT),
+    ("freenet.de", &P_FREENET_DE),
+    ("gmail.com", &P_GMAIL),
+    ("googlemail.com", &P_GMAIL),
+    ("google.com", &P_GMAIL),
+    ("gmx.net", &P_GMX_NET),
+    ("gmx.de", &P_GMX_NET),
+    ("gmx.at", &P_GMX_NET),
+    ("gmx.ch", &P_GMX_NET),
+    ("gmx.org", &P_GMX_NET),
+    ("gmx.eu", &P_GMX_NET),
+    ("gmx.info", &P_GMX_NET),
+    ("gmx.biz", &P_GMX_NET),
+    ("gmx.com", &P_GMX_NET),
+    ("*.hermes.radio", &P_HERMES_RADIO),
+    ("*.aco-connexion.org", &P_HERMES_RADIO),
+    ("hey.com", &P_HEY_COM),
+    ("i.ua", &P_I_UA),
+    ("i3.net", &P_I3_NET),
+    ("icloud.com", &P_ICLOUD),
+    ("me.com", &P_ICLOUD),
+    ("mac.com", &P_ICLOUD),
+    ("ik.me", &P_INFOMANIAK_COM),
+    ("kolst.com", &P_KOLST_COM),
+    ("kontent.com", &P_KONTENT_COM),
+    ("mail.de", &P_MAIL_DE),
+    ("mail.ru", &P_MAIL_RU),
+    ("inbox.ru", &P_MAIL_RU),
+    ("internet.ru", &P_MAIL_RU),
+    ("bk.ru", &P_MAIL_RU),
+    ("list.ru", &P_MAIL_RU),
+    ("mail2tor.com", &P_MAIL2TOR),
+    ("mailbox.org", &P_MAILBOX_ORG),
+    ("secure.mailbox.org", &P_MAILBOX_ORG),
+    ("mailo.com", &P_MAILO_COM),
+    ("nauta.cu", &P_NAUTA_CU),
+    ("naver.com", &P_NAVER),
+    ("nine.testrun.org", &P_NINE_TESTRUN_ORG),
+    ("nubo.coop", &P_NUBO_COOP),
+    ("hotmail.com", &P_OUTLOOK_COM),
+    ("outlook.com", &P_OUTLOOK_COM),
+    ("office365.com", &P_OUTLOOK_COM),
+    ("outlook.com.tr", &P_OUTLOOK_COM),
+    ("live.com", &P_OUTLOOK_COM),
+    ("outlook.de", &P_OUTLOOK_COM),
+    ("ouvaton.org", &P_OUVATON_COOP),
+    ("posteo.de", &P_POSTEO),
+    ("posteo.af", &P_POSTEO),
+    ("posteo.at", &P_POSTEO),
+    ("posteo.be", &P_POSTEO),
+    ("posteo.ca", &P_POSTEO),
+    ("posteo.ch", &P_POSTEO),
+    ("posteo.cl", &P_POSTEO),
+    ("posteo.co", &P_POSTEO),
+    ("posteo.co.uk", &P_POSTEO),
+    ("posteo.com.br", &P_POSTEO),
+    ("posteo.cr", &P_POSTEO),
+    ("posteo.cz", &P_POSTEO),
+    ("posteo.dk", &P_POSTEO),
+    ("posteo.ee", &P_POSTEO),
+    ("posteo.es", &P_POSTEO),
+    ("posteo.eu", &P_POSTEO),
+    ("posteo.fi", &P_POSTEO),
+    ("posteo.gl", &P_POSTEO),
+    ("posteo.gr", &P_POSTEO),
+    ("posteo.hn", &P_POSTEO),
+    ("posteo.hr", &P_POSTEO),
+    ("posteo.hu", &P_POSTEO),
+    ("posteo.ie", &P_POSTEO),
+    ("posteo.in", &P_POSTEO),
+    ("posteo.is", &P_POSTEO),
+    ("posteo.it", &P_POSTEO),
+    ("posteo.jp", &P_POSTEO),
+    ("posteo.la", &P_POSTEO),
+    ("posteo.li", &P_POSTEO),
+    ("posteo.lt", &P_POSTEO),
+    ("posteo.lu", &P_POSTEO),
+    ("posteo.me", &P_POSTEO),
+    ("posteo.mx", &P_POSTEO),
+    ("posteo.my", &P_POSTEO),
+    ("posteo.net", &P_POSTEO),
+    ("posteo.nl", &P_POSTEO),
+    ("posteo.no", &P_POSTEO),
+    ("posteo.nz", &P_POSTEO),
+    ("posteo.org", &P_POSTEO),
+    ("posteo.pe", &P_POSTEO),
+    ("posteo.pl", &P_POSTEO),
+    ("posteo.pm", &P_POSTEO),
+    ("posteo.pt", &P_POSTEO),
+    ("posteo.ro", &P_POSTEO),
+    ("posteo.ru", &P_POSTEO),
+    ("posteo.se", &P_POSTEO),
+    ("posteo.sg", &P_POSTEO),
+    ("posteo.si", &P_POSTEO),
+    ("posteo.tn", &P_POSTEO),
+    ("posteo.uk", &P_POSTEO),
+    ("posteo.us", &P_POSTEO),
+    ("protonmail.com", &P_PROTONMAIL),
+    ("protonmail.ch", &P_PROTONMAIL),
+    ("pm.me", &P_PROTONMAIL),
+    ("qq.com", &P_QQ),
+    ("foxmail.com", &P_QQ),
+    ("riseup.net", &P_RISEUP_NET),
+    ("rogers.com", &P_ROGERS_COM),
+    ("sonic.net", &P_SONIC),
+    ("systemausfall.org", &P_SYSTEMAUSFALL_ORG),
+    ("solidaris.me", &P_SYSTEMAUSFALL_ORG),
+    ("systemli.org", &P_SYSTEMLI_ORG),
+    ("t-online.de", &P_T_ONLINE),
+    ("magenta.de", &P_T_ONLINE),
+    ("testrun.org", &P_TESTRUN),
+    ("tiscali.it", &P_TISCALI_IT),
+    ("tutanota.com", &P_TUTANOTA),
+    ("tutanota.de", &P_TUTANOTA),
+    ("tutamail.com", &P_TUTANOTA),
+    ("tuta.io", &P_TUTANOTA),
+    ("keemail.me", &P_TUTANOTA),
+    ("ukr.net", &P_UKR_NET),
+    ("undernet.uy", &P_UNDERNET_UY),
+    ("vfemail.net", &P_VFEMAIL),
+    ("vivaldi.net", &P_VIVALDI),
+    ("vodafone.de", &P_VODAFONE_DE),
+    ("vodafonemail.de", &P_VODAFONE_DE),
+    ("web.de", &P_WEB_DE),
+    ("email.de", &P_WEB_DE),
+    ("flirt.ms", &P_WEB_DE),
+    ("hallo.ms", &P_WEB_DE),
+    ("kuss.ms", &P_WEB_DE),
+    ("love.ms", &P_WEB_DE),
+    ("magic.ms", &P_WEB_DE),
+    ("singles.ms", &P_WEB_DE),
+    ("cool.ms", &P_WEB_DE),
+    ("kanzler.ms", &P_WEB_DE),
+    ("okay.ms", &P_WEB_DE),
+    ("party.ms", &P_WEB_DE),
+    ("pop.ms", &P_WEB_DE),
+    ("stars.ms", &P_WEB_DE),
+    ("techno.ms", &P_WEB_DE),
+    ("clever.ms", &P_WEB_DE),
+    ("deutschland.ms", &P_WEB_DE),
+    ("genial.ms", &P_WEB_DE),
+    ("ich.ms", &P_WEB_DE),
+    ("online.ms", &P_WEB_DE),
+    ("smart.ms", &P_WEB_DE),
+    ("wichtig.ms", &P_WEB_DE),
+    ("action.ms", &P_WEB_DE),
+    ("fussball.ms", &P_WEB_DE),
+    ("joker.ms", &P_WEB_DE),
+    ("planet.ms", &P_WEB_DE),
+    ("power.ms", &P_WEB_DE),
+    ("yahoo.com", &P_YAHOO),
+    ("yahoo.de", &P_YAHOO),
+    ("yahoo.it", &P_YAHOO),
+    ("yahoo.fr", &P_YAHOO),
+    ("yahoo.es", &P_YAHOO),
+    ("yahoo.se", &P_YAHOO),
+    ("yahoo.co.uk", &P_YAHOO),
+    ("yahoo.co.nz", &P_YAHOO),
+    ("yahoo.com.au", &P_YAHOO),
+    ("yahoo.com.ar", &P_YAHOO),
+    ("yahoo.com.br", &P_YAHOO),
+    ("yahoo.com.mx", &P_YAHOO),
+    ("ymail.com", &P_YAHOO),
+    ("rocketmail.com", &P_YAHOO),
+    ("yahoodns.net", &P_YAHOO),
+    ("yandex.com", &P_YANDEX_RU),
+    ("yandex.by", &P_YANDEX_RU),
+    ("yandex.kz", &P_YANDEX_RU),
+    ("yandex.ru", &P_YANDEX_RU),
+    ("yandex.ua", &P_YANDEX_RU),
+    ("ya.ru", &P_YANDEX_RU),
+    ("narod.ru", &P_YANDEX_RU),
+    ("yggmail", &P_YGGMAIL),
+    ("ziggo.nl", &P_ZIGGO_NL),
+    ("zohomail.eu", &P_ZOHO),
+    ("zohomail.com", &P_ZOHO),
+    ("zoho.com", &P_ZOHO),
+];

 pub(crate) static PROVIDER_IDS: Lazy<HashMap<&'static str, &'static Provider>> = Lazy::new(|| {
    HashMap::from([
@@ -2050,4 +2001,4 @@ pub(crate) static PROVIDER_IDS: Lazy<HashMap<&'static str, &'static Provider>> =
 });

 pub static _PROVIDER_UPDATED: Lazy<chrono::NaiveDate> =
-    Lazy::new(|| chrono::NaiveDate::from_ymd_opt(2023, 11, 5).unwrap());
+    Lazy::new(|| chrono::NaiveDate::from_ymd_opt(2024, 2, 5).unwrap());
--- a/src/qr.rs
+++ b/src/qr.rs
@@ -25,6 +25,8 @@ use crate::socks::Socks5Config;
 use crate::token;

 const OPENPGP4FPR_SCHEME: &str = "OPENPGP4FPR:"; // yes: uppercase
+const IDELTACHAT_SCHEME: &str = "https://i.delta.chat/#";
+const IDELTACHAT_NOSLASH_SCHEME: &str = "https://i.delta.chat#";
 const DCACCOUNT_SCHEME: &str = "DCACCOUNT:";
 pub(super) const DCLOGIN_SCHEME: &str = "DCLOGIN:";
 const DCWEBRTC_SCHEME: &str = "DCWEBRTC:";
@@ -253,6 +255,10 @@ pub async fn check_qr(context: &Context, qr: &str) -> Result<Qr> {
        decode_openpgp(context, qr)
            .await
            .context("failed to decode OPENPGP4FPR QR code")?
+    } else if qr.starts_with(IDELTACHAT_SCHEME) {
+        decode_ideltachat(context, IDELTACHAT_SCHEME, qr).await?
+    } else if qr.starts_with(IDELTACHAT_NOSLASH_SCHEME) {
+        decode_ideltachat(context, IDELTACHAT_NOSLASH_SCHEME, qr).await?
    } else if starts_with_ignore_case(qr, DCACCOUNT_SCHEME) {
        decode_account(qr)?
    } else if starts_with_ignore_case(qr, DCLOGIN_SCHEME) {
@@ -301,11 +307,12 @@ pub fn format_backup(qr: &Qr) -> Result<String> {
 async fn decode_openpgp(context: &Context, qr: &str) -> Result<Qr> {
    let payload = &qr[OPENPGP4FPR_SCHEME.len()..];

-    let (fingerprint, fragment) = match payload.find('#').map(|offset| {
-        let (fp, rest) = payload.split_at(offset);
-        // need to remove the # from the fragment
-        (fp, &rest[1..])
-    }) {
+    // macOS and iOS sometimes replace the # with %23 (uri encode it), we should be able to parse this wrong format too.
+    // see issue https://github.com/deltachat/deltachat-core-rust/issues/1969 for more info
+    let (fingerprint, fragment) = match payload
+        .split_once('#')
+        .or_else(|| payload.split_once("%23"))
+    {
        Some(pair) => pair,
        None => (payload, ""),
    };
@@ -376,7 +383,7 @@ async fn decode_openpgp(context: &Context, qr: &str) -> Result<Qr> {
                .await
                .with_context(|| format!("can't check if address {addr:?} is our address"))?
            {
-                if token::exists(context, token::Namespace::InviteNumber, &invitenumber).await {
+                if token::exists(context, token::Namespace::InviteNumber, &invitenumber).await? {
                    Ok(Qr::WithdrawVerifyGroup {
                        grpname,
                        grpid,
@@ -406,7 +413,7 @@ async fn decode_openpgp(context: &Context, qr: &str) -> Result<Qr> {
                })
            }
        } else if context.is_self_addr(&addr).await? {
-            if token::exists(context, token::Namespace::InviteNumber, &invitenumber).await {
+            if token::exists(context, token::Namespace::InviteNumber, &invitenumber).await? {
                Ok(Qr::WithdrawVerifyContact {
                    contact_id,
                    fingerprint,
@@ -453,6 +460,15 @@ async fn decode_openpgp(context: &Context, qr: &str) -> Result<Qr> {
    }
 }

+/// scheme: `https://i.delta.chat[/]#FINGERPRINT&a=ADDR[&OPTIONAL_PARAMS]`
+async fn decode_ideltachat(context: &Context, prefix: &str, qr: &str) -> Result<Qr> {
+    let qr = qr.replacen(prefix, OPENPGP4FPR_SCHEME, 1);
+    let qr = qr.replacen('&', "#", 1);
+    decode_openpgp(context, &qr)
+        .await
+        .context("failed to decode {prefix} QR code")
+}
+
 /// scheme: `DCACCOUNT:https://example.org/new_email?t=1w_7wDjgjelxeX884x96v3`
 fn decode_account(qr: &str) -> Result<Qr> {
    let payload = qr
@@ -544,8 +560,12 @@ async fn set_account_from_qr(context: &Context, qr: &str) -> Result<()> {
                    "Cannot create account, response from {url_str:?} is malformed:\n{response_text:?}"
                )
            })?;
-        context.set_config(Config::Addr, Some(&email)).await?;
-        context.set_config(Config::MailPw, Some(&password)).await?;
+        context
+            .set_config_internal(Config::Addr, Some(&email))
+            .await?;
+        context
+            .set_config_internal(Config::MailPw, Some(&password))
+            .await?;

        Ok(())
    } else {
@@ -573,7 +593,7 @@ pub async fn set_config_from_qr(context: &Context, qr: &str) -> Result<()> {
            instance_pattern,
        } => {
            context
-                .set_config(Config::WebrtcInstance, Some(&instance_pattern))
+                .set_config_internal(Config::WebrtcInstance, Some(&instance_pattern))
                .await?;
        }
        Qr::WithdrawVerifyContact {
@@ -943,6 +963,40 @@ mod tests {
        Ok(())
    }

+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn test_decode_ideltachat_link() -> Result<()> {
+        let ctx = TestContext::new().await;
+
+        let qr = check_qr(
+            &ctx.ctx,
+            "https://i.delta.chat/#79252762C34C5096AF57958F4FC3D21A81B0F0A7&a=cli%40deltachat.de&g=test%20%3F+test%20%21&x=h-0oKQf2CDK&i=9JEXlxAqGM0&s=0V7LzL9cxRL"
+        ).await?;
+        assert!(matches!(qr, Qr::AskVerifyGroup { .. }));
+
+        let qr = check_qr(
+            &ctx.ctx,
+            "https://i.delta.chat#79252762C34C5096AF57958F4FC3D21A81B0F0A7&a=cli%40deltachat.de&g=test%20%3F+test%20%21&x=h-0oKQf2CDK&i=9JEXlxAqGM0&s=0V7LzL9cxRL"
+        ).await?;
+        assert!(matches!(qr, Qr::AskVerifyGroup { .. }));
+
+        Ok(())
+    }
+
+    // macOS and iOS sometimes replace the # with %23 (uri encode it), we should be able to parse this wrong format too.
+    // see issue https://github.com/deltachat/deltachat-core-rust/issues/1969 for more info
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn test_decode_openpgp_tolerance_for_issue_1969() -> Result<()> {
+        let ctx = TestContext::new().await;
+
+        let qr = check_qr(
+            &ctx.ctx,
+            "OPENPGP4FPR:79252762C34C5096AF57958F4FC3D21A81B0F0A7%23a=cli%40deltachat.de&g=test%20%3F+test%20%21&x=h-0oKQf2CDK&i=9JEXlxAqGM0&s=0V7LzL9cxRL"
+        ).await?;
+
+        assert!(matches!(qr, Qr::AskVerifyGroup { .. }));
+        Ok(())
+    }
+
    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
    async fn test_decode_openpgp_group() -> Result<()> {
        let ctx = TestContext::new().await;
--- a/src/qr/dclogin_scheme.rs
+++ b/src/qr/dclogin_scheme.rs
@@ -163,7 +163,9 @@ pub(crate) async fn configure_from_login_qr(
    address: &str,
    options: LoginOptions,
 ) -> Result<()> {
-    context.set_config(Config::Addr, Some(address)).await?;
+    context
+        .set_config_internal(Config::Addr, Some(address))
+        .await?;

    match options {
        LoginOptions::V1 {
@@ -181,27 +183,35 @@ pub(crate) async fn configure_from_login_qr(
            smtp_security,
            smtp_certificate_checks,
        } => {
-            context.set_config(Config::MailPw, Some(&mail_pw)).await?;
+            context
+                .set_config_internal(Config::MailPw, Some(&mail_pw))
+                .await?;
            if let Some(value) = imap_host {
-                context.set_config(Config::MailServer, Some(&value)).await?;
+                context
+                    .set_config_internal(Config::MailServer, Some(&value))
+                    .await?;
            }
            if let Some(value) = imap_port {
                context
-                    .set_config(Config::MailPort, Some(&value.to_string()))
+                    .set_config_internal(Config::MailPort, Some(&value.to_string()))
                    .await?;
            }
            if let Some(value) = imap_username {
-                context.set_config(Config::MailUser, Some(&value)).await?;
+                context
+                    .set_config_internal(Config::MailUser, Some(&value))
+                    .await?;
            }
            if let Some(value) = imap_password {
-                context.set_config(Config::MailPw, Some(&value)).await?;
+                context
+                    .set_config_internal(Config::MailPw, Some(&value))
+                    .await?;
            }
            if let Some(value) = imap_security {
                let code = value
                    .to_u8()
                    .context("could not convert imap security value to number")?;
                context
-                    .set_config(Config::MailSecurity, Some(&code.to_string()))
+                    .set_config_internal(Config::MailSecurity, Some(&code.to_string()))
                    .await?;
            }
            if let Some(value) = imap_certificate_checks {
@@ -209,29 +219,35 @@ pub(crate) async fn configure_from_login_qr(
                    .to_u32()
                    .context("could not convert imap certificate checks value to number")?;
                context
-                    .set_config(Config::ImapCertificateChecks, Some(&code.to_string()))
+                    .set_config_internal(Config::ImapCertificateChecks, Some(&code.to_string()))
                    .await?;
            }
            if let Some(value) = smtp_host {
-                context.set_config(Config::SendServer, Some(&value)).await?;
+                context
+                    .set_config_internal(Config::SendServer, Some(&value))
+                    .await?;
            }
            if let Some(value) = smtp_port {
                context
-                    .set_config(Config::SendPort, Some(&value.to_string()))
+                    .set_config_internal(Config::SendPort, Some(&value.to_string()))
                    .await?;
            }
            if let Some(value) = smtp_username {
-                context.set_config(Config::SendUser, Some(&value)).await?;
+                context
+                    .set_config_internal(Config::SendUser, Some(&value))
+                    .await?;
            }
            if let Some(value) = smtp_password {
-                context.set_config(Config::SendPw, Some(&value)).await?;
+                context
+                    .set_config_internal(Config::SendPw, Some(&value))
+                    .await?;
            }
            if let Some(value) = smtp_security {
                let code = value
                    .to_u8()
                    .context("could not convert smtp security value to number")?;
                context
-                    .set_config(Config::SendSecurity, Some(&code.to_string()))
+                    .set_config_internal(Config::SendSecurity, Some(&code.to_string()))
                    .await?;
            }
            if let Some(value) = smtp_certificate_checks {
@@ -239,7 +255,7 @@ pub(crate) async fn configure_from_login_qr(
                    .to_u32()
                    .context("could not convert smtp certificate checks value to number")?;
                context
-                    .set_config(Config::SmtpCertificateChecks, Some(&code.to_string()))
+                    .set_config_internal(Config::SmtpCertificateChecks, Some(&code.to_string()))
                    .await?;
            }
            Ok(())
--- a/src/quota.rs
+++ b/src/quota.rs
@@ -10,9 +10,8 @@ use crate::config::Config;
 use crate::context::Context;
 use crate::imap::scan_folders::get_watched_folders;
 use crate::imap::session::Session as ImapSession;
-use crate::imap::Imap;
 use crate::message::{Message, Viewtype};
-use crate::tools::time;
+use crate::tools;
 use crate::{stock_str, EventType};

 /// warn about a nearly full mailbox after this usage percentage is reached.
@@ -40,8 +39,8 @@ pub struct QuotaInfo {
    /// set to `Ok()` for valid quota information.
    pub(crate) recent: Result<BTreeMap<String, Vec<QuotaResource>>>,

-    /// Timestamp when structure was modified.
-    pub(crate) modified: i64,
+    /// When the structure was modified.
+    pub(crate) modified: tools::Time,
 }

 async fn get_unique_quota_roots_and_usage(
@@ -111,13 +110,7 @@ impl Context {
    /// As the message is added only once, the user is not spammed
    /// in case for some providers the quota is always at ~100%
    /// and new space is allocated as needed.
-    pub(crate) async fn update_recent_quota(&self, imap: &mut Imap) -> Result<()> {
-        if let Err(err) = imap.prepare(self).await {
-            warn!(self, "could not connect: {:#}", err);
-            return Ok(());
-        }
-
-        let session = imap.session.as_mut().context("no session")?;
+    pub(crate) async fn update_recent_quota(&self, session: &mut ImapSession) -> Result<()> {
        let quota = if session.can_check_quota() {
            let folders = get_watched_folders(self).await?;
            get_unique_quota_roots_and_usage(session, folders).await
@@ -132,13 +125,17 @@ impl Context {
                        highest,
                        self.get_config_int(Config::QuotaExceeding).await? as u64,
                    ) {
-                        self.set_config(Config::QuotaExceeding, Some(&highest.to_string()))
-                            .await?;
+                        self.set_config_internal(
+                            Config::QuotaExceeding,
+                            Some(&highest.to_string()),
+                        )
+                        .await?;
                        let mut msg = Message::new(Viewtype::Text);
                        msg.text = stock_str::quota_exceeding(self, highest).await;
                        add_device_msg_with_importance(self, None, Some(&mut msg), true).await?;
                    } else if highest <= QUOTA_ALLCLEAR_PERCENTAGE {
-                        self.set_config(Config::QuotaExceeding, None).await?;
+                        self.set_config_internal(Config::QuotaExceeding, None)
+                            .await?;
                    }
                }
                Err(err) => warn!(self, "cannot get highest quota usage: {:#}", err),
@@ -147,7 +144,7 @@ impl Context {

        *self.quota.write().await = Some(QuotaInfo {
            recent: quota,
-            modified: time(),
+            modified: tools::Time::now(),
        });

        self.emit_event(EventType::ConnectivityChanged);
--- a/src/reaction.rs
+++ b/src/reaction.rs
@@ -252,7 +252,7 @@ pub(crate) async fn set_msg_reaction(
    contact_id: ContactId,
    reaction: Reaction,
 ) -> Result<()> {
-    if let Some(msg_id) = rfc724_mid_exists(context, in_reply_to).await? {
+    if let Some((msg_id, _)) = rfc724_mid_exists(context, in_reply_to).await? {
        set_msg_id_reaction(context, msg_id, chat_id, contact_id, reaction).await
    } else {
        info!(
@@ -316,7 +316,7 @@ mod tests {
    use crate::contact::{Contact, ContactAddress, Origin};
    use crate::download::DownloadState;
    use crate::message::MessageState;
-    use crate::receive_imf::{receive_imf, receive_imf_inner};
+    use crate::receive_imf::{receive_imf, receive_imf_from_inbox};
    use crate::test_utils::TestContext;
    use crate::test_utils::TestContextManager;

@@ -425,7 +425,7 @@ Content-Disposition: reaction\n\
        let contacts = reactions.contacts();
        assert_eq!(contacts.len(), 1);

-        assert_eq!(contacts.get(0), Some(&bob_id));
+        assert_eq!(contacts.first(), Some(&bob_id));
        let bob_reaction = reactions.get(bob_id);
        assert_eq!(bob_reaction.is_empty(), false);
        assert_eq!(bob_reaction.emojis(), vec!["👍"]);
@@ -526,7 +526,7 @@ Here's my footer -- bob@example.net"
        assert_eq!(reactions.to_string(), "👍1");
        let contacts = reactions.contacts();
        assert_eq!(contacts.len(), 1);
-        let bob_id = contacts.get(0).unwrap();
+        let bob_id = contacts.first().unwrap();
        let bob_reaction = reactions.get(*bob_id);
        assert_eq!(bob_reaction.is_empty(), false);
        assert_eq!(bob_reaction.emojis(), vec!["👍"]);
@@ -568,7 +568,7 @@ Here's my footer -- bob@example.net"
        let msg_full = format!("{msg_header}\n\n100k text...");

        // Alice downloads message from Bob partially.
-        let alice_received_message = receive_imf_inner(
+        let alice_received_message = receive_imf_from_inbox(
            &alice,
            "first@example.org",
            msg_header.as_bytes(),
@@ -578,13 +578,13 @@ Here's my footer -- bob@example.net"
        )
        .await?
        .unwrap();
-        let alice_msg_id = *alice_received_message.msg_ids.get(0).unwrap();
+        let alice_msg_id = *alice_received_message.msg_ids.first().unwrap();

        // Bob downloads own message on the other device.
        let bob_received_message = receive_imf(&bob, msg_full.as_bytes(), false)
            .await?
            .unwrap();
-        let bob_msg_id = *bob_received_message.msg_ids.get(0).unwrap();
+        let bob_msg_id = *bob_received_message.msg_ids.first().unwrap();

        // Bob reacts to own message.
        send_reaction(&bob, bob_msg_id, "👍").await.unwrap();
@@ -599,7 +599,7 @@ Here's my footer -- bob@example.net"
        assert_eq!(msg.download_state(), DownloadState::Available);

        // Alice downloads full message.
-        receive_imf_inner(
+        receive_imf_from_inbox(
            &alice,
            "first@example.org",
            msg_full.as_bytes(),
--- a/Show More
+++ b/Show More
@@ -1 +1 @@
 -12-12
 -02-20