Serialize mime_compressed

Serialize uid
Do not serialize is_default
2026-04-04 22:42:11 +03:00 · 2024-04-06 16:37:51 +00:00 · 2024-04-06 15:54:12 +00:00 · 2024-04-06 15:27:11 +00:00 · 2024-04-06 02:48:27 +00:00 · 2024-04-06 01:45:14 +00:00
148 changed files with 10894 additions and 6343 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.75.0
+      RUSTUP_TOOLCHAIN: 1.77.1
    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.75.0
+            rust: 1.77.1
          - os: windows-latest
-            rust: 1.75.0
+            rust: 1.77.1
          - os: macos-latest
-            rust: 1.75.0
+            rust: 1.77.1

-          # Minimum Supported Rust Version = 1.72.0
+          # Minimum Supported Rust Version = 1.77.0
          - os: ubuntu-latest
-            rust: 1.72.0
+            rust: 1.77.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,69 +21,65 @@ 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: 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:
-    name: Build deltachat-rpc-server for Windows
+    name: Windows
    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:
-    name: Build deltachat-rpc-server for macOS
+    name: macOS
    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,61 +88,140 @@ 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
          if-no-files-found: error

+  build_android:
+    name: Android
+    strategy:
+      fail-fast: false
+      matrix:
+        arch: [arm64-v8a, armeabi-v7a]
+    runs-on: ubuntu-latest
+    steps:
+      - 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: nix build .#deltachat-rpc-server-${{ matrix.arch }}-android
+
+      - name: Upload binary
+        uses: actions/upload-artifact@v4
+        with:
+          name: deltachat-rpc-server-${{ matrix.arch }}-android
+          path: result/bin/deltachat-rpc-server
+          if-no-files-found: error
+
  publish:
    name: Build wheels and upload binaries to the release
    needs: ["build_linux", "build_windows", "build_macos"]
+    environment:
+      name: pypi
+      url: https://pypi.org/p/deltachat-rpc-server
    permissions:
+      id-token: write
      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
+      - uses: DeterminateSystems/nix-installer-action@main
+      - uses: DeterminateSystems/magic-nix-cache-action@main

-      - 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
+      - name: Download Android binary for arm64-v8a
+        uses: actions/download-artifact@v4
+        with:
+          name: deltachat-rpc-server-arm64-v8a-android
+          path: deltachat-rpc-server-arm64-v8a-android.d
+
+      - name: Download Android binary for armeabi-v7a
+        uses: actions/download-artifact@v4
+        with:
+          name: deltachat-rpc-server-armeabi-v7a-android
+          path: deltachat-rpc-server-armeabi-v7a-android.d
+
+      - name: Create bin/ 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
-          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
+          mkdir -p bin
+          mv deltachat-rpc-server-aarch64-linux.d/deltachat-rpc-server bin/deltachat-rpc-server-aarch64-linux
+          mv deltachat-rpc-server-armv7l-linux.d/deltachat-rpc-server bin/deltachat-rpc-server-armv7l-linux
+          mv deltachat-rpc-server-armv6l-linux.d/deltachat-rpc-server bin/deltachat-rpc-server-armv6l-linux
+          mv deltachat-rpc-server-i686-linux.d/deltachat-rpc-server bin/deltachat-rpc-server-i686-linux
+          mv deltachat-rpc-server-x86_64-linux.d/deltachat-rpc-server bin/deltachat-rpc-server-x86_64-linux
+          mv deltachat-rpc-server-win32.d/deltachat-rpc-server.exe bin/deltachat-rpc-server-win32.exe
+          mv deltachat-rpc-server-win64.d/deltachat-rpc-server.exe bin/deltachat-rpc-server-win64.exe
+          mv deltachat-rpc-server-x86_64-macos.d/deltachat-rpc-server bin/deltachat-rpc-server-x86_64-macos
+          mv deltachat-rpc-server-aarch64-macos.d/deltachat-rpc-server bin/deltachat-rpc-server-aarch64-macos
+          mv deltachat-rpc-server-arm64-v8a-android.d/deltachat-rpc-server bin/deltachat-rpc-server-arm64-v8a-android
+          mv deltachat-rpc-server-armeabi-v7a-android.d/deltachat-rpc-server bin/deltachat-rpc-server-armeabi-v7a-android
+
+      - name: List binaries
+        run: ls -l bin/

      # 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

@@ -154,15 +229,40 @@ jobs:
        run: pip install wheel

      - name: Build deltachat-rpc-server Python wheels and source package
-        run: scripts/wheel-rpc-server.py
+        run: |
+          mkdir -p dist
+          nix build .#deltachat-rpc-server-x86_64-linux-wheel
+          cp result/*.whl dist/
+          nix build .#deltachat-rpc-server-armv7l-linux-wheel
+          cp result/*.whl dist/
+          nix build .#deltachat-rpc-server-armv6l-linux-wheel
+          cp result/*.whl dist/
+          nix build .#deltachat-rpc-server-aarch64-linux-wheel
+          cp result/*.whl dist/
+          nix build .#deltachat-rpc-server-i686-linux-wheel
+          cp result/*.whl dist/
+          nix build .#deltachat-rpc-server-win64-wheel
+          cp result/*.whl dist/
+          nix build .#deltachat-rpc-server-win32-wheel
+          cp result/*.whl dist/
+          nix build .#deltachat-rpc-server-source
+          cp result/*.tar.gz dist/
+          python3 scripts/wheel-rpc-server.py x86_64-darwin bin/deltachat-rpc-server-x86_64-macos
+          python3 scripts/wheel-rpc-server.py aarch64-darwin bin/deltachat-rpc-server-aarch64-macos
+          mv *.whl dist/

-      - name: List downloaded artifacts
+      - name: List artifacts
        run: ls -l dist/

      - name: Upload binaries to the GitHub release
+        if: github.event_name == 'release'
        env:
          GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
        run: |
          gh release upload ${{ github.ref_name }} \
            --repo ${{ github.repository }} \
-            dist/*
+            bin/* dist/*
+
+      - name: Publish deltachat-rpc-client to PyPI
+        if: github.event_name == 'release'
+        uses: pypa/gh-action-pypi-publish@release/v1
--- a/.github/workflows/jsonrpc-client-npm-package.yml
+++ b/.github/workflows/jsonrpc-client-npm-package.yml
@@ -13,9 +13,10 @@ jobs:
    steps:
      - name: Install tree
        run: sudo apt install tree
-      - name: Checkout
-        uses: actions/checkout@v3
-      - uses: actions/setup-node@v3
+      - uses: actions/checkout@v4
+        with:
+          show-progress: false
+      - uses: actions/setup-node@v4
        with:
          node-version: "18"
      - name: Get tag
@@ -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,9 +14,11 @@ 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
+        uses: actions/setup-node@v4
        with:
          node-version: 18.x
      - name: Add Rust cache
--- a/.github/workflows/node-docs.yml
+++ b/.github/workflows/node-docs.yml
@@ -14,10 +14,12 @@ 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
+        uses: actions/setup-node@v4
        with:
          node-version: 18.x

--- a/.github/workflows/node-package.yml
+++ b/.github/workflows/node-package.yml
@@ -14,9 +14,10 @@ jobs:
      matrix:
        os: [macos-latest, windows-latest]
    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-      - uses: actions/setup-node@v3
+      - uses: actions/checkout@v4
+        with:
+          show-progress: false
+      - uses: actions/setup-node@v4
        with:
          node-version: "18"
      - name: System info
@@ -28,7 +29,7 @@ jobs:
          node --version

      - name: Cache node modules
-        uses: actions/cache@v3
+        uses: actions/cache@v4
        with:
          path: |
            ${{ env.APPDATA }}/npm-cache
@@ -36,7 +37,7 @@ jobs:
          key: ${{ matrix.os }}-node-${{ hashFiles('**/package.json') }}

      - name: Cache cargo index
-        uses: actions/cache@v3
+        uses: actions/cache@v4
        with:
          path: |
            ~/.cargo/registry/
@@ -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,9 +75,10 @@ jobs:
      - name: Change working directory owner
        run: chown root:root .

-      - name: Checkout
-        uses: actions/checkout@v3
-      - uses: actions/setup-node@v3
+      - uses: actions/checkout@v4
+        with:
+          show-progress: false
+      - uses: actions/setup-node@v4
        with:
          node-version: "18"
      - run: apt-get update
@@ -97,7 +99,7 @@ jobs:
          node --version

      - name: Cache node modules
-        uses: actions/cache@v3
+        uses: actions/cache@v4
        with:
          path: |
            ${{ env.APPDATA }}/npm-cache
@@ -105,7 +107,7 @@ jobs:
          key: ${{ matrix.os }}-node-${{ hashFiles('**/package.json') }}

      - name: Cache cargo index
-        uses: actions/cache@v3
+        uses: actions/cache@v4
        with:
          path: |
            ~/.cargo/registry/
@@ -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,9 +139,10 @@ jobs:
    steps:
      - name: Install tree
        run: sudo apt install tree
-      - name: Checkout
-        uses: actions/checkout@v3
-      - uses: actions/setup-node@v2
+      - uses: actions/checkout@v4
+        with:
+          show-progress: false
+      - uses: actions/setup-node@v4
        with:
          node-version: "18"
      - name: Get tag
@@ -165,25 +168,25 @@ 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
+          rm -f linux.tar.gz macos-latest.tar.gz windows-latest.tar.gz
      - name: Install dependencies without running scripts
        run: |
          npm install --ignore-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,9 +23,10 @@ jobs:
      matrix:
        os: [ubuntu-latest, macos-latest, windows-latest]
    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-      - uses: actions/setup-node@v3
+      - uses: actions/checkout@v4
+        with:
+          show-progress: false
+      - uses: actions/setup-node@v4
        with:
          node-version: "18"
      - name: System info
@@ -37,7 +38,7 @@ jobs:
          node --version

      - name: Cache node modules
-        uses: actions/cache@v3
+        uses: actions/cache@v4
        with:
          path: |
            ${{ env.APPDATA }}/npm-cache
@@ -45,7 +46,7 @@ jobs:
          key: ${{ matrix.os }}-node-${{ hashFiles('**/package.json') }}

      - name: Cache cargo index
-        uses: actions/cache@v3
+        uses: actions/cache@v4
        with:
          path: |
            ~/.cargo/registry/
--- a/.github/workflows/publish-deltachat-rpc-client-pypi.yml
+++ b/.github/workflows/publish-deltachat-rpc-client-pypi.yml
@@ -0,0 +1,47 @@
+name: Publish deltachat-rpc-client to PyPI
+
+on:
+  workflow_dispatch:
+  release:
+    types: [published]
+
+jobs:
+  build:
+    name: Build distribution
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          show-progress: false
+      - name: Install pypa/build
+        run: python3 -m pip install build
+      - name: Build a binary wheel and a source tarball
+        working-directory: deltachat-rpc-client
+        run: python3 -m build
+      - name: Store the distribution packages
+        uses: actions/upload-artifact@v4
+        with:
+          name: python-package-distributions
+          path: deltachat-rpc-client/dist/
+
+  publish-to-pypi:
+    name: Publish Python distribution to PyPI
+    if: github.event_name == 'release'
+    needs:
+      - build
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/deltachat-rpc-client
+    permissions:
+      id-token: write
+
+    steps:
+      - name: Download all the dists
+        uses: actions/download-artifact@v4
+        with:
+          name: python-package-distributions
+          path: dist/
+      - name: Publish deltachat-rpc-client to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
--- 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
@@ -1,4 +1,4 @@
-name: Build & Deploy Documentation on rs.delta.chat
+name: Build & Deploy Documentation on rs.delta.chat, c.delta.chat, py.delta.chat

 on:
  push:
@@ -6,11 +6,13 @@ on:
      - main

 jobs:
-  build:
+  build-rs:
    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
@@ -22,3 +24,41 @@ jobs:
          HOST: "delta.chat"
          SOURCE: "target/doc"
          TARGET: "/var/www/html/rs/"
+
+  build-python:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          show-progress: false
+          fetch-depth: 0 # Fetch history to calculate VCS version number.
+      - uses: DeterminateSystems/nix-installer-action@main
+      - uses: DeterminateSystems/magic-nix-cache-action@main
+      - name: Build Python documentation
+        run: nix build .#python-docs
+      - name: Upload to py.delta.chat
+        run: |
+          mkdir -p "$HOME/.ssh"
+          echo "${{ secrets.CODESPEAK_KEY }}" > "$HOME/.ssh/key"
+          chmod 600 "$HOME/.ssh/key"
+          rsync -avzh -e "ssh -i $HOME/.ssh/key -o StrictHostKeyChecking=no" $GITHUB_WORKSPACE/result/html/ "delta@py.delta.chat:/home/delta/build/master"
+
+  build-c:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          show-progress: false
+          fetch-depth: 0 # Fetch history to calculate VCS version number.
+      - uses: DeterminateSystems/nix-installer-action@main
+      - uses: DeterminateSystems/magic-nix-cache-action@main
+      - name: Build C documentation
+        run: nix build .#docs
+      - name: Upload to py.delta.chat
+        run: |
+          mkdir -p "$HOME/.ssh"
+          echo "${{ secrets.CODESPEAK_KEY }}" > "$HOME/.ssh/key"
+          chmod 600 "$HOME/.ssh/key"
+          rsync -avzh -e "ssh -i $HOME/.ssh/key -o StrictHostKeyChecking=no" $GITHUB_WORKSPACE/result/html/ "delta@c.delta.chat:/home/delta/build-c/master"
--- a/.github/workflows/upload-ffi-docs.yml
+++ b/.github/workflows/upload-ffi-docs.yml
@@ -14,15 +14,15 @@ 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
      - name: Upload to cffi.delta.chat
-        uses: up9cloud/action-rsync@v1.3
-        env:
-          USER: ${{ secrets.USERNAME }}
-          KEY: ${{ secrets.KEY }}
-          HOST: "delta.chat"
-          SOURCE: "target/doc"
-          TARGET: "/var/www/html/cffi/"
+        run: |
+          mkdir -p "$HOME/.ssh"
+          echo "${{ secrets.KEY }}" > "$HOME/.ssh/key"
+          chmod 600 "$HOME/.ssh/key"
+          rsync -avzh -e "ssh -i $HOME/.ssh/key -o StrictHostKeyChecking=no" $GITHUB_WORKSPACE/target/doc/ "${{ secrets.USERNAME }}@delta.chat:/var/www/html/cffi/"
--- a/.github/workflows/upload-python-docs.yml
+++ b/.github/workflows/upload-python-docs.yml
@@ -1,25 +0,0 @@
-name: Build & Deploy Documentation on py.delta.chat
-
-on:
-  push:
-    branches:
-      - main
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v3
-        with:
-          fetch-depth: 0 # Fetch history to calculate VCS version number.
-      - name: Build Python documentation
-        run: scripts/build-python-docs.sh
-      - name: Upload to py.delta.chat
-        uses: up9cloud/action-rsync@v1.3
-        env:
-          USER: delta
-          KEY: ${{ secrets.CODESPEAK_KEY }}
-          HOST: "lists.codespeak.net"
-          SOURCE: "dist/html/"
-          TARGET: "/home/delta/build/master"
--- a/.gitignore
+++ b/.gitignore
@@ -44,3 +44,10 @@ node/build/
 node/dist/
 node/prebuilds/
 node/.nyc_output/
+
+# Nix symlink.
+result
+
+# direnv
+.envrc
+.direnv
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,426 @@
 # Changelog

+## [1.137.2] - 2024-04-05
+
+### API-Changes
+
+- [**breaking**] Increase Minimum Supported Rust Version to 1.77.0.
+
+### Features / Changes
+
+- Show reactions in summaries ([#5387](https://github.com/deltachat/deltachat-core-rust/pull/5387)).
+
+### Tests
+
+- Test reactions for forwarded messages
+
+### Refactor
+
+- `is_probably_private_reply`: Remove reaction-specific code.
+- Use Rust 1.77.0 support for recursion in async functions.
+
+### Miscellaneous Tasks
+
+- cargo: Bump rustyline from 13.0.0 to 14.0.0.
+- Update chrono from 0.4.34 to 0.4.37.
+- Update from brotli 3.4.0 to brotli 4.0.0.
+- Upgrade `h2` from 0.4.3 to 0.4.4.
+- Upgrade `image` from 0.24.9 to 0.25.1.
+- cargo: Bump fast-socks5 from 0.9.5 to 0.9.6.
+
+## [1.137.1] - 2024-04-03
+
+### CI
+
+- Remove android builds for `x86` and `x86_64`.
+
+## [1.137.0] - 2024-04-02
+
+### API-Changes
+
+- [**breaking**] Remove data from `DC_EVENT_INCOMING_MSG_BUNCH`.
+- [**breaking**] Remove unused `dc_accounts_all_work_done()` ([#5384](https://github.com/deltachat/deltachat-core-rust/pull/5384)).
+- deltachat-rpc-client: Add futures.
+
+### Build system
+
+- cmake: Build outside the source tree.
+- nix: Add outputs for Android binaries.
+- Add `repository` to Cargo.toml.
+- python: Remove `setuptools_scm` dependency.
+- Add development shell ([#5390](https://github.com/deltachat/deltachat-core-rust/pull/5390)).
+
+### CI
+
+- Update to Rust 1.77.0.
+- Build deltachat-rpc-server for Android.
+- Shorter names for deltachat-rpc-server jobs.
+
+### Features / Changes
+
+- Do not include provider hostname in `Message-ID`.
+- Include 3 recent Message-IDs in `References` header.
+- Include more entries into DNS fallback cache.
+
+### Fixes
+
+- Preserve upper-/lowercase of links parsed by `dehtml()` ([#5362](https://github.com/deltachat/deltachat-core-rust/pull/5362)).
+- Rescan folders after changing `Config::SentboxWatch`.
+- Do not ignore `Contact::get_by_id()` error in `from_field_to_contact_id()`.
+- Put overridden sender name into message info.
+- Don't send selfavatar in `SecureJoin` messages before contact verification ([#5354](https://github.com/deltachat/deltachat-core-rust/pull/5354)).
+- Always set correct `chat_id` for `DC_EVENT_REACTIONS_CHANGED` ([#5419](https://github.com/deltachat/deltachat-core-rust/pull/5419)).
+
+### Refactor
+
+- Remove `MessageObject::from_message_id()`.
+- jsonrpc: Add `msg_id` and `account_id` to `get_message()` errors.
+- Cleanup `jobs` and `Params` relicts.
+
+### Tests
+
+- `Test_mvbox_sentbox_threads`: Check that sentbox gets configured after setting `sentbox_watch` ([#5105](https://github.com/deltachat/deltachat-core-rust/pull/5105)).
+- Remove flaky time check from `test_list_from()`.
+- Add failing test for #5418 (wrong `DC_EVENT_REACTIONS_CHANGED`)
+
+### Miscellaneous Tasks
+
+- Add `result` to .gitignore.
+- cargo: Bump thiserror from 1.0.57 to 1.0.58.
+- cargo: Bump tokio from 1.36.0 to 1.37.0.
+- cargo: Bump pin-project from 1.1.4 to 1.1.5.
+- cargo: Bump strum from 0.26.1 to 0.26.2.
+- cargo: Bump uuid from 1.7.0 to 1.8.0.
+- cargo: Bump toml from 0.8.10 to 0.8.12.
+- cargo: Bump tokio-stream from 0.1.14 to 0.1.15.
+- cargo: Bump smallvec from 1.13.1 to 1.13.2.
+- cargo: Bump async-smtp from 0.9.0 to 0.9.1.
+- cargo: Bump strum_macros from 0.26.1 to 0.26.2.
+- cargo: Bump serde_json from 1.0.114 to 1.0.115.
+- cargo: Bump anyhow from 1.0.80 to 1.0.81.
+- cargo: Bump syn from 2.0.52 to 2.0.57.
+- cargo: Bump futures-lite from 2.2.0 to 2.3.0.
+- cargo: Bump axum from 0.7.4 to 0.7.5.
+- cargo: Bump reqwest from 0.11.24 to 0.12.2.
+- cargo: Bump backtrace from 0.3.69 to 0.3.71.
+- cargo: Bump regex from 1.10.3 to 1.10.4.
+- cargo: Update aho-corasick from 1.1.2 to 1.1.3.
+- Update deny.toml.
+
+## [1.136.6] - 2024-03-19
+
+### Build system
+
+- Add description to deltachat-rpc-server wheels.
+- Read version from Cargo.toml in wheel-rpc-server.py.
+
+### CI
+
+- Update actions/cache from v3 to v4.
+- Automate publishing of deltachat-rpc-server to PyPI.
+
+### Documentation
+
+- deltachat-rpc-server: Update deltachat-rpc-client URL.
+
+### Miscellaneous Tasks
+
+- Nix flake update.
+
+## [1.136.5] - 2024-03-18
+
+### Features / Changes
+
+- Nicer summaries: prefer emoji over names
+- Add `save_mime_headers` to debug info ([#5350](https://github.com/deltachat/deltachat-core-rust/pull/5350))
+
+### Fixes
+
+- Terminate ephemeral and location loop immediately on channel close.
+- Update MemberListTimestamp when sending a group message.
+- On iOS, use FILE (default) instead of MEMORY ([#5349](https://github.com/deltachat/deltachat-core-rust/pull/5349)).
+- Add white background to recoded avatars ([#3787](https://github.com/deltachat/deltachat-core-rust/pull/3787)).
+
+### Build system
+
+- Add README to deltachat-rpc-client Python packages.
+
+### Documentation
+
+- deltachat-rpc-client: Document that 0 is a special value of `set_ephemeral_timer()`.
+
+### Tests
+
+- Test that reordering of Member added message results in square bracket error.
+
+## [1.136.4] - 2024-03-11
+
+### Build system
+
+- nix: Make .#libdeltachat buildable on macOS.
+- Build deltachat-rpc-server wheels with nix.
+
+### CI
+
+- Add workflow for automatic publishing of deltachat-rpc-client.
+
+### Fixes
+
+- Remove duplicate CHANGELOG entries for 1.135.1.
+
+## [1.136.3] - 2024-03-09
+
+### Features / Changes
+
+- Start IMAP loop for sentbox only if it is configured ([#5105](https://github.com/deltachat/deltachat-core-rust/pull/5105)).
+
+### Fixes
+
+- Remove leading whitespace from Subject ([#5106](https://github.com/deltachat/deltachat-core-rust/pull/5106)).
+- Create new Peerstate for unencrypted message with already known Autocrypt key, but a new address.
+
+### Build system
+
+- nix: Cleanup cross-compilation code.
+- nix: Include SystemConfiguration framework on darwin systems.
+
+### CI
+
+- Wait for `build_windows` task before trying to publish it.
+- Remove artifacts from npm package.
+
+### Refactor
+
+- Don't parse Autocrypt header for outgoing messages ([#5259](https://github.com/deltachat/deltachat-core-rust/pull/5259)).
+- Remove `deduplicate_peerstates()`.
+- Fix 2024-03-05 nightly clippy warnings.
+
+### Miscellaneous Tasks
+
+- deps: Bump mio from 0.8.8 to 0.8.11 in /fuzz.
+- RPC client: Add missing constants ([#5110](https://github.com/deltachat/deltachat-core-rust/pull/5110)).
+
+## [1.136.2] - 2024-03-05
+
+### Build system
+
+- Downgrade `cc` to 1.0.83 to fix build for Android.
+
+### CI
+
+- Update setup-node action.
+
+## [1.136.1] - 2024-03-05
+
+### Build system
+
+- Revert to OpenSSL 3.1.
+- Restore MSRV 1.70.0.
+
+### Miscellaneous Tasks
+
+- Update node constants.
+
+## [1.136.0] - 2024-03-04
+
+### Features / Changes
+
+- Recognise Trash folder by name ([#5275](https://github.com/deltachat/deltachat-core-rust/pull/5275)).
+- Send Chat-Group-Avatar as inline base64 ([#5253](https://github.com/deltachat/deltachat-core-rust/pull/5253)).
+- Self-Reporting: Report number of protected/encrypted/unencrypted chats ([#5292](https://github.com/deltachat/deltachat-core-rust/pull/5292)).
+
+### Fixes
+
+- Don't send sync messages on self-{status,avatar} update from self-sent messages ([#5289](https://github.com/deltachat/deltachat-core-rust/pull/5289)).
+- imap: Allow `maybe_network` to interrupt connection ratelimit.
+- imap: Set connectivity to "connecting" only after ratelimit.
+- Remove `Group-ID` from `Message-ID`.
+- Prioritize protected `Message-ID` over `X-Microsoft-Original-Message-ID`.
+
+### API-Changes
+
+- Make `store_self_keypair` private.
+- Add `ContextBuilder.build()` to build Context without opening.
+- `dc_accounts_set_push_device_token` and `dc_get_push_state` APIs for iOS push notifications.
+
+### Build system
+
+- Tag armv6 wheels with tags accepted by PyPI.
+- Unpin OpenSSL.
+- Remove deprecated `unmaintained` field from deny.toml.
+- Do not vendor OpenSSL when cross-compiling ([#5316](https://github.com/deltachat/deltachat-core-rust/pull/5316)).
+- Increase MSRV to 1.74.0.
+
+### CI
+
+- Upgrade setup-python GitHub Action.
+- Update to Rust 1.76 and fix clippy warnings.
+- Build Python docs with Nix.
+- Upload python docs without GH actions.
+- Upload cffi docs without GH actions.
+- Build c.delta.chat docs with nix.
+
+### Other
+
+- refactor: move more methods from Imap into Session.
+- Add deltachat-time to sources.
+
+### Refactor
+
+- Remove Session from Imap structure.
+- Merge ImapConfig into Imap.
+- Get rid of ImapActionResult.
+- Build contexts using ContextBuilder.
+- Do not send `Secure-Join-Group` in `vg-request`.
+
+### Tests
+
+- Fix `test_verified_oneonone_chat_broken_by_device_change()` ([#5280](https://github.com/deltachat/deltachat-core-rust/pull/5280)).
+- `get_protected_chat()`: Use FFIEventTracker instead of `dc_wait_next_msgs()` ([#5207](https://github.com/deltachat/deltachat-core-rust/pull/5207)).
+- Fixup `tests/test_3_offline.py::TestOfflineAccountBasic::test_wrong_db`.
+- Fix pytest compat ([#5317](https://github.com/deltachat/deltachat-core-rust/pull/5317)).
+
+## [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.
+- Fixup node-package.yml after artifact actions upgrade.
+- Update to actions/checkout@v4.
+- Replace download-artifact v1 with v4.
+
+### 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.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
@@ -3437,3 +3858,17 @@ https://github.com/deltachat/deltachat-core-rust/pulls?q=is%3Apr+is%3Aclosed
 [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
+[1.136.0]: https://github.com/deltachat/deltachat-core-rust/compare/v1.135.1...v1.136.0
+[1.136.1]: https://github.com/deltachat/deltachat-core-rust/compare/v1.136.0...v1.136.1
+[1.136.2]: https://github.com/deltachat/deltachat-core-rust/compare/v1.136.1...v1.136.2
+[1.136.3]: https://github.com/deltachat/deltachat-core-rust/compare/v1.136.2...v1.136.3
+[1.136.4]: https://github.com/deltachat/deltachat-core-rust/compare/v1.136.3...v1.136.4
+[1.136.5]: https://github.com/deltachat/deltachat-core-rust/compare/v1.136.4...v1.136.5
+[1.136.6]: https://github.com/deltachat/deltachat-core-rust/compare/v1.136.5...v1.136.6
+[1.137.0]: https://github.com/deltachat/deltachat-core-rust/compare/v1.136.6...v1.137.0
+[1.137.1]: https://github.com/deltachat/deltachat-core-rust/compare/v1.137.0...v1.137.1
+[1.137.2]: https://github.com/deltachat/deltachat-core-rust/compare/v1.137.1...v1.137.2
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -14,24 +14,14 @@ endif()

 add_custom_command(
 	OUTPUT
-	"target/release/libdeltachat.a"
-	"target/release/libdeltachat.${DYNAMIC_EXT}"
-	"target/release/pkgconfig/deltachat.pc"
+	"${CMAKE_BINARY_DIR}/target/release/libdeltachat.a"
+	"${CMAKE_BINARY_DIR}/target/release/libdeltachat.${DYNAMIC_EXT}"
+	"${CMAKE_BINARY_DIR}/target/release/pkgconfig/deltachat.pc"
        COMMAND
        PREFIX=${CMAKE_INSTALL_PREFIX}
        LIBDIR=${CMAKE_INSTALL_FULL_LIBDIR}
        INCLUDEDIR=${CMAKE_INSTALL_FULL_INCLUDEDIR}
-        ${CARGO} build --release --no-default-features --features jsonrpc
-
-	# Build in `deltachat-ffi` directory instead of using
-	# `--package deltachat_ffi` to avoid feature resolver version
-	# "1" bug which makes `--no-default-features` affect only
-	# `deltachat`, but not `deltachat-ffi` package.
-	#
-	# We can't enable version "2" resolver [1] because it is not
-	# stable yet on rust 1.50.0.
-	#
-	# [1] https://doc.rust-lang.org/nightly/cargo/reference/features.html#resolver-version-2-command-line-flags
+	${CARGO} build --target-dir=${CMAKE_BINARY_DIR}/target --release --no-default-features --features jsonrpc
 	WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/deltachat-ffi
 )

@@ -39,12 +29,12 @@ add_custom_target(
 	lib_deltachat
 	ALL
 	DEPENDS
-	"target/release/libdeltachat.a"
-	"target/release/libdeltachat.${DYNAMIC_EXT}"
-	"target/release/pkgconfig/deltachat.pc"
+	"${CMAKE_BINARY_DIR}/target/release/libdeltachat.a"
+	"${CMAKE_BINARY_DIR}/target/release/libdeltachat.${DYNAMIC_EXT}"
+	"${CMAKE_BINARY_DIR}/target/release/pkgconfig/deltachat.pc"
 )

 install(FILES "deltachat-ffi/deltachat.h" DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
-install(FILES "target/release/libdeltachat.a" DESTINATION ${CMAKE_INSTALL_LIBDIR})
-install(FILES "target/release/libdeltachat.${DYNAMIC_EXT}" DESTINATION ${CMAKE_INSTALL_LIBDIR})
-install(FILES "target/release/pkgconfig/deltachat.pc" DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
+install(FILES "${CMAKE_BINARY_DIR}/target/release/libdeltachat.a" DESTINATION ${CMAKE_INSTALL_LIBDIR})
+install(FILES "${CMAKE_BINARY_DIR}/target/release/libdeltachat.${DYNAMIC_EXT}" DESTINATION ${CMAKE_INSTALL_LIBDIR})
+install(FILES "${CMAKE_BINARY_DIR}/target/release/pkgconfig/deltachat.pc" DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,9 +1,10 @@
 [package]
 name = "deltachat"
-version = "1.133.1"
+version = "1.137.2"
 edition = "2021"
 license = "MPL-2.0"
-rust-version = "1.72"
+rust-version = "1.77"
+repository = "https://github.com/deltachat/deltachat-core-rust"

 [profile.dev]
 debug = 0
@@ -30,63 +31,36 @@ opt-level = "z"
 codegen-units = 1
 strip = true

-[patch.crates-io]
-imap-proto = { git = "https://github.com/djc/tokio-imap.git", rev = "01ff256a7e42a9f7d2732706f8b71a16ce93427e" }
-"iroh-blake3" = { git = "https://github.com/n0-computer/iroh-blake3.git", branch = "master" }
-
 [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-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",
-] }
+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"] }
 backtrace = "0.3"
 base64 = "0.21"
-brotli = { version = "3.4", default-features = false, features = ["std"] }
-chrono = { version = "0.4", default-features = false, features = [
-  "clock",
-  "std",
-] }
+brotli = { version = "4", default-features=false, features = ["std"] }
+bitflags = "1.3"
+bstr = { version = "1.4.0", default-features=false, features = ["std", "alloc"] }
+chrono = { version = "0.4", default-features=false, features = ["clock", "std"] }
 email = { git = "https://github.com/deltachat/rust-email", branch = "master" }
 encoded-words = { git = "https://github.com/async-email/encoded-words", branch = "master" }
 escaper = "0.1"
 fast-socks5 = "0.9"
 fd-lock = "4"
 futures = "0.3"
-futures-lite = "2.0.0"
+futures-lite = "2.3.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",
-] }
-iroh = { git = "https://github.com/deltachat/iroh", branch = "0.4-update-quic", default-features = false }
-iroh-net = { git = "https://github.com/n0-computer/iroh", branch = "main" }
-iroh-base = { git = "https://github.com/n0-computer/iroh", branch = "main" }
-iroh-gossip = { git = "https://github.com/n0-computer/iroh", branch = "main", features = [
-  "net",
-] }
-quinn = "0.10"
+image = { version = "0.25.1", 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" }
 libc = "0.2"
@@ -98,16 +72,16 @@ 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"] }
-rusqlite = { version = "0.30", features = ["sqlcipher"] }
+regex = "1.10"
+reqwest = { version = "0.12.2", features = ["json"] }
+rusqlite = { version = "0.31", features = ["sqlcipher"] }
 rust-hsluv = "0.1"
 sanitize-filename = "0.5"
 serde_json = "1"
@@ -115,42 +89,39 @@ 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"
+textwrap = "0.16.1"
 thiserror = "1"
-tokio = { version = "1", features = [
-  "fs",
-  "rt-multi-thread",
-  "macros",
-  "time",
-] }
+tokio = { version = "1", features = ["fs", "rt-multi-thread", "macros"] }
 tokio-io-timeout = "1.2.0"
-tokio-stream = { version = "0.1.14", features = ["fs"] }
+tokio-stream = { version = "0.1.15", features = ["fs"] }
 tokio-tar = { version = "0.3" } # TODO: integrate tokio into async-tar
 tokio-util = "0.7.9"
 toml = "0.8"
 url = "2"
 uuid = { version = "1", features = ["serde", "v4"] }

+# Pin OpenSSL to 3.1 releases.
+# OpenSSL 3.2 has a regression tracked at <https://github.com/openssl/openssl/issues/23376>
+# which results in broken `deltachat-rpc-server` binaries when cross-compiled using Zig toolchain.
+# See <https://github.com/deltachat/deltachat-core-rust/issues/5206> for Delta Chat issue.
+# According to <https://www.openssl.org/policies/releasestrat.html>
+# 3.1 branch will be supported until 2025-03-14.
+openssl-src = "~300.1"
+
 [dev-dependencies]
 ansi_term = "0.12.0"
-anyhow = { version = "1", features = [
-  "backtrace",
-] } # Enable `backtrace` feature in tests.
+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.3.0"
 log = "0.4"
 pretty_env_logger = "0.5"
 proptest = { version = "1", default-features = false, features = ["std"] }
 tempfile = "3"
 testdir = "0.9.0"
-tokio = { version = "1", features = [
-  "parking_lot",
-  "rt-multi-thread",
-  "macros",
-] }
+tokio = { version = "1", features = ["parking_lot", "rt-multi-thread", "macros"] }
 pretty_assertions = "1.3.0"

 [workspace]
@@ -161,6 +132,7 @@ members = [
  "deltachat-rpc-server",
  "deltachat-ratelimit",
  "deltachat-repl",
+  "deltachat-time",
  "format-flowed",
 ]

@@ -198,5 +170,5 @@ internals = []
 vendored = [
  "async-native-tls/vendored",
  "rusqlite/bundled-sqlcipher-vendored-openssl",
-  "reqwest/native-tls-vendored",
+  "reqwest/native-tls-vendored"
 ]
--- 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.133.1"
+version = "1.137.2"
 description = "Deltachat FFI"
 edition = "2018"
 readme = "README.md"
--- 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)=
@@ -689,8 +686,25 @@ int             dc_get_connectivity          (dc_context_t* context);
 char*           dc_get_connectivity_html     (dc_context_t* context);


+#define DC_PUSH_NOT_CONNECTED 0
+#define DC_PUSH_HEARTBEAT     1
+#define DC_PUSH_CONNECTED     2
+
+/**
+ * Get the current push notification state.
+ * One of:
+ * - DC_PUSH_NOT_CONNECTED
+ * - DC_PUSH_HEARTBEAT
+ * - DC_PUSH_CONNECTED
+ *
+ * @memberof dc_context_t
+ * @param context The context object.
+ * @return Push notification state.
+ */
+int              dc_get_push_state           (dc_context_t* context);
+
+
 /**
- * Standalone version of dc_accounts_all_work_done().
 * Only used by the python tests.
 */
 int             dc_all_work_done             (dc_context_t* context);
@@ -3084,23 +3098,6 @@ dc_context_t*  dc_accounts_get_selected_account (dc_accounts_t* accounts);
 int            dc_accounts_select_account       (dc_accounts_t* accounts, uint32_t account_id);


-/**
- * This is meant especially for iOS, because iOS needs to tell the system when its background work is done.
- *
- * iOS can:
- * - call dc_start_io() (in case IO was not running)
- * - call dc_maybe_network()
- * - while dc_accounts_all_work_done() returns false:
- *   - Wait for #DC_EVENT_CONNECTIVITY_CHANGED
- *
- * @memberof dc_accounts_t
- * @param accounts The account manager as created by dc_accounts_new().
- * @return Whether all accounts finished their background work.
- *      #DC_EVENT_CONNECTIVITY_CHANGED will be sent when this turns to true.
- */
-int            dc_accounts_all_work_done        (dc_accounts_t* accounts);
-
-
 /**
 * Start job and IMAP/SMTP tasks for all accounts managed by the account manager.
 * If IO is already running, nothing happens.
@@ -3151,6 +3148,33 @@ 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);
+
+
+/**
+ * Sets device token for Apple Push Notification service.
+ * Returns immediately.
+ *
+ * @memberof dc_accounts_t
+ * @param token Hexadecimal device token
+ */
+void           dc_accounts_set_push_device_token (dc_accounts_t* accounts, const char *token);
+
 /**
 * Create the event emitter that is used to receive events.
 *
@@ -6032,10 +6056,12 @@ void dc_event_unref(dc_event_t* event);
 * Downloading a bunch of messages just finished. This is an
 * event to allow the UI to only show one notification per message bunch,
 * instead of cluttering the user with many notifications.
- * For each of the msg_ids, an additional #DC_EVENT_INCOMING_MSG event was emitted before.
+ * UI may store #DC_EVENT_INCOMING_MSG events
+ * and display notifications for all messages at once
+ * when this event arrives.
 * 
 * @param data1 0
- * @param data2 (char*) msg_ids, a json object with the message ids.
+ * @param data2 0
 */
 #define DC_EVENT_INCOMING_MSG_BUNCH       2006

@@ -6255,6 +6281,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

 /**
 * @}
@@ -7260,6 +7296,22 @@ void dc_event_unref(dc_event_t* event);
 /// `%1$s` will be replaced by the provider's domain.
 #define DC_STR_INVALID_UNENCRYPTED_MAIL 174

+/// "You reacted %1$s to '%2$s'"
+///
+/// `%1$s` will be replaced by the reaction, usually an emoji
+/// `%2$s` will be replaced by the summary of the message the reaction refers to
+///
+/// Used in summaries.
+#define DC_STR_YOU_REACTED 176
+
+/// "%1$s reacted %2$s to '%3$s'"
+///
+/// `%1$s` will be replaced by the name the contact who reacted
+/// `%2$s` will be replaced by the reaction, usually an emoji
+/// `%3$s` will be replaced by the summary of the message the reaction refers to
+///
+/// Used in summaries.
+#define DC_STR_REACTED_BY 177

 /**
 * @}
--- a/deltachat-ffi/src/lib.rs
+++ b/deltachat-ffi/src/lib.rs
@@ -26,7 +26,7 @@ use anyhow::Context as _;
 use deltachat::chat::{ChatId, ChatVisibility, MessageListOptions, MuteDuration, ProtectionStatus};
 use deltachat::constants::DC_MSG_ID_LAST_SPECIAL;
 use deltachat::contact::{Contact, ContactId, Origin};
-use deltachat::context::Context;
+use deltachat::context::{Context, ContextBuilder};
 use deltachat::ephemeral::Timer as EphemeralTimer;
 use deltachat::imex::BackupProvider;
 use deltachat::key::preconfigure_keypair;
@@ -34,7 +34,6 @@ use deltachat::message::MsgId;
 use deltachat::qr_code_generator::{generate_backup_qr, get_securejoin_qr_svg};
 use deltachat::reaction::{get_msg_reactions, send_reaction, Reactions};
 use deltachat::stock_str::StockMessage;
-use deltachat::stock_str::StockStrings;
 use deltachat::webxdc::StatusUpdateSerial;
 use deltachat::*;
 use deltachat::{accounts::Accounts, log::LogExt};
@@ -104,12 +103,11 @@ pub unsafe extern "C" fn dc_context_new(
    let ctx = if blobdir.is_null() || *blobdir == 0 {
        // generate random ID as this functionality is not yet available on the C-api.
        let id = rand::thread_rng().gen();
-        block_on(Context::new(
-            as_path(dbfile),
-            id,
-            Events::new(),
-            StockStrings::new(),
-        ))
+        block_on(
+            ContextBuilder::new(as_path(dbfile).to_path_buf())
+                .with_id(id)
+                .open(),
+        )
    } else {
        eprintln!("blobdir can not be defined explicitly anymore");
        return ptr::null_mut();
@@ -133,12 +131,11 @@ pub unsafe extern "C" fn dc_context_new_closed(dbfile: *const libc::c_char) -> *
    }

    let id = rand::thread_rng().gen();
-    match block_on(Context::new_closed(
-        as_path(dbfile),
-        id,
-        Events::new(),
-        StockStrings::new(),
-    )) {
+    match block_on(
+        ContextBuilder::new(as_path(dbfile).to_path_buf())
+            .with_id(id)
+            .build(),
+    ) {
        Ok(context) => Box::into_raw(Box::new(context)),
        Err(err) => {
            eprintln!("failed to create context: {err:#}");
@@ -387,7 +384,7 @@ pub unsafe extern "C" fn dc_get_connectivity(context: *const dc_context_t) -> li
        return 0;
    }
    let ctx = &*context;
-    block_on(async move { ctx.get_connectivity().await as u32 as libc::c_int })
+    block_on(ctx.get_connectivity()) as u32 as libc::c_int
 }

 #[no_mangle]
@@ -410,6 +407,16 @@ pub unsafe extern "C" fn dc_get_connectivity_html(
    })
 }

+#[no_mangle]
+pub unsafe extern "C" fn dc_get_push_state(context: *const dc_context_t) -> libc::c_int {
+    if context.is_null() {
+        eprintln!("ignoring careless call to dc_get_push_state()");
+        return 0;
+    }
+    let ctx = &*context;
+    block_on(ctx.push_state()) as libc::c_int
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn dc_all_work_done(context: *mut dc_context_t) -> libc::c_int {
    if context.is_null() {
@@ -559,6 +566,7 @@ pub unsafe extern "C" fn dc_event_get_id(event: *mut dc_event_t) -> libc::c_int
        EventType::ConfigSynced { .. } => 2111,
        EventType::WebxdcStatusUpdate { .. } => 2120,
        EventType::WebxdcInstanceDeleted { .. } => 2121,
+        EventType::AccountsBackgroundFetchDone => 2200,
    }
 }

@@ -586,7 +594,8 @@ pub unsafe extern "C" fn dc_event_get_data1_int(event: *mut dc_event_t) -> libc:
        | 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, .. }
@@ -646,6 +655,7 @@ pub unsafe extern "C" fn dc_event_get_data2_int(event: *mut dc_event_t) -> libc:
        | EventType::WebxdcInstanceDeleted { .. }
        | EventType::IncomingMsgBunch { .. }
        | EventType::SelfavatarChanged
+        | EventType::AccountsBackgroundFetchDone
        | EventType::ConfigSynced { .. } => 0,
        EventType::ChatModified(_) => 0,
        EventType::MsgsChanged { msg_id, .. }
@@ -708,7 +718,9 @@ pub unsafe extern "C" fn dc_event_get_data2_str(event: *mut dc_event_t) -> *mut
        | EventType::SelfavatarChanged
        | EventType::WebxdcStatusUpdate { .. }
        | EventType::WebxdcInstanceDeleted { .. }
-        | EventType::ChatEphemeralTimerModified { .. } => ptr::null_mut(),
+        | EventType::AccountsBackgroundFetchDone
+        | EventType::ChatEphemeralTimerModified { .. }
+        | EventType::IncomingMsgBunch { .. } => ptr::null_mut(),
        EventType::ConfigureProgress { comment, .. } => {
            if let Some(comment) = comment {
                comment.to_c_string().unwrap_or_default().into_raw()
@@ -720,11 +732,6 @@ pub unsafe extern "C" fn dc_event_get_data2_str(event: *mut dc_event_t) -> *mut
            let data2 = file.to_c_string().unwrap_or_default();
            data2.into_raw()
        }
-        EventType::IncomingMsgBunch { msg_ids } => serde_json::to_string(msg_ids)
-            .unwrap_or_default()
-            .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()
@@ -4844,16 +4851,6 @@ pub unsafe extern "C" fn dc_accounts_get_all(accounts: *mut dc_accounts_t) -> *m
    Box::into_raw(Box::new(array))
 }

-#[no_mangle]
-pub unsafe extern "C" fn dc_accounts_all_work_done(accounts: *mut dc_accounts_t) -> libc::c_int {
-    if accounts.is_null() {
-        eprintln!("ignoring careless call to dc_accounts_all_work_done()");
-        return 0;
-    }
-    let accounts = &*accounts;
-    block_on(async move { accounts.read().await.all_work_done().await as libc::c_int })
-}
-
 #[no_mangle]
 pub unsafe extern "C" fn dc_accounts_start_io(accounts: *mut dc_accounts_t) {
    if accounts.is_null() {
@@ -4898,6 +4895,49 @@ 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_set_push_device_token(
+    accounts: *mut dc_accounts_t,
+    token: *const libc::c_char,
+) {
+    if accounts.is_null() {
+        eprintln!("ignoring careless call to dc_accounts_set_push_device_token()");
+        return;
+    }
+
+    let accounts = &*accounts;
+    let token = to_string_lossy(token);
+
+    block_on(async move {
+        let mut accounts = accounts.write().await;
+        if let Err(err) = accounts.set_push_device_token(&token).await {
+            accounts.emit_event(EventType::Error(format!(
+                "Failed to set notify token: {err:#}."
+            )));
+        }
+    })
+}
+
 #[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,10 +1,11 @@
 [package]
 name = "deltachat-jsonrpc"
-version = "1.133.1"
+version = "1.137.2"
 description = "DeltaChat JSON-RPC API"
 edition = "2021"
 default-run = "deltachat-jsonrpc-server"
 license = "MPL-2.0"
+repository = "https://github.com/deltachat/deltachat-core-rust"

 [[bin]]
 name = "deltachat-jsonrpc-server"
@@ -17,16 +18,16 @@ deltachat = { path = ".." }
 num-traits = "0.2"
 schemars = "0.8.13"
 serde = { version = "1.0", features = ["derive"] }
-tempfile = "3.9.0"
+tempfile = "3.10.1"
 log = "0.4"
 async-channel = { version = "2.0.0" }
 futures = { version = "0.3.30" }
 serde_json = "1"
 yerpc = { version = "0.5.2", features = ["anyhow_expose", "openrpc"] }
 typescript-type-def = { version = "0.5.8", features = ["json_value"] }
-tokio = { version = "1.33.0" }
+tokio = { version = "1.37.0" }
 sanitize-filename = "0.5"
-walkdir = "2.3.3"
+walkdir = "2.5.0"
 base64 = "0.21"

 # optional dependencies
@@ -34,7 +35,7 @@ axum = { version = "0.7", optional = true, features = ["ws"] }
 env_logger = { version = "0.10.0", optional = true }

 [dev-dependencies]
-tokio = { version = "1.33.0", features = ["full", "rt-multi-thread"] }
+tokio = { version = "1.37.0", features = ["full", "rt-multi-thread"] }


 [features]
--- a/deltachat-jsonrpc/src/api.rs
+++ b/deltachat-jsonrpc/src/api.rs
@@ -15,6 +15,7 @@ use deltachat::constants::DC_MSG_ID_DAYMARKER;
 use deltachat::contact::{may_be_valid_addr, Contact, ContactId, Origin};
 use deltachat::context::get_info;
 use deltachat::ephemeral::Timer;
+use deltachat::imex;
 use deltachat::location;
 use deltachat::message::get_msg_read_receipts;
 use deltachat::message::{
@@ -27,7 +28,6 @@ use deltachat::reaction::{get_msg_reactions, send_reaction};
 use deltachat::securejoin;
 use deltachat::stock_str::StockMessage;
 use deltachat::webxdc::StatusUpdateSerial;
-use deltachat::{imex, webxdc};
 use sanitize_filename::is_sanitized;
 use tokio::fs;
 use tokio::sync::{watch, Mutex, RwLock};
@@ -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_.
@@ -1062,9 +1097,12 @@ impl CommandApi {
            .collect::<Vec<JSONRPCMessageListItem>>())
    }

-    async fn get_message(&self, account_id: u32, message_id: u32) -> Result<MessageObject> {
+    async fn get_message(&self, account_id: u32, msg_id: u32) -> Result<MessageObject> {
        let ctx = self.get_context(account_id).await?;
-        MessageObject::from_message_id(&ctx, message_id).await
+        let msg_id = MsgId::new(msg_id);
+        MessageObject::from_msg_id(&ctx, msg_id)
+            .await
+            .with_context(|| format!("Failed to load message {msg_id} for account {account_id}"))
    }

    async fn get_message_html(&self, account_id: u32, message_id: u32) -> Result<Option<String>> {
@@ -1084,7 +1122,7 @@ impl CommandApi {
        let ctx = self.get_context(account_id).await?;
        let mut messages: HashMap<u32, MessageLoadResult> = HashMap::new();
        for message_id in message_ids {
-            let message_result = MessageObject::from_message_id(&ctx, message_id).await;
+            let message_result = MessageObject::from_msg_id(&ctx, MsgId::new(message_id)).await;
            messages.insert(
                message_id,
                match message_result {
@@ -1675,16 +1713,6 @@ impl CommandApi {
            .await
    }

-    async fn join_gossip_topic(
-        &self,
-        account_id: u32,
-        instance_msg_id: u32,
-        topic: String,
-    ) -> Result<()> {
-        let ctx = self.get_context(account_id).await?;
-        webxdc::join_gossip_topic(&ctx, MsgId::new(instance_msg_id), &topic).await
-    }
-
    async fn get_webxdc_status_updates(
        &self,
        account_id: u32,
@@ -1818,38 +1846,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();
@@ -2048,11 +2045,9 @@ impl CommandApi {
                )
                .await?;
        }
-        let msg_id = chat::send_msg(&ctx, ChatId::new(chat_id), &mut message)
-            .await?
-            .to_u32();
-        let message = MessageObject::from_message_id(&ctx, msg_id).await?;
-        Ok((msg_id, message))
+        let msg_id = chat::send_msg(&ctx, ChatId::new(chat_id), &mut message).await?;
+        let message = MessageObject::from_msg_id(&ctx, msg_id).await?;
+        Ok((msg_id.to_u32(), message))
    }

    // mimics the old desktop call, will get replaced with something better in the composer rewrite,
@@ -2131,13 +2126,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/events.rs
+++ b/deltachat-jsonrpc/src/api/types/events.rs
@@ -101,17 +101,15 @@ pub enum EventType {
    /// There is a fresh message. Typically, the user will show an notification
    /// when receiving this message.
    ///
-    /// There is no extra #DC_EVENT_MSGS_CHANGED event send together with this event.
+    /// There is no extra #DC_EVENT_MSGS_CHANGED event sent together with this event.
    #[serde(rename_all = "camelCase")]
    IncomingMsg { chat_id: u32, msg_id: u32 },

-    /// Downloading a bunch of messages just finished. This is an experimental
+    /// Downloading a bunch of messages just finished. This is an
    /// event to allow the UI to only show one notification per message bunch,
    /// instead of cluttering the user with many notifications.
-    ///
-    /// msg_ids contains the message ids.
    #[serde(rename_all = "camelCase")]
-    IncomingMsgBunch { msg_ids: Vec<u32> },
+    IncomingMsgBunch,

    /// Messages were seen or noticed.
    /// chat id is always set.
@@ -245,6 +243,13 @@ pub enum EventType {
    /// Inform that a message containing a webxdc instance has been deleted
    #[serde(rename_all = "camelCase")]
    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 {
@@ -280,9 +285,7 @@ impl From<CoreEventType> for EventType {
                chat_id: chat_id.to_u32(),
                msg_id: msg_id.to_u32(),
            },
-            CoreEventType::IncomingMsgBunch { msg_ids } => IncomingMsgBunch {
-                msg_ids: msg_ids.into_iter().map(|id| id.to_u32()).collect(),
-            },
+            CoreEventType::IncomingMsgBunch => IncomingMsgBunch,
            CoreEventType::MsgsNoticed(chat_id) => MsgsNoticed {
                chat_id: chat_id.to_u32(),
            },
@@ -353,6 +356,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
@@ -105,11 +105,6 @@ enum MessageQuote {
 }

 impl MessageObject {
-    pub async fn from_message_id(context: &Context, message_id: u32) -> Result<Self> {
-        let msg_id = MsgId::new(message_id);
-        Self::from_msg_id(context, msg_id).await
-    }
-
    pub async fn from_msg_id(context: &Context, msg_id: MsgId) -> Result<Self> {
        let message = Message::load_from_db(context, msg_id).await?;

@@ -548,6 +543,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.133.1"
+  "version": "1.137.2"
 }
--- a/deltachat-repl/Cargo.toml
+++ b/deltachat-repl/Cargo.toml
@@ -1,18 +1,19 @@
 [package]
 name = "deltachat-repl"
-version = "1.133.1"
+version = "1.137.2"
 license = "MPL-2.0"
 edition = "2021"
+repository = "https://github.com/deltachat/deltachat-core-rust"

 [dependencies]
 ansi_term = "0.12.1"
 anyhow = "1"
 deltachat = { path = "..", features = ["internals"]}
 dirs = "5"
-log = "0.4.20"
+log = "0.4.21"
 pretty_env_logger = "0.5"
-rusqlite = "0.30"
-rustyline = "13"
+rusqlite = "0.31"
+rustyline = "14"
 tokio = { version = "1", features = ["fs", "rt-multi-thread", "macros"] }

 [features]
--- a/deltachat-repl/src/cmdline.rs
+++ b/deltachat-repl/src/cmdline.rs
@@ -3,7 +3,7 @@ extern crate dirs;

 use std::path::Path;
 use std::str::FromStr;
-use std::time::{Duration, SystemTime};
+use std::time::Duration;

 use anyhow::{bail, ensure, Result};
 use deltachat::chat::{
@@ -33,14 +33,6 @@ use tokio::fs;
 /// e.g. bitmask 7 triggers actions defined with bits 1, 2 and 4.
 async fn reset_tables(context: &Context, bits: i32) {
    println!("Resetting tables ({bits})...");
-    if 0 != bits & 1 {
-        context
-            .sql()
-            .execute("DELETE FROM jobs;", ())
-            .await
-            .unwrap();
-        println!("(1) Jobs reset.");
-    }
    if 0 != bits & 2 {
        context
            .sql()
@@ -347,6 +339,8 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                 export-keys\n\
                 import-keys\n\
                 export-setup\n\
+                 dump <filename>\n\n
+                 read <filename>\n\n
                 poke [<eml-file>|<folder>|<addr> <key-file>]\n\
                 reset <flags>\n\
                 stop\n\
@@ -522,6 +516,14 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                &setup_code,
            );
        }
+        "dump" => {
+            ensure!(!arg1.is_empty(), "Argument <filename> missing.");
+            serialize_database(&context, arg1).await?;
+        }
+        "read" => {
+            ensure!(!arg1.is_empty(), "Argument <filename> missing.");
+            deserialize_database(&context, arg1).await?;
+        }
        "poke" => {
            ensure!(poke_spec(&context, Some(arg1)).await, "Poke failed");
        }
--- a/deltachat-repl/src/main.rs
+++ b/deltachat-repl/src/main.rs
@@ -9,7 +9,6 @@ extern crate deltachat;

 use std::borrow::Cow::{self, Borrowed, Owned};
 use std::io::{self, Write};
-use std::path::Path;
 use std::process::Command;

 use ansi_term::Color;
@@ -20,8 +19,7 @@ use deltachat::context::*;
 use deltachat::oauth2::*;
 use deltachat::qr_code_generator::get_securejoin_qr_svg;
 use deltachat::securejoin::*;
-use deltachat::stock_str::StockStrings;
-use deltachat::{EventType, Events};
+use deltachat::EventType;
 use log::{error, info, warn};
 use rustyline::completion::{Completer, FilenameCompleter, Pair};
 use rustyline::error::ReadlineError;
@@ -312,7 +310,10 @@ async fn start(args: Vec<String>) -> Result<(), Error> {
        println!("Error: Bad arguments, expected [db-name].");
        bail!("No db-name specified");
    }
-    let context = Context::new(Path::new(&args[1]), 0, Events::new(), StockStrings::new()).await?;
+    let context = ContextBuilder::new(args[1].clone().into())
+        .with_id(1)
+        .open()
+        .await?;

    let events = context.get_event_emitter();
    tokio::task::spawn(async move {
@@ -401,7 +402,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/pyproject.toml
+++ b/deltachat-rpc-client/pyproject.toml
@@ -1,9 +1,10 @@
 [build-system]
-requires = ["setuptools>=45", "setuptools_scm[toml]>=6.2"]
+requires = ["setuptools>=45"]
 build-backend = "setuptools.build_meta"

 [project]
 name = "deltachat-rpc-client"
+version = "1.137.2"
 description = "Python client for Delta Chat core JSON-RPC interface"
 classifiers = [
    "Development Status :: 5 - Production/Stable",
@@ -19,9 +20,7 @@ classifiers = [
    "Topic :: Communications :: Chat",
    "Topic :: Communications :: Email"
 ]
-dynamic = [
-    "version"
-]
+readme = "README.md"

 [tool.setuptools.package-data]
 deltachat_rpc_client = [
@@ -31,9 +30,6 @@ deltachat_rpc_client = [
 [project.entry-points.pytest11]
 "deltachat_rpc_client.pytestplugin" = "deltachat_rpc_client.pytestplugin"

-[tool.setuptools_scm]
-root = ".."
-
 [tool.black]
 line-length = 120

--- 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/_utils.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/_utils.py
@@ -168,3 +168,33 @@ def parse_system_add_remove(text: str) -> Optional[Tuple[str, str, str]]:
            return "removed", addr, addr

    return None
+
+
+class futuremethod:  # noqa: N801
+    """Decorator for async methods."""
+
+    def __init__(self, func):
+        self._func = func
+
+    def __get__(self, instance, owner=None):
+        if instance is None:
+            return self
+
+        def future(*args):
+            generator = self._func(instance, *args)
+            res = next(generator)
+
+            def f():
+                try:
+                    generator.send(res())
+                except StopIteration as e:
+                    return e.value
+
+            return f
+
+        def wrapper(*args):
+            f = future(*args)
+            return f()
+
+        wrapper.future = future
+        return wrapper
--- a/deltachat-rpc-client/src/deltachat_rpc_client/account.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/account.py
@@ -2,7 +2,7 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING, List, Optional, Tuple, Union
 from warnings import warn

-from ._utils import AttrDict
+from ._utils import AttrDict, futuremethod
 from .chat import Chat
 from .const import ChatlistFlag, ContactFlag, EventType, SpecialContactId
 from .contact import Contact
@@ -76,9 +76,16 @@ class Account:
        """Get self avatar."""
        return self.get_config("selfavatar")

-    def configure(self) -> None:
+    def check_qr(self, qr):
+        return self._rpc.check_qr(self.id, qr)
+
+    def set_config_from_qr(self, qr: str):
+        self._rpc.set_config_from_qr(self.id, qr)
+
+    @futuremethod
+    def configure(self):
        """Configure an account."""
-        self._rpc.configure(self.id)
+        yield self._rpc.configure.future(self.id)

    def create_contact(self, obj: Union[int, str, Contact], name: Optional[str] = None) -> Contact:
        """Create a new Contact or return an existing one.
--- a/deltachat-rpc-client/src/deltachat_rpc_client/chat.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/chat.py
@@ -84,7 +84,9 @@ class Chat:
        self._rpc.set_chat_name(self.account.id, self.id, name)

    def set_ephemeral_timer(self, timer: int) -> None:
-        """Set ephemeral timer of this chat."""
+        """Set ephemeral timer of this chat in seconds.
+
+        0 means the timer is disabled, use 1 for immediate deletion."""
        self._rpc.set_chat_ephemeral_timer(self.account.id, self.id, timer)

    def get_encryption_info(self) -> str:
--- 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/const.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/const.py
@@ -61,6 +61,15 @@ class EventType(str, Enum):
    WEBXDC_INSTANCE_DELETED = "WebxdcInstanceDeleted"


+class ChatId(IntEnum):
+    """Special chat ids"""
+
+    TRASH = 3
+    ARCHIVED_LINK = 6
+    ALLDONE_HINT = 7
+    LAST_SPECIAL = 9
+
+
 class ChatType(IntEnum):
    """Chat types"""

@@ -122,3 +131,107 @@ class SystemMessageType(str, Enum):
    EPHEMERAL_TIMER_CHANGED = "EphemeralTimerChanged"
    MULTI_DEVICE_SYNC = "MultiDeviceSync"
    WEBXDC_INFO_MESSAGE = "WebxdcInfoMessage"
+
+
+class MessageState(IntEnum):
+    """State of the message."""
+
+    UNDEFINED = 0
+    IN_FRESH = 10
+    IN_NOTICED = 13
+    IN_SEEN = 16
+    OUT_PREPARING = 18
+    OUT_DRAFT = 19
+    OUT_PENDING = 20
+    OUT_FAILED = 24
+    OUT_DELIVERED = 26
+    OUT_MDN_RCVD = 28
+
+
+class MessageId(IntEnum):
+    """Special message ids"""
+
+    DAYMARKER = 9
+    LAST_SPECIAL = 9
+
+
+class CertificateChecks(IntEnum):
+    """Certificate checks mode"""
+
+    AUTOMATIC = 0
+    STRICT = 1
+    ACCEPT_INVALID_CERTIFICATES = 3
+
+
+class Connectivity(IntEnum):
+    """Connectivity states"""
+
+    NOT_CONNECTED = 1000
+    CONNECTING = 2000
+    WORKING = 3000
+    CONNECTED = 4000
+
+
+class KeyGenType(IntEnum):
+    """Type of the key to generate"""
+
+    DEFAULT = 0
+    RSA2048 = 1
+    ED25519 = 2
+    RSA4096 = 3
+
+
+# "Lp" means "login parameters"
+class LpAuthFlag(IntEnum):
+    """Authorization flags"""
+
+    OAUTH2 = 0x2
+    NORMAL = 0x4
+
+
+class MediaQuality(IntEnum):
+    """Media quality setting"""
+
+    BALANCED = 0
+    WORSE = 1
+
+
+class ProviderStatus(IntEnum):
+    """Provider status according to manual testing"""
+
+    OK = 1
+    PREPARATION = 2
+    BROKEN = 3
+
+
+class PushNotifyState(IntEnum):
+    """Push notifications state"""
+
+    NOT_CONNECTED = 0
+    HEARTBEAT = 1
+    CONNECTED = 2
+
+
+class ShowEmails(IntEnum):
+    """Show emails mode"""
+
+    OFF = 0
+    ACCEPTED_CONTACTS = 1
+    ALL = 2
+
+
+class SocketSecurity(IntEnum):
+    """Socket security"""
+
+    AUTOMATIC = 0
+    SSL = 1
+    STARTTLS = 2
+    PLAIN = 3
+
+
+class VideochatType(IntEnum):
+    """Video chat URL type"""
+
+    UNKNOWN = 0
+    BASICWEBRTC = 1
+    JITSI = 2
--- 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/src/deltachat_rpc_client/pytestplugin.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/pytestplugin.py
@@ -5,6 +5,7 @@ from typing import AsyncGenerator, List, Optional
 import pytest

 from . import Account, AttrDict, Bot, Client, DeltaChat, EventType, Message
+from ._utils import futuremethod
 from .rpc import Rpc


@@ -37,9 +38,10 @@ class ACFactory:
        assert not account.is_configured()
        return account

-    def new_configured_account(self) -> Account:
+    @futuremethod
+    def new_configured_account(self):
        account = self.new_preconfigured_account()
-        account.configure()
+        yield account.configure.future()
        assert account.is_configured()
        return account

@@ -49,8 +51,9 @@ class ACFactory:
        bot.configure(credentials["email"], credentials["password"])
        return bot

-    def get_online_account(self) -> Account:
-        account = self.new_configured_account()
+    @futuremethod
+    def get_online_account(self):
+        account = yield self.new_configured_account.future()
        account.start_io()
        while True:
            event = account.wait_for_event()
@@ -59,7 +62,8 @@ class ACFactory:
        return account

    def get_online_accounts(self, num: int) -> List[Account]:
-        return [self.get_online_account() for _ in range(num)]
+        futures = [self.get_online_account.future() for _ in range(num)]
+        return [f() for f in futures]

    def resetup_account(self, ac: Account) -> Account:
        """Resetup account from scratch, losing the encryption key."""
--- a/deltachat-rpc-client/src/deltachat_rpc_client/rpc.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/rpc.py
@@ -13,6 +13,48 @@ class JsonRpcError(Exception):
    pass


+class RpcFuture:
+    def __init__(self, rpc: "Rpc", request_id: int, event: Event):
+        self.rpc = rpc
+        self.request_id = request_id
+        self.event = event
+
+    def __call__(self):
+        self.event.wait()
+        response = self.rpc.request_results.pop(self.request_id)
+        if "error" in response:
+            raise JsonRpcError(response["error"])
+        if "result" in response:
+            return response["result"]
+        return None
+
+
+class RpcMethod:
+    def __init__(self, rpc: "Rpc", name: str):
+        self.rpc = rpc
+        self.name = name
+
+    def __call__(self, *args) -> Any:
+        """Synchronously calls JSON-RPC method."""
+        future = self.future(*args)
+        return future()
+
+    def future(self, *args) -> Any:
+        """Asynchronously calls JSON-RPC method."""
+        request_id = next(self.rpc.id_iterator)
+        request = {
+            "jsonrpc": "2.0",
+            "method": self.name,
+            "params": args,
+            "id": request_id,
+        }
+        event = Event()
+        self.rpc.request_events[request_id] = event
+        self.rpc.request_queue.put(request)
+
+        return RpcFuture(self.rpc, request_id, event)
+
+
 class Rpc:
    def __init__(self, accounts_dir: Optional[str] = None, **kwargs):
        """The given arguments will be passed to subprocess.Popen()"""
@@ -145,24 +187,4 @@ class Rpc:
        return queue.get()

    def __getattr__(self, attr: str):
-        def method(*args) -> Any:
-            request_id = next(self.id_iterator)
-            request = {
-                "jsonrpc": "2.0",
-                "method": attr,
-                "params": args,
-                "id": request_id,
-            }
-            event = Event()
-            self.request_events[request_id] = event
-            self.request_queue.put(request)
-            event.wait()
-
-            response = self.request_results.pop(request_id)
-            if "error" in response:
-                raise JsonRpcError(response["error"])
-            if "result" in response:
-                return response["result"]
-            return None
-
-        return method
+        return RpcMethod(self, attr)
--- a/deltachat-rpc-client/tests/test_securejoin.py
+++ b/deltachat-rpc-client/tests/test_securejoin.py
@@ -1,7 +1,7 @@
 import logging

 import pytest
-from deltachat_rpc_client import Chat, SpecialContactId
+from deltachat_rpc_client import Chat, EventType, SpecialContactId


 def test_qr_setup_contact(acfactory, tmp_path) -> None:
@@ -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)
@@ -564,3 +579,40 @@ def test_securejoin_after_contact_resetup(acfactory) -> None:

    # ac1 is still "not verified" for ac2 due to inconsistent state.
    assert not ac2_contact_ac1.get_snapshot().is_verified
+
+
+def test_withdraw_securejoin_qr(acfactory):
+    alice, bob = acfactory.get_online_accounts(2)
+
+    logging.info("Alice creates a verified group")
+    alice_chat = alice.create_group("Verified group", protect=True)
+    assert alice_chat.get_basic_snapshot().is_protected
+    logging.info("Bob joins verified group")
+
+    qr_code, _svg = alice_chat.get_qr_code()
+    bob_chat = bob.secure_join(qr_code)
+    bob.wait_for_securejoin_joiner_success()
+
+    snapshot = bob.get_message_by_id(bob.wait_for_incoming_msg_event().msg_id).get_snapshot()
+    assert snapshot.text == "Member Me ({}) added by {}.".format(bob.get_config("addr"), alice.get_config("addr"))
+    assert snapshot.chat.get_basic_snapshot().is_protected
+    bob_chat.leave()
+
+    snapshot = alice.get_message_by_id(alice.wait_for_incoming_msg_event().msg_id).get_snapshot()
+    assert snapshot.text == "Group left by {}.".format(bob.get_config("addr"))
+
+    logging.info("Alice withdraws QR code.")
+    qr = alice.check_qr(qr_code)
+    assert qr["kind"] == "withdrawVerifyGroup"
+    alice.set_config_from_qr(qr_code)
+
+    logging.info("Bob scans withdrawn QR code.")
+    bob_chat = bob.secure_join(qr_code)
+
+    logging.info("Bob scanned withdrawn QR code")
+    while True:
+        event = alice.wait_for_event()
+        if event.kind == EventType.MSGS_CHANGED and event.chat_id != 0:
+            break
+    snapshot = alice.get_message_by_id(event.msg_id).get_snapshot()
+    assert snapshot.text == "Cannot establish guaranteed end-to-end encryption with {}".format(bob.get_config("addr"))
--- a/deltachat-rpc-server/Cargo.toml
+++ b/deltachat-rpc-server/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "deltachat-rpc-server"
-version = "1.133.1"
+version = "1.137.2"
 description = "DeltaChat JSON-RPC server"
 edition = "2021"
 readme = "README.md"
@@ -15,11 +15,11 @@ deltachat = { path = "..", default-features = false }

 anyhow = "1"
 env_logger = { version = "0.10.0" }
-futures-lite = "2.0.0"
+futures-lite = "2.3.0"
 log = "0.4"
 serde_json = "1"
 serde = { version = "1.0", features = ["derive"] }
-tokio = { version = "1.33.0", features = ["io-std"] }
+tokio = { version = "1.37.0", features = ["io-std"] }
 tokio-util = "0.7.9"
 yerpc = { version = "0.5.2", features = ["anyhow_expose", "openrpc"] }

--- a/deltachat-rpc-server/README.md
+++ b/deltachat-rpc-server/README.md
@@ -30,7 +30,7 @@ deltachat-rpc-server
 The common use case for this program is to create bindings to use Delta Chat core from programming
 languages other than Rust, for example:

-1. Python: https://github.com/deltachat/deltachat-core-rust/tree/master/deltachat-rpc-client/
+1. Python: https://pypi.org/project/deltachat-rpc-client/
 2. Go: https://github.com/deltachat/deltachat-rpc-client-go/

 Run `deltachat-rpc-server --version` to check the version of the server.
--- 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
@@ -1,5 +1,4 @@
 [advisories]
-unmaintained = "allow"
 ignore = [
    "RUSTSEC-2020-0071",
    "RUSTSEC-2022-0093",
@@ -10,6 +9,12 @@ ignore = [
    # There is no fix at the time of writing this (2023-11-28).
    # <https://rustsec.org/advisories/RUSTSEC-2023-0071>
    "RUSTSEC-2023-0071",
+
+    # Unmaintained ansi_term
+    "RUSTSEC-2021-0139",
+
+    # Unmaintained encoding
+    "RUSTSEC-2021-0153",
 ]

 [bans]
@@ -18,58 +23,55 @@ ignore = [
 # when upgrading.
 # Please keep this list alphabetically sorted.
 skip = [
-    { name = "async-channel", version = "1.9.0" },
-    { name = "base16ct", version = "0.1.1" },
-    { name = "base64", version = "<0.21" },
-    { name = "bitflags", version = "1.3.2" },
-    { name = "block-buffer", version = "<0.10" },
-    { name = "convert_case", version = "0.4.0" },
-    { name = "curve25519-dalek", version = "3.2.0" },
-    { name = "darling_core", version = "<0.14" },
-    { name = "darling_macro", version = "<0.14" },
-    { name = "darling", version = "<0.14" },
-    { name = "der", version = "0.6.1" },
-    { name = "digest", version = "<0.10" },
-    { 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" },
-    { name = "http", version = "0.2.11" },
-    { name = "hyper", version = "0.14.27" },
-    { name = "idna", version = "0.4.0" },
-    { name = "pem-rfc7468", version = "0.6.0" },
-    { name = "pkcs8", version = "0.9.0" },
-    { name = "quick-error", version = "<2.0" },
-    { name = "rand_chacha", version = "<0.3" },
-    { name = "rand_core", version = "<0.6" },
-    { name = "rand", version = "<0.8" },
-    { name = "redox_syscall", version = "0.3.5" },
-    { name = "regex-automata", version = "0.1.10" },
-    { name = "regex-syntax", version = "0.6.29" },
-    { name = "ring", version = "0.16.20" },
-    { name = "sec1", version = "0.3.0" },
-    { name = "sha2", version = "<0.10" },
-    { name = "signature", version = "1.6.4" },
-    { name = "socket2", version = "0.4.9" },
-    { name = "spin", version = "<0.9.6" },
-    { name = "spki", version = "0.6.0" },
-    { name = "syn", version = "1.0.109" },
-    { name = "time", version = "<0.3" },
-    { name = "untrusted", version = "0.7.1" },
-    { name = "wasi", version = "<0.11" },
-    { name = "windows_aarch64_gnullvm", version = "<0.52" },
-    { name = "windows_aarch64_msvc", version = "<0.52" },
-    { name = "windows_i686_gnu", version = "<0.52" },
-    { name = "windows_i686_msvc", version = "<0.52" },
-    { name = "windows-sys", version = "<0.52" },
-    { name = "windows-targets", version = "<0.52" },
-    { name = "windows", version = "0.32.0" },
-    { name = "windows_x86_64_gnullvm", version = "<0.52" },
-    { name = "windows_x86_64_gnu", version = "<0.52" },
-    { name = "windows_x86_64_msvc", version = "<0.52" },
+     { name = "async-channel", version = "1.9.0" },
+     { name = "base16ct", version = "0.1.1" },
+     { name = "base64", version = "<0.21" },
+     { name = "bitflags", version = "1.3.2" },
+     { name = "block-buffer", version = "<0.10" },
+     { name = "convert_case", version = "0.4.0" },
+     { name = "curve25519-dalek", version = "3.2.0" },
+     { name = "darling_core", version = "<0.14" },
+     { name = "darling_macro", version = "<0.14" },
+     { name = "darling", version = "<0.14" },
+     { name = "der", version = "0.6.1" },
+     { name = "digest", version = "<0.10" },
+     { name = "ed25519-dalek", version = "1.0.1" },
+     { name = "ed25519", version = "1.5.3" },
+     { name = "event-listener", version = "2.5.3" },
+     { name = "getrandom", version = "<0.2" },
+     { name = "idna", version = "0.4.0" },
+     { name = "pem-rfc7468", version = "0.6.0" },
+     { name = "pkcs8", version = "0.9.0" },
+     { name = "quick-error", version = "<2.0" },
+     { name = "rand_chacha", version = "<0.3" },
+     { name = "rand_core", version = "<0.6" },
+     { name = "rand", version = "<0.8" },
+     { name = "redox_syscall", version = "0.3.5" },
+     { name = "regex-automata", version = "0.1.10" },
+     { name = "regex-syntax", version = "0.6.29" },
+     { name = "ring", version = "0.16.20" },
+     { name = "sec1", version = "0.3.0" },
+     { name = "sha2", version = "<0.10" },
+     { name = "signature", version = "1.6.4" },
+     { name = "spin", version = "<0.9.6" },
+     { name = "spki", version = "0.6.0" },
+     { name = "sync_wrapper", version = "0.1.2" },
+     { 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" },
+     { name = "windows_aarch64_msvc", version = "<0.52" },
+     { name = "windows_i686_gnu", version = "<0.52" },
+     { name = "windows_i686_msvc", version = "<0.52" },
+     { name = "windows-sys", version = "<0.52" },
+     { name = "windows-targets", version = "<0.52" },
+     { name = "windows", version = "0.32.0" },
+     { name = "windows_x86_64_gnullvm", version = "<0.52" },
+     { name = "windows_x86_64_gnu", version = "<0.52" },
+     { name = "windows_x86_64_msvc", version = "<0.52" },
+     { name = "winnow", version = "0.5.40" },
 ]


@@ -79,7 +81,7 @@ allow = [
    "Apache-2.0",
    "BSD-2-Clause",
    "BSD-3-Clause",
-    "BSL-1.0",          # Boost Software License 1.0
+    "BSL-1.0", # Boost Software License 1.0
    "CC0-1.0",
    "ISC",
    "MIT",
@@ -92,13 +94,13 @@ allow = [
 [[licenses.clarify]]
 name = "ring"
 expression = "MIT AND ISC AND OpenSSL"
-license-files = [{ path = "LICENSE", hash = 0xbd0eed23 }]
+license-files = [
+      { path = "LICENSE", hash = 0xbd0eed23 },
+]

 [sources.allow-org]
 # Organisations which we allow git sources from.
 github = [
-    "async-email",
-    "deltachat",
-    "djc",
-    "n0-computer", # iroh
+       "async-email",
+       "deltachat",
 ]
--- a/flake.lock
+++ b/flake.lock
@@ -0,0 +1,288 @@
+{
+  "nodes": {
+    "android": {
+      "inputs": {
+        "devshell": "devshell",
+        "flake-utils": "flake-utils_2",
+        "nixpkgs": "nixpkgs"
+      },
+      "locked": {
+        "lastModified": 1710633978,
+        "narHash": "sha256-yemnwSvW7cdWtXGpivFA5jDO35rGPs6fqxlQ4l6ODXs=",
+        "owner": "tadfisher",
+        "repo": "android-nixpkgs",
+        "rev": "e91fb3d8517538e5ad9b422c9a4f604b56008a9e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "tadfisher",
+        "repo": "android-nixpkgs",
+        "type": "github"
+      }
+    },
+    "devshell": {
+      "inputs": {
+        "flake-utils": "flake-utils",
+        "nixpkgs": [
+          "android",
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1708939976,
+        "narHash": "sha256-O5+nFozxz2Vubpdl1YZtPrilcIXPcRAjqNdNE8oCRoA=",
+        "owner": "numtide",
+        "repo": "devshell",
+        "rev": "5ddecd67edbd568ebe0a55905273e56cc82aabe3",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "devshell",
+        "type": "github"
+      }
+    },
+    "fenix": {
+      "inputs": {
+        "nixpkgs": "nixpkgs_2",
+        "rust-analyzer-src": "rust-analyzer-src"
+      },
+      "locked": {
+        "lastModified": 1710742993,
+        "narHash": "sha256-W0PQCe0bW3hKF5lHawXrKynBcdSP18Qa4sb8DcUfOqI=",
+        "owner": "nix-community",
+        "repo": "fenix",
+        "rev": "6f2fec850f569d61562d3a47dc263f19e9c7d825",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-community",
+        "repo": "fenix",
+        "type": "github"
+      }
+    },
+    "flake-utils": {
+      "inputs": {
+        "systems": "systems"
+      },
+      "locked": {
+        "lastModified": 1701680307,
+        "narHash": "sha256-kAuep2h5ajznlPMD9rnQyffWG8EM/C73lejGofXvdM8=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "4022d587cbbfd70fe950c1e2083a02621806a725",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "flake-utils_2": {
+      "inputs": {
+        "systems": "systems_2"
+      },
+      "locked": {
+        "lastModified": 1709126324,
+        "narHash": "sha256-q6EQdSeUZOG26WelxqkmR7kArjgWCdw5sfJVHPH/7j8=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "d465f4819400de7c8d874d50b982301f28a84605",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "flake-utils_3": {
+      "inputs": {
+        "systems": "systems_3"
+      },
+      "locked": {
+        "lastModified": 1710146030,
+        "narHash": "sha256-SZ5L6eA7HJ/nmkzGG7/ISclqe6oZdOZTNoesiInkXPQ=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "b1d9ab70662946ef0850d488da1c9019f3a9752a",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "naersk": {
+      "inputs": {
+        "nixpkgs": "nixpkgs_3"
+      },
+      "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": 1710156097,
+        "narHash": "sha256-1Wvk8UP7PXdf8bCCaEoMnOT1qe5/Duqgj+rL8sRQsSM=",
+        "owner": "numtide",
+        "repo": "nix-filter",
+        "rev": "3342559a24e85fc164b295c3444e8a139924675b",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "nix-filter",
+        "type": "github"
+      }
+    },
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1709237383,
+        "narHash": "sha256-cy6ArO4k5qTx+l5o+0mL9f5fa86tYUX3ozE1S+Txlds=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "1536926ef5621b09bba54035ae2bb6d806d72ac8",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs_2": {
+      "locked": {
+        "lastModified": 1710631334,
+        "narHash": "sha256-rL5LSYd85kplL5othxK5lmAtjyMOBg390sGBTb3LRMM=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "c75037bbf9093a2acb617804ee46320d6d1fea5a",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs_3": {
+      "locked": {
+        "lastModified": 1710765496,
+        "narHash": "sha256-p7ryWEeQfMwTB6E0wIUd5V2cFTgq+DRRBz2hYGnJZyA=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "e367f7a1fb93137af22a3908f00b9a35e2d286a7",
+        "type": "github"
+      },
+      "original": {
+        "id": "nixpkgs",
+        "type": "indirect"
+      }
+    },
+    "nixpkgs_4": {
+      "locked": {
+        "lastModified": 1710631334,
+        "narHash": "sha256-rL5LSYd85kplL5othxK5lmAtjyMOBg390sGBTb3LRMM=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "c75037bbf9093a2acb617804ee46320d6d1fea5a",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "android": "android",
+        "fenix": "fenix",
+        "flake-utils": "flake-utils_3",
+        "naersk": "naersk",
+        "nix-filter": "nix-filter",
+        "nixpkgs": "nixpkgs_4"
+      }
+    },
+    "rust-analyzer-src": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1710708100,
+        "narHash": "sha256-Jd6pmXlwKk5uYcjyO/8BfbUVmx8g31Qfk7auI2IG66A=",
+        "owner": "rust-lang",
+        "repo": "rust-analyzer",
+        "rev": "b6d1887bc4f9543b6c6bf098179a62446f34a6c3",
+        "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"
+      }
+    },
+    "systems_2": {
+      "locked": {
+        "lastModified": 1681028828,
+        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
+    },
+    "systems_3": {
+      "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,542 @@
+{
+  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";
+    android.url = "github:tadfisher/android-nixpkgs";
+  };
+  outputs = { self, nixpkgs, flake-utils, nix-filter, naersk, fenix, android }:
+    flake-utils.lib.eachDefaultSystem (system:
+      let
+        pkgs = nixpkgs.legacyPackages.${system};
+        inherit (pkgs.stdenv) isDarwin;
+        fenixPkgs = fenix.packages.${system};
+        naersk' = pkgs.callPackage naersk { };
+        manifest = (pkgs.lib.importTOML ./Cargo.toml).package;
+        androidSdk = android.sdk.${system} (sdkPkgs:
+          builtins.attrValues {
+            inherit (sdkPkgs) ndk-24-0-8215888 cmdline-tools-latest;
+          });
+        androidNdkRoot = "${androidSdk}/share/android-sdk/ndk/24.0.8215888";
+
+        rustSrc = 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-time
+            ./deltachat-rpc-server
+            ./format-flowed
+            ./release-date.in
+            ./src
+          ];
+          exclude = [
+            (nix-filter.lib.matchExt "nix")
+            "flake.lock"
+          ];
+        };
+
+        # Map from architecture name to rust targets and nixpkgs targets.
+        arch2targets = {
+          "x86_64-linux" = {
+            rustTarget = "x86_64-unknown-linux-musl";
+            crossTarget = "x86_64-unknown-linux-musl";
+          };
+          "armv7l-linux" = {
+            rustTarget = "armv7-unknown-linux-musleabihf";
+            crossTarget = "armv7l-unknown-linux-musleabihf";
+          };
+          "armv6l-linux" = {
+            rustTarget = "arm-unknown-linux-musleabihf";
+            crossTarget = "armv6l-unknown-linux-musleabihf";
+          };
+          "aarch64-linux" = {
+            rustTarget = "aarch64-unknown-linux-musl";
+            crossTarget = "aarch64-unknown-linux-musl";
+          };
+          "i686-linux" = {
+            rustTarget = "i686-unknown-linux-musl";
+            crossTarget = "i686-unknown-linux-musl";
+          };
+
+          "x86_64-darwin" = {
+            rustTarget = "x86_64-apple-darwin";
+            crossTarget = "x86_64-darwin";
+          };
+          "aarch64-darwin" = {
+            rustTarget = "aarch64-apple-darwin";
+            crossTarget = "aarch64-darwin";
+          };
+        };
+        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.
+            ];
+            buildInputs = pkgs.lib.optionals isDarwin [
+              pkgs.darwin.apple_sdk.frameworks.SystemConfiguration
+            ];
+            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";
+            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: {
+                configureFlags = oldAttr.configureFlags ++ [
+                  "--disable-sjlj-exceptions --with-dwarf2"
+                ];
+              })
+            );
+          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 = arch: packageName:
+          let
+            rustTarget = arch2targets."${arch}".rustTarget;
+            crossTarget = arch2targets."${arch}".crossTarget;
+            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 = rustSrc;
+            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";
+          };
+
+        androidAttrs = {
+          armeabi-v7a = {
+            cc = "armv7a-linux-androideabi19-clang";
+            rustTarget = "armv7-linux-androideabi";
+          };
+          arm64-v8a = {
+            cc = "aarch64-linux-android21-clang";
+            rustTarget = "aarch64-linux-android";
+          };
+        };
+
+        mkAndroidRustPackage = arch: packageName:
+          let
+            rustTarget = androidAttrs.${arch}.rustTarget;
+            toolchain = fenixPkgs.combine [
+              fenixPkgs.stable.rustc
+              fenixPkgs.stable.cargo
+              fenixPkgs.targets.${rustTarget}.stable.rust-std
+            ];
+            naersk-lib = pkgs.callPackage naersk {
+              cargo = toolchain;
+              rustc = toolchain;
+            };
+            targetToolchain = "${androidNdkRoot}/toolchains/llvm/prebuilt/linux-x86_64";
+            targetCcName = androidAttrs.${arch}.cc;
+            targetCc = "${targetToolchain}/bin/${targetCcName}";
+          in
+          naersk-lib.buildPackage rec {
+            pname = packageName;
+            cargoBuildOptions = x: x ++ [ "--package" packageName ];
+            version = manifest.version;
+            strictDeps = true;
+            src = rustSrc;
+            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 = "${targetCc}";
+            CARGO_BUILD_RUSTFLAGS = [
+              "-C"
+              "linker=${TARGET_CC}"
+            ];
+
+            CC = "${targetCc}";
+            LD = "${targetCc}";
+          };
+
+        mkAndroidPackages = arch: {
+          "deltachat-rpc-server-${arch}-android" = mkAndroidRustPackage arch "deltachat-rpc-server";
+          "deltachat-repl-${arch}-android" = mkAndroidRustPackage arch "deltachat-repl";
+        };
+
+        mkRustPackages = arch:
+          let
+            rpc-server = mkCrossRustPackage arch "deltachat-rpc-server";
+          in
+          {
+            "deltachat-repl-${arch}" = mkCrossRustPackage arch "deltachat-repl";
+            "deltachat-rpc-server-${arch}" = rpc-server;
+            "deltachat-rpc-server-${arch}-wheel" =
+              pkgs.stdenv.mkDerivation {
+                pname = "deltachat-rpc-server-${arch}-wheel";
+                version = manifest.version;
+                src = nix-filter.lib {
+                  root = ./.;
+                  include = [
+                    "scripts/wheel-rpc-server.py"
+                    "deltachat-rpc-server/README.md"
+                    "LICENSE"
+                    "Cargo.toml"
+                  ];
+                };
+                nativeBuildInputs = [
+                  pkgs.python3
+                  pkgs.python3Packages.wheel
+                ];
+                buildInputs = [
+                  rpc-server
+                ];
+                buildPhase = ''
+                  mkdir tmp
+                  cp ${rpc-server}/bin/deltachat-rpc-server tmp/deltachat-rpc-server
+                  python3 scripts/wheel-rpc-server.py ${arch} tmp/deltachat-rpc-server
+                '';
+                installPhase = ''mkdir -p $out; cp -av deltachat_rpc_server-*.whl $out'';
+              };
+          };
+      in
+      {
+        formatter = pkgs.nixpkgs-fmt;
+
+        packages =
+          mkRustPackages "aarch64-linux" //
+          mkRustPackages "i686-linux" //
+          mkRustPackages "x86_64-linux" //
+          mkRustPackages "armv7l-linux" //
+          mkRustPackages "armv6l-linux" //
+          mkAndroidPackages "armeabi-v7a" //
+          mkAndroidPackages "arm64-v8a" //
+          mkAndroidPackages "x86" //
+          mkAndroidPackages "x86_64" // 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-rpc-server-win64-wheel =
+              pkgs.stdenv.mkDerivation {
+                pname = "deltachat-rpc-server-win64-wheel";
+                version = manifest.version;
+                src = nix-filter.lib {
+                  root = ./.;
+                  include = [
+                    "scripts/wheel-rpc-server.py"
+                    "deltachat-rpc-server/README.md"
+                    "LICENSE"
+                    "Cargo.toml"
+                  ];
+                };
+                nativeBuildInputs = [
+                  pkgs.python3
+                  pkgs.python3Packages.wheel
+                ];
+                buildInputs = [
+                  deltachat-rpc-server-win64
+                ];
+                buildPhase = ''
+                  mkdir tmp
+                  cp ${deltachat-rpc-server-win64}/bin/deltachat-rpc-server.exe tmp/deltachat-rpc-server.exe
+                  python3 scripts/wheel-rpc-server.py win64 tmp/deltachat-rpc-server.exe
+                '';
+                installPhase = ''mkdir -p $out; cp -av deltachat_rpc_server-*.whl $out'';
+              };
+
+            deltachat-repl-win32 = mkWin32RustPackage "deltachat-repl";
+            deltachat-rpc-server-win32 = mkWin32RustPackage "deltachat-rpc-server";
+            deltachat-rpc-server-win32-wheel =
+              pkgs.stdenv.mkDerivation {
+                pname = "deltachat-rpc-server-win32-wheel";
+                version = manifest.version;
+                src = nix-filter.lib {
+                  root = ./.;
+                  include = [
+                    "scripts/wheel-rpc-server.py"
+                    "deltachat-rpc-server/README.md"
+                    "LICENSE"
+                    "Cargo.toml"
+                  ];
+                };
+                nativeBuildInputs = [
+                  pkgs.python3
+                  pkgs.python3Packages.wheel
+                ];
+                buildInputs = [
+                  deltachat-rpc-server-win32
+                ];
+                buildPhase = ''
+                  mkdir tmp
+                  cp ${deltachat-rpc-server-win32}/bin/deltachat-rpc-server.exe tmp/deltachat-rpc-server.exe
+                  python3 scripts/wheel-rpc-server.py win32 tmp/deltachat-rpc-server.exe
+                '';
+                installPhase = ''mkdir -p $out; cp -av deltachat_rpc_server-*.whl $out'';
+              };
+            # 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 {
+                pname = "libdeltachat";
+                version = manifest.version;
+                src = rustSrc;
+                cargoDeps = pkgs.rustPlatform.importCargoLock cargoLock;
+
+                nativeBuildInputs = [
+                  pkgs.perl # Needed to build vendored OpenSSL.
+                  pkgs.cmake
+                  pkgs.rustPlatform.cargoSetupHook
+                  pkgs.cargo
+                ];
+                buildInputs = pkgs.lib.optionals isDarwin [
+                  pkgs.darwin.apple_sdk.frameworks.CoreFoundation
+                  pkgs.darwin.apple_sdk.frameworks.Security
+                  pkgs.darwin.apple_sdk.frameworks.SystemConfiguration
+                  pkgs.libiconv
+                ];
+
+                postInstall = ''
+                  substituteInPlace $out/include/deltachat.h \
+                    --replace __FILE__ '"${placeholder "out"}/include/deltachat.h"'
+                '';
+              };
+
+            # Source package for deltachat-rpc-server.
+            # Fake package that downloads Linux version,
+            # needed to install deltachat-rpc-server on Android with `pip`.
+            deltachat-rpc-server-source =
+              pkgs.stdenv.mkDerivation {
+                pname = "deltachat-rpc-server-source";
+                version = manifest.version;
+                src = pkgs.lib.cleanSource ./.;
+                nativeBuildInputs = [
+                  pkgs.python3
+                  pkgs.python3Packages.wheel
+                ];
+                buildPhase = ''python3 scripts/wheel-rpc-server.py source deltachat-rpc-server-${manifest.version}.tar.gz'';
+                installPhase = ''mkdir -p $out; cp -av deltachat-rpc-server-${manifest.version}.tar.gz $out'';
+              };
+
+            deltachat-rpc-client =
+              pkgs.python3Packages.buildPythonPackage {
+                pname = "deltachat-rpc-client";
+                version = manifest.version;
+                src = pkgs.lib.cleanSource ./deltachat-rpc-client;
+                format = "pyproject";
+                propagatedBuildInputs = [
+                  pkgs.python3Packages.setuptools
+                ];
+              };
+
+            deltachat-python =
+              pkgs.python3Packages.buildPythonPackage {
+                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.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'';
+              };
+          };
+
+        devShells.default = pkgs.mkShell {
+          buildInputs = with pkgs; [
+            (fenixPkgs.complete.withComponents [
+              "cargo"
+              "clippy"
+              "rust-src"
+              "rustc"
+              "rustfmt"
+            ])
+            cargo-deny
+            fenixPkgs.rust-analyzer
+            perl # needed to build vendored OpenSSL
+          ];
+        };
+      }
+    );
+}
--- a/fuzz/Cargo.lock
+++ b/fuzz/Cargo.lock
--- a/node/constants.js
+++ b/node/constants.js
@@ -29,6 +29,7 @@ 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,
@@ -114,6 +115,9 @@ module.exports = {
  DC_PROVIDER_STATUS_BROKEN: 3,
  DC_PROVIDER_STATUS_OK: 1,
  DC_PROVIDER_STATUS_PREPARATION: 2,
+  DC_PUSH_CONNECTED: 2,
+  DC_PUSH_HEARTBEAT: 1,
+  DC_PUSH_NOT_CONNECTED: 0,
  DC_QR_ACCOUNT: 250,
  DC_QR_ADDR: 320,
  DC_QR_ASK_VERIFYCONTACT: 200,
@@ -253,6 +257,7 @@ module.exports = {
  DC_STR_PARTIAL_DOWNLOAD_MSG_BODY: 99,
  DC_STR_PART_OF_TOTAL_USED: 116,
  DC_STR_QUOTA_EXCEEDING_MSG_BODY: 98,
+  DC_STR_REACTED_BY: 177,
  DC_STR_READRCPT: 31,
  DC_STR_READRCPT_MAILBODY: 32,
  DC_STR_REMOVE_MEMBER_BY_OTHER: 131,
@@ -280,6 +285,7 @@ module.exports = {
  DC_STR_VIDEOCHAT_INVITE_MSG_BODY: 83,
  DC_STR_VOICEMESSAGE: 7,
  DC_STR_WELCOME_MESSAGE: 71,
+  DC_STR_YOU_REACTED: 176,
  DC_TEXT1_DRAFT: 1,
  DC_TEXT1_SELF: 3,
  DC_TEXT1_USERNAME: 2,
--- a/node/events.js
+++ b/node/events.js
@@ -36,5 +36,6 @@ module.exports = {
  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,6 +29,7 @@ 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,
@@ -114,6 +115,9 @@ export enum C {
  DC_PROVIDER_STATUS_BROKEN = 3,
  DC_PROVIDER_STATUS_OK = 1,
  DC_PROVIDER_STATUS_PREPARATION = 2,
+  DC_PUSH_CONNECTED = 2,
+  DC_PUSH_HEARTBEAT = 1,
+  DC_PUSH_NOT_CONNECTED = 0,
  DC_QR_ACCOUNT = 250,
  DC_QR_ADDR = 320,
  DC_QR_ASK_VERIFYCONTACT = 200,
@@ -253,6 +257,7 @@ export enum C {
  DC_STR_PARTIAL_DOWNLOAD_MSG_BODY = 99,
  DC_STR_PART_OF_TOTAL_USED = 116,
  DC_STR_QUOTA_EXCEEDING_MSG_BODY = 98,
+  DC_STR_REACTED_BY = 177,
  DC_STR_READRCPT = 31,
  DC_STR_READRCPT_MAILBODY = 32,
  DC_STR_REMOVE_MEMBER_BY_OTHER = 131,
@@ -280,6 +285,7 @@ export enum C {
  DC_STR_VIDEOCHAT_INVITE_MSG_BODY = 83,
  DC_STR_VOICEMESSAGE = 7,
  DC_STR_WELCOME_MESSAGE = 71,
+  DC_STR_YOU_REACTED = 176,
  DC_TEXT1_DRAFT = 1,
  DC_TEXT1_SELF = 3,
  DC_TEXT1_USERNAME = 2,
@@ -326,4 +332,5 @@ export const EventId2EventName: { [key: number]: string } = {
  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/src/module.c
+++ b/node/src/module.c
@@ -3048,14 +3048,6 @@ NAPI_METHOD(dcn_accounts_select_account) {
  NAPI_RETURN_UINT32(result);
 }

-NAPI_METHOD(dcn_accounts_all_work_done) {
-  NAPI_ARGV(1);
-  NAPI_DCN_ACCOUNTS();
-
-  int result = dc_accounts_all_work_done(dcn_accounts->dc_accounts);
-  NAPI_RETURN_INT32(result);
-}
-
 NAPI_METHOD(dcn_accounts_start_io) {
  NAPI_ARGV(1);
  NAPI_DCN_ACCOUNTS();
@@ -3382,7 +3374,6 @@ NAPI_INIT() {
  NAPI_EXPORT_FUNCTION(dcn_accounts_get_account);
  NAPI_EXPORT_FUNCTION(dcn_accounts_get_selected_account);
  NAPI_EXPORT_FUNCTION(dcn_accounts_select_account);
-  NAPI_EXPORT_FUNCTION(dcn_accounts_all_work_done);
  NAPI_EXPORT_FUNCTION(dcn_accounts_start_io);
  NAPI_EXPORT_FUNCTION(dcn_accounts_stop_io);
  NAPI_EXPORT_FUNCTION(dcn_accounts_maybe_network);
--- a/node/test/test.mjs
+++ b/node/test/test.mjs
@@ -239,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',
@@ -250,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
@@ -55,5 +55,5 @@
    "test:mocha": "mocha node/test/test.mjs --growl --reporter=spec --bail --exit"
  },
  "types": "node/dist/index.d.ts",
-  "version": "1.133.1"
+  "version": "1.137.2"
 }
--- a/python/pyproject.toml
+++ b/python/pyproject.toml
@@ -1,9 +1,10 @@
 [build-system]
-requires = ["setuptools>=45", "wheel", "setuptools_scm[toml]>=6.2", "cffi>=1.0.0", "pkgconfig"]
+requires = ["setuptools>=45", "wheel", "cffi>=1.0.0", "pkgconfig"]
 build-backend = "setuptools.build_meta"

 [project]
 name = "deltachat"
+version = "1.137.2"
 description = "Python bindings for the Delta Chat Core library using CFFI against the Rust-implemented libdeltachat"
 readme = "README.rst"
 requires-python = ">=3.7"
@@ -26,9 +27,6 @@ dependencies = [
    "pluggy",
    "requests",
 ]
-dynamic = [
-    "version"
-]

 [project.urls]
 "Home" = "https://github.com/deltachat/deltachat-core-rust/"
@@ -44,11 +42,6 @@ deltachat = [
    "py.typed"
 ]

-[tool.setuptools_scm]
-root = ".."
-tag_regex = '^(?P<prefix>v)?(?P<version>[^\+]+)(?P<suffix>.*)?$'
-git_describe_command = "git describe --dirty --tags --long --match v*.*"
-
 [tool.black]
 line-length = 120

--- 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
@@ -376,22 +375,6 @@ class Account:
        dc_array = ffi.gc(lib.dc_get_fresh_msgs(self._dc_context), lib.dc_array_unref)
        return (x for x in iter_array(dc_array, lambda x: Message.from_db(self, x)) if x is not None)

-    def _wait_next_message_ids(self) -> List[int]:
-        """Return IDs of all next messages from all chats."""
-        dc_array = ffi.gc(lib.dc_wait_next_msgs(self._dc_context), lib.dc_array_unref)
-        return [lib.dc_array_get_id(dc_array, i) for i in range(lib.dc_array_get_cnt(dc_array))]
-
-    def wait_next_incoming_message(self) -> Message:
-        """Waits until the next incoming message
-        with ID higher than given is received and returns it."""
-        while True:
-            message_ids = self._wait_next_message_ids()
-            for msg_id in message_ids:
-                message = Message.from_db(self, msg_id)
-                if message and not message.is_from_self() and not message.is_from_device():
-                    self.set_config("last_msg_id", str(msg_id))
-                    return message
-
    def create_chat(self, obj) -> Chat:
        """Create a 1:1 chat with Account, Contact or e-mail address."""
        return self.create_contact(obj).create_chat()
@@ -478,6 +461,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/events.py
+++ b/python/src/deltachat/events.py
@@ -182,6 +182,12 @@ class FFIEventTracker:
                print(f"** SECUREJOINT-INVITER PROGRESS {target}", self.account)
                break

+    def wait_securejoin_joiner_progress(self, target):
+        while True:
+            event = self.get_matching("DC_EVENT_SECUREJOIN_JOINER_PROGRESS")
+            if event.data2 >= target:
+                break
+
    def wait_idle_inbox_ready(self):
        """Has to be called after start_io() to wait for fetch_existing_msgs to run
        so that new messages are not mistaken for old ones:
--- a/python/src/deltachat/testplugin.py
+++ b/python/src/deltachat/testplugin.py
@@ -10,7 +10,6 @@ import time
 import weakref
 import random
 from queue import Queue
-from threading import Event
 from typing import Callable, Dict, List, Optional, Set

 import pytest
@@ -116,7 +115,7 @@ def pytest_configure(config):
    deltachat.register_global_plugin(la)


-def pytest_report_header(config, startdir):
+def pytest_report_header(config):
    info = get_core_info()
    summary = [
        "Deltachat core={} sqlite={} journal_mode={}".format(
@@ -592,23 +591,16 @@ class ACFactory:
        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()
+        ac2._evtracker.wait_securejoin_joiner_progress(1000)
+        ev = ac2._evtracker.get_matching("DC_EVENT_MSGS_CHANGED")
+        msg = ac2.get_message_by_id(ev.data2)
+        assert msg is not None
        assert msg.text == "Messages are guaranteed to be end-to-end encrypted from now on."
-        msg = ac2.wait_next_incoming_message()
+        msg = ac2._evtracker.wait_next_incoming_message()
+        assert msg is not None
        assert "Member Me " in msg.text and " added by " in msg.text
        return chat

--- a/python/tests/test_0_complex_or_slow.py
+++ b/python/tests/test_0_complex_or_slow.py
@@ -547,13 +547,14 @@ def test_see_new_verified_member_after_going_online(acfactory, tmp_path, lp):
    assert msg_in.get_sender_contact().addr == ac2_addr


-def test_use_new_verified_group_after_going_online(acfactory, tmp_path, lp):
+def test_use_new_verified_group_after_going_online(acfactory, data, tmp_path, lp):
    """Another test for the bug #3836:
    - Bob has two devices, the second is offline.
    - Alice creates a verified group and sends a QR invitation to Bob.
    - Bob joins the group.
    - Bob's second devices goes online, but sees a contact request instead of the verified group.
    - The "member added" message is not a system message but a plain text message.
+    - Bob's second device doesn't display the Alice's avatar (bug #5354).
    - Sending a message fails as the key is missing -- message info says "proper enc-key for <Alice>
      missing, cannot encrypt".
    """
@@ -568,6 +569,10 @@ def test_use_new_verified_group_after_going_online(acfactory, tmp_path, lp):
    ac2_offl.import_self_keys(str(dir))
    ac2_offl.stop_io()

+    lp.sec("ac1: set avatar")
+    avatar_path = data.get_path("d.png")
+    ac1.set_avatar(avatar_path)
+
    lp.sec("ac1: create verified-group QR, ac2 scans and joins")
    chat = ac1.create_group_chat("hello", verified=True)
    assert chat.is_protected()
@@ -580,11 +585,13 @@ def test_use_new_verified_group_after_going_online(acfactory, tmp_path, lp):
    ac2_offl.start_io()
    # Receive "Member Me (<addr>) added by <addr>." message.
    msg_in = ac2_offl._evtracker.wait_next_incoming_message()
+    contact = msg_in.get_sender_contact()
    assert msg_in.is_system_message()
-    assert msg_in.get_sender_contact().addr == ac1.get_config("addr")
+    assert contact.addr == ac1.get_config("addr")
    chat2 = msg_in.chat
    assert chat2.is_protected()
    assert chat2.get_messages()[0].text == "Messages are guaranteed to be end-to-end encrypted from now on."
+    assert open(contact.get_profile_image(), "rb").read() == open(avatar_path, "rb").read()

    lp.sec("ac2_offl: sending message")
    msg_out = chat2.send_text("hello")
--- a/python/tests/test_1_online.py
+++ b/python/tests/test_1_online.py
@@ -44,21 +44,21 @@ def test_configure_generate_key(acfactory, lp):
    lp.sec("ac1: send unencrypted message to ac2")
    chat.send_text("message1")
    lp.sec("ac2: waiting for message from ac1")
-    msg_in = ac2.wait_next_incoming_message()
+    msg_in = ac2._evtracker.wait_next_incoming_message()
    assert msg_in.text == "message1"
    assert not msg_in.is_encrypted()

    lp.sec("ac2: send encrypted message to ac1")
    msg_in.chat.send_text("message2")
    lp.sec("ac1: waiting for message from ac2")
-    msg2_in = ac1.wait_next_incoming_message()
+    msg2_in = ac1._evtracker.wait_next_incoming_message()
    assert msg2_in.text == "message2"
    assert msg2_in.is_encrypted()

    lp.sec("ac1: send encrypted message to ac2")
    msg2_in.chat.send_text("message3")
    lp.sec("ac2: waiting for message from ac1")
-    msg3_in = ac2.wait_next_incoming_message()
+    msg3_in = ac2._evtracker.wait_next_incoming_message()
    assert msg3_in.text == "message3"
    assert msg3_in.is_encrypted()

@@ -382,9 +382,24 @@ 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)
+    ac1 = acfactory.new_online_configuring_account(mvbox_move=True, sentbox_watch=False)

    lp.sec("ac2: start without mvbox/sentbox threads")
    ac2 = acfactory.new_online_configuring_account(mvbox_move=False, sentbox_watch=False)
@@ -392,10 +407,18 @@ def test_mvbox_sentbox_threads(acfactory, lp):
    lp.sec("ac2 and ac1: waiting for configuration")
    acfactory.bring_accounts_online()

+    lp.sec("ac1: create and configure sentbox")
+    ac1.direct_imap.create_folder("Sent")
+    ac1.set_config("sentbox_watch", "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"

+    assert ac1.get_config("configured_mvbox_folder") == "DeltaChat"
+    while ac1.get_config("configured_sentbox_folder") != "Sent":
+        ac1._evtracker.get_matching("DC_EVENT_CONNECTIVITY_CHANGED")
+

 def test_move_works(acfactory):
    ac1 = acfactory.new_online_configuring_account()
@@ -505,7 +528,7 @@ def test_forward_encrypted_to_unencrypted(acfactory, lp):
    lp.sec("ac1: send encrypted message to ac2")
    txt = "This should be encrypted"
    chat.send_text(txt)
-    msg = ac2.wait_next_incoming_message()
+    msg = ac2._evtracker.wait_next_incoming_message()
    assert msg.text == txt
    assert msg.is_encrypted()

@@ -543,6 +566,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".
@@ -1551,10 +1595,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

@@ -1571,7 +1616,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/python/tests/test_3_offline.py
+++ b/python/tests/test_3_offline.py
@@ -52,8 +52,8 @@ class TestOfflineAccountBasic:
    def test_wrong_db(self, tmp_path):
        p = tmp_path / "hello.db"
        p.write_text("123")
-        account = Account(str(p))
-        assert not account.is_open()
+        with pytest.raises(ValueError):
+            _account = Account(str(p))

    def test_os_name(self, tmp_path):
        p = tmp_path / "hello.db"
--- a/release-date.in
+++ b/release-date.in
@@ -1 +1 @@
-2024-01-21
+2024-04-05
--- a/scripts/README.md
+++ b/scripts/README.md
@@ -35,12 +35,8 @@ 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/`.
-
 ## Triggering runs on the build machine locally (fast!)

 There is experimental support for triggering a remote Python or Rust test run 
--- a/scripts/build-python-docs.sh
+++ b/scripts/build-python-docs.sh
@@ -1,13 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-export DCC_RS_TARGET=debug
-export DCC_RS_DEV="$PWD"
-cargo build -p deltachat_ffi --features jsonrpc
-
-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/concourse/docs_wheels.yml
+++ b/scripts/concourse/docs_wheels.yml
@@ -15,55 +15,6 @@ resources:
      tag_filter: "v*"

 jobs:
-  - name: doxygen
-    plan:
-      - get: deltachat-core-rust
-        trigger: true
-
-      # Build Doxygen documentation
-      - task: build-doxygen
-        config:
-          inputs:
-            - name: deltachat-core-rust
-          outputs:
-            - name: c-docs
-          image_resource:
-            source:
-              repository: alpine
-            type: registry-image
-          platform: linux
-          run:
-            path: sh
-            args:
-              - -ec
-              - |
-                apk add --no-cache doxygen git
-                cd deltachat-core-rust
-                scripts/run-doxygen.sh
-                cd ..
-                cp -av deltachat-core-rust/deltachat-ffi/html deltachat-core-rust/deltachat-ffi/xml c-docs/
-
-      - task: upload-c-docs
-        config:
-          inputs:
-            - name: c-docs
-          image_resource:
-            type: registry-image
-            source:
-              repository: alpine
-          platform: linux
-          run:
-            path: sh
-            args:
-              - -ec
-              - |
-                apk add --no-cache rsync openssh-client
-                mkdir -p ~/.ssh
-                chmod 700 ~/.ssh
-                echo "(("c.delta.chat".private_key))" > ~/.ssh/id_ed25519
-                chmod 600 ~/.ssh/id_ed25519
-                rsync -e "ssh -o StrictHostKeyChecking=no" -avz --delete c-docs/html/ delta@c.delta.chat:build-c/master
-
  - name: python-x86_64
    plan:
      - get: deltachat-core-rust
--- a/scripts/coredeps/install-rust.sh
+++ b/scripts/coredeps/install-rust.sh
@@ -7,7 +7,7 @@ set -euo pipefail
 #
 # Avoid using rustup here as it depends on reading /proc/self/exe and
 # has problems running under QEMU.
-RUST_VERSION=1.72.0
+RUST_VERSION=1.77.1

 ARCH="$(uname -m)"
 test -f "/lib/libc.musl-$ARCH.so.1" && LIBC=musl || LIBC=gnu
--- 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
@@ -73,6 +73,8 @@ def main():
        "deltachat-jsonrpc/Cargo.toml",
        "deltachat-rpc-server/Cargo.toml",
        "deltachat-repl/Cargo.toml",
+        "python/pyproject.toml",
+        "deltachat-rpc-client/pyproject.toml",
    ]
    try:
        opts = parser.parse_args()
--- 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,24 +1,26 @@
 #!/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
 import tarfile
+import sys
 from io import BytesIO


 def metadata_contents(version):
+    readme_text = (Path("deltachat-rpc-server") / "README.md").read_text()
    return f"""Metadata-Version: 2.1
 Name: deltachat-rpc-server
 Version: {version}
 Summary: Delta Chat JSON-RPC server
+Description-Content-Type: text/markdown
+
+{readme_text}
 """


-def build_source_package(version):
-    filename = f"dist/deltachat-rpc-server-{version}.tar.gz"
-
+def build_source_package(version, filename):
    with tarfile.open(filename, "w:gz") as pkg:

        def pack(name, contents):
@@ -99,7 +101,7 @@ setup(


 def build_wheel(version, binary, tag, windows=False):
-    filename = f"dist/deltachat_rpc_server-{version}-{tag}.whl"
+    filename = f"deltachat_rpc_server-{version}-{tag}.whl"

    with WheelFile(filename, "w") as wheel:
        wheel.write("LICENSE", "deltachat_rpc_server/LICENSE")
@@ -126,9 +128,11 @@ def main():
        Path(binary).chmod(0o755)
        wheel.write(
            binary,
-            "deltachat_rpc_server/deltachat-rpc-server.exe"
-            if windows
-            else "deltachat_rpc_server/deltachat-rpc-server",
+            (
+                "deltachat_rpc_server/deltachat-rpc-server.exe"
+                if windows
+                else "deltachat_rpc_server/deltachat-rpc-server"
+            ),
        )
        wheel.writestr(
            f"deltachat_rpc_server-{version}.dist-info/METADATA",
@@ -144,54 +148,41 @@ def main():
        )


-def main():
-    with open("deltachat-rpc-server/Cargo.toml", "rb") as f:
-        cargo_toml = tomllib.load(f)
-        version = cargo_toml["package"]["version"]
-    Path("dist").mkdir(exist_ok=True)
-    build_source_package(version)
-    build_wheel(
-        version,
-        "dist/deltachat-rpc-server-x86_64-linux",
-        "py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.musllinux_1_1_x86_64",
-    )
-    build_wheel(
-        version,
-        "dist/deltachat-rpc-server-armv7-linux",
-        "py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.musllinux_1_1_armv7l",
-    )
-    build_wheel(
-        version,
-        "dist/deltachat-rpc-server-aarch64-linux",
-        "py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.musllinux_1_1_aarch64",
-    )
-    build_wheel(
-        version,
-        "dist/deltachat-rpc-server-i686-linux",
-        "py3-none-manylinux_2_12_i686.manylinux2010_i686.musllinux_1_1_i686",
-    )
-
+arch2tags = {
+    "x86_64-linux": "manylinux_2_17_x86_64.manylinux2014_x86_64.musllinux_1_1_x86_64",
+    "armv7l-linux": "linux_armv7l.manylinux_2_17_armv7l.manylinux2014_armv7l.musllinux_1_1_armv7l",
+    "armv6l-linux": "linux_armv6l",
+    "aarch64-linux": "manylinux_2_17_aarch64.manylinux2014_aarch64.musllinux_1_1_aarch64",
+    "i686-linux": "manylinux_2_12_i686.manylinux2010_i686.musllinux_1_1_i686",
+    "win64": "win_amd64",
+    "win32": "win32",
    # macOS versions for platform compatibility tags are taken from https://doc.rust-lang.org/rustc/platform-support.html
-    build_wheel(
-        version,
-        "dist/deltachat-rpc-server-x86_64-macos",
-        "py3-none-macosx_10_7_x86_64",
-    )
-    build_wheel(
-        version,
-        "dist/deltachat-rpc-server-aarch64-macos",
-        "py3-none-macosx_11_0_arm64",
-    )
+    "x86_64-darwin": "macosx_10_7_x86_64",
+    "aarch64-darwin": "macosx_11_0_arm64",
+}

-    build_wheel(
-        version, "dist/deltachat-rpc-server-win32.exe", "py3-none-win32", windows=True
-    )
-    build_wheel(
-        version,
-        "dist/deltachat-rpc-server-win64.exe",
-        "py3-none-win_amd64",
-        windows=True,
-    )
+
+def main():
+    with Path("Cargo.toml").open("rb") as fp:
+        cargo_manifest = tomllib.load(fp)
+    version = cargo_manifest["package"]["version"]
+    if sys.argv[1] == "source":
+        filename = f"deltachat-rpc-server-{version}.tar.gz"
+        build_source_package(version, filename)
+    else:
+        arch = sys.argv[1]
+        executable = sys.argv[2]
+        tags = arch2tags[arch]
+
+        if arch in ["win32", "win64"]:
+            build_wheel(
+                version,
+                executable,
+                f"py3-none-{tags}",
+                windows=True,
+            )
+        else:
+            build_wheel(version, executable, f"py3-none-{tags}")


 main()
--- 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/spec.md
+++ b/spec.md
@@ -119,8 +119,9 @@ All group members form the member list.
 To allow different groups with the same members,
 groups are identified by a group-id.
 The group-id MUST be created only from the characters
-`0`-`9`, `A`-`Z`, `a`-`z` `_` and `-`
-and MUST have a length of at least 11 characters.
+`0`-`9`, `A`-`Z`, `a`-`z` `_` and `-`,
+MUST have a length of at least 11 characters
+and no more than 32 characters.

 Groups MUST have a group-name.
 The group-name is any non-zero-length UTF-8 string.
--- 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;
@@ -16,8 +17,9 @@ use tokio::sync::oneshot;
 #[cfg(not(target_os = "ios"))]
 use tokio::time::{sleep, Duration};

-use crate::context::Context;
+use crate::context::{Context, ContextBuilder};
 use crate::events::{Event, EventEmitter, EventType, Events};
+use crate::push::PushSubscriber;
 use crate::stock_str::StockStrings;

 /// Account manager, that can handle multiple accounts in a single place.
@@ -36,6 +38,9 @@ pub struct Accounts {
    /// This way changing a translation for one context automatically
    /// changes it for all other contexts.
    pub(crate) stockstrings: StockStrings,
+
+    /// Push notification subscriber shared between accounts.
+    push_subscriber: PushSubscriber,
 }

 impl Accounts {
@@ -72,8 +77,9 @@ impl Accounts {
            .context("failed to load accounts config")?;
        let events = Events::new();
        let stockstrings = StockStrings::new();
+        let push_subscriber = PushSubscriber::new();
        let accounts = config
-            .load_accounts(&events, &stockstrings, &dir)
+            .load_accounts(&events, &stockstrings, push_subscriber.clone(), &dir)
            .await
            .context("failed to load accounts")?;

@@ -83,6 +89,7 @@ impl Accounts {
            accounts,
            events,
            stockstrings,
+            push_subscriber,
        })
    }

@@ -119,13 +126,17 @@ impl Accounts {
        let account_config = self.config.new_account().await?;
        let dbfile = account_config.dbfile(&self.dir);

-        let ctx = Context::new(
-            &dbfile,
-            account_config.id,
-            self.events.clone(),
-            self.stockstrings.clone(),
-        )
-        .await?;
+        let ctx = ContextBuilder::new(dbfile)
+            .with_id(account_config.id)
+            .with_events(self.events.clone())
+            .with_stock_strings(self.stockstrings.clone())
+            .with_push_subscriber(self.push_subscriber.clone())
+            .build()
+            .await?;
+        // Try to open without a passphrase,
+        // but do not return an error if account is passphare-protected.
+        ctx.open("".to_string()).await?;
+
        self.accounts.insert(account_config.id, ctx);

        Ok(account_config.id)
@@ -134,14 +145,15 @@ impl Accounts {
    /// Adds a new closed account.
    pub async fn add_closed_account(&mut self) -> Result<u32> {
        let account_config = self.config.new_account().await?;
+        let dbfile = account_config.dbfile(&self.dir);

-        let ctx = Context::new_closed(
-            &account_config.dbfile(&self.dir),
-            account_config.id,
-            self.events.clone(),
-            self.stockstrings.clone(),
-        )
-        .await?;
+        let ctx = ContextBuilder::new(dbfile)
+            .with_id(account_config.id)
+            .with_events(self.events.clone())
+            .with_stock_strings(self.stockstrings.clone())
+            .with_push_subscriber(self.push_subscriber.clone())
+            .build()
+            .await?;
        self.accounts.insert(account_config.id, ctx);

        Ok(account_config.id)
@@ -241,25 +253,6 @@ impl Accounts {
        self.accounts.keys().copied().collect()
    }

-    /// This is meant especially for iOS, because iOS needs to tell the system when its background work is done.
-    ///
-    /// Returns whether all accounts finished their background work.
-    /// DC_EVENT_CONNECTIVITY_CHANGED will be sent when this turns to true.
-    ///
-    /// iOS can:
-    /// - call dc_start_io() (in case IO was not running)
-    /// - call dc_maybe_network()
-    /// - while dc_accounts_all_work_done() returns false:
-    ///   -  Wait for DC_EVENT_CONNECTIVITY_CHANGED
-    pub async fn all_work_done(&self) -> bool {
-        for account in self.accounts.values() {
-            if !account.all_work_done().await {
-                return false;
-            }
-        }
-        true
-    }
-
    /// Starts background tasks such as IMAP and SMTP loops for all accounts.
    pub async fn start_io(&mut self) {
        for account in self.accounts.values_mut() {
@@ -291,6 +284,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 })
@@ -300,6 +329,12 @@ impl Accounts {
    pub fn get_event_emitter(&self) -> EventEmitter {
        self.events.get_emitter()
    }
+
+    /// Sets notification token for Apple Push Notification service.
+    pub async fn set_push_device_token(&mut self, token: &str) -> Result<()> {
+        self.push_subscriber.set_device_token(token).await;
+        Ok(())
+    }
 }

 /// Configuration file name.
@@ -485,24 +520,24 @@ impl Config {
        &self,
        events: &Events,
        stockstrings: &StockStrings,
+        push_subscriber: PushSubscriber,
        dir: &Path,
    ) -> Result<BTreeMap<u32, Context>> {
        let mut accounts = BTreeMap::new();

        for account_config in &self.inner.accounts {
-            let ctx = Context::new(
-                &account_config.dbfile(dir),
-                account_config.id,
-                events.clone(),
-                stockstrings.clone(),
-            )
-            .await
-            .with_context(|| {
-                format!(
-                    "failed to create context from file {:?}",
-                    account_config.dbfile(dir)
-                )
-            })?;
+            let dbfile = account_config.dbfile(dir);
+            let ctx = ContextBuilder::new(dbfile.clone())
+                .with_id(account_config.id)
+                .with_events(events.clone())
+                .with_stock_strings(stockstrings.clone())
+                .with_push_subscriber(push_subscriber.clone())
+                .build()
+                .await
+                .with_context(|| format!("failed to create context from file {:?}", &dbfile))?;
+            // Try to open without a passphrase,
+            // but do not return an error if account is passphare-protected.
+            ctx.open("".to_string()).await?;

            accounts.insert(account_config.id, ctx);
        }
--- 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
@@ -5,11 +5,14 @@ use std::ffi::OsStr;
 use std::fmt;
 use std::io::Cursor;
 use std::iter::FusedIterator;
+use std::mem;
 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 image::codecs::jpeg::JpegEncoder;
+use image::{DynamicImage, GenericImage, GenericImageView, ImageFormat, Pixel, Rgba};
 use num_traits::FromPrimitive;
 use tokio::io::AsyncWriteExt;
 use tokio::{fs, io};
@@ -33,6 +36,12 @@ pub struct BlobObject<'a> {
    name: String,
 }

+#[derive(Debug, Clone)]
+enum ImageOutputFormat {
+    Png,
+    Jpeg { quality: u8 },
+}
+
 impl<'a> BlobObject<'a> {
    /// Creates a new blob object with a unique name.
    ///
@@ -312,6 +321,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();

@@ -388,6 +421,8 @@ impl<'a> BlobObject<'a> {
        max_bytes: usize,
        strict_limits: bool,
    ) -> Result<Option<String>> {
+        // Add white background only to avatars to spare the CPU.
+        let mut add_white_bg = img_wh <= constants::BALANCED_AVATAR_SIZE;
        let mut no_exif = false;
        let no_exif_ref = &mut no_exif;
        let res = tokio::task::block_in_place(move || {
@@ -421,13 +456,19 @@ impl<'a> BlobObject<'a> {
            let exceeds_wh = img.width() > img_wh || img.height() > img_wh;
            let exceeds_max_bytes = nr_bytes > max_bytes as u64;

+            let jpeg_quality = 75;
            let fmt = ImageFormat::from_path(&blob_abs);
            let ofmt = match fmt {
                Ok(ImageFormat::Png) if !exceeds_max_bytes => ImageOutputFormat::Png,
-                _ => {
-                    let jpeg_quality = 75;
-                    ImageOutputFormat::Jpeg(jpeg_quality)
+                Ok(ImageFormat::Jpeg) => {
+                    add_white_bg = false;
+                    ImageOutputFormat::Jpeg {
+                        quality: jpeg_quality,
+                    }
                }
+                _ => ImageOutputFormat::Jpeg {
+                    quality: jpeg_quality,
+                },
            };
            // We need to rewrite images with Exif to remove metadata such as location,
            // camera model, etc.
@@ -438,14 +479,18 @@ impl<'a> BlobObject<'a> {
            let do_scale = exceeds_max_bytes
                || strict_limits
                    && (exceeds_wh
-                        || exif.is_some()
-                            && encoded_img_exceeds_bytes(
+                        || exif.is_some() && {
+                            if mem::take(&mut add_white_bg) {
+                                self::add_white_bg(&mut img);
+                            }
+                            encoded_img_exceeds_bytes(
                                context,
                                &img,
                                ofmt.clone(),
                                max_bytes,
                                &mut encoded,
-                            )?);
+                            )?
+                        });

            if do_scale {
                if !exceeds_wh {
@@ -458,6 +503,9 @@ impl<'a> BlobObject<'a> {
                }

                loop {
+                    if mem::take(&mut add_white_bg) {
+                        self::add_white_bg(&mut img);
+                    }
                    let new_img = img.thumbnail(img_wh, img_wh);

                    if encoded_img_exceeds_bytes(
@@ -491,7 +539,7 @@ impl<'a> BlobObject<'a> {
            if do_scale || exif.is_some() {
                // The file format is JPEG/PNG now, we may have to change the file extension
                if !matches!(fmt, Ok(ImageFormat::Jpeg))
-                    && matches!(ofmt, ImageOutputFormat::Jpeg(_))
+                    && matches!(ofmt, ImageOutputFormat::Jpeg { .. })
                {
                    blob_abs = blob_abs.with_extension("jpg");
                    let file_name = blob_abs.file_name().context("No image file name (???)")?;
@@ -500,6 +548,9 @@ impl<'a> BlobObject<'a> {
                }

                if encoded.is_empty() {
+                    if mem::take(&mut add_white_bg) {
+                        self::add_white_bg(&mut img);
+                    }
                    encode_img(&img, ofmt, &mut encoded)?;
                }

@@ -643,7 +694,13 @@ fn encode_img(
 ) -> anyhow::Result<()> {
    encoded.clear();
    let mut buf = Cursor::new(encoded);
-    img.write_to(&mut buf, fmt)?;
+    match fmt {
+        ImageOutputFormat::Png => img.write_to(&mut buf, ImageFormat::Png)?,
+        ImageOutputFormat::Jpeg { quality } => {
+            let encoder = JpegEncoder::new_with_quality(&mut buf, quality);
+            img.write_with_encoder(encoder)?;
+        }
+    }
    Ok(())
 }

@@ -669,11 +726,21 @@ fn encoded_img_exceeds_bytes(
    Ok(false)
 }

+/// Removes transparency from an image using a white background.
+fn add_white_bg(img: &mut DynamicImage) {
+    for y in 0..img.height() {
+        for x in 0..img.width() {
+            let mut p = Rgba([255u8, 255, 255, 255]);
+            p.blend(&img.get_pixel(x, y));
+            img.put_pixel(x, y, p);
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
-    use anyhow::Result;
    use fs::File;
-    use image::{GenericImageView, Pixel};
+    use image::Pixel;

    use super::*;
    use crate::chat::{self, create_group_chat, ProtectionStatus};
@@ -885,6 +952,40 @@ mod tests {
        assert!(!stem.contains('?'));
    }

+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn test_add_white_bg() {
+        let t = TestContext::new().await;
+        let bytes0 = include_bytes!("../test-data/image/logo.png").as_slice();
+        let bytes1 = include_bytes!("../test-data/image/avatar900x900.png").as_slice();
+        for (bytes, color) in [
+            (bytes0, [255u8, 255, 255, 255]),
+            (bytes1, [253u8, 198, 0, 255]),
+        ] {
+            let avatar_src = t.dir.path().join("avatar.png");
+            fs::write(&avatar_src, bytes).await.unwrap();
+
+            let mut blob = BlobObject::new_from_path(&t, &avatar_src).await.unwrap();
+            let img_wh = 128;
+            let maybe_sticker = &mut false;
+            let strict_limits = true;
+            blob.recode_to_size(
+                &t,
+                blob.to_abs_path(),
+                maybe_sticker,
+                img_wh,
+                20_000,
+                strict_limits,
+            )
+            .unwrap();
+            tokio::task::block_in_place(move || {
+                let img = image::open(blob.to_abs_path()).unwrap();
+                assert!(img.width() == img_wh);
+                assert!(img.height() == img_wh);
+                assert_eq!(img.get_pixel(0, 0), Rgba(color));
+            });
+        }
+    }
+
    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
    async fn test_selfavatar_outside_blobdir() {
        let t = TestContext::new().await;
--- a/src/chat.rs
+++ b/src/chat.rs
@@ -2,11 +2,10 @@

 use std::cmp;
 use std::collections::{HashMap, HashSet};
-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 +43,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 +782,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() {
@@ -1788,18 +1789,10 @@ impl Chat {
        update_msg_id: Option<MsgId>,
        timestamp: i64,
    ) -> Result<MsgId> {
-        let mut new_references = "".into();
        let mut to_id = 0;
        let mut location_id = 0;

-        let from = context.get_primary_self_addr().await?;
-        let new_rfc724_mid = {
-            let grpid = match self.typ {
-                Chattype::Group => Some(self.grpid.as_str()),
-                _ => None,
-            };
-            create_outgoing_rfc724_mid(grpid, &from)
-        };
+        let new_rfc724_mid = create_outgoing_rfc724_mid();

        if self.typ == Chattype::Single {
            if let Some(id) = context
@@ -1837,58 +1830,72 @@ impl Chat {
        // reset encrypt error state eg. for forwarding
        msg.param.remove(Param::ErroneousE2ee);

-        // set "In-Reply-To:" to identify the message to which the composed message is a reply;
-        // set "References:" to identify the "thread" of the conversation;
-        // both according to RFC 5322 3.6.4, page 25
-        //
-        // as self-talks are mainly used to transfer data between devices,
-        // we do not set In-Reply-To/References in this case.
-        if !self.is_self_talk() {
-            if let Some((parent_rfc724_mid, parent_in_reply_to, parent_references)) =
-                // We don't filter `OutPending` and `OutFailed` messages because the new message for
-                // which `parent_query()` is done may assume that it will be received in a context
-                // affected by those messages, e.g. they could add new members to a group and the
-                // new message will contain them in "To:". Anyway recipients must be prepared to
-                // orphaned references.
-                self
-                    .id
-                    .get_parent_mime_headers(context, MessageState::OutPending)
-                    .await?
-            {
-                // "In-Reply-To:" is not changed if it is set manually.
-                // This does not affect "References:" header, it will contain "default parent" (the
-                // latest message in the thread) anyway.
-                if msg.in_reply_to.is_none() && !parent_rfc724_mid.is_empty() {
-                    msg.in_reply_to = Some(parent_rfc724_mid.clone());
-                }
-
-                // the whole list of messages referenced may be huge;
-                // only use the oldest and the parent message
-                let parent_references = parent_references
-                    .find(' ')
-                    .and_then(|n| parent_references.get(..n))
-                    .unwrap_or(&parent_references);
-
-                if !parent_references.is_empty() && !parent_rfc724_mid.is_empty() {
-                    // angle brackets are added by the mimefactory later
-                    new_references = format!("{parent_references} {parent_rfc724_mid}");
-                } else if !parent_references.is_empty() {
-                    new_references = parent_references.to_string();
-                } else if !parent_in_reply_to.is_empty() && !parent_rfc724_mid.is_empty() {
-                    new_references = format!("{parent_in_reply_to} {parent_rfc724_mid}");
-                } else if !parent_in_reply_to.is_empty() {
-                    new_references = parent_in_reply_to;
-                } else {
-                    // as a fallback, use our Message-ID, see reasoning below.
-                    new_references = new_rfc724_mid.clone();
-                }
-            } else {
-                // this is a top-level message, add our Message-ID as first reference.
-                // as we always try to extract the grpid also from `References:`-header,
-                // this allows group conversations also if smtp-server as outlook change `Message-ID:`-header
-                // (MUAs usually keep the first Message-ID in `References:`-header unchanged).
-                new_references = new_rfc724_mid.clone();
+        // Set "In-Reply-To:" to identify the message to which the composed message is a reply.
+        // Set "References:" to identify the "thread" of the conversation.
+        // Both according to [RFC 5322 3.6.4, page 25](https://www.rfc-editor.org/rfc/rfc5322#section-3.6.4).
+        let new_references;
+        if self.is_self_talk() {
+            // As self-talks are mainly used to transfer data between devices,
+            // we do not set In-Reply-To/References in this case.
+            new_references = String::new();
+        } else if let Some((parent_rfc724_mid, parent_in_reply_to, parent_references)) =
+            // We don't filter `OutPending` and `OutFailed` messages because the new message for
+            // which `parent_query()` is done may assume that it will be received in a context
+            // affected by those messages, e.g. they could add new members to a group and the
+            // new message will contain them in "To:". Anyway recipients must be prepared to
+            // orphaned references.
+            self
+                .id
+                .get_parent_mime_headers(context, MessageState::OutPending)
+                .await?
+        {
+            // "In-Reply-To:" is not changed if it is set manually.
+            // This does not affect "References:" header, it will contain "default parent" (the
+            // latest message in the thread) anyway.
+            if msg.in_reply_to.is_none() && !parent_rfc724_mid.is_empty() {
+                msg.in_reply_to = Some(parent_rfc724_mid.clone());
            }
+
+            // Use parent `In-Reply-To` as a fallback
+            // in case parent message has no `References` header
+            // as specified in RFC 5322:
+            // > If the parent message does not contain
+            // > a "References:" field but does have an "In-Reply-To:" field
+            // > containing a single message identifier, then the "References:" field
+            // > will contain the contents of the parent's "In-Reply-To:" field
+            // > followed by the contents of the parent's "Message-ID:" field (if
+            // > any).
+            let parent_references = if parent_references.is_empty() {
+                parent_in_reply_to
+            } else {
+                parent_references
+            };
+
+            // The whole list of messages referenced may be huge.
+            // Only take 2 recent references and add third from `In-Reply-To`.
+            let mut references_vec: Vec<&str> = parent_references.rsplit(' ').take(2).collect();
+            references_vec.reverse();
+
+            if !parent_rfc724_mid.is_empty()
+                && !references_vec.contains(&parent_rfc724_mid.as_str())
+            {
+                references_vec.push(&parent_rfc724_mid)
+            }
+
+            if references_vec.is_empty() {
+                // As a fallback, use our Message-ID,
+                // same as in the case of top-level message.
+                new_references = new_rfc724_mid.clone();
+            } else {
+                new_references = references_vec.join(" ");
+            }
+        } else {
+            // This is a top-level message.
+            // Add our Message-ID as first references.
+            // This allows us to identify replies to our message even if
+            // email server such as Outlook changes `Message-ID:` header.
+            // MUAs usually keep the first Message-ID in `References:` header unchanged.
+            new_references = new_rfc724_mid.clone();
        }

        // add independent location to database
@@ -2691,7 +2698,9 @@ async fn send_msg_inner(context: &Context, chat_id: ChatId, msg: &mut Message) -
    }

    if !prepare_send_msg(context, chat_id, msg).await?.is_empty() {
-        context.emit_msgs_changed(msg.chat_id, msg.id);
+        if !msg.hidden {
+            context.emit_msgs_changed(msg.chat_id, msg.id);
+        }

        if msg.param.exists(Param::SetLatitude) {
            context.emit_event(EventType::LocationChanged(Some(ContactId::SELF)));
@@ -2735,17 +2744,8 @@ async fn prepare_send_msg(
 /// The caller has to interrupt SMTP loop or otherwise process new rows.
 pub(crate) async fn create_send_msg_jobs(context: &Context, msg: &mut Message) -> Result<Vec<i64>> {
    let needs_encryption = msg.param.get_bool(Param::GuaranteeE2ee).unwrap_or_default();
-
-    let attach_selfavatar = match shall_attach_selfavatar(context, msg.chat_id).await {
-        Ok(attach_selfavatar) => attach_selfavatar,
-        Err(err) => {
-            warn!(context, "SMTP job cannot get selfavatar-state: {err:#}.");
-            false
-        }
-    };
-
-    let mimefactory = MimeFactory::from_msg(context, msg, attach_selfavatar).await?;
-
+    let mimefactory = MimeFactory::from_msg(context, msg).await?;
+    let attach_selfavatar = mimefactory.attach_selfavatar;
    let mut recipients = mimefactory.recipients();

    let from = context.get_primary_self_addr().await?;
@@ -2804,12 +2804,20 @@ 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 rendered_msg.is_group {
+        msg.chat_id
+            .update_timestamp(context, Param::MemberListTimestamp, 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 {
@@ -2828,7 +2836,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:#}.");
        }
    }
@@ -3652,7 +3660,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 {
@@ -4076,6 +4084,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;
        }
@@ -4146,7 +4155,7 @@ pub async fn add_device_msg_with_importance(
    if let Some(msg) = msg {
        chat_id = ChatId::get_for_contact(context, ContactId::DEVICE).await?;

-        let rfc724_mid = create_outgoing_rfc724_mid(None, "@device");
+        let rfc724_mid = create_outgoing_rfc724_mid();
        prepare_msg_blob(context, msg).await?;

        let timestamp_sent = create_smeared_timestamp(context);
@@ -4265,7 +4274,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(())
 }

@@ -4284,7 +4295,7 @@ pub(crate) async fn add_info_msg_with_cmd(
    parent: Option<&Message>,
    from_id: Option<ContactId>,
 ) -> Result<MsgId> {
-    let rfc724_mid = create_outgoing_rfc724_mid(None, "@device");
+    let rfc724_mid = create_outgoing_rfc724_mid();
    let ephemeral_timer = chat_id.get_ephemeral_timer(context).await?;

    let mut param = Params::new();
@@ -4467,9 +4478,8 @@ impl Context {
 #[cfg(test)]
 mod tests {
    use super::*;
-    use crate::chatlist::{get_archived_cnt, Chatlist};
+    use crate::chatlist::get_archived_cnt;
    use crate::constants::{DC_GCL_ARCHIVED_ONLY, DC_GCL_NO_SPECIALS};
-    use crate::contact::{Contact, ContactAddress};
    use crate::message::delete_msgs;
    use crate::receive_imf::receive_imf;
    use crate::test_utils::{sync, TestContext, TestContextManager};
@@ -5925,11 +5935,11 @@ mod tests {
        // Alice has an SMTP-server replacing the `Message-ID:`-header (as done eg. by outlook.com).
        let sent_msg = alice.pop_sent_msg().await;
        let msg = sent_msg.payload();
-        assert_eq!(msg.match_indices("Message-ID: <Gr.").count(), 2);
-        assert_eq!(msg.match_indices("References: <Gr.").count(), 1);
-        let msg = msg.replace("Message-ID: <Gr.", "Message-ID: <XXX");
-        assert_eq!(msg.match_indices("Message-ID: <Gr.").count(), 0);
-        assert_eq!(msg.match_indices("References: <Gr.").count(), 1);
+        assert_eq!(msg.match_indices("Message-ID: <Mr.").count(), 2);
+        assert_eq!(msg.match_indices("References: <Mr.").count(), 1);
+        let msg = msg.replace("Message-ID: <Mr.", "Message-ID: <XXX");
+        assert_eq!(msg.match_indices("Message-ID: <Mr.").count(), 0);
+        assert_eq!(msg.match_indices("References: <Mr.").count(), 1);

        // Bob receives this message, he may detect group by `References:`- or `Chat-Group:`-header
        receive_imf(&bob, msg.as_bytes(), false).await.unwrap();
@@ -5946,7 +5956,7 @@ mod tests {
        send_text_msg(&bob, bob_chat.id, "ho!".to_string()).await?;
        let sent_msg = bob.pop_sent_msg().await;
        let msg = sent_msg.payload();
-        let msg = msg.replace("Message-ID: <Gr.", "Message-ID: <XXX");
+        let msg = msg.replace("Message-ID: <Mr.", "Message-ID: <XXX");
        let msg = msg.replace("Chat-", "XXXX-");
        assert_eq!(msg.match_indices("Chat-").count(), 0);

@@ -6502,6 +6512,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);
@@ -6524,6 +6535,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/chatlist.rs
+++ b/src/chatlist.rs
@@ -416,7 +416,7 @@ impl Chatlist {
        if chat.id.is_archived_link() {
            Ok(Default::default())
        } else if let Some(lastmsg) = lastmsg.filter(|msg| msg.from_id != ContactId::UNDEFINED) {
-            Ok(Summary::new(context, &lastmsg, chat, lastcontact.as_ref()).await)
+            Summary::new(context, &lastmsg, chat, lastcontact.as_ref()).await
        } else {
            Ok(Summary {
                text: stock_str::no_messages(context).await,
--- 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, EnumString};
+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,
@@ -348,8 +353,9 @@ pub enum Config {
    /// used for signatures, encryption to self and included in `Autocrypt` header.
    KeyId,

-    /// Iroh secret key.
-    IrohSecretKey,
+    /// 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 {
@@ -357,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
        )
    }
 }
@@ -453,6 +475,15 @@ impl Context {
            || self.get_config_bool(Config::OnlyFetchMvbox).await?)
    }

+    /// Returns true if sentbox ("Sent" folder) should be watched.
+    pub(crate) async fn should_watch_sentbox(&self) -> Result<bool> {
+        Ok(self.get_config_bool(Config::SentboxWatch).await?
+            && self
+                .get_config(Config::ConfiguredSentboxFolder)
+                .await?
+                .is_some())
+    }
+
    /// Gets configured "delete_server_after" value.
    ///
    /// `None` means never delete the message, `Some(0)` means delete
@@ -487,51 +518,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
@@ -552,6 +557,82 @@ 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?;
+        if key == Config::SentboxWatch {
+            self.last_full_folder_scan.lock().await.take();
+        }
+        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 => {
@@ -559,15 +640,22 @@ 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(());
        }
-        self.emit_event(EventType::ConfigSynced { key });
        let Some(val) = value else {
            return Ok(());
        };
@@ -592,8 +680,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(())
    }

@@ -613,6 +700,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.
@@ -639,13 +731,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(())
@@ -693,13 +785,10 @@ fn get_config_keys_string() -> String {

 #[cfg(test)]
 mod tests {
-    use std::string::ToString;
-
    use num_traits::FromPrimitive;

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

    #[test]
    fn test_to_string() {
@@ -871,42 +960,9 @@ mod tests {
        // versions.
        alice0.set_config(Config::MdnsEnabled, None).await?;
        assert_eq!(alice0.get_config_bool(Config::MdnsEnabled).await?, true);
-        alice0
-            .evtracker
-            .get_matching(|e| {
-                matches!(
-                    e,
-                    EventType::ConfigSynced {
-                        key: Config::MdnsEnabled
-                    }
-                )
-            })
-            .await;
        alice0.set_config_bool(Config::MdnsEnabled, false).await?;
-        alice0
-            .evtracker
-            .get_matching(|e| {
-                matches!(
-                    e,
-                    EventType::ConfigSynced {
-                        key: Config::MdnsEnabled
-                    }
-                )
-            })
-            .await;
        sync(&alice0, &alice1).await;
        assert_eq!(alice1.get_config_bool(Config::MdnsEnabled).await?, false);
-        alice1
-            .evtracker
-            .get_matching(|e| {
-                matches!(
-                    e,
-                    EventType::ConfigSynced {
-                        key: Config::MdnsEnabled
-                    }
-                )
-            })
-            .await;

        let show_emails = alice0.get_config_bool(Config::ShowEmails).await?;
        alice0
@@ -926,14 +982,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,10 +22,10 @@ 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;
+use crate::imap::{session::Session as ImapSession, Imap};
 use crate::log::LogExt;
 use crate::login_param::{CertificateChecks, LoginParam, ServerLoginParam};
 use crate::message::{Message, Viewtype};
@@ -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(())
    }
@@ -394,7 +395,7 @@ async fn configure(ctx: &Context, param: &mut LoginParam) -> Result<()> {

    // Configure IMAP

-    let mut imap: Option<Imap> = None;
+    let mut imap: Option<(Imap, ImapSession)> = None;
    let imap_servers: Vec<&ServerParams> = servers
        .iter()
        .filter(|params| params.protocol == Protocol::Imap)
@@ -432,7 +433,7 @@ async fn configure(ctx: &Context, param: &mut LoginParam) -> Result<()> {
            600 + (800 - 600) * (1 + imap_server_index) / imap_servers_count
        );
    }
-    let mut imap = match imap {
+    let (mut imap, mut imap_session) = match imap {
        Some(imap) => imap,
        None => bail!(nicer_configuration_error(ctx, errors).await),
    };
@@ -453,9 +454,11 @@ async fn configure(ctx: &Context, param: &mut LoginParam) -> Result<()> {

    let create_mvbox = ctx.should_watch_mvbox().await?;

-    imap.configure_folders(ctx, create_mvbox).await?;
+    imap.configure_folders(ctx, &mut imap_session, create_mvbox)
+        .await?;

-    imap.select_with_uidvalidity(ctx, "INBOX")
+    imap_session
+        .select_with_uidvalidity(ctx, "INBOX")
        .await
        .context("could not read INBOX status")?;

@@ -473,7 +476,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 +484,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;

@@ -575,7 +578,7 @@ async fn try_imap_one_param(
    socks5_config: &Option<Socks5Config>,
    addr: &str,
    provider_strict_tls: bool,
-) -> Result<Imap, ConfigurationError> {
+) -> Result<(Imap, ImapSession), ConfigurationError> {
    let inf = format!(
        "imap: {}@{}:{} security={} certificate_checks={} oauth2={} socks5_config={}",
        param.user,
@@ -613,9 +616,9 @@ async fn try_imap_one_param(
                msg: format!("{err:#}"),
            })
        }
-        Ok(()) => {
+        Ok(session) => {
            info!(context, "success: {}", inf);
-            Ok(imap)
+            Ok((imap, session))
        }
    }
 }
--- 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
@@ -2,11 +2,10 @@

 use std::cmp::Reverse;
 use std::collections::BinaryHeap;
-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};
@@ -36,7 +35,7 @@ use crate::sql::{self, params_iter};
 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};

@@ -1537,7 +1536,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,
@@ -1550,7 +1549,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.");
@@ -1563,7 +1562,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.");
                }
@@ -1595,7 +1596,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 {
@@ -1730,6 +1731,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.
        //
@@ -1740,7 +1747,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")?;
@@ -1755,8 +1762,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() {
                    (
--- a/src/context.rs
+++ b/src/context.rs
@@ -6,30 +6,37 @@ 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 iroh_gossip::net::Gossip;
-use iroh_net::MagicEndpoint;
+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::contact::Contact;
+use crate::constants::{
+    self, DC_BACKGROUND_FETCH_QUOTA_CHECK_RATELIMIT, DC_CHAT_ID_TRASH, DC_VERSION_STR,
+};
+use crate::contact::{Contact, ContactId};
 use crate::debug_logging::DebugLogging;
+use crate::download::DownloadState;
 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::param::{Param, Params};
+use crate::peerstate::Peerstate;
+use crate::push::PushSubscriber;
 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`].
 ///
@@ -80,6 +87,8 @@ pub struct ContextBuilder {
    events: Events,
    stock_strings: StockStrings,
    password: Option<String>,
+
+    push_subscriber: Option<PushSubscriber>,
 }

 impl ContextBuilder {
@@ -95,6 +104,7 @@ impl ContextBuilder {
            events: Events::new(),
            stock_strings: StockStrings::new(),
            password: None,
+            push_subscriber: None,
        }
    }

@@ -149,11 +159,32 @@ impl ContextBuilder {
        self
    }

-    /// Opens the [`Context`].
+    /// Sets push subscriber.
+    pub(crate) fn with_push_subscriber(mut self, push_subscriber: PushSubscriber) -> Self {
+        self.push_subscriber = Some(push_subscriber);
+        self
+    }
+
+    /// Builds the [`Context`] without opening it.
+    pub async fn build(self) -> Result<Context> {
+        let push_subscriber = self.push_subscriber.unwrap_or_default();
+        let context = Context::new_closed(
+            &self.dbfile,
+            self.id,
+            self.events,
+            self.stock_strings,
+            push_subscriber,
+        )
+        .await?;
+        Ok(context)
+    }
+
+    /// Builds the [`Context`] and opens it.
+    ///
+    /// Returns error if context cannot be opened with the given passphrase.
    pub async fn open(self) -> Result<Context> {
-        let context =
-            Context::new_closed(&self.dbfile, self.id, self.events, self.stock_strings).await?;
-        let password = self.password.unwrap_or_default();
+        let password = self.password.clone().unwrap_or_default();
+        let context = self.build().await?;
        match context.open(password).await? {
            true => Ok(context),
            false => bail!("database could not be decrypted, incorrect or missing password"),
@@ -226,7 +257,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.
    ///
@@ -234,7 +268,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,
@@ -247,11 +281,12 @@ pub struct InnerContext {
    /// because the lock is used from synchronous [`Context::emit_event`].
    pub(crate) debug_logging: std::sync::RwLock<Option<DebugLogging>>,

-    /// [MagicEndpoint] needed for iroh peer channels.
-    pub(crate) endpoint: Mutex<Option<MagicEndpoint>>,
+    /// Push subscriber to store device token
+    /// and register for heartbeat notifications.
+    pub(crate) push_subscriber: PushSubscriber,

-    /// [Gossip] needed for iroh peer channels.
-    pub(crate) gossip: Mutex<Option<Gossip>>,
+    /// True if account has subscribed to push notifications via IMAP.
+    pub(crate) push_subscribed: AtomicBool,
 }

 /// The state of ongoing process.
@@ -261,7 +296,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,
@@ -297,7 +332,8 @@ impl Context {
        events: Events,
        stock_strings: StockStrings,
    ) -> Result<Context> {
-        let context = Self::new_closed(dbfile, id, events, stock_strings).await?;
+        let context =
+            Self::new_closed(dbfile, id, events, stock_strings, Default::default()).await?;

        // Open the database if is not encrypted.
        if context.check_passphrase("".to_string()).await? {
@@ -312,6 +348,7 @@ impl Context {
        id: u32,
        events: Events,
        stockstrings: StockStrings,
+        push_subscriber: PushSubscriber,
    ) -> Result<Context> {
        let mut blob_fname = OsString::new();
        blob_fname.push(dbfile.file_name().unwrap_or_default());
@@ -320,7 +357,14 @@ impl Context {
        if !blobdir.exists() {
            tokio::fs::create_dir_all(&blobdir).await?;
        }
-        let context = Context::with_blobdir(dbfile.into(), blobdir, id, events, stockstrings)?;
+        let context = Context::with_blobdir(
+            dbfile.into(),
+            blobdir,
+            id,
+            events,
+            stockstrings,
+            push_subscriber,
+        )?;
        Ok(context)
    }

@@ -363,6 +407,7 @@ impl Context {
        id: u32,
        events: Events,
        stockstrings: StockStrings,
+        push_subscriber: PushSubscriber,
    ) -> Result<Context> {
        ensure!(
            blobdir.is_dir(),
@@ -392,12 +437,13 @@ 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),
-            endpoint: Mutex::new(None),
-            gossip: Mutex::new(None),
+            push_subscriber,
+            push_subscribed: AtomicBool::new(false),
        };

        let ctx = Context {
@@ -408,7 +454,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;
@@ -427,17 +473,11 @@ impl Context {
                *lock = Ratelimit::new(Duration::new(3, 0), 3.0);
            }
        }
-
-        if let Err(e) = self.create_gossip().await {
-            warn!(self, "{e}");
-        }
        self.scheduler.start(self.clone()).await;
    }

    /// Stops the IO scheduler.
    pub async fn stop_io(&self) {
-        self.endpoint.lock().await.take();
-        self.gossip.lock().await.take();
        self.scheduler.stop(self).await;
    }

@@ -449,12 +489,61 @@ impl Context {

    /// Indicate that the network likely has come back.
    pub async fn maybe_network(&self) {
-        if let Some(ref mut endpoint) = *self.endpoint.lock().await {
-            endpoint.network_change().await;
-        }
        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?;
+        let mut session = 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, &mut session, &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 Err(err) = self.update_recent_quota(&mut 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;
@@ -551,7 +640,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;
    }
@@ -566,7 +655,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 => {
@@ -632,7 +721,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();

@@ -672,7 +761,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)
@@ -688,6 +777,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",
@@ -705,6 +804,12 @@ impl Context {
            "show_emails",
            self.get_config_int(Config::ShowEmails).await?.to_string(),
        );
+        res.insert(
+            "save_mime_headers",
+            self.get_config_bool(Config::SaveMimeHeaders)
+                .await?
+                .to_string(),
+        );
        res.insert(
            "download_limit",
            self.get_config_int(Config::DownloadLimit)
@@ -714,7 +819,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);
@@ -765,6 +873,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)
@@ -808,12 +922,177 @@ 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> {
+        #[derive(Default)]
+        struct ChatNumbers {
+            protected: u32,
+            protection_broken: u32,
+            opportunistic_dc: u32,
+            opportunistic_mua: u32,
+            unencrypted_dc: u32,
+            unencrypted_mua: u32,
+        }
+
+        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);
+
+        // how many of the chats active in the last months are:
+        // - protected
+        // - protection-broken
+        // - opportunistic-encrypted and the contact uses Delta Chat
+        // - opportunistic-encrypted and the contact uses a classical MUA
+        // - unencrypted and the contact uses Delta Chat
+        // - unencrypted and the contact uses a classical MUA
+        let three_months_ago = time().saturating_sub(3600 * 24 * 30 * 3);
+        let chats = self
+            .sql
+            .query_map(
+                "SELECT c.protected, m.param, m.msgrmsg
+                    FROM chats c
+                    JOIN msgs m
+                        ON c.id=m.chat_id
+                        AND m.id=(
+                                SELECT id
+                                FROM msgs
+                                WHERE chat_id=c.id
+                                AND hidden=0
+                                AND download_state=?
+                                AND to_id!=?
+                                ORDER BY timestamp DESC, id DESC LIMIT 1)
+                    WHERE c.id>9
+                    AND (c.blocked=0 OR c.blocked=2)
+                    AND IFNULL(m.timestamp,c.created_timestamp) > ?
+                    GROUP BY c.id",
+                (DownloadState::Done, ContactId::INFO, three_months_ago),
+                |row| {
+                    let protected: ProtectionStatus = row.get(0)?;
+                    let message_param: Params =
+                        row.get::<_, String>(1)?.parse().unwrap_or_default();
+                    let is_dc_message: bool = row.get(2)?;
+                    Ok((protected, message_param, is_dc_message))
+                },
+                |rows| {
+                    let mut chats = ChatNumbers::default();
+                    for row in rows {
+                        let (protected, message_param, is_dc_message) = row?;
+                        let encrypted = message_param
+                            .get_bool(Param::GuaranteeE2ee)
+                            .unwrap_or(false);
+
+                        if protected == ProtectionStatus::Protected {
+                            chats.protected += 1;
+                        } else if protected == ProtectionStatus::ProtectionBroken {
+                            chats.protection_broken += 1;
+                        } else if encrypted {
+                            if is_dc_message {
+                                chats.opportunistic_dc += 1;
+                            } else {
+                                chats.opportunistic_mua += 1;
+                            }
+                        } else if is_dc_message {
+                            chats.unencrypted_dc += 1;
+                        } else {
+                            chats.unencrypted_mua += 1;
+                        }
+                    }
+                    Ok(chats)
+                },
+            )
+            .await?;
+        res += &format!("chats_protected {}\n", chats.protected);
+        res += &format!("chats_protection_broken {}\n", chats.protection_broken);
+        res += &format!("chats_opportunistic_dc {}\n", chats.opportunistic_dc);
+        res += &format!("chats_opportunistic_mua {}\n", chats.opportunistic_mua);
+        res += &format!("chats_unencrypted_dc {}\n", chats.unencrypted_dc);
+        res += &format!("chats_unencrypted_mua {}\n", chats.unencrypted_mua);
+
+        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
@@ -1070,23 +1349,18 @@ pub fn get_version_str() -> &'static str {

 #[cfg(test)]
 mod tests {
-    use std::time::Duration;
-
    use anyhow::Context as _;
    use strum::IntoEnumIterator;
    use tempfile::tempdir;

    use super::*;
-    use crate::chat::{
-        get_chat_contacts, get_chat_msgs, send_msg, set_muted, Chat, ChatId, MuteDuration,
-    };
+    use crate::chat::{get_chat_contacts, get_chat_msgs, send_msg, set_muted, Chat, MuteDuration};
    use crate::chatlist::Chatlist;
    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<()> {
@@ -1121,7 +1395,7 @@ mod tests {
             \n\
             hello\n",
            contact.get_addr(),
-            create_outgoing_rfc724_mid(None, contact.get_addr())
+            create_outgoing_rfc724_mid()
        );
        println!("{msg}");
        receive_imf(t, msg.as_bytes(), false).await.unwrap();
@@ -1271,7 +1545,14 @@ mod tests {
        let tmp = tempfile::tempdir().unwrap();
        let dbfile = tmp.path().join("db.sqlite");
        let blobdir = PathBuf::new();
-        let res = Context::with_blobdir(dbfile, blobdir, 1, Events::new(), StockStrings::new());
+        let res = Context::with_blobdir(
+            dbfile,
+            blobdir,
+            1,
+            Events::new(),
+            StockStrings::new(),
+            Default::default(),
+        );
        assert!(res.is_err());
    }

@@ -1280,7 +1561,14 @@ mod tests {
        let tmp = tempfile::tempdir().unwrap();
        let dbfile = tmp.path().join("db.sqlite");
        let blobdir = tmp.path().join("blobs");
-        let res = Context::with_blobdir(dbfile, blobdir, 1, Events::new(), StockStrings::new());
+        let res = Context::with_blobdir(
+            dbfile,
+            blobdir,
+            1,
+            Events::new(),
+            StockStrings::new(),
+            Default::default(),
+        );
        assert!(res.is_err());
    }

@@ -1295,14 +1583,14 @@ mod tests {
        let t = TestContext::new().await;

        let info = t.get_info().await.unwrap();
-        assert!(info.get("database_dir").is_some());
+        assert!(info.contains_key("database_dir"));
    }

    #[test]
    fn test_get_info_no_context() {
        let info = get_info();
-        assert!(info.get("deltachat_core_version").is_some());
-        assert!(info.get("database_dir").is_none());
+        assert!(info.contains_key("deltachat_core_version"));
+        assert!(!info.contains_key("database_dir"));
        assert_eq!(info.get("level").unwrap(), "awesome");
    }

@@ -1323,7 +1611,7 @@ mod tests {
            "mail_port",
            "mail_security",
            "notify_about_wrong_pw",
-            "save_mime_headers",
+            "self_reporting_id",
            "selfstatus",
            "send_server",
            "send_user",
@@ -1338,7 +1626,6 @@ mod tests {
            "socks5_user",
            "socks5_password",
            "key_id",
-            "iroh_secret_key",
        ];
        let t = TestContext::new().await;
        let info = t.get_info().await.unwrap();
@@ -1503,16 +1790,18 @@ mod tests {
        let dir = tempdir()?;
        let dbfile = dir.path().join("db.sqlite");

-        let id = 1;
-        let context = Context::new_closed(&dbfile, id, Events::new(), StockStrings::new())
+        let context = ContextBuilder::new(dbfile.clone())
+            .with_id(1)
+            .build()
            .await
            .context("failed to create context")?;
        assert_eq!(context.open("foo".to_string()).await?, true);
        assert_eq!(context.is_open().await, true);
        drop(context);

-        let id = 2;
-        let context = Context::new(&dbfile, id, Events::new(), StockStrings::new())
+        let context = ContextBuilder::new(dbfile)
+            .with_id(2)
+            .build()
            .await
            .context("failed to create context")?;
        assert_eq!(context.is_open().await, false);
@@ -1528,8 +1817,9 @@ mod tests {
        let dir = tempdir()?;
        let dbfile = dir.path().join("db.sqlite");

-        let id = 1;
-        let context = Context::new_closed(&dbfile, id, Events::new(), StockStrings::new())
+        let context = ContextBuilder::new(dbfile)
+            .with_id(1)
+            .build()
            .await
            .context("failed to create context")?;
        assert_eq!(context.open("foo".to_string()).await?, true);
@@ -1627,12 +1917,21 @@ mod tests {
    }

    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_keypair_saving() -> Result<()> {
+    async fn test_draft_self_report() -> Result<()> {
        let alice = TestContext::new_alice().await;

-        let key = alice.get_or_generate_iroh_keypair().await?;
-        let loaded_key = alice.get_or_generate_iroh_keypair().await?;
-        assert_eq!(key.to_bytes(), loaded_key.to_bytes());
+        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/debug_logging.rs
+++ b/src/debug_logging.rs
@@ -63,7 +63,6 @@ pub async fn debug_logging_loop(context: &Context, events: Receiver<DebugEventLo
                    summary: None,
                    document: None,
                    uid: None,
-                    gossip_topic: None,
                },
            )
            .await
@@ -73,10 +72,12 @@ pub async fn debug_logging_loop(context: &Context, events: Receiver<DebugEventLo
            }
            Ok(serial) => {
                if let Some(serial) = serial {
-                    context.emit_event(EventType::WebxdcStatusUpdate {
-                        msg_id,
-                        status_update_serial: serial,
-                    });
+                    if !matches!(event, EventType::WebxdcStatusUpdate { .. }) {
+                        context.emit_event(EventType::WebxdcStatusUpdate {
+                            msg_id,
+                            status_update_serial: serial,
+                        });
+                    }
                } else {
                    // This should not happen as the update has no `uid`.
                    error!(context, "Debug logging update is not created.");
--- a/src/decrypt.rs
+++ b/src/decrypt.rs
@@ -27,12 +27,8 @@ pub fn try_decrypt(
    private_keyring: &[SignedSecretKey],
    public_keyring_for_validate: &[SignedPublicKey],
 ) -> Result<Option<(Vec<u8>, HashSet<Fingerprint>)>> {
-    let encrypted_data_part = match get_autocrypt_mime(mail)
-        .or_else(|| get_mixed_up_mime(mail))
-        .or_else(|| get_attachment_mime(mail))
-    {
-        None => return Ok(None),
-        Some(res) => res,
+    let Some(encrypted_data_part) = get_encrypted_mime(mail) else {
+        return Ok(None);
    };

    decrypt_part(
@@ -69,28 +65,29 @@ pub(crate) async fn prepare_decryption(
        });
    }

-    let autocrypt_header =
-        if let Some(autocrypt_header_value) = mail.headers.get_header_value(HeaderDef::Autocrypt) {
-            match Aheader::from_str(&autocrypt_header_value) {
-                Ok(header) if addr_cmp(&header.addr, from) => Some(header),
-                Ok(header) => {
-                    warn!(
-                        context,
-                        "Autocrypt header address {:?} is not {:?}.", header.addr, from
-                    );
-                    None
-                }
-                Err(err) => {
-                    warn!(context, "Failed to parse Autocrypt header: {:#}.", err);
-                    None
-                }
+    let autocrypt_header = if context.is_self_addr(from).await? {
+        None
+    } else if let Some(aheader_value) = mail.headers.get_header_value(HeaderDef::Autocrypt) {
+        match Aheader::from_str(&aheader_value) {
+            Ok(header) if addr_cmp(&header.addr, from) => Some(header),
+            Ok(header) => {
+                warn!(
+                    context,
+                    "Autocrypt header address {:?} is not {:?}.", header.addr, from
+                );
+                None
            }
-        } else {
-            None
-        };
+            Err(err) => {
+                warn!(context, "Failed to parse Autocrypt header: {:#}.", err);
+                None
+            }
+        }
+    } else {
+        None
+    };

    let dkim_results = handle_authres(context, mail, from, message_time).await?;
-
+    let allow_aeap = get_encrypted_mime(mail).is_some();
    let peerstate = get_autocrypt_peerstate(
        context,
        from,
@@ -98,6 +95,7 @@ pub(crate) async fn prepare_decryption(
        message_time,
        // Disallowing keychanges is disabled for now:
        true, // dkim_results.allow_keychange,
+        allow_aeap,
    )
    .await?;

@@ -126,6 +124,13 @@ pub struct DecryptionInfo {
    pub(crate) dkim_results: authres::DkimResults,
 }

+/// Returns a reference to the encrypted payload of a message.
+fn get_encrypted_mime<'a, 'b>(mail: &'a ParsedMail<'b>) -> Option<&'a ParsedMail<'b>> {
+    get_autocrypt_mime(mail)
+        .or_else(|| get_mixed_up_mime(mail))
+        .or_else(|| get_attachment_mime(mail))
+}
+
 /// Returns a reference to the encrypted payload of a ["Mixed
 /// Up"][pgpmime-message-mangling] message.
 ///
@@ -264,6 +269,7 @@ pub(crate) fn validate_detached_signature<'a, 'b>(
    }
 }

+/// Returns public keyring for `peerstate`.
 pub(crate) fn keyring_from_peerstate(peerstate: Option<&Peerstate>) -> Vec<SignedPublicKey> {
    let mut public_keyring_for_validate = Vec::new();
    if let Some(peerstate) = peerstate {
@@ -291,23 +297,28 @@ pub(crate) async fn get_autocrypt_peerstate(
    autocrypt_header: Option<&Aheader>,
    message_time: i64,
    allow_change: bool,
+    allow_aeap: bool,
 ) -> Result<Option<Peerstate>> {
+    let allow_change = allow_change && !context.is_self_addr(from).await?;
    let mut peerstate;

    // Apply Autocrypt header
    if let Some(header) = autocrypt_header {
-        // The "from_verified_fingerprint" part is for AEAP:
-        // If we know this fingerprint from another addr,
-        // we may want to do a transition from this other addr
-        // (and keep its peerstate)
-        // For security reasons, for now, we only do a transition
-        // if the fingerprint is verified.
-        peerstate = Peerstate::from_verified_fingerprint_or_addr(
-            context,
-            &header.public_key.fingerprint(),
-            from,
-        )
-        .await?;
+        if allow_aeap {
+            // If we know this fingerprint from another addr,
+            // we may want to do a transition from this other addr
+            // (and keep its peerstate)
+            // For security reasons, for now, we only do a transition
+            // if the fingerprint is verified.
+            peerstate = Peerstate::from_verified_fingerprint_or_addr(
+                context,
+                &header.public_key.fingerprint(),
+                from,
+            )
+            .await?;
+        } else {
+            peerstate = Peerstate::from_addr(context, from).await?;
+        }

        if let Some(ref mut peerstate) = peerstate {
            if addr_cmp(&peerstate.addr, from) {
--- 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.
@@ -296,7 +301,7 @@ fn dehtml_starttag_cb<B: std::io::BufRead>(
                let href = href
                    .decode_and_unescape_value(reader)
                    .unwrap_or_default()
-                    .to_lowercase();
+                    .to_string();

                if !href.is_empty() {
                    dehtml.last_href = Some(href);
@@ -458,6 +463,13 @@ mod tests {
        assert_eq!(plain, "[text](url)");
    }

+    #[test]
+    fn test_dehtml_case_sensitive_link() {
+        let html = "<html><A HrEf=\"https://foo.bar/Data\">case in URLs matter</A></html>";
+        let plain = dehtml(html).unwrap().text;
+        assert_eq!(plain, "[case in URLs matter](https://foo.bar/Data)");
+    }
+
    #[test]
    fn test_dehtml_bold_text() {
        let html = "<!DOCTYPE name [<!DOCTYPE ...>]><!-- comment -->text <b><?php echo ... ?>bold</b><![CDATA[<>]]>";
@@ -527,6 +539,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
@@ -3,13 +3,13 @@
 use std::cmp::max;
 use std::collections::BTreeMap;

-use anyhow::{anyhow, Result};
+use anyhow::{anyhow, bail, Result};
 use deltachat_derive::{FromSql, ToSql};
 use serde::{Deserialize, Serialize};

 use crate::config::Config;
 use crate::context::Context;
-use crate::imap::{Imap, ImapActionResult};
+use crate::imap::session::Session;
 use crate::message::{Message, MsgId, Viewtype};
 use crate::mimeparser::{MimeMessage, Part};
 use crate::tools::time;
@@ -129,40 +129,44 @@ impl Message {
 /// Actually download a message partially downloaded before.
 ///
 /// Most messages are downloaded automatically on fetch instead.
-pub(crate) async fn download_msg(context: &Context, msg_id: MsgId, imap: &mut Imap) -> Result<()> {
-    imap.prepare(context).await?;
-
+pub(crate) async fn download_msg(
+    context: &Context,
+    msg_id: MsgId,
+    session: &mut Session,
+) -> Result<()> {
    let msg = Message::load_from_db(context, msg_id).await?;
    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?;

-    let Some((server_uid, server_folder)) = row else {
+    let Some((server_uid, server_folder, uidvalidity)) = row else {
        // No IMAP record found, we don't know the UID and folder.
        return Err(anyhow!("Call download_full() again to try over."));
    };

-    match imap
-        .fetch_single_msg(context, &server_folder, server_uid, msg.rfc724_mid.clone())
-        .await
-    {
-        ImapActionResult::RetryLater | ImapActionResult::Failed => {
-            Err(anyhow!("Call download_full() again to try over."))
-        }
-        ImapActionResult::Success => Ok(()),
-    }
+    session
+        .fetch_single_msg(
+            context,
+            &server_folder,
+            uidvalidity,
+            server_uid,
+            msg.rfc724_mid.clone(),
+        )
+        .await?;
+    Ok(())
 }

-impl Imap {
+impl Session {
    /// Download a single message and pipe it to receive_imf().
    ///
    /// receive_imf() is not directly aware that this is a result of a call to download_msg(),
@@ -171,33 +175,36 @@ impl Imap {
        &mut self,
        context: &Context,
        folder: &str,
+        uidvalidity: u32,
        uid: u32,
        rfc724_mid: String,
-    ) -> ImapActionResult {
-        if let Some(imapresult) = self
-            .prepare_imap_operation_on_msg(context, folder, uid)
-            .await
-        {
-            return imapresult;
+    ) -> Result<()> {
+        if uid == 0 {
+            bail!("Attempt to fetch UID 0");
        }

+        self.select_folder(context, Some(folder)).await?;
+
        // we are connected, and the folder is selected
        info!(context, "Downloading message {}/{} fully...", folder, uid);

        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)
-            .await
-        {
-            Ok(res) => res,
-            Err(_) => return ImapActionResult::Failed,
-        };
+        let (last_uid, _received) = self
+            .fetch_many_msgs(
+                context,
+                folder,
+                uidvalidity,
+                vec![uid],
+                &uid_message_ids,
+                false,
+                false,
+            )
+            .await?;
        if last_uid.is_none() {
-            ImapActionResult::Failed
-        } else {
-            ImapActionResult::Success
+            bail!("Failed to fetch UID {uid}");
        }
+        Ok(())
    }
 }

@@ -246,8 +253,7 @@ mod tests {
    use super::*;
    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]
@@ -328,7 +334,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(),
@@ -344,7 +350,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(),
@@ -373,7 +379,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\
@@ -416,7 +422,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(),
@@ -432,7 +438,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(),
@@ -483,7 +489,7 @@ mod tests {
            ";

        // not downloading the mdn results in an placeholder
-        receive_imf_inner(
+        receive_imf_from_inbox(
            &bob,
            "bar@example.org",
            raw,
@@ -499,7 +505,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
@@ -95,6 +95,7 @@ impl EncryptHelper {
        verified: bool,
        mail_to_encrypt: lettre_email::PartBuilder,
        peerstates: Vec<(Option<Peerstate>, String)>,
+        compress: bool,
    ) -> Result<String> {
        let mut keyring: Vec<SignedPublicKey> = Vec::new();

@@ -135,7 +136,7 @@ impl EncryptHelper {

        let raw_message = mail_to_encrypt.build().as_string().into_bytes();

-        let ctext = pgp::pk_encrypt(&raw_message, keyring, Some(sign_key)).await?;
+        let ctext = pgp::pk_encrypt(&raw_message, keyring, Some(sign_key), compress).await?;

        Ok(ctext)
    }
--- a/src/ephemeral.rs
+++ b/src/ephemeral.rs
@@ -64,10 +64,10 @@

 use std::cmp::max;
 use std::collections::BTreeSet;
-use std::convert::{TryFrom, TryInto};
+use std::fmt;
 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)]
@@ -131,9 +131,9 @@ impl Default for Timer {
    }
 }

-impl ToString for Timer {
-    fn to_string(&self) -> String {
-        self.to_u32().to_string()
+impl fmt::Display for Timer {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.to_u32())
    }
 }

@@ -569,9 +569,21 @@ pub(crate) async fn ephemeral_loop(context: &Context, interrupt_receiver: Receiv
                "Ephemeral loop waiting for deletion in {} or interrupt",
                duration_to_str(duration)
            );
-            if timeout(duration, interrupt_receiver.recv()).await.is_ok() {
-                // received an interruption signal, recompute waiting time (if any)
-                continue;
+            match timeout(duration, interrupt_receiver.recv()).await {
+                Ok(Ok(())) => {
+                    // received an interruption signal, recompute waiting time (if any)
+                    continue;
+                }
+                Ok(Err(err)) => {
+                    warn!(
+                        context,
+                        "Interrupt channel closed, ephemeral loop exits now: {err:#}."
+                    );
+                    return;
+                }
+                Err(_err) => {
+                    // Timeout.
+                }
            }
        }

@@ -590,7 +602,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 +1143,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 +1229,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
@@ -107,10 +107,7 @@ pub enum EventType {
    },

    /// Downloading a bunch of messages just finished.
-    IncomingMsgBunch {
-        /// List of incoming message IDs.
-        msg_ids: Vec<MsgId>,
-    },
+    IncomingMsgBunch,

    /// Messages were seen or noticed.
    /// chat id is always set.
@@ -287,4 +284,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 {
@@ -74,6 +74,11 @@ pub enum HeaderDef {
    Autocrypt,
    AutocryptSetupMessage,
    SecureJoin,
+
+    /// Deprecated header containing Group-ID in `vg-request-with-auth` message.
+    ///
+    /// It is not used by Alice as Alice knows the group corresponding to the AUTH token.
+    /// Bob still sends it for backwards compatibility.
    SecureJoinGroup,
    SecureJoinFingerprint,
    SecureJoinInvitenumber,
@@ -88,9 +93,6 @@ pub enum HeaderDef {
    /// See <https://datatracker.ietf.org/doc/html/rfc8601>
    AuthenticationResults,

-    /// Public key to join gossip network.
-    IrohPublicGossip,
-
    #[cfg(test)]
    TestHeader,
 }
--- a/src/html.rs
+++ b/src/html.rs
@@ -7,13 +7,9 @@
 //! `MsgId.get_html()` will return HTML -
 //! this allows nice quoting, handling linebreaks properly etc.

-use std::future::Future;
-use std::pin::Pin;
-
 use anyhow::{Context as _, Result};
 use base64::Engine as _;
-use futures::future::FutureExt;
-use lettre_email::mime::{self, Mime};
+use lettre_email::mime::Mime;
 use lettre_email::PartBuilder;
 use mailparse::ParsedContentType;

@@ -67,7 +63,7 @@ enum MimeMultipartType {
 /// and checks and returns the rough mime-type.
 fn get_mime_multipart_type(ctype: &ParsedContentType) -> MimeMultipartType {
    let mimetype = ctype.mimetype.to_lowercase();
-    if mimetype.starts_with("multipart") && ctype.params.get("boundary").is_some() {
+    if mimetype.starts_with("multipart") && ctype.params.contains_key("boundary") {
        MimeMultipartType::Multiple
    } else if mimetype == "message/rfc822" {
        MimeMultipartType::Message
@@ -116,119 +112,109 @@ impl HtmlMsgParser {
    /// Usually, there is at most one plain-text and one HTML-text part,
    /// multiple plain-text parts might be used for mailinglist-footers,
    /// therefore we use the first one.
-    fn collect_texts_recursive<'a>(
+    async fn collect_texts_recursive<'a>(
        &'a mut self,
        mail: &'a mailparse::ParsedMail<'a>,
-    ) -> Pin<Box<dyn Future<Output = Result<()>> + 'a + Send>> {
-        // Boxed future to deal with recursion
-        async move {
-            match get_mime_multipart_type(&mail.ctype) {
-                MimeMultipartType::Multiple => {
-                    for cur_data in &mail.subparts {
-                        self.collect_texts_recursive(cur_data).await?
-                    }
-                    Ok(())
+    ) -> Result<()> {
+        match get_mime_multipart_type(&mail.ctype) {
+            MimeMultipartType::Multiple => {
+                for cur_data in &mail.subparts {
+                    Box::pin(self.collect_texts_recursive(cur_data)).await?
                }
-                MimeMultipartType::Message => {
-                    let raw = mail.get_body_raw()?;
-                    if raw.is_empty() {
-                        return Ok(());
-                    }
-                    let mail = mailparse::parse_mail(&raw).context("failed to parse mail")?;
-                    self.collect_texts_recursive(&mail).await
+                Ok(())
+            }
+            MimeMultipartType::Message => {
+                let raw = mail.get_body_raw()?;
+                if raw.is_empty() {
+                    return Ok(());
                }
-                MimeMultipartType::Single => {
-                    let mimetype = mail.ctype.mimetype.parse::<Mime>()?;
-                    if mimetype == mime::TEXT_HTML {
-                        if self.html.is_empty() {
-                            if let Ok(decoded_data) = mail.get_body() {
-                                self.html = decoded_data;
-                            }
-                        }
-                    } else if mimetype == mime::TEXT_PLAIN && self.plain.is_none() {
+                let mail = mailparse::parse_mail(&raw).context("failed to parse mail")?;
+                Box::pin(self.collect_texts_recursive(&mail)).await
+            }
+            MimeMultipartType::Single => {
+                let mimetype = mail.ctype.mimetype.parse::<Mime>()?;
+                if mimetype == mime::TEXT_HTML {
+                    if self.html.is_empty() {
                        if let Ok(decoded_data) = mail.get_body() {
-                            self.plain = Some(PlainText {
-                                text: decoded_data,
-                                flowed: if let Some(format) = mail.ctype.params.get("format") {
-                                    format.as_str().to_ascii_lowercase() == "flowed"
-                                } else {
-                                    false
-                                },
-                                delsp: if let Some(delsp) = mail.ctype.params.get("delsp") {
-                                    delsp.as_str().to_ascii_lowercase() == "yes"
-                                } else {
-                                    false
-                                },
-                            });
+                            self.html = decoded_data;
                        }
                    }
-                    Ok(())
+                } else if mimetype == mime::TEXT_PLAIN && self.plain.is_none() {
+                    if let Ok(decoded_data) = mail.get_body() {
+                        self.plain = Some(PlainText {
+                            text: decoded_data,
+                            flowed: if let Some(format) = mail.ctype.params.get("format") {
+                                format.as_str().to_ascii_lowercase() == "flowed"
+                            } else {
+                                false
+                            },
+                            delsp: if let Some(delsp) = mail.ctype.params.get("delsp") {
+                                delsp.as_str().to_ascii_lowercase() == "yes"
+                            } else {
+                                false
+                            },
+                        });
+                    }
                }
+                Ok(())
            }
        }
-        .boxed()
    }

    /// Replace cid:-protocol by the data:-protocol where appropriate.
    /// This allows the final html-file to be self-contained.
-    fn cid_to_data_recursive<'a>(
+    async fn cid_to_data_recursive<'a>(
        &'a mut self,
        context: &'a Context,
        mail: &'a mailparse::ParsedMail<'a>,
-    ) -> Pin<Box<dyn Future<Output = Result<()>> + 'a + Send>> {
-        // Boxed future to deal with recursion
-        async move {
-            match get_mime_multipart_type(&mail.ctype) {
-                MimeMultipartType::Multiple => {
-                    for cur_data in &mail.subparts {
-                        self.cid_to_data_recursive(context, cur_data).await?;
-                    }
-                    Ok(())
+    ) -> Result<()> {
+        match get_mime_multipart_type(&mail.ctype) {
+            MimeMultipartType::Multiple => {
+                for cur_data in &mail.subparts {
+                    Box::pin(self.cid_to_data_recursive(context, cur_data)).await?;
                }
-                MimeMultipartType::Message => {
-                    let raw = mail.get_body_raw()?;
-                    if raw.is_empty() {
-                        return Ok(());
-                    }
-                    let mail = mailparse::parse_mail(&raw).context("failed to parse mail")?;
-                    self.cid_to_data_recursive(context, &mail).await
+                Ok(())
+            }
+            MimeMultipartType::Message => {
+                let raw = mail.get_body_raw()?;
+                if raw.is_empty() {
+                    return Ok(());
                }
-                MimeMultipartType::Single => {
-                    let mimetype = mail.ctype.mimetype.parse::<Mime>()?;
-                    if mimetype.type_() == mime::IMAGE {
-                        if let Some(cid) = mail.headers.get_header_value(HeaderDef::ContentId) {
-                            if let Ok(cid) = parse_message_id(&cid) {
-                                if let Ok(replacement) = mimepart_to_data_url(mail) {
-                                    let re_string = format!(
-                                        "(<img[^>]*src[^>]*=[^>]*)(cid:{})([^>]*>)",
-                                        regex::escape(&cid)
-                                    );
-                                    match regex::Regex::new(&re_string) {
-                                        Ok(re) => {
-                                            self.html = re
-                                                .replace_all(
-                                                    &self.html,
-                                                    format!("${{1}}{replacement}${{3}}").as_str(),
-                                                )
-                                                .as_ref()
-                                                .to_string()
-                                        }
-                                        Err(e) => warn!(
-                                            context,
-                                            "Cannot create regex for cid: {} throws {}",
-                                            re_string,
-                                            e
-                                        ),
+                let mail = mailparse::parse_mail(&raw).context("failed to parse mail")?;
+                Box::pin(self.cid_to_data_recursive(context, &mail)).await
+            }
+            MimeMultipartType::Single => {
+                let mimetype = mail.ctype.mimetype.parse::<Mime>()?;
+                if mimetype.type_() == mime::IMAGE {
+                    if let Some(cid) = mail.headers.get_header_value(HeaderDef::ContentId) {
+                        if let Ok(cid) = parse_message_id(&cid) {
+                            if let Ok(replacement) = mimepart_to_data_url(mail) {
+                                let re_string = format!(
+                                    "(<img[^>]*src[^>]*=[^>]*)(cid:{})([^>]*>)",
+                                    regex::escape(&cid)
+                                );
+                                match regex::Regex::new(&re_string) {
+                                    Ok(re) => {
+                                        self.html = re
+                                            .replace_all(
+                                                &self.html,
+                                                format!("${{1}}{replacement}${{3}}").as_str(),
+                                            )
+                                            .as_ref()
+                                            .to_string()
                                    }
+                                    Err(e) => warn!(
+                                        context,
+                                        "Cannot create regex for cid: {} throws {}", re_string, e
+                                    ),
                                }
                            }
                        }
                    }
-                    Ok(())
                }
+                Ok(())
            }
        }
-        .boxed()
    }
 }

--- a/src/imap.rs
+++ b/src/imap.rs
--- a/src/imap/capabilities.rs
+++ b/src/imap/capabilities.rs
@@ -21,6 +21,17 @@ 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,
+
+    /// True if the server supports XDELTAPUSH capability.
+    /// This capability means setting /private/devicetoken IMAP METADATA
+    /// on the INBOX results in new mail notifications
+    /// via notifications.delta.chat service.
+    /// This is supported by <https://github.com/deltachat/chatmail>
+    pub can_push: 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,8 @@ 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"),
+        can_push: caps.has_str("XDELTAPUSH"),
        server_id,
    };
    Ok(capabilities)
--- a/src/imap/idle.rs
+++ b/src/imap/idle.rs
@@ -1,16 +1,16 @@
-use std::time::{Duration, SystemTime};
+use std::time::Duration;

 use anyhow::{bail, Context as _, Result};
 use async_channel::Receiver;
 use async_imap::extensions::idle::IdleResponse;
 use futures_lite::FutureExt;
+use tokio::time::timeout;

 use super::session::Session;
 use super::Imap;
-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.
@@ -97,97 +97,38 @@ impl Session {
 }

 impl Imap {
+    /// Idle using polling.
    pub(crate) async fn fake_idle(
        &mut self,
        context: &Context,
-        watch_folder: Option<String>,
+        session: &mut Session,
+        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).
+    ) -> Result<()> {
+        let fake_idle_start_time = tools::Time::now();

-        let fake_idle_start_time = SystemTime::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;
-        let mut timeout_ms: u64 = TIMEOUT_INIT_MS;
-        enum Event {
-            Tick,
-            Interrupt,
-        }
-        // loop until we are interrupted or if we fetched something
+        // Loop until we are interrupted or until we fetch something.
        loop {
-            use futures::future::FutureExt;
-            use rand::Rng;
-
-            let mut interval = tokio::time::interval(Duration::from_millis(timeout_ms));
-            timeout_ms = timeout_ms
-                .saturating_add(rand::thread_rng().gen_range((timeout_ms / 2)..=timeout_ms));
-            interval.tick().await; // The first tick completes immediately.
-            match interval
-                .tick()
-                .map(|_| Event::Tick)
-                .race(
-                    self.idle_interrupt_receiver
-                        .recv()
-                        .map(|_| Event::Interrupt),
-                )
-                .await
-            {
-                Event::Tick => {
-                    // try to connect with proper login params
-                    // (setup_handle_if_needed might not know about them if we
-                    // never successfully connected)
-                    if let Err(err) = self.prepare(context).await {
-                        warn!(context, "fake_idle: could not connect: {}", err);
-                        continue;
-                    }
-                    if let Some(session) = &self.session {
-                        if session.can_idle()
-                            && !context
-                                .get_config_bool(Config::DisableIdle)
-                                .await
-                                .context("Failed to get disable_idle config")
-                                .log_err(context)
-                                .unwrap_or_default()
-                        {
-                            // we only fake-idled because network was gone during IDLE, probably
-                            break;
-                        }
-                    }
-                    info!(context, "fake_idle is connected");
-                    // we are connected, let's see if fetching messages results
+            match timeout(Duration::from_secs(60), self.idle_interrupt_receiver.recv()).await {
+                Err(_) => {
+                    // Let's see if fetching messages results
                    // in anything.  If so, we behave as if IDLE had data but
                    // will have already fetched the messages so perform_*_fetch
                    // will not find any new.
-                    match self
-                        .fetch_new_messages(context, &watch_folder, folder_meaning, false)
-                        .await
-                    {
-                        Ok(res) => {
-                            info!(context, "fetch_new_messages returned {:?}", res);
-                            timeout_ms = TIMEOUT_INIT_MS;
-                            if res {
-                                break;
-                            }
-                        }
-                        Err(err) => {
-                            error!(context, "could not fetch from folder: {:#}", err);
-                            self.trigger_reconnect(context);
-                        }
+                    let res = self
+                        .fetch_new_messages(context, session, &watch_folder, folder_meaning, false)
+                        .await?;
+
+                    info!(context, "fetch_new_messages returned {:?}", res);
+
+                    if res {
+                        break;
                    }
                }
-                Event::Interrupt => {
-                    info!(context, "Fake IDLE interrupted");
+                Ok(_) => {
+                    info!(context, "Fake IDLE interrupted.");
                    break;
                }
            }
@@ -196,11 +137,8 @@ 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.,
        );
+        Ok(())
    }
 }
--- a/src/imap/scan_folders.rs
+++ b/src/imap/scan_folders.rs
@@ -1,21 +1,25 @@
-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::imap::{session::Session, Imap};
 use crate::log::LogExt;
+use crate::tools::{self, time_elapsed};
 use crate::{context::Context, imap::FolderMeaning};

 impl Imap {
    /// Returns true if folders were scanned, false if scanning was postponed.
-    pub(crate) async fn scan_folders(&mut self, context: &Context) -> Result<bool> {
+    pub(crate) async fn scan_folders(
+        &mut self,
+        context: &Context,
+        session: &mut Session,
+    ) -> Result<bool> {
        // 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?;
@@ -26,8 +30,7 @@ impl Imap {
        }
        info!(context, "Starting full folder scan");

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

        let mut folder_configs = BTreeMap::new();
@@ -63,18 +66,16 @@ impl Imap {
                && folder_meaning != FolderMeaning::Drafts
                && folder_meaning != FolderMeaning::Trash
            {
-                let session = self.session.as_mut().context("no session")?;
                // Drain leftover unsolicited EXISTS messages
                session.server_sent_unsolicited_exists(context)?;

                loop {
-                    self.fetch_move_delete(context, folder.name(), folder_meaning)
+                    self.fetch_move_delete(context, session, folder.name(), folder_meaning)
                        .await
                        .context("Can't fetch new msgs in scanned folder")
                        .log_err(context)
                        .ok();

-                    let session = self.session.as_mut().context("no session")?;
                    // If the server sent an unsocicited EXISTS during the fetch, we need to fetch again
                    if !session.server_sent_unsolicited_exists(context)? {
                        break;
@@ -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>;
@@ -51,7 +52,7 @@ impl ImapSession {
    /// Selects a folder, possibly updating uid_validity and, if needed,
    /// expunging the folder to remove delete-marked messages.
    /// Returns whether a new folder was selected.
-    pub(super) async fn select_folder(
+    pub(crate) async fn select_folder(
        &mut self,
        context: &Context,
        folder: Option<&str>,
@@ -112,20 +113,150 @@ 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)]
-pub(super) enum NewlySelected {
+pub(crate) enum NewlySelected {
    /// The folder was newly selected during this call to select_folder().
    Yes,
    /// No SELECT command was run because the folder already was selected
--- a/Show More
+++ b/Show More
@@ -1 +1 @@
 -01-21
 -04-05