fix: prevent reuse of the stream after an error

When a stream timeouts, `tokio_io_timeout::TimeoutStream` returns an error once, but then allows to keep using the stream, e.g. calling `poll_read()` again. This can be dangerous if the error is ignored. For example in case of IMAP stream, if IMAP command is sent, but then reading the response times out and the error is ignored, it is possible to send another IMAP command. In this case leftover response from a previous command may be read and interpreted as the response to the new IMAP command. ErrorCapturingStream wraps the stream to prevent its reuse after an error.
2026-08-13 04:42:05 +03:00 · 2025-07-19 13:44:00 +00:00
627 changed files with 31417 additions and 42243 deletions
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -7,14 +7,10 @@ updates:
    commit-message:
      prefix: "chore(cargo)"
    open-pull-requests-limit: 50
-    cooldown:
-      default-days: 7

  # Keep GitHub Actions up to date.
  # <https://docs.github.com/en/code-security/dependabot/working-with-dependabot/keeping-your-actions-up-to-date-with-dependabot>
  - package-ecosystem: "github-actions"
    directory: "/"
    schedule:
-      interval: "monthly"
-    cooldown:
-      default-days: 7
+      interval: "weekly"
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -20,18 +20,17 @@ permissions: {}

 env:
  RUSTFLAGS: -Dwarnings
-  RUST_VERSION: 1.97.1
+  RUST_VERSION: 1.88.0

  # Minimum Supported Rust Version
-  MSRV: 1.89.0
+  MSRV: 1.85.0

 jobs:
  lint_rust:
    name: Lint Rust
    runs-on: ubuntu-latest
-    timeout-minutes: 60
    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
        with:
          show-progress: false
          persist-credentials: false
@@ -40,10 +39,7 @@ jobs:
      - run: rustup override set $RUST_VERSION
        shell: bash
      - name: Cache rust cargo artifacts
-        uses: swatinem/rust-cache@c19371144df3bb44fab255c43d04cbc2ab54d1c4
-        with:
-          save-if: ${{ github.ref == 'refs/heads/main' }}
-          cache-bin: false
+        uses: swatinem/rust-cache@v2
      - name: Run rustfmt
        run: cargo fmt --all -- --check
      - name: Run clippy
@@ -56,34 +52,40 @@ jobs:
  cargo_deny:
    name: cargo deny
    runs-on: ubuntu-latest
-    timeout-minutes: 60
    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
        with:
          show-progress: false
          persist-credentials: false
-      - uses: EmbarkStudios/cargo-deny-action@3c6349835b2b7b196a839186cb8b78e02f7b5f25
+      - uses: EmbarkStudios/cargo-deny-action@v2
        with:
-          arguments: --workspace --all-features --locked
+          arguments: --all-features --workspace
          command: check
          command-arguments: "-Dwarnings"

+  provider_database:
+    name: Check provider database
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          show-progress: false
+          persist-credentials: false
+      - name: Check provider database
+        run: scripts/update-provider-database.sh
+
  docs:
    name: Rust doc comments
    runs-on: ubuntu-latest
-    timeout-minutes: 60
    env:
      RUSTDOCFLAGS: -Dwarnings
    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
        with:
          show-progress: false
          persist-credentials: false
      - name: Cache rust cargo artifacts
-        uses: swatinem/rust-cache@c19371144df3bb44fab255c43d04cbc2ab54d1c4
-        with:
-          save-if: ${{ github.ref == 'refs/heads/main' }}
-          cache-bin: false
+        uses: swatinem/rust-cache@v2
      - name: Rustdoc
        run: cargo doc --document-private-items --no-deps

@@ -103,7 +105,6 @@ jobs:
          - os: ubuntu-latest
            rust: minimum
    runs-on: ${{ matrix.os }}
-    timeout-minutes: 60
    steps:
      - run:
          echo "RUSTUP_TOOLCHAIN=$MSRV" >> $GITHUB_ENV
@@ -114,7 +115,7 @@ jobs:
        shell: bash
        if: matrix.rust == 'latest'

-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
        with:
          show-progress: false
          persist-credentials: false
@@ -126,25 +127,22 @@ jobs:
        shell: bash

      - name: Cache rust cargo artifacts
-        uses: swatinem/rust-cache@c19371144df3bb44fab255c43d04cbc2ab54d1c4
-        with:
-          save-if: ${{ github.ref == 'refs/heads/main' }}
-          cache-bin: false
+        uses: swatinem/rust-cache@v2

      - name: Install nextest
-        uses: taiki-e/install-action@3d7d7cd5ac7f994c1892ae0c06165095b9139094
+        uses: taiki-e/install-action@v2
        with:
          tool: nextest

      - name: Tests
        env:
          RUST_BACKTRACE: 1
-        run: cargo nextest run --workspace --locked
+        run: cargo nextest run --workspace

      - name: Doc-Tests
        env:
          RUST_BACKTRACE: 1
-        run: cargo test --workspace --locked --doc
+        run: cargo test --workspace --doc

      - name: Test cargo vendor
        run: cargo vendor
@@ -155,24 +153,20 @@ jobs:
      matrix:
        os: [ubuntu-latest, macos-latest]
    runs-on: ${{ matrix.os }}
-    timeout-minutes: 60
    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
        with:
          show-progress: false
          persist-credentials: false

      - name: Cache rust cargo artifacts
-        uses: swatinem/rust-cache@c19371144df3bb44fab255c43d04cbc2ab54d1c4
-        with:
-          save-if: ${{ github.ref == 'refs/heads/main' }}
-          cache-bin: false
+        uses: swatinem/rust-cache@v2

      - name: Build C library
-        run: cargo build -p deltachat_ffi --locked
+        run: cargo build -p deltachat_ffi

      - name: Upload C library
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@v4
        with:
          name: ${{ matrix.os }}-libdeltachat.a
          path: target/debug/libdeltachat.a
@@ -184,24 +178,20 @@ jobs:
      matrix:
        os: [ubuntu-latest, macos-latest, windows-latest]
    runs-on: ${{ matrix.os }}
-    timeout-minutes: 60
    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
        with:
          show-progress: false
          persist-credentials: false

      - name: Cache rust cargo artifacts
-        uses: swatinem/rust-cache@c19371144df3bb44fab255c43d04cbc2ab54d1c4
-        with:
-          save-if: ${{ github.ref == 'refs/heads/main' }}
-          cache-bin: false
+        uses: swatinem/rust-cache@v2

      - name: Build deltachat-rpc-server
-        run: cargo build -p deltachat-rpc-server --locked
+        run: cargo build -p deltachat-rpc-server

      - name: Upload deltachat-rpc-server
-        uses: actions/upload-artifact@v7
+        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' }}
@@ -210,9 +200,8 @@ jobs:
  python_lint:
    name: Python lint
    runs-on: ubuntu-latest
-    timeout-minutes: 60
    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
        with:
          show-progress: false
          persist-credentials: false
@@ -228,38 +217,6 @@ jobs:
        working-directory: deltachat-rpc-client
        run: tox -e lint

-  # mypy does not work with PyPy since mypy 1.19
-  # as it introduced native `librt` dependency
-  # that uses CPython internals.
-  # We only run mypy with CPython because of this.
-  cffi_python_mypy:
-    name: CFFI Python mypy
-    needs: ["c_library", "python_lint"]
-    runs-on: ubuntu-latest
-    timeout-minutes: 60
-    steps:
-      - uses: actions/checkout@v7
-        with:
-          show-progress: false
-          persist-credentials: false
-
-      - name: Download libdeltachat.a
-        uses: actions/download-artifact@v7
-        with:
-          name: ubuntu-latest-libdeltachat.a
-          path: target/debug
-
-      - name: Install tox
-        run: pip install tox
-
-      - name: Run mypy
-        env:
-          DCC_RS_TARGET: debug
-          DCC_RS_DEV: ${{ github.workspace }}
-        working-directory: python
-        run: tox -e mypy
-
-
  cffi_python_tests:
    name: CFFI Python tests
    needs: ["c_library", "python_lint"]
@@ -269,9 +226,9 @@ jobs:
        include:
          # Currently used Rust version.
          - os: ubuntu-latest
-            python: 3.14
+            python: 3.13
          - os: macos-latest
-            python: 3.14
+            python: 3.13

          # PyPy tests
          - os: ubuntu-latest
@@ -279,28 +236,27 @@ jobs:
          - os: macos-latest
            python: pypy3.10

-          # Minimum Supported Python Version = 3.10
+          # Minimum Supported Python Version = 3.8
          # This is the minimum version for which manylinux Python wheels are
          # built. Test it with minimum supported Rust version.
          - os: ubuntu-latest
-            python: "3.10"
+            python: 3.8

    runs-on: ${{ matrix.os }}
-    timeout-minutes: 60
    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
        with:
          show-progress: false
          persist-credentials: false

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

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

@@ -313,7 +269,7 @@ jobs:
          DCC_RS_TARGET: debug
          DCC_RS_DEV: ${{ github.workspace }}
        working-directory: python
-        run: tox -e doc,py
+        run: tox -e mypy,doc,py

  rpc_python_tests:
    name: JSON-RPC Python tests
@@ -323,11 +279,11 @@ jobs:
      matrix:
        include:
          - os: ubuntu-latest
-            python: 3.14
+            python: 3.13
          - os: macos-latest
-            python: 3.14
+            python: 3.13
          - os: windows-latest
-            python: 3.14
+            python: 3.13

          # PyPy tests
          - os: ubuntu-latest
@@ -335,20 +291,19 @@ jobs:
          - os: macos-latest
            python: pypy3.10

-          # Minimum Supported Python Version = 3.10
+          # Minimum Supported Python Version = 3.8
          - os: ubuntu-latest
-            python: "3.10"
+            python: 3.8

    runs-on: ${{ matrix.os }}
-    timeout-minutes: 60
    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
        with:
          show-progress: false
          persist-credentials: false

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

@@ -356,7 +311,7 @@ jobs:
        run: pip install tox

      - name: Download deltachat-rpc-server
-        uses: actions/download-artifact@v7
+        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
@@ -30,46 +30,22 @@ jobs:
        arch: [aarch64, armv7l, armv6l, i686, x86_64]
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
        with:
          show-progress: false
          persist-credentials: false
-      - uses: cachix/install-nix-action@630ae543ea3a38a9a4166f03376c02c50f408342 # v31.11.0
+      - uses: DeterminateSystems/nix-installer-action@main

      - name: Build deltachat-rpc-server binaries
        run: nix build .#deltachat-rpc-server-${{ matrix.arch }}-linux

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

-  build_linux_wheel:
-    name: Linux wheel
-    strategy:
-      fail-fast: false
-      matrix:
-        arch: [aarch64, armv7l, armv6l, i686, x86_64]
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v7
-        with:
-          show-progress: false
-          persist-credentials: false
-      - uses: cachix/install-nix-action@630ae543ea3a38a9a4166f03376c02c50f408342 # v31.11.0
-
-      - name: Build deltachat-rpc-server wheels
-        run: nix build .#deltachat-rpc-server-${{ matrix.arch }}-linux-wheel
-
-      - name: Upload wheel
-        uses: actions/upload-artifact@v7
-        with:
-          name: deltachat-rpc-server-${{ matrix.arch }}-linux-wheel
-          path: result/*.whl
-          if-no-files-found: error
-
  build_windows:
    name: Windows
    strategy:
@@ -78,46 +54,22 @@ jobs:
        arch: [win32, win64]
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
        with:
          show-progress: false
          persist-credentials: false
-      - uses: cachix/install-nix-action@630ae543ea3a38a9a4166f03376c02c50f408342 # v31.11.0
+      - uses: DeterminateSystems/nix-installer-action@main

      - name: Build deltachat-rpc-server binaries
        run: nix build .#deltachat-rpc-server-${{ matrix.arch }}

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

-  build_windows_wheel:
-    name: Windows wheel
-    strategy:
-      fail-fast: false
-      matrix:
-        arch: [win32, win64]
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v7
-        with:
-          show-progress: false
-          persist-credentials: false
-      - uses: cachix/install-nix-action@630ae543ea3a38a9a4166f03376c02c50f408342 # v31.11.0
-
-      - name: Build deltachat-rpc-server wheels
-        run: nix build .#deltachat-rpc-server-${{ matrix.arch }}-wheel
-
-      - name: Upload wheel
-        uses: actions/upload-artifact@v7
-        with:
-          name: deltachat-rpc-server-${{ matrix.arch }}-wheel
-          path: result/*.whl
-          if-no-files-found: error
-
  build_macos:
    name: macOS
    strategy:
@@ -127,7 +79,7 @@ jobs:

    runs-on: macos-latest
    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
        with:
          show-progress: false
          persist-credentials: false
@@ -139,7 +91,7 @@ jobs:
        run: cargo build --release --package deltachat-rpc-server --target ${{ matrix.arch }}-apple-darwin --features vendored

      - name: Upload binary
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@v4
        with:
          name: deltachat-rpc-server-${{ matrix.arch }}-macos
          path: target/${{ matrix.arch }}-apple-darwin/release/deltachat-rpc-server
@@ -153,49 +105,25 @@ jobs:
        arch: [arm64-v8a, armeabi-v7a]
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
        with:
          show-progress: false
          persist-credentials: false
-      - uses: cachix/install-nix-action@630ae543ea3a38a9a4166f03376c02c50f408342 # v31.11.0
+      - uses: DeterminateSystems/nix-installer-action@main

      - name: Build deltachat-rpc-server binaries
        run: nix build .#deltachat-rpc-server-${{ matrix.arch }}-android

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

-  build_android_wheel:
-    name: Android wheel
-    strategy:
-      fail-fast: false
-      matrix:
-        arch: [arm64-v8a, armeabi-v7a]
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v7
-        with:
-          show-progress: false
-          persist-credentials: false
-      - uses: cachix/install-nix-action@630ae543ea3a38a9a4166f03376c02c50f408342 # v31.11.0
-
-      - name: Build deltachat-rpc-server wheels
-        run: nix build .#deltachat-rpc-server-${{ matrix.arch }}-android-wheel
-
-      - name: Upload wheel
-        uses: actions/upload-artifact@v7
-        with:
-          name: deltachat-rpc-server-${{ matrix.arch }}-android-wheel
-          path: result/*.whl
-          if-no-files-found: error
-
  publish:
    name: Build wheels and upload binaries to the release
-    needs: ["build_linux", "build_linux_wheel", "build_windows", "build_windows_wheel", "build_macos", "build_android", "build_android_wheel"]
+    needs: ["build_linux", "build_windows", "build_macos"]
    environment:
      name: pypi
      url: https://pypi.org/p/deltachat-rpc-server
@@ -204,132 +132,78 @@ jobs:
      contents: write
    runs-on: "ubuntu-latest"
    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
        with:
          show-progress: false
          persist-credentials: false
-      - uses: cachix/install-nix-action@630ae543ea3a38a9a4166f03376c02c50f408342 # v31.11.0
+      - uses: DeterminateSystems/nix-installer-action@main

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

-      - name: Download Linux aarch64 wheel
-        uses: actions/download-artifact@v7
-        with:
-          name: deltachat-rpc-server-aarch64-linux-wheel
-          path: deltachat-rpc-server-aarch64-linux-wheel.d
-
      - name: Download Linux armv7l binary
-        uses: actions/download-artifact@v7
+        uses: actions/download-artifact@v4
        with:
          name: deltachat-rpc-server-armv7l-linux
          path: deltachat-rpc-server-armv7l-linux.d

-      - name: Download Linux armv7l wheel
-        uses: actions/download-artifact@v7
-        with:
-          name: deltachat-rpc-server-armv7l-linux-wheel
-          path: deltachat-rpc-server-armv7l-linux-wheel.d
-
      - name: Download Linux armv6l binary
-        uses: actions/download-artifact@v7
+        uses: actions/download-artifact@v4
        with:
          name: deltachat-rpc-server-armv6l-linux
          path: deltachat-rpc-server-armv6l-linux.d

-      - name: Download Linux armv6l wheel
-        uses: actions/download-artifact@v7
-        with:
-          name: deltachat-rpc-server-armv6l-linux-wheel
-          path: deltachat-rpc-server-armv6l-linux-wheel.d
-
      - name: Download Linux i686 binary
-        uses: actions/download-artifact@v7
+        uses: actions/download-artifact@v4
        with:
          name: deltachat-rpc-server-i686-linux
          path: deltachat-rpc-server-i686-linux.d

-      - name: Download Linux i686 wheel
-        uses: actions/download-artifact@v7
-        with:
-          name: deltachat-rpc-server-i686-linux-wheel
-          path: deltachat-rpc-server-i686-linux-wheel.d
-
      - name: Download Linux x86_64 binary
-        uses: actions/download-artifact@v7
+        uses: actions/download-artifact@v4
        with:
          name: deltachat-rpc-server-x86_64-linux
          path: deltachat-rpc-server-x86_64-linux.d

-      - name: Download Linux x86_64 wheel
-        uses: actions/download-artifact@v7
-        with:
-          name: deltachat-rpc-server-x86_64-linux-wheel
-          path: deltachat-rpc-server-x86_64-linux-wheel.d
-
      - name: Download Win32 binary
-        uses: actions/download-artifact@v7
+        uses: actions/download-artifact@v4
        with:
          name: deltachat-rpc-server-win32
          path: deltachat-rpc-server-win32.d

-      - name: Download Win32 wheel
-        uses: actions/download-artifact@v7
-        with:
-          name: deltachat-rpc-server-win32-wheel
-          path: deltachat-rpc-server-win32-wheel.d
-
      - name: Download Win64 binary
-        uses: actions/download-artifact@v7
+        uses: actions/download-artifact@v4
        with:
          name: deltachat-rpc-server-win64
          path: deltachat-rpc-server-win64.d

-      - name: Download Win64 wheel
-        uses: actions/download-artifact@v7
-        with:
-          name: deltachat-rpc-server-win64-wheel
-          path: deltachat-rpc-server-win64-wheel.d
-
      - name: Download macOS binary for x86_64
-        uses: actions/download-artifact@v7
+        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@v7
+        uses: actions/download-artifact@v4
        with:
          name: deltachat-rpc-server-aarch64-macos
          path: deltachat-rpc-server-aarch64-macos.d

      - name: Download Android binary for arm64-v8a
-        uses: actions/download-artifact@v7
+        uses: actions/download-artifact@v4
        with:
          name: deltachat-rpc-server-arm64-v8a-android
          path: deltachat-rpc-server-arm64-v8a-android.d

-      - name: Download Android wheel for arm64-v8a
-        uses: actions/download-artifact@v7
-        with:
-          name: deltachat-rpc-server-arm64-v8a-android-wheel
-          path: deltachat-rpc-server-arm64-v8a-android-wheel.d
-
      - name: Download Android binary for armeabi-v7a
-        uses: actions/download-artifact@v7
+        uses: actions/download-artifact@v4
        with:
          name: deltachat-rpc-server-armeabi-v7a-android
          path: deltachat-rpc-server-armeabi-v7a-android.d

-      - name: Download Android wheel for armeabi-v7a
-        uses: actions/download-artifact@v7
-        with:
-          name: deltachat-rpc-server-armeabi-v7a-android-wheel
-          path: deltachat-rpc-server-armeabi-v7a-android-wheel.d
-
      - name: Create bin/ directory
        run: |
          mkdir -p bin
@@ -348,21 +222,38 @@ jobs:
      - 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@v5
+        with:
+          python-version: 3.12
+
      - name: Install wheel
        run: pip install wheel

-      - name: Build deltachat-rpc-server Python wheels
+      - name: Build deltachat-rpc-server Python wheels and source package
        run: |
          mkdir -p dist
-          mv deltachat-rpc-server-aarch64-linux-wheel.d/*.whl dist/
-          mv deltachat-rpc-server-armv7l-linux-wheel.d/*.whl dist/
-          mv deltachat-rpc-server-armv6l-linux-wheel.d/*.whl dist/
-          mv deltachat-rpc-server-i686-linux-wheel.d/*.whl dist/
-          mv deltachat-rpc-server-x86_64-linux-wheel.d/*.whl dist/
-          mv deltachat-rpc-server-win64-wheel.d/*.whl dist/
-          mv deltachat-rpc-server-win32-wheel.d/*.whl dist/
-          mv deltachat-rpc-server-arm64-v8a-android-wheel.d/*.whl dist/
-          mv deltachat-rpc-server-armeabi-v7a-android-wheel.d/*.whl 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-arm64-v8a-android-wheel
+          cp result/*.whl dist/
+          nix build .#deltachat-rpc-server-armeabi-v7a-android-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/
@@ -380,93 +271,90 @@ jobs:
            --repo ${{ github.repository }} \
            bin/* dist/*

-      - name: Publish deltachat-rpc-server to PyPI
+      - name: Publish deltachat-rpc-client to PyPI
        if: github.event_name == 'release'
-        uses: pypa/gh-action-pypi-publish@ba38be9e461d3875417946c167d0b5f3d385a247
+        uses: pypa/gh-action-pypi-publish@release/v1

  publish_npm_package:
    name: Build & Publish npm prebuilds and deltachat-rpc-server
    needs: ["build_linux", "build_windows", "build_macos"]
    runs-on: "ubuntu-latest"
-    environment:
-      name: npm-stdio-rpc-server
-      url: https://www.npmjs.com/package/@deltachat/stdio-rpc-server
    permissions:
      id-token: write

      # Needed to publish the binaries to the release.
      contents: write
    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
        with:
          show-progress: false
          persist-credentials: false
-      - uses: actions/setup-python@v7.0.0
+      - uses: actions/setup-python@v5
        with:
          python-version: "3.11"

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

      - name: Download Linux armv7l binary
-        uses: actions/download-artifact@v7
+        uses: actions/download-artifact@v4
        with:
          name: deltachat-rpc-server-armv7l-linux
          path: deltachat-rpc-server-armv7l-linux.d

      - name: Download Linux armv6l binary
-        uses: actions/download-artifact@v7
+        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@v7
+        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@v7
+        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@v7
+        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@v7
+        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@v7
+        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@v7
+        uses: actions/download-artifact@v4
        with:
          name: deltachat-rpc-server-aarch64-macos
          path: deltachat-rpc-server-aarch64-macos.d

      - name: Download Android binary for arm64-v8a
-        uses: actions/download-artifact@v7
+        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@v7
+        uses: actions/download-artifact@v4
        with:
          name: deltachat-rpc-server-armeabi-v7a-android
          path: deltachat-rpc-server-armeabi-v7a-android.d
@@ -496,7 +384,7 @@ jobs:
          ls -lah

      - name: Upload to artifacts
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@v4
        with:
          name: deltachat-rpc-server-npm-package
          path: deltachat-rpc-server/npm-package/*.tgz
@@ -513,12 +401,10 @@ jobs:
            deltachat-rpc-server/npm-package/*.tgz

      # Configure Node.js for publishing.
-      # Check <https://docs.npmjs.com/trusted-publishers> for the version requirements.
-      - uses: actions/setup-node@v7
+      - uses: actions/setup-node@v4
        with:
-          node-version: 24
+          node-version: 20
          registry-url: "https://registry.npmjs.org"
-          package-manager-cache: false  # never use caching in release builds

      - name: Publish npm packets for prebuilds and `@deltachat/stdio-rpc-server`
        if: github.event_name == 'release'
@@ -526,3 +412,5 @@ jobs:
        run: |
          ls -lah platform_package
          for platform in *.tgz; do npm publish --provenance "$platform" --access public; done
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
--- a/.github/workflows/dependabot.yml
+++ b/.github/workflows/dependabot.yml
@@ -10,11 +10,11 @@ permissions:
 jobs:
  dependabot:
    runs-on: ubuntu-latest
-    if: github.event.pull_request.user.login == 'dependabot[bot]' && github.repository == github.event.pull_request.head.repo.full_name
+    if: ${{ github.actor == 'dependabot[bot]' }}
    steps:
      - name: Dependabot metadata
        id: metadata
-        uses: dependabot/fetch-metadata@v3.0.0
+        uses: dependabot/fetch-metadata@v2.4.0
        with:
          github-token: "${{ secrets.GITHUB_TOKEN }}"
      - name: Approve a PR
--- a/.github/workflows/dev-version.yml
+++ b/.github/workflows/dev-version.yml
@@ -1,23 +0,0 @@
-# Check that PRs are made against the -dev version.
-# 
-# If this fails, push commit to update the version to -dev to main.
-
-name: Check for -dev version
-
-on:
-  pull_request:
-
-permissions: {}
-
-jobs:
-  check_dev_version:
-    name: Check that current version ends with -dev
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v7
-        with:
-          show-progress: false
-          persist-credentials: false
-
-      - name: Run version-checking script
-        run: scripts/check-dev-version.py
--- a/.github/workflows/jsonrpc-client-npm-package.yml
+++ b/.github/workflows/jsonrpc-client-npm-package.yml
@@ -10,25 +10,19 @@ jobs:
  pack-module:
    name: "Publish @deltachat/jsonrpc-client"
    runs-on: ubuntu-latest
-    environment:
-      name: npm-jsonrpc-client
-      url: https://www.npmjs.com/package/@deltachat/jsonrpc-client
    permissions:
      id-token: write
      contents: read
    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
        with:
          show-progress: false
          persist-credentials: false

-      # Configure Node.js for publishing.
-      # Check <https://docs.npmjs.com/trusted-publishers> for the version requirements.
-      - uses: actions/setup-node@v7
+      - uses: actions/setup-node@v4
        with:
-          node-version: 24
+          node-version: 20
          registry-url: "https://registry.npmjs.org"
-          package-manager-cache: false  # never use caching in release builds

      - name: Install dependencies without running scripts
        working-directory: deltachat-jsonrpc/typescript
@@ -43,3 +37,5 @@ jobs:
      - name: Publish
        working-directory: deltachat-jsonrpc/typescript
        run: npm publish --provenance deltachat-jsonrpc-client-* --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
--- a/.github/workflows/jsonrpc.yml
+++ b/.github/workflows/jsonrpc.yml
@@ -16,19 +16,16 @@ jobs:
  build_and_test:
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
        with:
          show-progress: false
          persist-credentials: false
-      - name: Use Node.js 24
-        uses: actions/setup-node@v7
+      - name: Use Node.js 18.x
+        uses: actions/setup-node@v4
        with:
-          node-version: 24
+          node-version: 18.x
      - name: Add Rust cache
-        uses: swatinem/rust-cache@c19371144df3bb44fab255c43d04cbc2ab54d1c4
-        with:
-          save-if: ${{ github.ref == 'refs/heads/main' }}
-          cache-bin: false
+        uses: Swatinem/rust-cache@v2
      - name: npm install
        working-directory: deltachat-jsonrpc/typescript
        run: npm install
--- a/.github/workflows/nix.yml
+++ b/.github/workflows/nix.yml
@@ -5,12 +5,10 @@ on:
    paths:
      - flake.nix
      - flake.lock
-      - .github/workflows/nix.yml
  push:
    paths:
      - flake.nix
      - flake.lock
-      - .github/workflows/nix.yml
    branches:
      - main

@@ -21,12 +19,15 @@ jobs:
    name: check flake formatting
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
        with:
          show-progress: false
          persist-credentials: false
-      - uses: cachix/install-nix-action@630ae543ea3a38a9a4166f03376c02c50f408342 # v31.11.0
-      - run: nix fmt flake.nix -- --check
+      - uses: DeterminateSystems/nix-installer-action@main
+      - run: nix fmt
+
+      # Check that formatting does not change anything.
+      - run: git diff --exit-code

  build:
    name: nix build
@@ -63,6 +64,7 @@ jobs:
          - deltachat-rpc-server-armv7l-linux-wheel
          - deltachat-rpc-server-i686-linux
          - deltachat-rpc-server-i686-linux-wheel
+          - deltachat-rpc-server-source
          - deltachat-rpc-server-win32
          - deltachat-rpc-server-win32-wheel
          - deltachat-rpc-server-win64
@@ -79,11 +81,11 @@ jobs:
          #- deltachat-rpc-server-x86_64-android
          #- deltachat-rpc-server-x86-android
    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
        with:
          show-progress: false
          persist-credentials: false
-      - uses: cachix/install-nix-action@630ae543ea3a38a9a4166f03376c02c50f408342 # v31.11.0
+      - uses: DeterminateSystems/nix-installer-action@main
      - run: nix build .#${{ matrix.installable }}

  build-macos:
@@ -94,15 +96,14 @@ jobs:
      matrix:
        installable:
          - deltachat-rpc-server
-          - deltachat-rpc-server-x86_64-darwin

-          # Fails to build
-          # because of <https://github.com/NixOS/nixpkgs/issues/413910>.
+          # Fails to bulid
          # - deltachat-rpc-server-aarch64-darwin
+          # - deltachat-rpc-server-x86_64-darwin
    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
        with:
          show-progress: false
          persist-credentials: false
-      - uses: cachix/install-nix-action@630ae543ea3a38a9a4166f03376c02c50f408342 # v31.11.0
+      - uses: DeterminateSystems/nix-installer-action@main
      - run: nix build .#${{ matrix.installable }}
--- a/.github/workflows/publish-deltachat-rpc-client-pypi.yml
+++ b/.github/workflows/publish-deltachat-rpc-client-pypi.yml
@@ -13,7 +13,7 @@ jobs:
    runs-on: ubuntu-latest

    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
        with:
          show-progress: false
          persist-credentials: false
@@ -23,7 +23,7 @@ jobs:
        working-directory: deltachat-rpc-client
        run: python3 -m build
      - name: Store the distribution packages
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@v4
        with:
          name: python-package-distributions
          path: deltachat-rpc-client/dist/
@@ -42,9 +42,9 @@ jobs:

    steps:
      - name: Download all the dists
-        uses: actions/download-artifact@v7
+        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@ba38be9e461d3875417946c167d0b5f3d385a247
+        uses: pypa/gh-action-pypi-publish@release/v1
--- a/.github/workflows/repl.yml
+++ b/.github/workflows/repl.yml
@@ -14,15 +14,15 @@ jobs:
    name: Build REPL example
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
        with:
          show-progress: false
          persist-credentials: false
-      - uses: cachix/install-nix-action@630ae543ea3a38a9a4166f03376c02c50f408342 # v31.11.0
+      - uses: DeterminateSystems/nix-installer-action@main
      - name: Build
        run: nix build .#deltachat-repl-win64
      - name: Upload binary
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@v4
        with:
          name: repl.exe
          path: "result/bin/deltachat-repl.exe"
--- a/.github/workflows/upload-docs.yml
+++ b/.github/workflows/upload-docs.yml
@@ -1,21 +1,19 @@
-name: Build & deploy documentation on rs.delta.chat, c.delta.chat, py.delta.chat and cffi.delta.chat
+name: Build & deploy documentation on rs.delta.chat, c.delta.chat, and py.delta.chat

 on:
  push:
    branches:
      - main
+      - build_jsonrpc_docs_ci

 permissions: {}

 jobs:
  build-rs:
    runs-on: ubuntu-latest
-    environment:
-      name: rs.delta.chat
-      url: https://rs.delta.chat/

    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
        with:
          show-progress: false
          persist-credentials: false
@@ -25,74 +23,64 @@ jobs:
      - name: Upload to rs.delta.chat
        run: |
          mkdir -p "$HOME/.ssh"
-          echo "${{ secrets.RS_DOCS_SSH_KEY }}" > "$HOME/.ssh/key"
+          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.RS_DOCS_SSH_USER }}@rs.delta.chat:"
+          rsync -avzh -e "ssh -i $HOME/.ssh/key -o StrictHostKeyChecking=no" $GITHUB_WORKSPACE/target/doc "${{ secrets.USERNAME }}@rs.delta.chat:/var/www/html/rs/"

  build-python:
    runs-on: ubuntu-latest
-    environment:
-      name: py.delta.chat
-      url: https://py.delta.chat/

    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
        with:
          show-progress: false
          persist-credentials: false
          fetch-depth: 0 # Fetch history to calculate VCS version number.
-      - uses: cachix/install-nix-action@630ae543ea3a38a9a4166f03376c02c50f408342 # v31.11.0
+      - uses: DeterminateSystems/nix-installer-action@main
      - name: Build Python documentation
        run: nix build .#python-docs
      - name: Upload to py.delta.chat
        run: |
          mkdir -p "$HOME/.ssh"
-          echo "${{ secrets.PY_DOCS_SSH_KEY }}" > "$HOME/.ssh/key"
+          echo "${{ secrets.CODESPEAK_KEY }}" > "$HOME/.ssh/key"
          chmod 600 "$HOME/.ssh/key"
-          rsync -avzh --delete -e "ssh -i $HOME/.ssh/key -o StrictHostKeyChecking=no" $GITHUB_WORKSPACE/result/html/ "${{ secrets.PY_DOCS_SSH_USER }}@py.delta.chat:"
+          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
-    environment:
-      name: c.delta.chat
-      url: https://c.delta.chat/

    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
        with:
          show-progress: false
          persist-credentials: false
          fetch-depth: 0 # Fetch history to calculate VCS version number.
-      - uses: cachix/install-nix-action@630ae543ea3a38a9a4166f03376c02c50f408342 # v31.11.0
+      - uses: DeterminateSystems/nix-installer-action@main
      - name: Build C documentation
        run: nix build .#docs
      - name: Upload to c.delta.chat
        run: |
          mkdir -p "$HOME/.ssh"
-          echo "${{ secrets.C_DOCS_SSH_KEY }}" > "$HOME/.ssh/key"
+          echo "${{ secrets.CODESPEAK_KEY }}" > "$HOME/.ssh/key"
          chmod 600 "$HOME/.ssh/key"
-          rsync -avzh --delete -e "ssh -i $HOME/.ssh/key -o StrictHostKeyChecking=no" $GITHUB_WORKSPACE/result/html/ "${{ secrets.C_DOCS_SSH_USER }}@c.delta.chat:"
+          rsync -avzh -e "ssh -i $HOME/.ssh/key -o StrictHostKeyChecking=no" $GITHUB_WORKSPACE/result/html/ "delta@c.delta.chat:/home/delta/build-c/master"

  build-ts:
    runs-on: ubuntu-latest
-    environment:
-      name: js.jsonrpc.delta.chat
-      url: https://js.jsonrpc.delta.chat/
-
    defaults:
      run:
        working-directory: ./deltachat-jsonrpc/typescript

    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
        with:
          show-progress: false
          persist-credentials: false
          fetch-depth: 0 # Fetch history to calculate VCS version number.
      - name: Use Node.js
-        uses: actions/setup-node@v7
+        uses: actions/setup-node@v4
        with:
-          node-version: 24
+          node-version: '18'
      - name: npm install
        run: npm install
      - name: npm run build
@@ -102,27 +90,6 @@ jobs:
      - name: Upload to js.jsonrpc.delta.chat
        run: |
          mkdir -p "$HOME/.ssh"
-          echo "${{ secrets.JS_JSONRPC_DOCS_SSH_KEY }}" > "$HOME/.ssh/key"
+          echo "${{ secrets.KEY }}" > "$HOME/.ssh/key"
          chmod 600 "$HOME/.ssh/key"
-          rsync -avzh --delete -e "ssh -i $HOME/.ssh/key -o StrictHostKeyChecking=no" $GITHUB_WORKSPACE/deltachat-jsonrpc/typescript/docs/ "${{ secrets.JS_JSONRPC_DOCS_SSH_USER }}@js.jsonrpc.delta.chat:"
-
-  build-cffi:
-    runs-on: ubuntu-latest
-    environment:
-      name: cffi.delta.chat
-      url: https://cffi.delta.chat/
-
-    steps:
-      - uses: actions/checkout@v7
-        with:
-          show-progress: false
-          persist-credentials: false
-      - name: Build the documentation with cargo
-        run: |
-          cargo doc --package deltachat_ffi --no-deps
-      - name: Upload to cffi.delta.chat
-        run: |
-          mkdir -p "$HOME/.ssh"
-          echo "${{ secrets.CFFI_DOCS_SSH_KEY }}" > "$HOME/.ssh/key"
-          chmod 600 "$HOME/.ssh/key"
-          rsync -avzh --delete -e "ssh -i $HOME/.ssh/key -o StrictHostKeyChecking=no" $GITHUB_WORKSPACE/target/doc/ "${{ secrets.CFFI_DOCS_SSH_USER }}@delta.chat:"
+          rsync -avzh -e "ssh -i $HOME/.ssh/key -o StrictHostKeyChecking=no" $GITHUB_WORKSPACE/deltachat-jsonrpc/typescript/docs/ "${{ secrets.USERNAME }}@js.jsonrpc.delta.chat:/var/www/html/js-jsonrpc/"
--- a/.github/workflows/upload-ffi-docs.yml
+++ b/.github/workflows/upload-ffi-docs.yml
@@ -0,0 +1,31 @@
+# GitHub Actions workflow
+# to build `deltachat_ffi` crate documentation
+# and upload it to <https://cffi.delta.chat/>
+
+name: Build & Deploy Documentation on cffi.delta.chat
+
+on:
+  push:
+    branches:
+      - main
+
+permissions: {}
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          show-progress: false
+          persist-credentials: false
+      - name: Build the documentation with cargo
+        run: |
+          cargo doc --package deltachat_ffi --no-deps
+      - name: Upload to cffi.delta.chat
+        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/zizmor-scan.yml
+++ b/.github/workflows/zizmor-scan.yml
@@ -6,21 +6,26 @@ on:
  pull_request:
    branches: ["**"]

-permissions: {}
-
 jobs:
  zizmor:
-    name: Run zizmor
+    name: zizmor latest via PyPI
    runs-on: ubuntu-latest
    permissions:
-      security-events: write # Required for upload-sarif (used by zizmor-action) to upload SARIF files.
-      contents: read
-      actions: read
+      security-events: write
    steps:
      - name: Checkout repository
-        uses: actions/checkout@v7
+        uses: actions/checkout@v4
        with:
          persist-credentials: false

+      - name: Install the latest version of uv
+        uses: astral-sh/setup-uv@v6
+
      - name: Run zizmor
-        uses: zizmorcore/zizmor-action@6fc4b006235f201fdab3722e17240ab420d580e5 # v0.6.1
+        run: uvx zizmor --format sarif . > results.sarif
+
+      - name: Upload SARIF file
+        uses: github/codeql-action/upload-sarif@v3
+        with:
+          sarif_file: results.sarif
+          category: zizmor
--- a/.github/zizmor.yml
+++ b/.github/zizmor.yml
@@ -1,6 +0,0 @@
-rules:
-  unpinned-uses:
-    config:
-      policies:
-        actions/*: ref-pin
-        dependabot/*: ref-pin
--- a/.gitignore
+++ b/.gitignore
@@ -36,7 +36,6 @@ deltachat-ffi/xml
 coverage/
 .DS_Store
 .vscode
-.zed
 python/accounts.txt
 python/all-testaccounts.txt
 tmp/
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,4 +1,4 @@
-# Contributing to chatmail core
+# Contributing to Delta Chat

 ## Bug reports

@@ -44,7 +44,7 @@ If you want to contribute a code, follow this guide.

   The following prefix types are used:
   - `feat`: Features, e.g. "feat: Pause IO for BackupProvider". If you are unsure what's the category of your commit, you can often just use `feat`.
-   - `fix`: Bug fixes, e.g. "fix: delete `smtp` rows when message sending is canceled"
+   - `fix`: Bug fixes, e.g. "fix: delete `smtp` rows when message sending is cancelled"
   - `api`: API changes, e.g. "api(rust): add `get_msg_read_receipts(context, msg_id)`"
   - `refactor`: Refactorings, e.g. "refactor: iterate over `msg_ids` without `.iter()`"
   - `perf`: Performance improvements, e.g. "perf: improve SQLite performance with `PRAGMA synchronous=normal`"
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,9 +1,9 @@
 [package]
 name = "deltachat"
-version = "2.58.0-dev"
+version = "2.3.0"
 edition = "2024"
 license = "MPL-2.0"
-rust-version = "1.89"
+rust-version = "1.85"
 repository = "https://github.com/chatmail/core"

 [profile.dev]
@@ -44,33 +44,32 @@ ratelimit = { path = "./deltachat-ratelimit" }
 anyhow = { workspace = true }
 async-broadcast = "0.7.2"
 async-channel = { workspace = true }
-async-imap = { version = "0.11.3", default-features = false, features = ["runtime-tokio", "compress"] }
-async-native-tls = { version = "0.6", default-features = false, features = ["runtime-tokio"] }
+async-imap = { version = "0.10.4", default-features = false, features = ["runtime-tokio", "compress"] }
+async-native-tls = { version = "0.5", default-features = false, features = ["runtime-tokio"] }
 async-smtp = { version = "0.10.2", default-features = false, features = ["runtime-tokio"] }
-async_zip = { version = "0.0.18", default-features = false, features = ["deflate", "tokio-fs"] }
+async_zip = { version = "0.0.17", default-features = false, features = ["deflate", "tokio-fs"] }
 base64 = { workspace = true }
-blake3 = "1.8.2"
 brotli = { version = "8", default-features=false, features = ["std"] }
 bytes = "1"
 chrono = { workspace = true, features = ["alloc", "clock", "std"] }
-colorutils-rs = { version = "0.8.0", default-features = false }
 data-encoding = "2.9.0"
 escaper = "0.1"
-fast-socks5 = "1"
+fast-socks5 = "0.10"
 fd-lock = "4"
 futures-lite = { workspace = true }
 futures = { workspace = true }
 hex = "0.4.0"
+hickory-resolver = "0.25.2"
 http-body-util = "0.1.3"
 humansize = "2"
 hyper = "1"
-hyper-util = "0.1.16"
+hyper-util = "0.1.14"
 image = { version = "0.25.6", default-features=false, features = ["gif", "jpeg", "ico", "png", "pnm", "webp", "bmp"] }
 iroh-gossip = { version = "0.35", default-features = false, features = ["net"] }
 iroh = { version = "0.35", default-features = false }
 kamadak-exif = "0.6.1"
 libc = { workspace = true }
-mail-builder = { version = "0.4.4", default-features = false }
+mail-builder = { version = "0.4.3", default-features = false }
 mailparse = { workspace = true }
 mime = "0.3.17"
 num_cpus = "1.17"
@@ -78,43 +77,46 @@ num-derive = "0.4"
 num-traits = { workspace = true }
 parking_lot = "0.12.4"
 percent-encoding = "2.3"
-pgp = { version = "0.20.0", features = ["draft-pqc"], default-features = false }
+pgp = { version = "0.16.0", default-features = false }
 pin-project = "1"
 qrcodegen = "1.7.0"
-quick-xml = { version = "0.41", features = ["escape-html"] }
-rand-old = { package = "rand", version = "0.8" }
+quick-xml = "0.37"
+quoted_printable = "0.5"
 rand = { workspace = true }
 regex = { workspace = true }
 rusqlite = { workspace = true, features = ["sqlcipher"] }
+rust-hsluv = "0.1"
+rustls-pki-types = "1.12.0"
+rustls = { version = "0.23.22", default-features = false }
 sanitize-filename = { workspace = true }
-sdp = "0.17.1"
 serde_json = { workspace = true }
+serde_urlencoded = "0.7.1"
 serde = { workspace = true, features = ["derive"] }
 sha-1 = "0.10"
 sha2 = "0.10"
 shadowsocks = { version = "1.23.1", default-features = false, features = ["aead-cipher", "aead-cipher-2022"] }
 smallvec = "1.15.1"
-strum = "0.28"
-strum_macros = "0.28"
+strum = "0.27"
+strum_macros = "0.27"
 tagger = "4.3.4"
 textwrap = "0.16.2"
 thiserror = { workspace = true }
-tokio-io-timeout = "1.2.1"
-tokio-rustls = { version = "0.26.2", default-features = false, features = ["tls12", "brotli"] }
+tokio-io-timeout = "1.2.0"
+tokio-rustls = { version = "0.26.2", default-features = false }
 tokio-stream = { version = "0.1.17", features = ["fs"] }
-astral-tokio-tar = { version = "0.6.3", default-features = false }
+tokio-tar = { version = "0.3" } # TODO: integrate tokio into async-tar
 tokio-util = { workspace = true }
 tokio = { workspace = true, features = ["fs", "rt-multi-thread", "macros"] }
-toml = "0.9"
+toml = "0.8"
 tracing = "0.1.41"
 url = "2"
 uuid = { version = "1", features = ["serde", "v4"] }
-walkdir = "2.5.0"
 webpki-roots = "0.26.8"
+blake3 = "1.8.2"

 [dev-dependencies]
 anyhow = { workspace = true, features = ["backtrace"] } # Enable `backtrace` feature in tests.
-criterion = { version = "0.8.1", features = ["async_tokio"] }
+criterion = { version = "0.6.0", features = ["async_tokio"] }
 futures-lite = { workspace = true }
 log = { workspace = true }
 nu-ansi-term = { workspace = true }
@@ -155,11 +157,6 @@ name = "receive_emails"
 required-features = ["internals"]
 harness = false

-[[bench]]
-name = "decrypting"
-required-features = ["internals"]
-harness = false
-
 [[bench]]
 name = "get_chat_msgs"
 harness = false
@@ -178,29 +175,29 @@ harness = false

 [workspace.dependencies]
 anyhow = "1"
-async-channel = "2.5.0"
+async-channel = "2.3.1"
 base64 = "0.22"
-chrono = { version = "0.4.44", default-features = false }
+chrono = { version = "0.4.41", default-features = false }
 deltachat-contact-tools = { path = "deltachat-contact-tools" }
 deltachat-jsonrpc = { path = "deltachat-jsonrpc", default-features = false }
 deltachat = { path = ".", default-features = false }
-futures = "0.3.32"
-futures-lite = "2.6.1"
+futures = "0.3.31"
+futures-lite = "2.6.0"
 libc = "0.2"
 log = "0.4"
 mailparse = "0.16.1"
-nu-ansi-term = "0.50"
+nu-ansi-term = "0.46"
 num-traits = "0.2"
-rand = "0.9"
-regex = "1.12"
-rusqlite = "0.37"
-sanitize-filename = "0.6"
+rand = "0.8"
+regex = "1.10"
+rusqlite = "0.36"
+sanitize-filename = "0.5"
 serde = "1.0"
 serde_json = "1"
-tempfile = "3.27.0"
+tempfile = "3.20.0"
 thiserror = "2"
 tokio = "1"
-tokio-util = "0.7.18"
+tokio-util = "0.7.14"
 tracing-subscriber = "0.3"
 yerpc = "0.6.4"

--- a/README.md
+++ b/README.md
@@ -80,26 +80,18 @@ Connect to your mail server (if already configured):
 > connect
 ```

-Export your public key to a vCard file:
-
-```
-> make-vcard my.vcard 1
-```
-
-Create contacts by address or vCard file:
+Create a contact:

 ```
 > addcontact yourfriends@email.org
-> import-vcard key-contact.vcard
 ```

 List contacts:

 ```
 > listcontacts
-Contact#Contact#11: key-contact@email.org <key-contact@email.org>
 Contact#Contact#Self: Me √ <your@email.org>
-2 key contacts.
+1 key contacts.
 Contact#Contact#10: yourfriends@email.org <yourfriends@email.org>
 1 address contacts.
 ```
@@ -197,10 +189,12 @@ and then run the script.
 Language bindings are available for:

 - **C** \[[📂 source](./deltachat-ffi) | [📚 docs](https://c.delta.chat)\]
-   - -> libdeltachat is going to be deprecated and only exists because Android, iOS and Ubuntu Touch are still using it. If you build a new project, then please use the jsonrpc api instead.
 - **JS**: \[[📂 source](./deltachat-rpc-client) | [📦 npm](https://www.npmjs.com/package/@deltachat/jsonrpc-client) | [📚 docs](https://js.jsonrpc.delta.chat/)\]
 - **Python** \[[📂 source](./python) | [📦 pypi](https://pypi.org/project/deltachat) | [📚 docs](https://py.delta.chat)\]
- **Go** \[[📂 source](https://github.com/deltachat/deltachat-rpc-client-go/)\]
+- **Go**
+  - over jsonrpc: \[[📂 source](https://github.com/deltachat/deltachat-rpc-client-go/)\]
+  - over cffi[^1]: \[[📂 source](https://github.com/deltachat/go-deltachat/)\]
+- **Free Pascal**[^1] \[[📂 source](https://github.com/deltachat/deltachat-fp/)\]
 - **Java** and **Swift** (contained in the Android/iOS repos)

 The following "frontend" projects make use of the Rust-library
@@ -213,3 +207,5 @@ or its language bindings:
 - [Telepathy](https://code.ur.gs/lupine/telepathy-padfoot/)
 - [Ubuntu Touch](https://codeberg.org/lk108/deltatouch)
 - several **Bots**
+
+[^1]: Out of date / unmaintained, if you like those languages feel free to start maintaining them. If you have questions we'll help you, please ask in the issues.
--- a/RELEASE.md
+++ b/RELEASE.md
@@ -1,4 +1,4 @@
-# Releasing a new version of chatmail core
+# Releasing a new version of DeltaChat core

 For example, to release version 1.116.0 of the core, do the following steps.

@@ -14,55 +14,8 @@ For example, to release version 1.116.0 of the core, do the following steps.
 5. 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. Push the commit to the `main` branch.
+6. Tag the release: `git tag --annotate v1.116.0`.

-7. Once the commit is on the `main` branch and passed CI, tag the release: `git tag --annotate 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`.
-
-9. Create a GitHub release: `gh release create v1.116.0 --notes ''`.
-
-10. Update the version to the next development version:
-    `scripts/set_core_version.py 1.117.0-dev`.
-
-11. Commit and push the change:
-    `git commit -m "chore: bump version to 1.117.0-dev" && git push origin main`.
-
-12. Once the binaries are generated and [published](https://github.com/chatmail/core/releases),
-    check Windows binaries for false positive detections at [VirusTotal].
-    Either upload the binaries directly or submit a direct link to the artifact.
-    You can use [old browsers interface](https://www.virustotal.com/old-browsers/)
-    if there are problems with using the default website.
-    If you submit a direct link and get to the page saying
-    "No security vendors flagged this URL as malicious",
-    it does not mean that the file itself is not detected.
-    You need to go to the "details" tab
-    and click on the SHA-256 hash in the "Body SHA-256" section.
-    If any false positive is detected,
-    open an issue to track removing it.
-    See <https://github.com/chatmail/core/issues/7847>
-    for an example of false positive detection issue.
-    If there is a false positive "Microsoft" detection,
-    mark the issue as a blocker.
-
-[VirusTotal]: https://www.virustotal.com/
-
-## Dealing with antivirus false positives
-
-If Windows release is incorrectly detected by some antivirus, submit requests to remove detection.
-
-"Microsoft" antivirus is built in Windows and will break user setups so removing its detection should be highest priority.
-To submit false positive to Microsoft, go to <https://www.microsoft.com/en-us/wdsi/filesubmission> and select "Submit file as a ... Software developer" option.
-
-False positive contacts for other vendors can be found at <https://docs.virustotal.com/docs/false-positive-contacts>.
-Not all of them may be up to date, so check the links below first.
-Previously we successfully used the following contacts:
- [ESET-NOD32](mailto:samples@eset.com)
- [Symantec](https://symsubmit.symantec.com/)
-
-## Dealing with failed releases
-
-Once you make a GitHub release,
-CI will try to build and publish [PyPI](https://pypi.org/) and [npm](https://www.npmjs.com/) packages.
-If this fails for some reason, do not modify the failed tag, do not delete it and do not force-push to the `main` branch.
-Fix the build process and tag a new release instead.
+8. Create a GitHub release: `gh release create v1.116.0 --notes ''`.
--- a/STYLE.md
+++ b/STYLE.md
@@ -16,12 +16,11 @@ id INTEGER PRIMARY KEY AUTOINCREMENT,
 text TEXT DEFAULT '' NOT NULL -- message text
 ) STRICT",
    )
-    .await
-    .context("CREATE TABLE messages")?;
+    .await?;
 ```

 Do not use macros like [`concat!`](https://doc.rust-lang.org/std/macro.concat.html)
-or [`indoc!`](https://docs.rs/indoc).
+or [`indoc!](https://docs.rs/indoc).
 Do not escape newlines like this:
 ```
    sql.execute(
@@ -30,8 +29,7 @@ id INTEGER PRIMARY KEY AUTOINCREMENT, \
 text TEXT DEFAULT '' NOT NULL \
 ) STRICT",
    )
-    .await
-    .context("CREATE TABLE messages")?;
+    .await?;
 ```
 Escaping newlines
 is prone to errors like this if space before backslash is missing:
@@ -59,28 +57,12 @@ If column is already declared without `NOT NULL`, use `IFNULL` function to provi
 Use `HAVING COUNT(*) > 0` clause
 to [prevent aggregate functions such as `MIN` and `MAX` from returning `NULL`](https://stackoverflow.com/questions/66527856/aggregate-functions-max-etc-return-null-instead-of-no-rows).

-List columns explicitly in `INSERT` statements:
-```
-INSERT OR IGNORE INTO download (rfc724_mid, msg_id) VALUES (?,0);
-```
-Otherwise if a new column with default value is added in a future DB version, an upgraded DB can't
-be used with the old code, e.g. after transferring a DB from a device running a newer version.
-
 Don't delete unused columns too early, but maybe after several months/releases, unused columns are
 still used by older versions, so deleting them breaks downgrading the core or importing a backup in
 an older version. Also don't change the column type, consider adding a new column with another name
 instead. Finally, never change column semantics, this is especially dangerous because the `STRICT`
 keyword doesn't help here.

-Consider adding context to `anyhow` errors for SQL statements using `.context()` so that it's
-possible to understand from logs which statement failed. See [Errors](#errors) for more info.
-
-When changing complex SQL queries, test them on a new database with `EXPLAIN QUERY PLAN`
-to make sure that indexes are used and large tables are not going to be scanned.
-Never run `ANALYZE` on the databases,
-this makes query planner unpredictable
-and may make performance significantly worse: <https://github.com/chatmail/core/issues/6585>
-
 ## Errors

 Delta Chat core mostly uses [`anyhow`](https://docs.rs/anyhow/) errors.
@@ -96,27 +78,6 @@ All errors should be handled in one of these ways:
 - With `.log_err().ok()`.
 - Bubbled up with `?`.

-When working with [async streams](https://docs.rs/futures/0.3.31/futures/stream/index.html),
-prefer [`try_next`](https://docs.rs/futures/0.3.31/futures/stream/trait.TryStreamExt.html#method.try_next) over `next()`, e.g. do
-```
-while let Some(event) = stream.try_next().await? {
-    todo!();
-}
-```
-instead of
-```
-while let Some(event_res) = stream.next().await {
-    todo!();
-}
-```
-as it allows bubbling up the error early with `?`
-with no way to accidentally skip error processing
-with early `continue` or `break`.
-Some streams reading from a connection
-return infinite number of `Some(Err(_))`
-items when connection breaks and not processing
-errors may result in infinite loop.
-
 `backtrace` feature is enabled for `anyhow` crate
 and `debug = 1` option is set in the test profile.
 This allows to run `RUST_BACKTRACE=1 cargo test`
@@ -130,18 +91,6 @@ Follow
 <https://doc.rust-lang.org/core/error/index.html#common-message-styles>
 for `.expect` message style.

-## BTreeMap vs HashMap
-
-Prefer [BTreeMap](https://doc.rust-lang.org/std/collections/struct.BTreeMap.html)
-over [HashMap](https://doc.rust-lang.org/std/collections/struct.HashMap.html)
-and [BTreeSet](https://doc.rust-lang.org/std/collections/struct.BTreeSet.html)
-over [HashSet](https://doc.rust-lang.org/std/collections/struct.HashSet.html)
-as iterating over these structures returns items in deterministic order.
-
-Non-deterministic code may result in difficult to reproduce bugs,
-flaky tests, regression tests that miss bugs
-or different behavior on different devices when processing the same messages.
-
 ## Logging

 For logging, use `info!`, `warn!` and `error!` macros.
@@ -168,23 +117,3 @@ are documented.

 Follow Rust guidelines for the documentation comments:
 <https://rust-lang.github.io/rfcs/1574-more-api-documentation-conventions.html#summary-sentence>
-
-## Do not use `into()`, `try_into()` or `parse()`
-
-For internal types, implementing `From`, `TryFrom` or `FromStr` is discouraged.
-Instead, a `new()` function is recommended.
-
-For external types, prefer using `Type::from()`, `Type::try_from()` or `Type::from_str()`
-over `into()`, `try_into()` or `parse()`.
-
-Calling `into()`, `try_into()` or `parse()`
-creates an indirection,
-which is hard to follow for people who are not familiar with Rust,
-or who are not using rust-analyzer.
-
-## Use macros only when really needed
-
-Macros can be hard to read for people unfamiliar with Rust,
-and can have surprising effects like evaluating arguments multiple times.
-Therefore, macros should only be used when really needed;
-using functions is usually better.
--- a/assets/icon-address-contact.png
+++ b/assets/icon-address-contact.png
--- a/assets/icon-address-contact.svg
+++ b/assets/icon-address-contact.svg
--- a/assets/self-reporting-bot.vcf
+++ b/assets/self-reporting-bot.vcf
--- a/benches/decrypting.rs
+++ b/benches/decrypting.rs
@@ -1,142 +0,0 @@
-//! Benchmarks for message decryption,
-//! comparing decryption of symmetrically-encrypted messages
-//! to decryption of asymmetrically-encrypted messages.
-//!
-//! Call with
-//!
-//! ```text
-//! cargo bench --bench decrypting --features="internals"
-//! ```
-//!
-//! or, if you want to only run e.g. the 'Decrypt and parse a symmetrically encrypted message' benchmark:
-//!
-//! ```text
-//! cargo bench --bench decrypting --features="internals" -- 'Decrypt and parse a symmetrically encrypted message'
-//! ```
-//!
-//! You can also pass a substring:
-//!
-//! ```text
-//! cargo bench --bench decrypting --features="internals" -- 'symmetrically'
-//! ```
-//!
-//! Symmetric decryption has to try out all known secrets,
-//! You can benchmark this by adapting the `NUM_SECRETS` variable.
-
-use std::hint::black_box;
-use std::sync::LazyLock;
-
-use criterion::{Criterion, criterion_group, criterion_main};
-use deltachat::internals_for_benches::create_broadcast_secret;
-use deltachat::internals_for_benches::save_broadcast_secret;
-use deltachat::securejoin::get_securejoin_qr;
-use deltachat::{
-    Events, chat::ChatId, config::Config, context::Context, internals_for_benches::key_from_asc,
-    internals_for_benches::parse_and_get_text, internals_for_benches::store_self_keypair,
-    stock_str::StockStrings,
-};
-use tempfile::tempdir;
-
-static NUM_BROADCAST_SECRETS: LazyLock<usize> = LazyLock::new(|| {
-    std::env::var("NUM_BROADCAST_SECRETS")
-        .unwrap_or("500".to_string())
-        .parse()
-        .unwrap()
-});
-static NUM_AUTH_TOKENS: LazyLock<usize> = LazyLock::new(|| {
-    std::env::var("NUM_AUTH_TOKENS")
-        .unwrap_or("5000".to_string())
-        .parse()
-        .unwrap()
-});
-
-async fn create_context() -> Context {
-    let dir = tempdir().unwrap();
-    let dbfile = dir.path().join("db.sqlite");
-    let context = Context::new(dbfile.as_path(), 100, Events::new(), StockStrings::new())
-        .await
-        .unwrap();
-
-    context
-        .set_config(Config::ConfiguredAddr, Some("bob@example.net"))
-        .await
-        .unwrap();
-    let secret = key_from_asc(include_str!("../test-data/key/bob-secret.asc")).unwrap();
-    store_self_keypair(&context, &secret)
-        .await
-        .expect("Failed to save key");
-
-    context
-}
-
-fn criterion_benchmark(c: &mut Criterion) {
-    let mut group = c.benchmark_group("Decrypt");
-
-    // ===========================================================================================
-    // Benchmarks for the whole parsing pipeline, incl. decryption (but excl. receive_imf())
-    // ===========================================================================================
-
-    let rt = tokio::runtime::Runtime::new().unwrap();
-    let mut secrets = generate_secrets();
-
-    // "secret" is the shared secret that was used to encrypt text_symmetrically_encrypted.eml.
-    // Put it into the middle of our secrets:
-    secrets[*NUM_BROADCAST_SECRETS / 2] = "secret".to_string();
-
-    let context = rt.block_on(async {
-        let context = create_context().await;
-        for (i, secret) in secrets.iter().enumerate() {
-            save_broadcast_secret(&context, ChatId::new(10 + i as u32), secret)
-                .await
-                .unwrap();
-        }
-        for _i in 0..*NUM_AUTH_TOKENS {
-            get_securejoin_qr(&context, None).await.unwrap();
-        }
-        println!("NUM_AUTH_TOKENS={}", *NUM_AUTH_TOKENS);
-        context
-    });
-
-    group.bench_function("Decrypt and parse a symmetrically encrypted message", |b| {
-        b.to_async(&rt).iter(|| {
-            let ctx = context.clone();
-            async move {
-                let text = parse_and_get_text(
-                    &ctx,
-                    include_bytes!("../test-data/message/text_symmetrically_encrypted.eml"),
-                )
-                .await
-                .unwrap();
-                assert_eq!(black_box(text), "Symmetrically encrypted message");
-            }
-        });
-    });
-
-    group.bench_function("Decrypt and parse a public-key encrypted message", |b| {
-        b.to_async(&rt).iter(|| {
-            let ctx = context.clone();
-            async move {
-                let text = parse_and_get_text(
-                    &ctx,
-                    include_bytes!("../test-data/message/text_from_alice_encrypted.eml"),
-                )
-                .await
-                .unwrap();
-                assert_eq!(black_box(text), "hi");
-            }
-        });
-    });
-
-    group.finish();
-}
-
-fn generate_secrets() -> Vec<String> {
-    let secrets: Vec<String> = (0..*NUM_BROADCAST_SECRETS)
-        .map(|_| create_broadcast_secret())
-        .collect();
-    println!("NUM_BROADCAST_SECRETS={}", *NUM_BROADCAST_SECRETS);
-    secrets
-}
-
-criterion_group!(benches, criterion_benchmark);
-criterion_main!(benches);
--- a/cliff.toml
+++ b/cliff.toml
@@ -66,7 +66,7 @@ body = """
    {% for commit in commits %}
        - {% if commit.breaking %}[**breaking**] {% endif %}\
 	{% if commit.scope %}{{ commit.scope }}: {% endif %}\
-	{{ commit.message }}.\
+	{{ commit.message | upper_first }}.\
 	{% if commit.footers is defined %}\
 	  {% for footer in commit.footers %}{% if 'BREAKING CHANGE' in footer.token %}
 	    {% raw %}  {% endraw %}- {{ footer.value }}\
--- a/deltachat-contact-tools/Cargo.toml
+++ b/deltachat-contact-tools/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "deltachat-contact-tools"
 version = "0.0.0" # No semver-stable versioning
-edition = "2024"
+edition = "2021"
 description = "Contact-related tools, like parsing vcards and sanitizing name and address. Meant for internal use in the deltachat crate."
 license = "MPL-2.0"

--- a/deltachat-contact-tools/src/lib.rs
+++ b/deltachat-contact-tools/src/lib.rs
@@ -29,16 +29,17 @@

 use std::fmt;
 use std::ops::Deref;
+use std::sync::LazyLock;

-use anyhow::Result;
 use anyhow::bail;
-use regex::regex;
+use anyhow::Result;
+use regex::Regex;

 mod vcard;
-pub use vcard::{VcardContact, make_vcard, parse_vcard};
+pub use vcard::{make_vcard, parse_vcard, VcardContact};

 /// Valid contact address.
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone)]
 pub struct ContactAddress(String);

 impl Deref for ContactAddress {
@@ -67,7 +68,7 @@ impl ContactAddress {
    pub fn new(s: &str) -> Result<Self> {
        let addr = addr_normalize(s);
        if !may_be_valid_addr(&addr) {
-            bail!("invalid address {s:?}");
+            bail!("invalid address {:?}", s);
        }
        Ok(Self(addr.to_string()))
    }
@@ -87,7 +88,9 @@ impl rusqlite::types::ToSql for ContactAddress {
 /// - Removes special characters from the name, see [`sanitize_name()`]
 /// - Removes the name if it is equal to the address by setting it to ""
 pub fn sanitize_name_and_addr(name: &str, addr: &str) -> (String, String) {
-    let (name, addr) = if let Some(captures) = regex!("(.*)<(.*)>").captures(addr.as_ref()) {
+    static ADDR_WITH_NAME_REGEX: LazyLock<Regex> =
+        LazyLock::new(|| Regex::new("(.*)<(.*)>").unwrap());
+    let (name, addr) = if let Some(captures) = ADDR_WITH_NAME_REGEX.captures(addr.as_ref()) {
        (
            if name.is_empty() {
                captures.get(1).map_or("", |m| m.as_str())
@@ -254,16 +257,16 @@ impl EmailAddress {
            .chars()
            .any(|c| c.is_whitespace() || c == '<' || c == '>')
        {
-            bail!("Email {input:?} must not contain whitespaces, '>' or '<'");
+            bail!("Email {:?} must not contain whitespaces, '>' or '<'", input);
        }

        match &parts[..] {
            [domain, local] => {
                if local.is_empty() {
-                    bail!("empty string is not valid for local part in {input:?}");
+                    bail!("empty string is not valid for local part in {:?}", input);
                }
                if domain.is_empty() {
-                    bail!("missing domain after '@' in {input:?}");
+                    bail!("missing domain after '@' in {:?}", input);
                }
                if domain.ends_with('.') {
                    bail!("Domain {domain:?} should not contain the dot in the end");
@@ -273,7 +276,7 @@ impl EmailAddress {
                    domain: (*domain).to_string(),
                })
            }
-            _ => bail!("Email {input:?} must contain '@' character"),
+            _ => bail!("Email {:?} must contain '@' character", input),
        }
    }
 }
--- a/deltachat-contact-tools/src/vcard.rs
+++ b/deltachat-contact-tools/src/vcard.rs
@@ -1,8 +1,10 @@
+use std::sync::LazyLock;
+
 use anyhow::Context as _;
 use anyhow::Result;
 use chrono::DateTime;
 use chrono::NaiveDateTime;
-use regex::regex;
+use regex::Regex;

 use crate::sanitize_name_and_addr;

@@ -34,45 +36,6 @@ impl VcardContact {
    }
 }

-fn escape(s: &str) -> String {
-    // https://www.rfc-editor.org/rfc/rfc6350.html#section-3.4
-    s
-        // backslash must be first!
-        .replace(r"\", r"\\")
-        .replace(',', r"\,")
-        .replace(';', r"\;")
-        .replace('\n', r"\n")
-}
-
-fn unescape(s: &str) -> String {
-    // https://www.rfc-editor.org/rfc/rfc6350.html#section-3.4
-    let mut out = String::new();
-
-    let mut chars = s.chars();
-    while let Some(c) = chars.next() {
-        if c == '\\' {
-            if let Some(next) = chars.next() {
-                match next {
-                    '\\' | ',' | ';' => out.push(next),
-                    'n' | 'N' => out.push('\n'),
-                    _ => {
-                        // Invalid escape sequence (keep unchanged)
-                        out.push('\\');
-                        out.push(next);
-                    }
-                }
-            } else {
-                // Invalid escape sequence (keep unchanged)
-                out.push('\\');
-            }
-        } else {
-            out.push(c);
-        }
-    }
-
-    out
-}
-
 /// Returns a vCard containing given contacts.
 ///
 /// Calling [`parse_vcard()`] on the returned result is a reverse operation.
@@ -83,6 +46,10 @@ pub fn make_vcard(contacts: &[VcardContact]) -> String {
        Some(datetime.format("%Y%m%dT%H%M%SZ").to_string())
    }

+    fn escape(s: &str) -> String {
+        s.replace(',', "\\,")
+    }
+
    let mut res = "".to_string();
    for c in contacts {
        // Mustn't contain ',', but it's easier to escape than to error out.
@@ -157,7 +124,7 @@ pub fn parse_vcard(vcard: &str) -> Vec<VcardContact> {
    fn vcard_property<'a>(line: &'a str, property: &str) -> Option<(&'a str, String)> {
        let (params, value) = vcard_property_raw(line, property)?;
        // Some fields can't contain commas, but unescape them everywhere for safety.
-        Some((params, unescape(value)))
+        Some((params, value.replace("\\,", ",")))
    }
    fn base64_key(line: &str) -> Option<&str> {
        let (params, value) = vcard_property_raw(line, "key")?;
@@ -208,7 +175,9 @@ pub fn parse_vcard(vcard: &str) -> Vec<VcardContact> {
    }

    // Remove line folding, see https://datatracker.ietf.org/doc/html/rfc6350#section-3.2
-    let unfolded_lines = regex!("\r?\n[\t ]").replace_all(vcard, "");
+    static NEWLINE_AND_SPACE_OR_TAB: LazyLock<Regex> =
+        LazyLock::new(|| Regex::new("\r?\n[\t ]").unwrap());
+    let unfolded_lines = NEWLINE_AND_SPACE_OR_TAB.replace_all(vcard, "");

    let mut lines = unfolded_lines.lines().peekable();
    let mut contacts = Vec::new();
--- a/deltachat-contact-tools/src/vcard/vcard_tests.rs
+++ b/deltachat-contact-tools/src/vcard/vcard_tests.rs
@@ -91,7 +91,7 @@ fn test_make_and_parse_vcard() {
            authname: "Alice Wonderland".to_string(),
            key: Some("[base64-data]".to_string()),
            profile_image: Some("image in Base64".to_string()),
-            biography: Some("Hi,\nI'm Alice; and this is a backslash: \\".to_string()),
+            biography: Some("Hi, I'm Alice".to_string()),
            timestamp: Ok(1713465762),
        },
        VcardContact {
@@ -110,7 +110,7 @@ fn test_make_and_parse_vcard() {
             FN:Alice Wonderland\r\n\
             KEY:data:application/pgp-keys;base64\\,[base64-data]\r\n\
             PHOTO:data:image/jpeg;base64\\,image in Base64\r\n\
-             NOTE:Hi\\,\\nI'm Alice\\; and this is a backslash: \\\\\r\n\
+             NOTE:Hi\\, I'm Alice\r\n\
             REV:20240418T184242Z\r\n\
             END:VCARD\r\n",
        "BEGIN:VCARD\r\n\
@@ -220,10 +220,7 @@ END:VCARD
        assert_eq!(contacts[0].addr, "bob@example.org".to_string());
        assert_eq!(contacts[0].authname, "Bob".to_string());
        assert_eq!(contacts[0].key, None);
-        assert_eq!(
-            contacts[0].profile_image.as_deref().unwrap(),
-            "/9j/4AAQSkZJRgABAQAAAQABAAD/4gIoSUNDX1BST0ZJTEUAAQEAAAIYAAAAAAQwAABtbnRyUkdCIFhZWiAAAAAAAAAAAAAAAABhY3NwAAAAAAAAAAAAAAAAL8bRuAJYoZUYrI4ZY3VWwxw4Ay28AAGBISScmf/2Q=="
-        );
+        assert_eq!(contacts[0].profile_image.as_deref().unwrap(), "/9j/4AAQSkZJRgABAQAAAQABAAD/4gIoSUNDX1BST0ZJTEUAAQEAAAIYAAAAAAQwAABtbnRyUkdCIFhZWiAAAAAAAAAAAAAAAABhY3NwAAAAAAAAAAAAAAAAL8bRuAJYoZUYrI4ZY3VWwxw4Ay28AAGBISScmf/2Q==");
    }
 }

@@ -247,10 +244,7 @@ END:VCARD",
    assert_eq!(contacts.len(), 1);
    assert_eq!(&contacts[0].addr, "alice@example.org");
    assert_eq!(&contacts[0].authname, "Alice Wonderland");
-    assert_eq!(
-        contacts[0].key.as_ref().unwrap(),
-        "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
-    );
+    assert_eq!(contacts[0].key.as_ref().unwrap(), "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
    assert!(contacts[0].timestamp.is_err());
    assert_eq!(contacts[0].profile_image, None);
 }
@@ -278,24 +272,7 @@ END:VCARD",
    assert_eq!(contacts.len(), 1);
    assert_eq!(&contacts[0].addr, "alice@example.org");
    assert_eq!(&contacts[0].authname, "Alice");
-    assert_eq!(
-        contacts[0].key.as_ref().unwrap(),
-        "xsaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa=="
-    );
+    assert_eq!(contacts[0].key.as_ref().unwrap(), "xsaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa==");
    assert!(contacts[0].timestamp.is_err());
-    assert_eq!(
-        contacts[0].profile_image.as_ref().unwrap(),
-        "/9aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/Z"
-    );
-}
-
-#[test]
-fn test_vcard_value_escape_unescape() {
-    let original = "Text, with; chars and a \\ and a newline\nand a literal newline \\n";
-    let expected_escaped = r"Text\, with\; chars and a \\ and a newline\nand a literal newline \\n";
-
-    let escaped = escape(original);
-    assert_eq!(escaped, expected_escaped);
-    let unescaped = unescape(&escaped);
-    assert_eq!(original, unescaped);
+    assert_eq!(contacts[0].profile_image.as_ref().unwrap(), "/9aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/Z");
 }
--- a/deltachat-ffi/Cargo.toml
+++ b/deltachat-ffi/Cargo.toml
@@ -1,8 +1,8 @@
 [package]
 name = "deltachat_ffi"
-version = "2.58.0-dev"
+version = "2.3.0"
 description = "Deltachat FFI"
-edition = "2024"
+edition = "2018"
 readme = "README.md"
 license = "MPL-2.0"

--- a/deltachat-ffi/deltachat.h
+++ b/deltachat-ffi/deltachat.h
--- a/deltachat-ffi/src/lib.rs
+++ b/deltachat-ffi/src/lib.rs
--- a/deltachat-ffi/src/lot.rs
+++ b/deltachat-ffi/src/lot.rs
@@ -45,23 +45,21 @@ impl Lot {
            Self::Qr(qr) => match qr {
                Qr::AskVerifyContact { .. } => None,
                Qr::AskVerifyGroup { grpname, .. } => Some(Cow::Borrowed(grpname)),
-                Qr::AskJoinBroadcast { name, .. } => Some(Cow::Borrowed(name)),
                Qr::FprOk { .. } => None,
                Qr::FprMismatch { .. } => None,
                Qr::FprWithoutAddr { fingerprint, .. } => Some(Cow::Borrowed(fingerprint)),
                Qr::Account { domain } => Some(Cow::Borrowed(domain)),
                Qr::Backup2 { .. } => None,
                Qr::BackupTooNew { .. } => None,
+                Qr::WebrtcInstance { domain, .. } => Some(Cow::Borrowed(domain)),
                Qr::Proxy { host, port, .. } => Some(Cow::Owned(format!("{host}:{port}"))),
                Qr::Addr { draft, .. } => draft.as_deref().map(Cow::Borrowed),
                Qr::Url { url } => Some(Cow::Borrowed(url)),
                Qr::Text { text } => Some(Cow::Borrowed(text)),
                Qr::WithdrawVerifyContact { .. } => None,
                Qr::WithdrawVerifyGroup { grpname, .. } => Some(Cow::Borrowed(grpname)),
-                Qr::WithdrawJoinBroadcast { name, .. } => Some(Cow::Borrowed(name)),
                Qr::ReviveVerifyContact { .. } => None,
                Qr::ReviveVerifyGroup { grpname, .. } => Some(Cow::Borrowed(grpname)),
-                Qr::ReviveJoinBroadcast { name, .. } => Some(Cow::Borrowed(name)),
                Qr::Login { address, .. } => Some(Cow::Borrowed(address)),
            },
            Self::Error(err) => Some(Cow::Borrowed(err)),
@@ -101,23 +99,21 @@ impl Lot {
            Self::Qr(qr) => match qr {
                Qr::AskVerifyContact { .. } => LotState::QrAskVerifyContact,
                Qr::AskVerifyGroup { .. } => LotState::QrAskVerifyGroup,
-                Qr::AskJoinBroadcast { .. } => LotState::QrAskJoinBroadcast,
                Qr::FprOk { .. } => LotState::QrFprOk,
                Qr::FprMismatch { .. } => LotState::QrFprMismatch,
                Qr::FprWithoutAddr { .. } => LotState::QrFprWithoutAddr,
                Qr::Account { .. } => LotState::QrAccount,
                Qr::Backup2 { .. } => LotState::QrBackup2,
                Qr::BackupTooNew { .. } => LotState::QrBackupTooNew,
+                Qr::WebrtcInstance { .. } => LotState::QrWebrtcInstance,
                Qr::Proxy { .. } => LotState::QrProxy,
                Qr::Addr { .. } => LotState::QrAddr,
                Qr::Url { .. } => LotState::QrUrl,
                Qr::Text { .. } => LotState::QrText,
                Qr::WithdrawVerifyContact { .. } => LotState::QrWithdrawVerifyContact,
                Qr::WithdrawVerifyGroup { .. } => LotState::QrWithdrawVerifyGroup,
-                Qr::WithdrawJoinBroadcast { .. } => LotState::QrWithdrawJoinBroadcast,
                Qr::ReviveVerifyContact { .. } => LotState::QrReviveVerifyContact,
                Qr::ReviveVerifyGroup { .. } => LotState::QrReviveVerifyGroup,
-                Qr::ReviveJoinBroadcast { .. } => LotState::QrReviveJoinBroadcast,
                Qr::Login { .. } => LotState::QrLogin,
            },
            Self::Error(_err) => LotState::QrError,
@@ -130,23 +126,21 @@ impl Lot {
            Self::Qr(qr) => match qr {
                Qr::AskVerifyContact { contact_id, .. } => contact_id.to_u32(),
                Qr::AskVerifyGroup { .. } => Default::default(),
-                Qr::AskJoinBroadcast { .. } => Default::default(),
                Qr::FprOk { contact_id } => contact_id.to_u32(),
                Qr::FprMismatch { contact_id } => contact_id.unwrap_or_default().to_u32(),
                Qr::FprWithoutAddr { .. } => Default::default(),
                Qr::Account { .. } => Default::default(),
                Qr::Backup2 { .. } => Default::default(),
                Qr::BackupTooNew { .. } => Default::default(),
+                Qr::WebrtcInstance { .. } => Default::default(),
                Qr::Proxy { .. } => Default::default(),
                Qr::Addr { contact_id, .. } => contact_id.to_u32(),
                Qr::Url { .. } => Default::default(),
                Qr::Text { .. } => Default::default(),
                Qr::WithdrawVerifyContact { contact_id, .. } => contact_id.to_u32(),
-                Qr::WithdrawVerifyGroup { .. } | Qr::WithdrawJoinBroadcast { .. } => {
-                    Default::default()
-                }
+                Qr::WithdrawVerifyGroup { .. } => Default::default(),
                Qr::ReviveVerifyContact { contact_id, .. } => contact_id.to_u32(),
-                Qr::ReviveVerifyGroup { .. } | Qr::ReviveJoinBroadcast { .. } => Default::default(),
+                Qr::ReviveVerifyGroup { .. } => Default::default(),
                Qr::Login { .. } => Default::default(),
            },
            Self::Error(_) => Default::default(),
@@ -175,9 +169,6 @@ pub enum LotState {
    /// text1=groupname
    QrAskVerifyGroup = 202,

-    /// text1=broadcast_name
-    QrAskJoinBroadcast = 204,
-
    /// id=contact
    QrFprOk = 210,

@@ -194,6 +185,9 @@ pub enum LotState {

    QrBackupTooNew = 255,

+    /// text1=domain, text2=instance pattern
+    QrWebrtcInstance = 260,
+
    /// text1=address, text2=protocol
    QrProxy = 271,

@@ -213,15 +207,11 @@ pub enum LotState {

    /// text1=groupname
    QrWithdrawVerifyGroup = 502,
-    /// text1=broadcast channel name
-    QrWithdrawJoinBroadcast = 504,

    QrReviveVerifyContact = 510,

    /// text1=groupname
    QrReviveVerifyGroup = 512,
-    /// text1=groupname
-    QrReviveJoinBroadcast = 514,

    /// text1=email_address
    QrLogin = 520,
@@ -230,6 +220,7 @@ pub enum LotState {
    MsgInFresh = 10,
    MsgInNoticed = 13,
    MsgInSeen = 16,
+    MsgOutPreparing = 18,
    MsgOutDraft = 19,
    MsgOutPending = 20,
    MsgOutFailed = 24,
@@ -245,6 +236,7 @@ impl From<MessageState> for LotState {
            InFresh => LotState::MsgInFresh,
            InNoticed => LotState::MsgInNoticed,
            InSeen => LotState::MsgInSeen,
+            OutPreparing => LotState::MsgOutPreparing,
            OutDraft => LotState::MsgOutDraft,
            OutPending => LotState::MsgOutPending,
            OutFailed => LotState::MsgOutFailed,
--- a/deltachat-ffi/src/string.rs
+++ b/deltachat-ffi/src/string.rs
@@ -17,15 +17,13 @@ use std::ptr;
 /// }
 /// ```
 unsafe fn dc_strdup(s: *const libc::c_char) -> *mut libc::c_char {
-    unsafe {
-        let ret: *mut libc::c_char = if !s.is_null() {
-            libc::strdup(s)
-        } else {
-            libc::calloc(1, 1) as *mut libc::c_char
-        };
-        assert!(!ret.is_null());
-        ret
-    }
+    let ret: *mut libc::c_char = if !s.is_null() {
+        libc::strdup(s)
+    } else {
+        libc::calloc(1, 1) as *mut libc::c_char
+    };
+    assert!(!ret.is_null());
+    ret
 }

 /// Error type for the [OsStrExt] trait
@@ -166,40 +164,34 @@ pub(crate) trait Strdup {
    /// This function will panic when the original string contains an
    /// interior null byte as this can not be represented in raw C
    /// strings.
-    fn strdup(&self) -> *mut libc::c_char;
+    unsafe fn strdup(&self) -> *mut libc::c_char;
 }

 impl Strdup for str {
-    fn strdup(&self) -> *mut libc::c_char {
-        unsafe {
-            let tmp = CString::new_lossy(self);
-            dc_strdup(tmp.as_ptr())
-        }
+    unsafe fn strdup(&self) -> *mut libc::c_char {
+        let tmp = CString::new_lossy(self);
+        dc_strdup(tmp.as_ptr())
    }
 }

 impl Strdup for String {
-    fn strdup(&self) -> *mut libc::c_char {
+    unsafe fn strdup(&self) -> *mut libc::c_char {
        let s: &str = self;
        s.strdup()
    }
 }

 impl Strdup for std::path::Path {
-    fn strdup(&self) -> *mut libc::c_char {
-        unsafe {
-            let tmp = self.to_c_string().unwrap_or_else(|_| CString::default());
-            dc_strdup(tmp.as_ptr())
-        }
+    unsafe fn strdup(&self) -> *mut libc::c_char {
+        let tmp = self.to_c_string().unwrap_or_else(|_| CString::default());
+        dc_strdup(tmp.as_ptr())
    }
 }

 impl Strdup for [u8] {
-    fn strdup(&self) -> *mut libc::c_char {
-        unsafe {
-            let tmp = CString::new_lossy(self);
-            dc_strdup(tmp.as_ptr())
-        }
+    unsafe fn strdup(&self) -> *mut libc::c_char {
+        let tmp = CString::new_lossy(self);
+        dc_strdup(tmp.as_ptr())
    }
 }

@@ -217,15 +209,15 @@ pub(crate) trait OptStrdup {
    /// Allocate a new raw C `*char` version of this string, or NULL.
    ///
    /// See [Strdup::strdup] for details.
-    fn strdup(&self) -> *mut libc::c_char;
+    unsafe fn strdup(&self) -> *mut libc::c_char;
 }

 impl<T: AsRef<str>> OptStrdup for Option<T> {
-    fn strdup(&self) -> *mut libc::c_char {
+    unsafe fn strdup(&self) -> *mut libc::c_char {
        match self {
            Some(s) => {
                let tmp = CString::new_lossy(s.as_ref());
-                unsafe { dc_strdup(tmp.as_ptr()) }
+                dc_strdup(tmp.as_ptr())
            }
            None => ptr::null_mut(),
        }
@@ -263,18 +255,20 @@ pub(crate) fn to_opt_string_lossy(s: *const libc::c_char) -> Option<String> {
 ///
 /// [Path]: std::path::Path
 #[cfg(not(target_os = "windows"))]
-pub(crate) unsafe fn as_path<'a>(s: *const libc::c_char) -> &'a std::path::Path {
+pub(crate) fn as_path<'a>(s: *const libc::c_char) -> &'a std::path::Path {
    assert!(!s.is_null(), "cannot be used on null pointers");
    use std::os::unix::ffi::OsStrExt;
-    let c_str = unsafe { std::ffi::CStr::from_ptr(s) }.to_bytes();
-    let os_str = std::ffi::OsStr::from_bytes(c_str);
-    std::path::Path::new(os_str)
+    unsafe {
+        let c_str = std::ffi::CStr::from_ptr(s).to_bytes();
+        let os_str = std::ffi::OsStr::from_bytes(c_str);
+        std::path::Path::new(os_str)
+    }
 }

 // as_path() implementation for windows, documented above.
 #[cfg(target_os = "windows")]
-pub(crate) unsafe fn as_path<'a>(s: *const libc::c_char) -> &'a std::path::Path {
-    unsafe { as_path_unicode(s) }
+pub(crate) fn as_path<'a>(s: *const libc::c_char) -> &'a std::path::Path {
+    as_path_unicode(s)
 }

 // Implementation for as_path() on Windows.
@@ -282,7 +276,7 @@ pub(crate) unsafe fn as_path<'a>(s: *const libc::c_char) -> &'a std::path::Path
 // Having this as a separate function means it can be tested on unix
 // too.
 #[allow(dead_code)]
-unsafe fn as_path_unicode<'a>(s: *const libc::c_char) -> &'a std::path::Path {
+fn as_path_unicode<'a>(s: *const libc::c_char) -> &'a std::path::Path {
    assert!(!s.is_null(), "cannot be used on null pointers");

    let cstr = unsafe { CStr::from_ptr(s) };
@@ -370,20 +364,14 @@ mod tests {
    fn test_as_path() {
        let some_path = CString::new("/some/path").unwrap();
        let ptr = some_path.as_ptr();
-        assert_eq!(
-            unsafe { as_path(ptr) },
-            std::ffi::OsString::from("/some/path")
-        )
+        assert_eq!(as_path(ptr), std::ffi::OsString::from("/some/path"))
    }

    #[test]
    fn test_as_path_unicode_fn() {
        let some_path = CString::new("/some/path").unwrap();
        let ptr = some_path.as_ptr();
-        assert_eq!(
-            unsafe { as_path_unicode(ptr) },
-            std::ffi::OsString::from("/some/path")
-        );
+        assert_eq!(as_path_unicode(ptr), std::ffi::OsString::from("/some/path"));
    }

    #[test]
--- a/deltachat-jsonrpc/Cargo.toml
+++ b/deltachat-jsonrpc/Cargo.toml
@@ -1,8 +1,8 @@
 [package]
 name = "deltachat-jsonrpc"
-version = "2.58.0-dev"
+version = "2.3.0"
 description = "DeltaChat JSON-RPC API"
-edition = "2024"
+edition = "2021"
 license = "MPL-2.0"
 repository = "https://github.com/chatmail/core"

@@ -19,6 +19,7 @@ yerpc = { workspace = true, features = ["anyhow_expose", "openrpc"] }
 typescript-type-def = { version = "0.5.13", features = ["json_value"] }
 tokio = { workspace = true }
 sanitize-filename = { workspace = true }
+walkdir = "2.5.0"
 base64 = { workspace = true }

 [dev-dependencies]
--- a/deltachat-jsonrpc/src/api.rs
+++ b/deltachat-jsonrpc/src/api.rs
--- a/deltachat-jsonrpc/src/api/types/account.rs
+++ b/deltachat-jsonrpc/src/api/types/account.rs
@@ -15,7 +15,7 @@ pub enum Account {
        display_name: Option<String>,
        addr: Option<String>,
        // size: u32,
-        profile_image: Option<String>,
+        profile_image: Option<String>, // TODO: This needs to be converted to work with blob http server.
        color: String,
        /// Optional tag as "Work", "Family".
        /// Meant to help profile owner to differ between profiles with similar names.
@@ -32,10 +32,7 @@ impl Account {
            let addr = ctx.get_config(Config::Addr).await?;
            let profile_image = ctx.get_config(Config::Selfavatar).await?;
            let color = color_int_to_hex_string(
-                Contact::get_by_id(ctx, ContactId::SELF)
-                    .await?
-                    .get_or_gen_color(ctx)
-                    .await?,
+                Contact::get_by_id(ctx, ContactId::SELF).await?.get_color(),
            );
            let private_tag = ctx.get_config(Config::PrivateTag).await?;
            Ok(Account::Configured {
--- a/deltachat-jsonrpc/src/api/types/calls.rs
+++ b/deltachat-jsonrpc/src/api/types/calls.rs
@@ -1,97 +0,0 @@
-use anyhow::{Context as _, Result};
-
-use deltachat::calls::{CallState, call_state};
-use deltachat::context::Context;
-use deltachat::message::MsgId;
-use serde::Serialize;
-use typescript_type_def::TypeDef;
-
-#[derive(Serialize, TypeDef, schemars::JsonSchema)]
-#[serde(rename = "CallInfo", rename_all = "camelCase")]
-pub struct JsonrpcCallInfo {
-    /// SDP offer.
-    ///
-    /// Can be used to manually answer the call
-    /// even if incoming call event was missed.
-    pub sdp_offer: String,
-
-    /// True if the call is started as a video call.
-    pub has_video: bool,
-
-    /// Call state.
-    ///
-    /// For example, if the call is accepted, active, canceled, declined etc.
-    pub state: JsonrpcCallState,
-}
-
-impl JsonrpcCallInfo {
-    pub async fn from_msg_id(context: &Context, msg_id: MsgId) -> Result<JsonrpcCallInfo> {
-        let call_info = context.load_call_by_id(msg_id).await?.with_context(|| {
-            format!("Attempting to get call state of non-call message {msg_id}")
-        })?;
-        let sdp_offer = call_info.place_call_info.clone();
-        let has_video = call_info.has_video_initially();
-        let state = JsonrpcCallState::from_msg_id(context, msg_id).await?;
-
-        Ok(JsonrpcCallInfo {
-            sdp_offer,
-            has_video,
-            state,
-        })
-    }
-}
-
-#[derive(Serialize, TypeDef, schemars::JsonSchema)]
-#[serde(rename = "CallState", tag = "kind")]
-pub enum JsonrpcCallState {
-    /// Fresh incoming or outgoing call that is still ringing.
-    ///
-    /// There is no separate state for outgoing call
-    /// that has been dialled but not ringing on the other side yet
-    /// as we don't know whether the other side received our call.
-    Alerting,
-
-    /// Active call.
-    Active,
-
-    /// Completed call that was once active
-    /// and then was terminated for any reason.
-    Completed {
-        /// Call duration in seconds.
-        duration: i64,
-    },
-
-    /// Incoming call that was not picked up within a timeout
-    /// or was explicitly ended by the caller before we picked up.
-    Missed,
-
-    /// Incoming call that was explicitly ended on our side
-    /// before picking up or outgoing call
-    /// that was declined before the timeout.
-    Declined,
-
-    /// Outgoing call that has been canceled on our side
-    /// before receiving a response.
-    ///
-    /// Incoming calls cannot be canceled,
-    /// on the receiver side canceled calls
-    /// usually result in missed calls.
-    Canceled,
-}
-
-impl JsonrpcCallState {
-    pub async fn from_msg_id(context: &Context, msg_id: MsgId) -> Result<JsonrpcCallState> {
-        let call_state = call_state(context, msg_id).await?;
-
-        let jsonrpc_call_state = match call_state {
-            CallState::Alerting => JsonrpcCallState::Alerting,
-            CallState::Active => JsonrpcCallState::Active,
-            CallState::Completed { duration } => JsonrpcCallState::Completed { duration },
-            CallState::Missed => JsonrpcCallState::Missed,
-            CallState::Declined => JsonrpcCallState::Declined,
-            CallState::Canceled => JsonrpcCallState::Canceled,
-        };
-
-        Ok(jsonrpc_call_state)
-    }
-}
--- a/deltachat-jsonrpc/src/api/types/chat.rs
+++ b/deltachat-jsonrpc/src/api/types/chat.rs
@@ -1,15 +1,17 @@
 use std::time::{Duration, SystemTime};

-use anyhow::{Context as _, Result, bail};
-use deltachat::chat::{self, ChatVisibility, get_chat_contacts, get_past_chat_contacts};
+use anyhow::{bail, Context as _, Result};
+use deltachat::chat::{self, get_chat_contacts, get_past_chat_contacts, ChatVisibility};
 use deltachat::chat::{Chat, ChatId};
 use deltachat::constants::Chattype;
 use deltachat::contact::{Contact, ContactId};
 use deltachat::context::Context;
+use num_traits::cast::ToPrimitive;
 use serde::{Deserialize, Serialize};
 use typescript_type_def::TypeDef;

 use super::color_int_to_hex_string;
+use super::contact::ContactObject;

 #[derive(Serialize, TypeDef, schemars::JsonSchema)]
 #[serde(rename_all = "camelCase")]
@@ -17,6 +19,17 @@ pub struct FullChat {
    id: u32,
    name: String,

+    /// True if the chat is protected.
+    ///
+    /// UI should display a green checkmark
+    /// in the chat title,
+    /// in the chat profile title and
+    /// in the chatlist item
+    /// if chat protection is enabled.
+    /// UI should also display a green checkmark
+    /// in the contact profile
+    /// if 1:1 chat with this contact exists and is protected.
+    is_protected: bool,
    /// True if the chat is encrypted.
    /// This means that all messages in the chat are encrypted,
    /// and all contacts in the chat are "key-contacts",
@@ -44,9 +57,10 @@ pub struct FullChat {
    archived: bool,
    pinned: bool,
    // subtitle  - will be moved to frontend because it uses translation functions
-    chat_type: JsonrpcChatType,
+    chat_type: u32,
    is_unpromoted: bool,
    is_self_talk: bool,
+    contacts: Vec<ContactObject>,
    contact_ids: Vec<u32>,

    /// Contact IDs of the past chat members.
@@ -56,18 +70,11 @@ pub struct FullChat {
    fresh_message_counter: usize,
    // is_group - please check over chat.type in frontend instead
    is_contact_request: bool,
-
+    is_protection_broken: bool,
    is_device_chat: bool,
-    /// Note that this is different from
-    /// [`ChatListItem::is_self_in_group`](`crate::api::types::chat_list::ChatListItemFetchResult::ChatListItem::is_self_in_group`).
-    /// This property should only be accessed
-    /// when [`FullChat::chat_type`] is [`Chattype::Group`].
-    //
-    // We could utilize [`Chat::is_self_in_chat`],
-    // but that would be an extra DB query.
    self_in_group: bool,
    is_muted: bool,
-    ephemeral_timer: u32,
+    ephemeral_timer: u32, //TODO look if there are more important properties in newer core versions
    can_send: bool,
    was_seen_recently: bool,
    mailing_list_address: Option<String>,
@@ -81,6 +88,20 @@ impl FullChat {
        let contact_ids = get_chat_contacts(context, rust_chat_id).await?;
        let past_contact_ids = get_past_chat_contacts(context, rust_chat_id).await?;

+        let mut contacts = Vec::with_capacity(contact_ids.len());
+
+        for contact_id in &contact_ids {
+            contacts.push(
+                ContactObject::try_from_dc_contact(
+                    context,
+                    Contact::get_by_id(context, *contact_id)
+                        .await
+                        .context("failed to load contact")?,
+                )
+                .await?,
+            )
+        }
+
        let profile_image = match chat.get_profile_image(context).await? {
            Some(path_buf) => path_buf.to_str().map(|s| s.to_owned()),
            None => None,
@@ -109,18 +130,21 @@ impl FullChat {
        Ok(FullChat {
            id: chat_id,
            name: chat.name.clone(),
+            is_protected: chat.is_protected(),
            is_encrypted: chat.is_encrypted(context).await?,
            profile_image, //BLOBS ?
            archived: chat.get_visibility() == chat::ChatVisibility::Archived,
            pinned: chat.get_visibility() == chat::ChatVisibility::Pinned,
-            chat_type: chat.get_type().into(),
+            chat_type: chat.get_type().to_u32().context("unknown chat type id")?,
            is_unpromoted: chat.is_unpromoted(),
            is_self_talk: chat.is_self_talk(),
+            contacts,
            contact_ids: contact_ids.iter().map(|id| id.to_u32()).collect(),
            past_contact_ids: past_contact_ids.iter().map(|id| id.to_u32()).collect(),
            color,
            fresh_message_counter,
            is_contact_request: chat.is_contact_request(),
+            is_protection_broken: chat.is_protection_broken(),
            is_device_chat: chat.is_device_talk(),
            self_in_group: contact_ids.contains(&ContactId::SELF),
            is_muted: chat.is_muted(),
@@ -133,6 +157,7 @@ impl FullChat {
 }

 /// cheaper version of fullchat, omits:
+/// - contacts
 /// - contact_ids
 /// - fresh_message_counter
 /// - ephemeral_timer
@@ -147,6 +172,18 @@ pub struct BasicChat {
    id: u32,
    name: String,

+    /// True if the chat is protected.
+    ///
+    /// UI should display a green checkmark
+    /// in the chat title,
+    /// in the chat profile title and
+    /// in the chatlist item
+    /// if chat protection is enabled.
+    /// UI should also display a green checkmark
+    /// in the contact profile
+    /// if 1:1 chat with this contact exists and is protected.
+    is_protected: bool,
+
    /// True if the chat is encrypted.
    /// This means that all messages in the chat are encrypted,
    /// and all contacts in the chat are "key-contacts",
@@ -173,12 +210,12 @@ pub struct BasicChat {
    profile_image: Option<String>, //BLOBS ?
    archived: bool,
    pinned: bool,
-    chat_type: JsonrpcChatType,
+    chat_type: u32,
    is_unpromoted: bool,
    is_self_talk: bool,
    color: String,
    is_contact_request: bool,
-
+    is_protection_broken: bool,
    is_device_chat: bool,
    is_muted: bool,
 }
@@ -197,15 +234,17 @@ impl BasicChat {
        Ok(BasicChat {
            id: chat_id,
            name: chat.name.clone(),
+            is_protected: chat.is_protected(),
            is_encrypted: chat.is_encrypted(context).await?,
            profile_image, //BLOBS ?
            archived: chat.get_visibility() == chat::ChatVisibility::Archived,
            pinned: chat.get_visibility() == chat::ChatVisibility::Pinned,
-            chat_type: chat.get_type().into(),
+            chat_type: chat.get_type().to_u32().context("unknown chat type id")?,
            is_unpromoted: chat.is_unpromoted(),
            is_self_talk: chat.is_self_talk(),
            color,
            is_contact_request: chat.is_contact_request(),
+            is_protection_broken: chat.is_protection_broken(),
            is_device_chat: chat.is_device_talk(),
            is_muted: chat.is_muted(),
        })
@@ -240,52 +279,18 @@ impl MuteDuration {

 #[derive(Clone, Serialize, Deserialize, TypeDef, schemars::JsonSchema)]
 #[serde(rename = "ChatVisibility")]
-pub enum JsonrpcChatVisibility {
+pub enum JSONRPCChatVisibility {
    Normal,
    Archived,
    Pinned,
 }

-impl JsonrpcChatVisibility {
+impl JSONRPCChatVisibility {
    pub fn into_core_type(self) -> ChatVisibility {
        match self {
-            JsonrpcChatVisibility::Normal => ChatVisibility::Normal,
-            JsonrpcChatVisibility::Archived => ChatVisibility::Archived,
-            JsonrpcChatVisibility::Pinned => ChatVisibility::Pinned,
-        }
-    }
-}
-
-#[derive(Clone, Serialize, Deserialize, PartialEq, TypeDef, schemars::JsonSchema)]
-#[serde(rename = "ChatType")]
-pub enum JsonrpcChatType {
-    Single,
-    Group,
-    Mailinglist,
-    OutBroadcast,
-    InBroadcast,
-}
-
-impl From<Chattype> for JsonrpcChatType {
-    fn from(chattype: Chattype) -> Self {
-        match chattype {
-            Chattype::Single => JsonrpcChatType::Single,
-            Chattype::Group => JsonrpcChatType::Group,
-            Chattype::Mailinglist => JsonrpcChatType::Mailinglist,
-            Chattype::OutBroadcast => JsonrpcChatType::OutBroadcast,
-            Chattype::InBroadcast => JsonrpcChatType::InBroadcast,
-        }
-    }
-}
-
-impl From<JsonrpcChatType> for Chattype {
-    fn from(chattype: JsonrpcChatType) -> Self {
-        match chattype {
-            JsonrpcChatType::Single => Chattype::Single,
-            JsonrpcChatType::Group => Chattype::Group,
-            JsonrpcChatType::Mailinglist => Chattype::Mailinglist,
-            JsonrpcChatType::OutBroadcast => Chattype::OutBroadcast,
-            JsonrpcChatType::InBroadcast => Chattype::InBroadcast,
+            JSONRPCChatVisibility::Normal => ChatVisibility::Normal,
+            JSONRPCChatVisibility::Archived => ChatVisibility::Archived,
+            JSONRPCChatVisibility::Pinned => ChatVisibility::Pinned,
        }
    }
 }
--- a/deltachat-jsonrpc/src/api/types/chat_list.rs
+++ b/deltachat-jsonrpc/src/api/types/chat_list.rs
@@ -2,16 +2,15 @@ use anyhow::{Context, Result};
 use deltachat::chat::{Chat, ChatId};
 use deltachat::chatlist::get_last_message_for_chat;
 use deltachat::constants::*;
-use deltachat::contact::Contact;
+use deltachat::contact::{Contact, ContactId};
 use deltachat::{
-    chat::{ChatVisibility, get_chat_contacts},
+    chat::{get_chat_contacts, ChatVisibility},
    chatlist::Chatlist,
 };
 use num_traits::cast::ToPrimitive;
 use serde::Serialize;
 use typescript_type_def::TypeDef;

-use super::chat::JsonrpcChatType;
 use super::color_int_to_hex_string;
 use super::message::MessageViewtype;

@@ -24,13 +23,14 @@ pub enum ChatListItemFetchResult {
        name: String,
        avatar_path: Option<String>,
        color: String,
-        chat_type: JsonrpcChatType,
+        chat_type: u32,
        last_updated: Option<i64>,
        summary_text1: String,
        summary_text2: String,
        summary_status: u32,
        /// showing preview if last chat message is image
        summary_preview_image: Option<String>,
+        is_protected: bool,

        /// True if the chat is encrypted.
        /// This means that all messages in the chat are encrypted,
@@ -127,8 +127,11 @@ pub(crate) async fn get_chat_list_item_by_id(
        None => (None, None),
    };

+    let chat_contacts = get_chat_contacts(ctx, chat_id).await?;
+
+    let self_in_group = chat_contacts.contains(&ContactId::SELF);
+
    let (dm_chat_contact, was_seen_recently) = if chat.get_type() == Chattype::Single {
-        let chat_contacts = get_chat_contacts(ctx, chat_id).await?;
        let contact = chat_contacts.first();
        let was_seen_recently = match contact {
            Some(contact) => Contact::get_by_id(ctx, *contact)
@@ -152,18 +155,19 @@ pub(crate) async fn get_chat_list_item_by_id(
        name: chat.get_name().to_owned(),
        avatar_path,
        color,
-        chat_type: chat.get_type().into(),
+        chat_type: chat.get_type().to_u32().context("unknown chat type id")?,
        last_updated,
        summary_text1,
        summary_text2,
        summary_status: summary.state.to_u32().expect("impossible"), // idea and a function to transform the constant to strings? or return string enum
        summary_preview_image,
+        is_protected: chat.is_protected(),
        is_encrypted: chat.is_encrypted(ctx).await?,
        is_group: chat.get_type() == Chattype::Group,
        fresh_message_counter,
        is_self_talk: chat.is_self_talk(),
        is_device_talk: chat.is_device_talk(),
-        is_self_in_group: chat.is_self_in_chat(ctx).await?,
+        is_self_in_group: self_in_group,
        is_sending_location: chat.is_sending_locations(),
        is_archived: visibility == ChatVisibility::Archived,
        is_pinned: visibility == ChatVisibility::Pinned,
--- a/deltachat-jsonrpc/src/api/types/contact.rs
+++ b/deltachat-jsonrpc/src/api/types/contact.rs
@@ -1,6 +1,6 @@
 use anyhow::Result;
+use deltachat::color;
 use deltachat::context::Context;
-use deltachat::key::{DcKey, SignedPublicKey};
 use serde::Serialize;
 use typescript_type_def::TypeDef;

@@ -31,35 +31,27 @@ pub struct ContactObject {
    /// e.g. if we just scanned the fingerprint from a QR code.
    e2ee_avail: bool,

-    /// True if the contact
-    /// can be added to protected chats
-    /// because SELF and contact have verified their fingerprints in both directions.
+    /// True if the contact can be added to verified groups.
    ///
-    /// See [`Self::verifier_id`]/`Contact.verifierId` for a guidance how to display these information.
+    /// If this is true
+    /// UI should display green checkmark after the contact name
+    /// in contact list items,
+    /// in chat member list items
+    /// and in profiles if no chat with the contact exist.
    is_verified: bool,

-    /// The contact ID that verified a contact.
+    /// True if the contact profile title should have a green checkmark.
    ///
-    /// As verifier may be unknown,
-    /// use [`Self::is_verified`]/`Contact.isVerified` to check if a contact can be added to a protected chat.
+    /// This indicates whether 1:1 chat has a green checkmark
+    /// or will have a green checkmark if created.
+    is_profile_verified: bool,
+
+    /// The ID of the contact that verified this contact.
    ///
-    /// UI should display the information in the contact's profile as follows:
-    ///
-    /// - If `verifierId` != 0,
-    ///   display text "Introduced by ..."
-    ///   with the name of the contact.
-    ///   Prefix the text by a green checkmark.
-    ///
-    /// - If `verifierId` == 0 and `isVerified` != 0,
-    ///   display "Introduced" prefixed by a green checkmark.
-    ///
-    /// - if `verifierId` == 0 and `isVerified` == 0,
-    ///   display nothing
-    ///
-    /// This contains the contact ID of the verifier.
-    /// If it is `DC_CONTACT_ID_SELF`, we verified the contact ourself.
-    /// If it is None/Null, we don't have verifier information or
-    /// the contact is not verified.
+    /// If this is present,
+    /// display a green checkmark and "Introduced by ..."
+    /// string followed by the verifier contact name and address
+    /// in the contact profile.
    verifier_id: Option<u32>,

    /// the contact's last seen timestamp
@@ -80,6 +72,7 @@ impl ContactObject {
            None => None,
        };
        let is_verified = contact.is_verified(context).await?;
+        let is_profile_verified = contact.is_profile_verified(context).await?;

        let verifier_id = contact
            .get_verifier_id(context)
@@ -101,6 +94,7 @@ impl ContactObject {
            is_key_contact: contact.is_key_contact(),
            e2ee_avail: contact.e2ee_avail(context).await?,
            is_verified,
+            is_profile_verified,
            verifier_id,
            last_seen: contact.last_seen(),
            was_seen_recently: contact.was_seen_recently(),
@@ -129,13 +123,7 @@ pub struct VcardContact {
 impl From<deltachat_contact_tools::VcardContact> for VcardContact {
    fn from(vc: deltachat_contact_tools::VcardContact) -> Self {
        let display_name = vc.display_name().to_string();
-        let is_self = false;
-        let fpr = vc.key.as_deref().and_then(|k| {
-            SignedPublicKey::from_base64(k)
-                .ok()
-                .map(|k| k.dc_fingerprint())
-        });
-        let color = deltachat::contact::get_color(is_self, &vc.addr, &fpr);
+        let color = color::str_to_color(&vc.addr.to_lowercase());
        Self {
            addr: vc.addr,
            display_name,
--- a/deltachat-jsonrpc/src/api/types/events.rs
+++ b/deltachat-jsonrpc/src/api/types/events.rs
@@ -2,8 +2,6 @@ use deltachat::{Event as CoreEvent, EventType as CoreEventType};
 use serde::Serialize;
 use typescript_type_def::TypeDef;

-use super::chat::JsonrpcChatType;
-
 #[derive(Serialize, TypeDef, schemars::JsonSchema)]
 #[serde(rename_all = "camelCase")]
 pub struct Event {
@@ -203,17 +201,6 @@ pub enum EventType {
        msg_id: u32,
    },

-    /// Like [`EventType::MsgRead`], but also fires on subsequent MDNs,
-    /// if there are multiple receivers, i.e. in groups and channels.
-    #[serde(rename_all = "camelCase")]
-    MsgReadCountChanged {
-        /// ID of the chat which the message belongs to.
-        chat_id: u32,
-
-        /// ID of the message that was read.
-        msg_id: u32,
-    },
-
    /// A single message was deleted.
    ///
    /// This event means that the message will no longer appear in the messagelist.
@@ -237,6 +224,7 @@ pub enum EventType {
    },

    /// Chat changed.  The name or the image of a chat group was changed or members were added or removed.
+    /// Or the verify state of a chat has changed.
    /// See setChatName(), setChatProfileImage(), addContactToChat()
    /// and removeContactFromChat().
    ///
@@ -282,7 +270,7 @@ pub enum EventType {
        /// Progress.
        ///
        /// 0=error, 1-999=progress in permille, 1000=success and done
-        progress: u16,
+        progress: usize,

        /// Progress comment or error, something to display to the user.
        comment: Option<String>,
@@ -293,7 +281,7 @@ pub enum EventType {
    #[serde(rename_all = "camelCase")]
    ImexProgress {
        /// 0=error, 1-999=progress in permille, 1000=success and done
-        progress: u16,
+        progress: usize,
    },

    /// A file has been exported. A file has been written by imex().
@@ -306,8 +294,8 @@ pub enum EventType {
    #[serde(rename_all = "camelCase")]
    ImexFileWritten { path: String },

-    /// Progress event sent when SecureJoin protocol has finished
-    /// from the view of the inviter (Alice, the person who shows the QR code).
+    /// Progress information of a secure-join handshake from the view of the inviter
+    /// (Alice, the person who shows the QR code).
    ///
    /// These events are typically sent after a joiner has scanned the QR code
    /// generated by getChatSecurejoinQrCodeSvg().
@@ -316,15 +304,12 @@ pub enum EventType {
        /// ID of the contact that wants to join.
        contact_id: u32,

-        /// The type of the joined chat.
-        /// This can take the same values
-        /// as `BasicChat.chatType` ([`crate::api::types::chat::BasicChat::chat_type`]).
-        chat_type: JsonrpcChatType,
-        /// ID of the chat in case of success.
-        chat_id: u32,
-
-        /// Progress, always 1000.
-        progress: u16,
+        /// Progress as:
+        /// 300=vg-/vc-request received, typically shown as "bob@addr joins".
+        /// 600=vg-/vc-request-with-auth received, vg-member-added/vc-contact-confirm sent, typically shown as "bob@addr verified".
+        /// 800=contact added to chat, shown as "bob@addr securely joined GROUP". Only for the verified-group-protocol.
+        /// 1000=Protocol finished for this contact.
+        progress: usize,
    },

    /// Progress information of a secure-join handshake from the view of the joiner
@@ -340,7 +325,7 @@ pub enum EventType {
        /// 400=vg-/vc-request-with-auth sent, typically shown as "alice@addr verified, introducing myself."
        /// (Bob has verified alice and waits until Alice does the same for him)
        /// 1000=vg-member-added/vc-contact-confirm received
-        progress: u16,
+        progress: usize,
    },

    /// The connectivity to the server changed.
@@ -432,56 +417,6 @@ pub enum EventType {
        /// Number of events skipped.
        n: u64,
    },
-
-    /// Incoming call.
-    IncomingCall {
-        /// ID of the info message referring to the call.
-        msg_id: u32,
-        /// ID of the chat which the message belongs to.
-        chat_id: u32,
-        /// User-defined info as passed to place_outgoing_call()
-        place_call_info: String,
-        /// True if incoming call is a video call.
-        has_video: bool,
-    },
-
-    /// Incoming call accepted.
-    /// This is esp. interesting to stop ringing on other devices.
-    IncomingCallAccepted {
-        /// ID of the info message referring to the call.
-        msg_id: u32,
-        /// ID of the chat which the message belongs to.
-        chat_id: u32,
-        /// The call was accepted from this device (process).
-        from_this_device: bool,
-    },
-
-    /// Outgoing call accepted.
-    OutgoingCallAccepted {
-        /// ID of the info message referring to the call.
-        msg_id: u32,
-        /// ID of the chat which the message belongs to.
-        chat_id: u32,
-        /// User-defined info passed to dc_accept_incoming_call(
-        accept_call_info: String,
-    },
-
-    /// Call ended.
-    CallEnded {
-        /// ID of the info message referring to the call.
-        msg_id: u32,
-        /// ID of the chat which the message belongs to.
-        chat_id: u32,
-    },
-
-    /// One or more transports has changed.
-    ///
-    /// UI should update the list.
-    ///
-    /// This event is emitted when transport
-    /// synchronization messages arrives,
-    /// but not when the UI modifies the transport list by itself.
-    TransportsModified,
 }

 impl From<CoreEventType> for EventType {
@@ -557,10 +492,6 @@ impl From<CoreEventType> for EventType {
                chat_id: chat_id.to_u32(),
                msg_id: msg_id.to_u32(),
            },
-            CoreEventType::MsgReadCountChanged { chat_id, msg_id } => MsgReadCountChanged {
-                chat_id: chat_id.to_u32(),
-                msg_id: msg_id.to_u32(),
-            },
            CoreEventType::MsgDeleted { chat_id, msg_id } => MsgDeleted {
                chat_id: chat_id.to_u32(),
                msg_id: msg_id.to_u32(),
@@ -592,13 +523,9 @@ impl From<CoreEventType> for EventType {
            },
            CoreEventType::SecurejoinInviterProgress {
                contact_id,
-                chat_type,
-                chat_id,
                progress,
            } => SecurejoinInviterProgress {
                contact_id: contact_id.to_u32(),
-                chat_type: chat_type.into(),
-                chat_id: chat_id.to_u32(),
                progress,
            },
            CoreEventType::SecurejoinJoinerProgress {
@@ -640,41 +567,6 @@ impl From<CoreEventType> for EventType {
            CoreEventType::EventChannelOverflow { n } => EventChannelOverflow { n },
            CoreEventType::AccountsChanged => AccountsChanged,
            CoreEventType::AccountsItemChanged => AccountsItemChanged,
-            CoreEventType::IncomingCall {
-                msg_id,
-                chat_id,
-                place_call_info,
-                has_video,
-            } => IncomingCall {
-                msg_id: msg_id.to_u32(),
-                chat_id: chat_id.to_u32(),
-                place_call_info,
-                has_video,
-            },
-            CoreEventType::IncomingCallAccepted {
-                msg_id,
-                chat_id,
-                from_this_device,
-            } => IncomingCallAccepted {
-                msg_id: msg_id.to_u32(),
-                chat_id: chat_id.to_u32(),
-                from_this_device,
-            },
-            CoreEventType::OutgoingCallAccepted {
-                msg_id,
-                chat_id,
-                accept_call_info,
-            } => OutgoingCallAccepted {
-                msg_id: msg_id.to_u32(),
-                chat_id: chat_id.to_u32(),
-                accept_call_info,
-            },
-            CoreEventType::CallEnded { msg_id, chat_id } => CallEnded {
-                msg_id: msg_id.to_u32(),
-                chat_id: chat_id.to_u32(),
-            },
-            CoreEventType::TransportsModified => TransportsModified,
-
            #[allow(unreachable_patterns)]
            #[cfg(test)]
            _ => unreachable!("This is just to silence a rust_analyzer false-positive"),
--- a/deltachat-jsonrpc/src/api/types/http.rs
+++ b/deltachat-jsonrpc/src/api/types/http.rs
@@ -16,7 +16,7 @@ pub struct HttpResponse {

 impl From<CoreHttpResponse> for HttpResponse {
    fn from(response: CoreHttpResponse) -> Self {
-        use base64::{Engine as _, engine::general_purpose};
+        use base64::{engine::general_purpose, Engine as _};
        let blob = general_purpose::STANDARD_NO_PAD.encode(response.blob);
        let mimetype = response.mimetype;
        let encoding = response.encoding;
--- a/deltachat-jsonrpc/src/api/types/login_param.rs
+++ b/deltachat-jsonrpc/src/api/types/login_param.rs
@@ -4,16 +4,6 @@ use serde::Deserialize;
 use serde::Serialize;
 use yerpc::TypeDef;

-#[derive(Serialize, TypeDef, schemars::JsonSchema)]
-#[serde(rename_all = "camelCase")]
-pub struct TransportListEntry {
-    /// The login data entered by the user.
-    pub param: EnteredLoginParam,
-    /// Whether this transport is set to 'unpublished'.
-    /// See `set_transport_unpublished` / `setTransportUnpublished` for details.
-    pub is_unpublished: bool,
-}
-
 /// Login parameters entered by the user.
 ///
 /// Usually it will be enough to only set `addr` and `password`,
@@ -33,12 +23,6 @@ pub struct EnteredLoginParam {
    /// Imap server port.
    pub imap_port: Option<u16>,

-    /// IMAP server folder.
-    ///
-    /// Defaults to "INBOX" if not set.
-    /// Should not be an empty string.
-    pub imap_folder: Option<String>,
-
    /// Imap socket security.
    pub imap_security: Option<Socket>,

@@ -66,15 +50,10 @@ pub struct EnteredLoginParam {
    /// invalid hostnames.
    /// Default: Automatic
    pub certificate_checks: Option<EnteredCertificateChecks>,
-}

-impl From<dc::TransportListEntry> for TransportListEntry {
-    fn from(transport: dc::TransportListEntry) -> Self {
-        TransportListEntry {
-            param: transport.param.into(),
-            is_unpublished: transport.is_unpublished,
-        }
-    }
+    /// If true, login via OAUTH2 (not recommended anymore).
+    /// Default: false
+    pub oauth2: Option<bool>,
 }

 impl From<dc::EnteredLoginParam> for EnteredLoginParam {
@@ -87,7 +66,6 @@ impl From<dc::EnteredLoginParam> for EnteredLoginParam {
            password: param.imap.password,
            imap_server: param.imap.server.into_option(),
            imap_port: param.imap.port.into_option(),
-            imap_folder: param.imap.folder.into_option(),
            imap_security: imap_security.into_option(),
            imap_user: param.imap.user.into_option(),
            smtp_server: param.smtp.server.into_option(),
@@ -96,6 +74,7 @@ impl From<dc::EnteredLoginParam> for EnteredLoginParam {
            smtp_user: param.smtp.user.into_option(),
            smtp_password: param.smtp.password.into_option(),
            certificate_checks: certificate_checks.into_option(),
+            oauth2: param.oauth2.into_option(),
        }
    }
 }
@@ -106,15 +85,14 @@ impl TryFrom<EnteredLoginParam> for dc::EnteredLoginParam {
    fn try_from(param: EnteredLoginParam) -> Result<Self> {
        Ok(Self {
            addr: param.addr,
-            imap: dc::EnteredImapLoginParam {
+            imap: dc::EnteredServerLoginParam {
                server: param.imap_server.unwrap_or_default(),
                port: param.imap_port.unwrap_or_default(),
-                folder: param.imap_folder.unwrap_or_default(),
                security: param.imap_security.unwrap_or_default().into(),
                user: param.imap_user.unwrap_or_default(),
                password: param.password,
            },
-            smtp: dc::EnteredSmtpLoginParam {
+            smtp: dc::EnteredServerLoginParam {
                server: param.smtp_server.unwrap_or_default(),
                port: param.smtp_port.unwrap_or_default(),
                security: param.smtp_security.unwrap_or_default().into(),
@@ -122,7 +100,7 @@ impl TryFrom<EnteredLoginParam> for dc::EnteredLoginParam {
                password: param.smtp_password.unwrap_or_default(),
            },
            certificate_checks: param.certificate_checks.unwrap_or_default().into(),
-            oauth2: false,
+            oauth2: param.oauth2.unwrap_or_default(),
        })
    }
 }
@@ -169,8 +147,9 @@ impl From<Socket> for dc::Socket {
 #[derive(Serialize, Deserialize, TypeDef, schemars::JsonSchema, Default, PartialEq)]
 #[serde(rename_all = "camelCase")]
 pub enum EnteredCertificateChecks {
-    /// `Automatic` means strict certificate checks,
-    /// unless a legacy-domain override disables them.
+    /// `Automatic` means that provider database setting should be taken.
+    /// If there is no provider database setting for certificate checks,
+    /// check certificates strictly.
    #[default]
    Automatic,

--- a/deltachat-jsonrpc/src/api/types/message.rs
+++ b/deltachat-jsonrpc/src/api/types/message.rs
@@ -16,10 +16,9 @@ use num_traits::cast::ToPrimitive;
 use serde::{Deserialize, Serialize};
 use typescript_type_def::TypeDef;

-use super::chat::JsonrpcChatType;
 use super::color_int_to_hex_string;
 use super::contact::ContactObject;
-use super::reactions::JsonrpcReactions;
+use super::reactions::JSONRPCReactions;

 #[derive(Serialize, TypeDef, schemars::JsonSchema)]
 #[serde(rename_all = "camelCase", tag = "kind")]
@@ -68,6 +67,7 @@ pub struct MessageObject {
    /// if `show_padlock` is `false`,
    /// and nothing if it is `true`.
    show_padlock: bool,
+    is_setupmessage: bool,
    is_info: bool,
    is_forwarded: bool,

@@ -84,14 +84,16 @@ pub struct MessageObject {
    dimensions_height: i32,
    dimensions_width: i32,

+    videochat_type: Option<u32>,
+    videochat_url: Option<String>,
+
    override_sender_name: Option<String>,
    sender: ContactObject,

+    setup_code_begin: Option<String>,
+
    file: Option<String>,
    file_mime: Option<String>,
-
-    /// The size of the file in bytes, if applicable.
-    /// If message is a pre-message, then this is the size of the file to be downloaded.
    file_bytes: u64,
    file_name: Option<String>,

@@ -103,7 +105,7 @@ pub struct MessageObject {

    saved_message_id: Option<u32>,

-    reactions: Option<JsonrpcReactions>,
+    reactions: Option<JSONRPCReactions>,

    vcard_contact: Option<VcardContact>,
 }
@@ -223,6 +225,7 @@ impl MessageObject {

            subject: message.get_subject().to_owned(),
            show_padlock: message.get_showpadlock(),
+            is_setupmessage: message.is_setupmessage(),
            is_info: message.is_info(),
            is_forwarded: message.is_forwarded(),
            is_bot: message.is_bot(),
@@ -236,9 +239,20 @@ impl MessageObject {
            dimensions_height: message.get_height(),
            dimensions_width: message.get_width(),

+            videochat_type: match message.get_videochat_type() {
+                Some(vct) => Some(
+                    vct.to_u32()
+                        .context("videochat type conversion to number failed")?,
+                ),
+                None => None,
+            },
+            videochat_url: message.get_videochat_url(),
+
            override_sender_name,
            sender,

+            setup_code_begin: message.get_setupcodebegin(context).await,
+
            file: match message.get_file(context) {
                Some(path_buf) => path_buf.to_str().map(|s| s.to_owned()),
                None => None,
@@ -287,6 +301,8 @@ pub enum MessageViewtype {
    Gif,

    /// Message containing a sticker, similar to image.
+    /// NB: When sending, the message viewtype may be changed to `Image` by some heuristics like
+    /// checking for transparent pixels. Use `Message::force_sticker()` to disable them.
    ///
    /// If possible, the ui should display the image without borders in a transparent way.
    /// A click on a sticker will offer to install the sticker set in some future.
@@ -305,8 +321,8 @@ pub enum MessageViewtype {
    /// Message containing any file, eg. a PDF.
    File,

-    /// Message is a call.
-    Call,
+    /// Message is an invitation to a videochat.
+    VideochatInvitation,

    /// Message is an webxdc instance.
    Webxdc,
@@ -329,7 +345,7 @@ impl From<Viewtype> for MessageViewtype {
            Viewtype::Voice => MessageViewtype::Voice,
            Viewtype::Video => MessageViewtype::Video,
            Viewtype::File => MessageViewtype::File,
-            Viewtype::Call => MessageViewtype::Call,
+            Viewtype::VideochatInvitation => MessageViewtype::VideochatInvitation,
            Viewtype::Webxdc => MessageViewtype::Webxdc,
            Viewtype::Vcard => MessageViewtype::Vcard,
        }
@@ -348,7 +364,7 @@ impl From<MessageViewtype> for Viewtype {
            MessageViewtype::Voice => Viewtype::Voice,
            MessageViewtype::Video => Viewtype::Video,
            MessageViewtype::File => Viewtype::File,
-            MessageViewtype::Call => Viewtype::Call,
+            MessageViewtype::VideochatInvitation => Viewtype::VideochatInvitation,
            MessageViewtype::Webxdc => Viewtype::Webxdc,
            MessageViewtype::Vcard => Viewtype::Vcard,
        }
@@ -380,7 +396,6 @@ impl From<download::DownloadState> for DownloadState {
 pub enum SystemMessageType {
    Unknown,
    GroupNameChanged,
-    GroupDescriptionChanged,
    GroupImageChanged,
    MemberAddedToGroup,
    MemberRemovedFromGroup,
@@ -390,11 +405,11 @@ pub enum SystemMessageType {
    LocationOnly,
    InvalidUnencryptedMail,

-    /// Single chats info message telling that SecureJoin has started and the user should wait for it
+    /// 1:1 chats info message telling that SecureJoin has started and the user should wait for it
    /// to complete.
    SecurejoinWait,

-    /// Single chats info message telling that SecureJoin is still running, but the user may already
+    /// 1:1 chats info message telling that SecureJoin is still running, but the user may already
    /// send messages.
    SecurejoinWaitTimeout,

@@ -422,9 +437,6 @@ pub enum SystemMessageType {

    /// This message contains a users iroh node address.
    IrohNodeAddr,
-
-    CallAccepted,
-    CallEnded,
 }

 impl From<deltachat::mimeparser::SystemMessage> for SystemMessageType {
@@ -433,7 +445,6 @@ impl From<deltachat::mimeparser::SystemMessage> for SystemMessageType {
        match system_message_type {
            SystemMessage::Unknown => SystemMessageType::Unknown,
            SystemMessage::GroupNameChanged => SystemMessageType::GroupNameChanged,
-            SystemMessage::GroupDescriptionChanged => SystemMessageType::GroupDescriptionChanged,
            SystemMessage::GroupImageChanged => SystemMessageType::GroupImageChanged,
            SystemMessage::MemberAddedToGroup => SystemMessageType::MemberAddedToGroup,
            SystemMessage::MemberRemovedFromGroup => SystemMessageType::MemberRemovedFromGroup,
@@ -452,8 +463,6 @@ impl From<deltachat::mimeparser::SystemMessage> for SystemMessageType {
            SystemMessage::IrohNodeAddr => SystemMessageType::IrohNodeAddr,
            SystemMessage::SecurejoinWait => SystemMessageType::SecurejoinWait,
            SystemMessage::SecurejoinWaitTimeout => SystemMessageType::SecurejoinWaitTimeout,
-            SystemMessage::CallAccepted => SystemMessageType::CallAccepted,
-            SystemMessage::CallEnded => SystemMessageType::CallEnded,
        }
    }
 }
@@ -529,7 +538,8 @@ pub struct MessageSearchResult {
    chat_profile_image: Option<String>,
    chat_color: String,
    chat_name: String,
-    chat_type: JsonrpcChatType,
+    chat_type: u32,
+    is_chat_protected: bool,
    is_chat_contact_request: bool,
    is_chat_archived: bool,
    message: String,
@@ -567,8 +577,9 @@ impl MessageSearchResult {
            chat_id: chat.id.to_u32(),
            chat_name: chat.get_name().to_owned(),
            chat_color,
-            chat_type: chat.get_type().into(),
+            chat_type: chat.get_type().to_u32().context("unknown chat type id")?,
            chat_profile_image,
+            is_chat_protected: chat.is_protected(),
            is_chat_contact_request: chat.is_contact_request(),
            is_chat_archived: chat.get_visibility() == ChatVisibility::Archived,
            message: message.get_text(),
@@ -579,7 +590,7 @@ impl MessageSearchResult {

 #[derive(Serialize, TypeDef, schemars::JsonSchema)]
 #[serde(rename_all = "camelCase", rename = "MessageListItem", tag = "kind")]
-pub enum JsonrpcMessageListItem {
+pub enum JSONRPCMessageListItem {
    Message {
        msg_id: u32,
    },
@@ -592,13 +603,13 @@ pub enum JsonrpcMessageListItem {
    },
 }

-impl From<ChatItem> for JsonrpcMessageListItem {
+impl From<ChatItem> for JSONRPCMessageListItem {
    fn from(item: ChatItem) -> Self {
        match item {
-            ChatItem::Message { msg_id } => JsonrpcMessageListItem::Message {
+            ChatItem::Message { msg_id } => JSONRPCMessageListItem::Message {
                msg_id: msg_id.to_u32(),
            },
-            ChatItem::DayMarker { timestamp } => JsonrpcMessageListItem::DayMarker { timestamp },
+            ChatItem::DayMarker { timestamp } => JSONRPCMessageListItem::DayMarker { timestamp },
        }
    }
 }
@@ -616,27 +627,6 @@ pub struct MessageData {
    /// Quoted message id. Takes preference over `quoted_text` (see below).
    pub quoted_message_id: Option<u32>,
    pub quoted_text: Option<String>,
-    /// Useful for WebXDC app attachments, which can also be opened
-    /// for draft messages.
-    /// Setting this to `true` will ensure that the WebXDC status updates
-    /// of the current draft are preserved when sending the message
-    /// or updating the draft.
-    ///
-    /// `false` by default, for backwards compatibility.
-    /// However, you probably want to set it to `true`
-    /// when sending or updating the draft
-    /// from the main message composer section,
-    /// and to `false` when sending a message from secondary places,
-    /// such as a notification "Reply" input.
-    ///
-    /// Reusing the draft will also automatically remove the draft
-    /// when it's sent.
-    ///
-    /// Note that sometimes the draft cannot be reused,
-    /// for example when the WebXDC attachment [`Self::file`] changes.
-    /// If the draft cannot be reused, it will not get auto-removed.
-    #[serde(default)]
-    pub reuse_existing_draft: bool,
 }

 impl MessageData {
@@ -747,9 +737,9 @@ impl From<deltachat::ephemeral::Timer> for EphemeralTimer {
    fn from(value: deltachat::ephemeral::Timer) -> Self {
        match value {
            deltachat::ephemeral::Timer::Disabled => EphemeralTimer::Disabled,
-            deltachat::ephemeral::Timer::Enabled { duration } => EphemeralTimer::Enabled {
-                duration: duration.get(),
-            },
+            deltachat::ephemeral::Timer::Enabled { duration } => {
+                EphemeralTimer::Enabled { duration }
+            }
        }
    }
 }
--- a/deltachat-jsonrpc/src/api/types/mod.rs
+++ b/deltachat-jsonrpc/src/api/types/mod.rs
@@ -1,5 +1,4 @@
 pub mod account;
-pub mod calls;
 pub mod chat;
 pub mod chat_list;
 pub mod contact;
@@ -8,6 +7,7 @@ pub mod http;
 pub mod location;
 pub mod login_param;
 pub mod message;
+pub mod provider_info;
 pub mod qr;
 pub mod reactions;
 pub mod webxdc;
--- a/deltachat-jsonrpc/src/api/types/provider_info.rs
+++ b/deltachat-jsonrpc/src/api/types/provider_info.rs
@@ -0,0 +1,25 @@
+use deltachat::provider::Provider;
+use num_traits::cast::ToPrimitive;
+use serde::Serialize;
+use typescript_type_def::TypeDef;
+
+#[derive(Serialize, TypeDef, schemars::JsonSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct ProviderInfo {
+    /// Unique ID, corresponding to provider database filename.
+    pub id: String,
+    pub before_login_hint: String,
+    pub overview_page: String,
+    pub status: u32, // in reality this is an enum, but for simplicity and because it gets converted into a number anyway, we use an u32 here.
+}
+
+impl ProviderInfo {
+    pub fn from_dc_type(provider: Option<&Provider>) -> Option<Self> {
+        provider.map(|p| ProviderInfo {
+            id: p.id.to_owned(),
+            before_login_hint: p.before_login_hint.to_owned(),
+            overview_page: p.overview_page.to_owned(),
+            status: p.status.to_u32().unwrap(),
+        })
+    }
+}
--- a/deltachat-jsonrpc/src/api/types/qr.rs
+++ b/deltachat-jsonrpc/src/api/types/qr.rs
@@ -1,5 +1,4 @@
 use deltachat::qr::Qr;
-use serde::Deserialize;
 use serde::Serialize;
 use typescript_type_def::TypeDef;

@@ -19,8 +18,6 @@ pub enum QrObject {
        invitenumber: String,
        /// Authentication code.
        authcode: String,
-        /// Whether the inviter supports the new Securejoin v3 protocol
-        is_v3: bool,
    },
    /// Ask the user whether to join the group.
    AskVerifyGroup {
@@ -36,30 +33,6 @@ pub enum QrObject {
        invitenumber: String,
        /// Authentication code.
        authcode: String,
-        /// Whether the inviter supports the new Securejoin v3 protocol
-        is_v3: bool,
-    },
-    /// Ask the user whether to join the broadcast channel.
-    AskJoinBroadcast {
-        /// The user-visible name of this broadcast channel
-        name: String,
-        /// A string of random characters,
-        /// uniquely identifying this broadcast channel across all databases/clients.
-        /// Called `grpid` for historic reasons:
-        /// The id of multi-user chats is always called `grpid` in the database
-        /// because groups were once the only multi-user chats.
-        grpid: String,
-        /// ID of the contact who owns the broadcast channel and created the QR code.
-        contact_id: u32,
-        /// Fingerprint of the broadcast channel owner's key as scanned from the QR code.
-        fingerprint: String,
-
-        /// Invite number.
-        invitenumber: String,
-        /// Authentication code.
-        authcode: String,
-        /// Whether the inviter supports the new Securejoin v3 protocol
-        is_v3: bool,
    },
    /// Contact fingerprint is verified.
    ///
@@ -163,21 +136,6 @@ pub enum QrObject {
        /// Authentication code.
        authcode: String,
    },
-    /// Ask the user if they want to withdraw their own broadcast channel invite QR code.
-    WithdrawJoinBroadcast {
-        /// Broadcast name.
-        name: String,
-        /// ID, uniquely identifying this chat. Called grpid for historic reasons.
-        grpid: String,
-        /// Contact ID. Always `ContactId::SELF`.
-        contact_id: u32,
-        /// Fingerprint of the contact key as scanned from the QR code.
-        fingerprint: String,
-        /// Invite number.
-        invitenumber: String,
-        /// Authentication code.
-        authcode: String,
-    },
    /// Ask the user if they want to revive their own QR code.
    ReviveVerifyContact {
        /// Contact ID.
@@ -204,21 +162,6 @@ pub enum QrObject {
        /// Authentication code.
        authcode: String,
    },
-    /// Ask the user if they want to revive their own broadcast channel invite QR code.
-    ReviveJoinBroadcast {
-        /// Broadcast name.
-        name: String,
-        /// Globally unique chat ID. Called grpid for historic reasons.
-        grpid: String,
-        /// Contact ID. Always `ContactId::SELF`.
-        contact_id: u32,
-        /// Fingerprint of the contact key as scanned from the QR code.
-        fingerprint: String,
-        /// Invite number.
-        invitenumber: String,
-        /// Authentication code.
-        authcode: String,
-    },
    /// `dclogin:` scheme parameters.
    ///
    /// Ask the user if they want to login with the email address.
@@ -235,17 +178,14 @@ impl From<Qr> for QrObject {
                fingerprint,
                invitenumber,
                authcode,
-                is_v3,
-                ..
            } => {
                let contact_id = contact_id.to_u32();
-                let fingerprint = fingerprint.human_readable();
+                let fingerprint = fingerprint.to_string();
                QrObject::AskVerifyContact {
                    contact_id,
                    fingerprint,
                    invitenumber,
                    authcode,
-                    is_v3,
                }
            }
            Qr::AskVerifyGroup {
@@ -255,11 +195,9 @@ impl From<Qr> for QrObject {
                fingerprint,
                invitenumber,
                authcode,
-                is_v3,
-                ..
            } => {
                let contact_id = contact_id.to_u32();
-                let fingerprint = fingerprint.human_readable();
+                let fingerprint = fingerprint.to_string();
                QrObject::AskVerifyGroup {
                    grpname,
                    grpid,
@@ -267,29 +205,6 @@ impl From<Qr> for QrObject {
                    fingerprint,
                    invitenumber,
                    authcode,
-                    is_v3,
-                }
-            }
-            Qr::AskJoinBroadcast {
-                name,
-                grpid,
-                contact_id,
-                fingerprint,
-                authcode,
-                invitenumber,
-                is_v3,
-                ..
-            } => {
-                let contact_id = contact_id.to_u32();
-                let fingerprint = fingerprint.human_readable();
-                QrObject::AskJoinBroadcast {
-                    name,
-                    grpid,
-                    contact_id,
-                    fingerprint,
-                    authcode,
-                    invitenumber,
-                    is_v3,
                }
            }
            Qr::FprOk { contact_id } => {
@@ -310,6 +225,13 @@ impl From<Qr> for QrObject {
                auth_token,
            },
            Qr::BackupTooNew {} => QrObject::BackupTooNew {},
+            Qr::WebrtcInstance {
+                domain,
+                instance_pattern,
+            } => QrObject::WebrtcInstance {
+                domain,
+                instance_pattern,
+            },
            Qr::Proxy { url, host, port } => QrObject::Proxy { url, host, port },
            Qr::Addr { contact_id, draft } => {
                let contact_id = contact_id.to_u32();
@@ -324,7 +246,7 @@ impl From<Qr> for QrObject {
                authcode,
            } => {
                let contact_id = contact_id.to_u32();
-                let fingerprint = fingerprint.human_readable();
+                let fingerprint = fingerprint.to_string();
                QrObject::WithdrawVerifyContact {
                    contact_id,
                    fingerprint,
@@ -341,7 +263,7 @@ impl From<Qr> for QrObject {
                authcode,
            } => {
                let contact_id = contact_id.to_u32();
-                let fingerprint = fingerprint.human_readable();
+                let fingerprint = fingerprint.to_string();
                QrObject::WithdrawVerifyGroup {
                    grpname,
                    grpid,
@@ -351,25 +273,6 @@ impl From<Qr> for QrObject {
                    authcode,
                }
            }
-            Qr::WithdrawJoinBroadcast {
-                name,
-                grpid,
-                contact_id,
-                fingerprint,
-                invitenumber,
-                authcode,
-            } => {
-                let contact_id = contact_id.to_u32();
-                let fingerprint = fingerprint.human_readable();
-                QrObject::WithdrawJoinBroadcast {
-                    name,
-                    grpid,
-                    contact_id,
-                    fingerprint,
-                    invitenumber,
-                    authcode,
-                }
-            }
            Qr::ReviveVerifyContact {
                contact_id,
                fingerprint,
@@ -377,7 +280,7 @@ impl From<Qr> for QrObject {
                authcode,
            } => {
                let contact_id = contact_id.to_u32();
-                let fingerprint = fingerprint.human_readable();
+                let fingerprint = fingerprint.to_string();
                QrObject::ReviveVerifyContact {
                    contact_id,
                    fingerprint,
@@ -394,7 +297,7 @@ impl From<Qr> for QrObject {
                authcode,
            } => {
                let contact_id = contact_id.to_u32();
-                let fingerprint = fingerprint.human_readable();
+                let fingerprint = fingerprint.to_string();
                QrObject::ReviveVerifyGroup {
                    grpname,
                    grpid,
@@ -404,76 +307,7 @@ impl From<Qr> for QrObject {
                    authcode,
                }
            }
-            Qr::ReviveJoinBroadcast {
-                name,
-                grpid,
-                contact_id,
-                fingerprint,
-                invitenumber,
-                authcode,
-            } => {
-                let contact_id = contact_id.to_u32();
-                let fingerprint = fingerprint.human_readable();
-                QrObject::ReviveJoinBroadcast {
-                    name,
-                    grpid,
-                    contact_id,
-                    fingerprint,
-                    invitenumber,
-                    authcode,
-                }
-            }
            Qr::Login { address, .. } => QrObject::Login { address },
        }
    }
 }
-
-#[derive(Deserialize, TypeDef, schemars::JsonSchema)]
-pub enum SecurejoinSource {
-    /// Because of some problem, it is unknown where the QR code came from.
-    Unknown,
-    /// The user opened a link somewhere outside Delta Chat
-    ExternalLink,
-    /// The user clicked on a link in a message inside Delta Chat
-    InternalLink,
-    /// The user clicked "Paste from Clipboard" in the QR scan activity
-    Clipboard,
-    /// The user clicked "Load QR code as image" in the QR scan activity
-    ImageLoaded,
-    /// The user scanned a QR code
-    Scan,
-}
-
-#[derive(Deserialize, TypeDef, schemars::JsonSchema)]
-pub enum SecurejoinUiPath {
-    /// The UI path is unknown, or the user didn't open the QR code screen at all.
-    Unknown,
-    /// The user directly clicked on the QR icon in the main screen
-    QrIcon,
-    /// The user first clicked on the `+` button in the main screen,
-    /// and then on "New Contact"
-    NewContact,
-}
-
-impl From<SecurejoinSource> for deltachat::SecurejoinSource {
-    fn from(value: SecurejoinSource) -> Self {
-        match value {
-            SecurejoinSource::Unknown => deltachat::SecurejoinSource::Unknown,
-            SecurejoinSource::ExternalLink => deltachat::SecurejoinSource::ExternalLink,
-            SecurejoinSource::InternalLink => deltachat::SecurejoinSource::InternalLink,
-            SecurejoinSource::Clipboard => deltachat::SecurejoinSource::Clipboard,
-            SecurejoinSource::ImageLoaded => deltachat::SecurejoinSource::ImageLoaded,
-            SecurejoinSource::Scan => deltachat::SecurejoinSource::Scan,
-        }
-    }
-}
-
-impl From<SecurejoinUiPath> for deltachat::SecurejoinUiPath {
-    fn from(value: SecurejoinUiPath) -> Self {
-        match value {
-            SecurejoinUiPath::Unknown => deltachat::SecurejoinUiPath::Unknown,
-            SecurejoinUiPath::QrIcon => deltachat::SecurejoinUiPath::QrIcon,
-            SecurejoinUiPath::NewContact => deltachat::SecurejoinUiPath::NewContact,
-        }
-    }
-}
--- a/deltachat-jsonrpc/src/api/types/reactions.rs
+++ b/deltachat-jsonrpc/src/api/types/reactions.rs
@@ -8,7 +8,7 @@ use typescript_type_def::TypeDef;
 /// A single reaction emoji.
 #[derive(Serialize, TypeDef, schemars::JsonSchema)]
 #[serde(rename = "Reaction", rename_all = "camelCase")]
-pub struct JsonrpcReaction {
+pub struct JSONRPCReaction {
    /// Emoji.
    emoji: String,

@@ -22,32 +22,41 @@ pub struct JsonrpcReaction {
 /// Structure representing all reactions to a particular message.
 #[derive(Serialize, TypeDef, schemars::JsonSchema)]
 #[serde(rename = "Reactions", rename_all = "camelCase")]
-pub struct JsonrpcReactions {
+pub struct JSONRPCReactions {
    /// Map from a contact to it's reaction to message.
-    /// There is only a single reaction per contact,
-    /// but this contains a list of reactions for historical reasons.
    reactions_by_contact: BTreeMap<u32, Vec<String>>,
    /// Unique reactions and their count, sorted in descending order.
-    reactions: Vec<JsonrpcReaction>,
+    reactions: Vec<JSONRPCReaction>,
 }

-impl From<Reactions> for JsonrpcReactions {
+impl From<Reactions> for JSONRPCReactions {
    fn from(reactions: Reactions) -> Self {
-        let reactions_by_contact: BTreeMap<u32, Vec<String>> = reactions
-            .iter()
-            .map(|(key, value)| (key.to_u32(), vec![value.as_str().to_string()]))
-            .collect();
-        let self_reaction = reactions_by_contact.get(&ContactId::SELF.to_u32());
+        let mut reactions_by_contact: BTreeMap<u32, Vec<String>> = BTreeMap::new();
+
+        for contact_id in reactions.contacts() {
+            let reaction = reactions.get(contact_id);
+            if reaction.is_empty() {
+                continue;
+            }
+            let emojis: Vec<String> = reaction
+                .emojis()
+                .into_iter()
+                .map(|emoji| emoji.to_owned())
+                .collect();
+            reactions_by_contact.insert(contact_id.to_u32(), emojis.clone());
+        }
+
+        let self_reactions = reactions_by_contact.get(&ContactId::SELF.to_u32());

        let mut reactions_v = Vec::new();
        for (emoji, count) in reactions.emoji_sorted_by_frequency() {
-            let is_from_self = if let Some(self_reaction) = self_reaction {
-                self_reaction.contains(&emoji)
+            let is_from_self = if let Some(self_reactions) = self_reactions {
+                self_reactions.contains(&emoji)
            } else {
                false
            };

-            let reaction = JsonrpcReaction {
+            let reaction = JSONRPCReaction {
                emoji,
                count,
                is_from_self,
@@ -55,7 +64,7 @@ impl From<Reactions> for JsonrpcReactions {
            reactions_v.push(reaction)
        }

-        JsonrpcReactions {
+        JSONRPCReactions {
            reactions_by_contact,
            reactions: reactions_v,
        }
--- a/deltachat-jsonrpc/src/api/types/webxdc.rs
+++ b/deltachat-jsonrpc/src/api/types/webxdc.rs
@@ -37,10 +37,6 @@ pub struct WebxdcMessageInfo {
    internet_access: bool,
    /// Address to be used for `window.webxdc.selfAddr` in JS land.
    self_addr: String,
-    /// Define if the local user is the one who initially shared the webxdc application in the chat.
-    is_app_sender: bool,
-    /// Define if the app runs in a broadcasting context.
-    is_broadcast: bool,
    /// Milliseconds to wait before calling `sendUpdate()` again since the last call.
    /// Should be exposed to `window.sendUpdateInterval` in JS land.
    send_update_interval: usize,
@@ -64,8 +60,6 @@ impl WebxdcMessageInfo {
            request_integration: _,
            internet_access,
            self_addr,
-            is_app_sender,
-            is_broadcast,
            send_update_interval,
            send_update_max_size,
        } = message.get_webxdc_info(context).await?;
@@ -78,8 +72,6 @@ impl WebxdcMessageInfo {
            source_code_url: maybe_empty_string_to_option(source_code_url),
            internet_access,
            self_addr,
-            is_app_sender,
-            is_broadcast,
            send_update_interval,
            send_update_max_size,
        })
--- a/deltachat-jsonrpc/src/lib.rs
+++ b/deltachat-jsonrpc/src/lib.rs
@@ -85,7 +85,7 @@ mod tests {
            assert_eq!(result, response.to_owned());
        }
        {
-            let request = r#"{"jsonrpc":"2.0","method":"batch_set_config","id":2,"params":[1,{"addr":"","mail_user":"","mail_pw":"","mail_server":"","mail_port":"","mail_security":"","imap_certificate_checks":"","send_user":"","send_pw":"","send_server":"","send_port":"","send_security":""}]}"#;
+            let request = r#"{"jsonrpc":"2.0","method":"batch_set_config","id":2,"params":[1,{"addr":"","mail_user":"","mail_pw":"","mail_server":"","mail_port":"","mail_security":"","imap_certificate_checks":"","send_user":"","send_pw":"","send_server":"","send_port":"","send_security":"","smtp_certificate_checks":""}]}"#;
            let response = r#"{"jsonrpc":"2.0","id":2,"result":null}"#;
            session.handle_incoming(request).await;
            let result = receiver.recv().await?;
--- a/deltachat-jsonrpc/typescript/package.json
+++ b/deltachat-jsonrpc/typescript/package.json
@@ -54,5 +54,5 @@
  },
  "type": "module",
  "types": "dist/deltachat.d.ts",
-  "version": "2.58.0-dev"
+  "version": "2.3.0"
 }
--- a/deltachat-jsonrpc/typescript/scripts/generate-constants.js
+++ b/deltachat-jsonrpc/typescript/scripts/generate-constants.js
@@ -40,34 +40,15 @@ const constants = data
      key.startsWith("DC_DOWNLOAD") ||
      key.startsWith("DC_INFO_") ||
      (key.startsWith("DC_MSG") && !key.startsWith("DC_MSG_ID")) ||
-      key.startsWith("DC_QR_") ||
-      key.startsWith("DC_CERTCK_") ||
-      key.startsWith("DC_SOCKET_") ||
-      key.startsWith("DC_LP_AUTH_") ||
-      key.startsWith("DC_TEXT1_") ||
-      key.startsWith("DC_CHAT_TYPE")
+      key.startsWith("DC_QR_")
    );
  })
  .map((row) => {
-    return `  export const ${row.key} = ${row.value};`;
+    return `  ${row.key}: ${row.value}`;
  })
-  .join("\n");
+  .join(",\n");

 writeFileSync(
  resolve(__dirname, "../generated/constants.ts"),
-  `// Generated!
-
-export namespace C {
-${constants}
-  /** @deprecated 10-8-2025 compare string directly with \`== "Group"\` */
-  export const DC_CHAT_TYPE_GROUP = "Group";
-  /** @deprecated 10-8-2025 compare string directly with \`== "InBroadcast"\`*/
-  export const DC_CHAT_TYPE_IN_BROADCAST = "InBroadcast";
-  /** @deprecated 10-8-2025 compare string directly with \`== "Mailinglist"\` */
-  export const DC_CHAT_TYPE_MAILINGLIST = "Mailinglist";
-  /** @deprecated 10-8-2025 compare string directly with \`== "OutBroadcast"\` */
-  export const DC_CHAT_TYPE_OUT_BROADCAST = "OutBroadcast";
-  /** @deprecated 10-8-2025 compare string directly with \`== "Single"\` */
-  export const DC_CHAT_TYPE_SINGLE = "Single";
-}\n`,
+  `// Generated!\n\nexport enum C {\n${constants.replace(/:/g, " =")},\n}\n`,
 );
--- a/deltachat-jsonrpc/typescript/src/client.ts
+++ b/deltachat-jsonrpc/typescript/src/client.ts
@@ -28,6 +28,7 @@ export class BaseDeltaChat<
  Transport extends BaseTransport<any>,
 > extends TinyEmitter<Events> {
  rpc: RawClient;
+  account?: T.Account;
  private contextEmitters: { [key: number]: TinyEmitter<ContextEvents> } = {};

  //@ts-ignore
@@ -35,10 +36,6 @@ export class BaseDeltaChat<

  constructor(
    public transport: Transport,
-    /**
-     * Whether to start calling {@linkcode RawClient.getNextEvent}
-     * and emitting the respective events on this class.
-     */
    startEventLoop: boolean,
  ) {
    super();
@@ -48,39 +45,28 @@ export class BaseDeltaChat<
    }
  }

-  /**
-   * @see the constructor's `startEventLoop`
-   */
  async eventLoop(): Promise<void> {
    while (true) {
-      for (const event of await this.rpc.getNextEventBatch()) {
-        //@ts-ignore
-        this.emit(event.event.kind, event.contextId, event.event);
-        this.emit("ALL", event.contextId, event.event);
+      const event = await this.rpc.getNextEvent();
+      //@ts-ignore
+      this.emit(event.event.kind, event.contextId, event.event);
+      this.emit("ALL", event.contextId, event.event);

-        if (this.contextEmitters[event.contextId]) {
-          this.contextEmitters[event.contextId].emit(
-            event.event.kind,
-            //@ts-ignore
-            event.event as any,
-          );
-          this.contextEmitters[event.contextId].emit("ALL", event.event as any);
-        }
+      if (this.contextEmitters[event.contextId]) {
+        this.contextEmitters[event.contextId].emit(
+          event.event.kind,
+          //@ts-ignore
+          event.event as any,
+        );
+        this.contextEmitters[event.contextId].emit("ALL", event.event as any);
      }
    }
  }

-  /**
-   * @deprecated use {@linkcode BaseDeltaChat.rpc.getAllAccounts} instead.
-   */
  async listAccounts(): Promise<T.Account[]> {
    return await this.rpc.getAllAccounts();
  }

-  /**
-   * A convenience function to listen on events binned by `account_id`
-   * (see {@linkcode RawClient.getAllAccounts}).
-   */
  getContextEvents(account_id: number) {
    if (this.contextEmitters[account_id]) {
      return this.contextEmitters[account_id];
--- a/deltachat-jsonrpc/typescript/test/online.ts
+++ b/deltachat-jsonrpc/typescript/test/online.ts
@@ -64,7 +64,6 @@ describe("online tests", function () {
    await dc.rpc.setConfig(accountId1, "addr", account1.email);
    await dc.rpc.setConfig(accountId1, "mail_pw", account1.password);
    await dc.rpc.configure(accountId1);
-    await waitForEvent(dc, "ImapInboxIdle", accountId1);

    accountId2 = await dc.rpc.addAccount();
    await dc.rpc.batchSetConfig(accountId2, {
@@ -72,7 +71,6 @@ describe("online tests", function () {
      mail_pw: account2.password,
    });
    await dc.rpc.configure(accountId2);
-    await waitForEvent(dc, "ImapInboxIdle", accountId2);
    accountsConfigured = true;
  });

@@ -148,6 +146,23 @@ describe("online tests", function () {
    expect(message2.text).equal("super secret message");
    expect(message2.showPadlock).equal(true);
  });
+
+  it("get provider info for example.com", async () => {
+    const acc = await dc.rpc.addAccount();
+    const info = await dc.rpc.getProviderInfo(acc, "example.com");
+    expect(info).to.be.not.null;
+    expect(info?.overviewPage).to.equal(
+      "https://providers.delta.chat/example-com",
+    );
+    expect(info?.status).to.equal(3);
+  });
+
+  it("get provider info - domain and email should give same result", async () => {
+    const acc = await dc.rpc.addAccount();
+    const info_domain = await dc.rpc.getProviderInfo(acc, "example.com");
+    const info_email = await dc.rpc.getProviderInfo(acc, "hi@example.com");
+    expect(info_email).to.deep.equal(info_domain);
+  });
 });

 async function waitForEvent<T extends DcEvent["kind"]>(
--- a/deltachat-ratelimit/Cargo.toml
+++ b/deltachat-ratelimit/Cargo.toml
@@ -2,7 +2,7 @@
 name = "ratelimit"
 version = "1.0.0"
 description = "Token bucket implementation"
-edition = "2024"
+edition = "2021"
 license = "MPL-2.0"

 [dependencies]
--- a/deltachat-repl/Cargo.toml
+++ b/deltachat-repl/Cargo.toml
@@ -1,8 +1,8 @@
 [package]
 name = "deltachat-repl"
-version = "2.58.0-dev"
+version = "2.3.0"
 license = "MPL-2.0"
-edition = "2024"
+edition = "2021"
 repository = "https://github.com/chatmail/core"

 [dependencies]
--- a/deltachat-repl/src/cmdline.rs
+++ b/deltachat-repl/src/cmdline.rs
@@ -5,10 +5,11 @@ use std::path::Path;
 use std::str::FromStr;
 use std::time::Duration;

-use anyhow::{Result, bail, ensure};
-use deltachat::chat::{self, Chat, ChatId, ChatItem, ChatVisibility, MuteDuration};
+use anyhow::{bail, ensure, Result};
+use deltachat::chat::{
+    self, Chat, ChatId, ChatItem, ChatVisibility, MuteDuration, ProtectionStatus,
+};
 use deltachat::chatlist::*;
-use deltachat::config;
 use deltachat::constants::*;
 use deltachat::contact::*;
 use deltachat::context::*;
@@ -25,6 +26,7 @@ use deltachat::reaction::send_reaction;
 use deltachat::receive_imf::*;
 use deltachat::sql;
 use deltachat::tools::*;
+use deltachat::{config, provider};
 use tokio::fs;

 /// Reset database tables.
@@ -70,6 +72,11 @@ async fn reset_tables(context: &Context, bits: i32) {
            .await
            .unwrap();
        context.sql().config_cache().write().await.clear();
+        context
+            .sql()
+            .execute("DELETE FROM leftgrps;", ())
+            .await
+            .unwrap();
        println!("(8) Rest but server config reset.");
    }

@@ -122,7 +129,7 @@ async fn poke_spec(context: &Context, spec: Option<&str>) -> bool {
                let name_f = entry.file_name();
                let name = name_f.to_string_lossy();
                if name.ends_with(".eml") {
-                    let path_plus_name = format!("{real_spec}/{name}");
+                    let path_plus_name = format!("{}/{}", &real_spec, name);
                    println!("Import: {path_plus_name}");
                    if poke_eml_file(context, Path::new(&path_plus_name))
                        .await
@@ -133,11 +140,11 @@ async fn poke_spec(context: &Context, spec: Option<&str>) -> bool {
                }
            }
        } else {
-            eprintln!("Import: Cannot open directory {real_spec:?}.");
+            eprintln!("Import: Cannot open directory \"{}\".", &real_spec);
            return false;
        }
    }
-    println!("Import: {read_cnt} items read from {real_spec:?}.");
+    println!("Import: {} items read from \"{}\".", read_cnt, &real_spec);
    if read_cnt > 0 {
        context.emit_msgs_changed_without_ids();
    }
@@ -179,7 +186,7 @@ async fn log_msg(context: &Context, prefix: impl AsRef<str>, msg: &Message) {
        msg.get_id(),
        if msg.get_showpadlock() { "🔒" } else { "" },
        if msg.has_location() { "📍" } else { "" },
-        contact_name,
+        &contact_name,
        contact_id,
        msgtext,
        if msg.has_html() { "[HAS-HTML]️" } else { "" },
@@ -203,7 +210,13 @@ async fn log_msg(context: &Context, prefix: impl AsRef<str>, msg: &Message) {
        } else {
            ""
        },
-        if msg.get_viewtype() == Viewtype::Webxdc {
+        if msg.get_viewtype() == Viewtype::VideochatInvitation {
+            format!(
+                "[VIDEOCHAT-INVITATION: {}, type={}]",
+                msg.get_videochat_url().unwrap_or_default(),
+                msg.get_videochat_type().unwrap_or_default()
+            )
+        } else if msg.get_viewtype() == Viewtype::Webxdc {
            match msg.get_webxdc_info(context).await {
                Ok(info) => format!(
                    "[WEBXDC: {}, icon={}, document={}, summary={}, source_code_url={}]",
@@ -221,7 +234,7 @@ async fn log_msg(context: &Context, prefix: impl AsRef<str>, msg: &Message) {
        },
        statestr,
        downloadstate,
-        temp2,
+        &temp2,
    );
 }

@@ -302,6 +315,9 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
            // TODO: reuse commands definition in main.rs.
            "imex" => println!(
                "====================Import/Export commands==\n\
+                 initiate-key-transfer\n\
+                 get-setupcodebegin <msg-id>\n\
+                 continue-key-transfer <msg-id> <setup-code>\n\
                 has-backup\n\
                 export-backup\n\
                 import-backup <backup-file>\n\
@@ -319,6 +335,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                 info\n\
                 set <configuration-key> [<value>]\n\
                 get <configuration-key>\n\
+                 oauth2\n\
                 configure\n\
                 connect\n\
                 disconnect\n\
@@ -336,17 +353,17 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                 createchat <contact-id>\n\
                 creategroup <name>\n\
                 createbroadcast <name>\n\
+                 createprotected <name>\n\
                 addmember <contact-id>\n\
                 removemember <contact-id>\n\
                 groupname <name>\n\
-                 groupdescription <description>\n\
                 groupimage <image>\n\
                 chatinfo\n\
                 sendlocations <seconds>\n\
                 setlocation <lat> <lng>\n\
+                 dellocations\n\
                 getlocations [<contact-id>]\n\
                 send <text>\n\
-                 send-sync <text>\n\
                 sendempty\n\
                 sendimage <file> [<text>]\n\
                 sendsticker <file> [<text>]\n\
@@ -354,6 +371,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                 sendhtml <file for html-part> [<text for plain-part>]\n\
                 sendsyncmsg\n\
                 sendupdate <msg-id> <json status update>\n\
+                 videochat\n\
                 draft [<text>]\n\
                 devicemsg <text>\n\
                 listmedia\n\
@@ -385,8 +403,6 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                 block <contact-id>\n\
                 unblock <contact-id>\n\
                 listblocked\n\
-                 import-vcard <file>\n\
-                 make-vcard <file> <contact-id> [contact-id ...]\n\
                 ======================================Misc.==\n\
                 getqr [<chat-id>]\n\
                 getqrsvg [<chat-id>]\n\
@@ -395,6 +411,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                 joinqr <qr-content>\n\
                 setqr <qr-content>\n\
                 createqrsvg <qr-content>\n\
+                 providerinfo <addr>\n\
                 fileinfo <file>\n\
                 estimatedeletion <seconds>\n\
                 clear -- clear screen\n\
@@ -402,6 +419,34 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                 ============================================="
            ),
        },
+        "initiate-key-transfer" => match initiate_key_transfer(&context).await {
+            Ok(setup_code) => {
+                println!("Setup code for the transferred setup message: {setup_code}",)
+            }
+            Err(err) => bail!("Failed to generate setup code: {}", err),
+        },
+        "get-setupcodebegin" => {
+            ensure!(!arg1.is_empty(), "Argument <msg-id> missing.");
+            let msg_id: MsgId = MsgId::new(arg1.parse()?);
+            let msg = Message::load_from_db(&context, msg_id).await?;
+            if msg.is_setupmessage() {
+                let setupcodebegin = msg.get_setupcodebegin(&context).await;
+                println!(
+                    "The setup code for setup message {} starts with: {}",
+                    msg_id,
+                    setupcodebegin.unwrap_or_default(),
+                );
+            } else {
+                bail!("{} is no setup message.", msg_id,);
+            }
+        }
+        "continue-key-transfer" => {
+            ensure!(
+                !arg1.is_empty() && !arg2.is_empty(),
+                "Arguments <msg-id> <setup-code> expected"
+            );
+            continue_key_transfer(&context, MsgId::new(arg1.parse()?), arg2).await?;
+        }
        "has-backup" => {
            has_backup(&context, blobdir).await?;
        }
@@ -487,7 +532,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                    println!("Report written to: {file:#?}");
                }
                Err(err) => {
-                    bail!("Failed to get connectivity html: {err}");
+                    bail!("Failed to get connectivity html: {}", err);
                }
            }
        }
@@ -522,7 +567,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                for i in (0..cnt).rev() {
                    let chat = Chat::load_from_db(&context, chatlist.get_chat_id(i)?).await?;
                    println!(
-                        "{}#{}: {} [{} fresh] {}{}{}",
+                        "{}#{}: {} [{} fresh] {}{}{}{}",
                        chat_prefix(&chat),
                        chat.get_id(),
                        chat.get_name(),
@@ -533,6 +578,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                            ChatVisibility::Archived => "📦",
                            ChatVisibility::Pinned => "📌",
                        },
+                        if chat.is_protected() { "🛡️" } else { "" },
                        if chat.is_contact_request() {
                            "🆕"
                        } else {
@@ -559,7 +605,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                            .map_or_else(String::new, |prefix| format!("{prefix}: ")),
                        summary.text,
                        statestr,
-                        timestr,
+                        &timestr,
                        if chat.is_sending_locations() {
                            "📍"
                        } else {
@@ -571,7 +617,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                    );
                }
            }
-            if location::is_sending(&context).await? {
+            if location::is_sending_locations_to_chat(&context, None).await? {
                println!("Location streaming enabled.");
            }
            println!("{cnt} chats");
@@ -620,6 +666,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                &context,
                sel_chat.get_id(),
                chat::MessageListOptions {
+                    info_only: false,
                    add_daymarker: true,
                },
            )
@@ -646,7 +693,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                format!("{} member(s)", members.len())
            };
            println!(
-                "{}#{}: {} [{}]{}{}{}",
+                "{}#{}: {} [{}]{}{}{} {}",
                chat_prefix(sel_chat),
                sel_chat.get_id(),
                sel_chat.get_name(),
@@ -664,6 +711,11 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                    },
                    _ => "".to_string(),
                },
+                if sel_chat.is_protected() {
+                    "🛡️"
+                } else {
+                    ""
+                },
            );
            log_msglist(&context, &msglist).await?;
            if let Some(draft) = sel_chat.get_id().get_draft(&context).await? {
@@ -692,7 +744,8 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
        }
        "creategroup" => {
            ensure!(!arg1.is_empty(), "Argument <name> missing.");
-            let chat_id = chat::create_group(&context, arg1).await?;
+            let chat_id =
+                chat::create_group_chat(&context, ProtectionStatus::Unprotected, arg1).await?;

            println!("Group#{chat_id} created successfully.");
        }
@@ -702,6 +755,13 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu

            println!("Broadcast#{chat_id} created successfully.");
        }
+        "createprotected" => {
+            ensure!(!arg1.is_empty(), "Argument <name> missing.");
+            let chat_id =
+                chat::create_group_chat(&context, ProtectionStatus::Protected, arg1).await?;
+
+            println!("Group#{chat_id} created and protected successfully.");
+        }
        "addmember" => {
            ensure!(sel_chat.is_some(), "No chat selected");
            ensure!(!arg1.is_empty(), "Argument <contact-id> missing.");
@@ -736,13 +796,6 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu

            println!("Chat name set");
        }
-        "groupdescription" => {
-            ensure!(sel_chat.is_some(), "No chat selected.");
-            ensure!(!arg1.is_empty(), "Argument <description> missing.");
-            chat::set_chat_description(&context, sel_chat.as_ref().unwrap().get_id(), arg1).await?;
-
-            println!("Chat description set");
-        }
        "groupimage" => {
            ensure!(sel_chat.is_some(), "No chat selected.");
            ensure!(!arg1.is_empty(), "Argument <image> missing.");
@@ -778,7 +831,11 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu

            println!(
                "Location streaming: {}",
-                location::is_sending_to_chat(&context, sel_chat.as_ref().unwrap().get_id()).await?,
+                location::is_sending_locations_to_chat(
+                    &context,
+                    Some(sel_chat.as_ref().unwrap().get_id())
+                )
+                .await?,
            );
        }
        "getlocations" => {
@@ -818,7 +875,12 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
            ensure!(!arg1.is_empty(), "No timeout given.");

            let seconds = arg1.parse()?;
-            location::send_to_chat(&context, sel_chat.as_ref().unwrap().get_id(), seconds).await?;
+            location::send_locations_to_chat(
+                &context,
+                sel_chat.as_ref().unwrap().get_id(),
+                seconds,
+            )
+            .await?;
            println!(
                "Locations will be sent to Chat#{} for {} seconds. Use 'setlocation <lat> <lng>' to play around.",
                sel_chat.as_ref().unwrap().get_id(),
@@ -840,6 +902,9 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                println!("Success, streaming can be stopped.");
            }
        }
+        "dellocations" => {
+            location::delete_all(&context).await?;
+        }
        "send" => {
            ensure!(sel_chat.is_some(), "No chat selected.");
            ensure!(!arg1.is_empty(), "No message text given.");
@@ -848,23 +913,6 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu

            chat::send_text_msg(&context, sel_chat.as_ref().unwrap().get_id(), msg).await?;
        }
-        "send-sync" => {
-            ensure!(sel_chat.is_some(), "No chat selected.");
-            ensure!(!arg1.is_empty(), "No message text given.");
-
-            // Send message over a dedicated SMTP connection
-            // and measure time.
-            //
-            // This can be used to benchmark SMTP connection establishment.
-            let time_start = std::time::Instant::now();
-
-            let msg = format!("{arg1} {arg2}");
-            let mut msg = Message::new_text(msg);
-            chat::send_msg_sync(&context, sel_chat.as_ref().unwrap().get_id(), &mut msg).await?;
-
-            let time_needed = time_start.elapsed();
-            println!("Sent message in {time_needed:?}.");
-        }
        "sendempty" => {
            ensure!(sel_chat.is_some(), "No chat selected.");
            chat::send_text_msg(&context, sel_chat.as_ref().unwrap().get_id(), "".into()).await?;
@@ -912,6 +960,10 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
            let msg_id = MsgId::new(arg1.parse()?);
            context.send_webxdc_status_update(msg_id, arg2).await?;
        }
+        "videochat" => {
+            ensure!(sel_chat.is_some(), "No chat selected.");
+            chat::send_videochat_invitation(&context, sel_chat.as_ref().unwrap().get_id()).await?;
+        }
        "listmsgs" => {
            ensure!(!arg1.is_empty(), "Argument <query> missing.");

@@ -1166,24 +1218,6 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
            log_contactlist(&context, &contacts).await?;
            println!("{} blocked contacts.", contacts.len());
        }
-        "import-vcard" => {
-            ensure!(!arg1.is_empty(), "Argument <file> missing.");
-            let vcard_content = fs::read_to_string(&arg1.to_string()).await?;
-            let contacts = import_vcard(&context, &vcard_content).await?;
-            println!("vCard contacts imported:");
-            log_contactlist(&context, &contacts).await?;
-        }
-        "make-vcard" => {
-            ensure!(!arg1.is_empty(), "Argument <file> missing.");
-            ensure!(!arg2.is_empty(), "Argument <contact-id> missing.");
-            let mut contact_ids = vec![];
-            for x in arg2.split_whitespace() {
-                contact_ids.push(ContactId::new(x.parse()?))
-            }
-            let vcard_content = make_vcard(&context, &contact_ids).await?;
-            fs::write(&arg1.to_string(), vcard_content).await?;
-            println!("vCard written to: {arg1}");
-        }
        "checkqr" => {
            ensure!(!arg1.is_empty(), "Argument <qr-content> missing.");
            let qr = check_qr(&context, arg1).await?;
@@ -1192,7 +1226,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
        "setqr" => {
            ensure!(!arg1.is_empty(), "Argument <qr-content> missing.");
            match set_config_from_qr(&context, arg1).await {
-                Ok(()) => eprintln!("Config set from the QR code."),
+                Ok(()) => println!("Config set from QR code, you can now call 'configure'"),
                Err(err) => eprintln!("Cannot set config from QR code: {err:?}"),
            }
        }
@@ -1203,24 +1237,48 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
            fs::write(&file, svg).await?;
            println!("{file:#?} written.");
        }
+        "providerinfo" => {
+            ensure!(!arg1.is_empty(), "Argument <addr> missing.");
+            let proxy_enabled = context
+                .get_config_bool(config::Config::ProxyEnabled)
+                .await?;
+            match provider::get_provider_info(&context, arg1, proxy_enabled).await {
+                Some(info) => {
+                    println!("Information for provider belonging to {arg1}:");
+                    println!("status: {}", info.status as u32);
+                    println!("before_login_hint: {}", info.before_login_hint);
+                    println!("after_login_hint: {}", info.after_login_hint);
+                    println!("overview_page: {}", info.overview_page);
+                    for server in info.server.iter() {
+                        println!("server: {}:{}", server.hostname, server.port,);
+                    }
+                }
+                None => {
+                    println!("No information for provider belonging to {arg1} found.");
+                }
+            }
+        }
        "fileinfo" => {
            ensure!(!arg1.is_empty(), "Argument <file> missing.");

-            let Ok(buf) = read_file(&context, Path::new(arg1)).await else {
+            if let Ok(buf) = read_file(&context, Path::new(arg1)).await {
+                let (width, height) = get_filemeta(&buf)?;
+                println!("width={width}, height={height}");
+            } else {
                bail!("Command failed.");
-            };
-            let (width, height) = get_filemeta(&buf)?;
-            println!("width={width}, height={height}");
+            }
        }
        "estimatedeletion" => {
            ensure!(!arg1.is_empty(), "Argument <seconds> missing");
            let seconds = arg1.parse()?;
-            let from_server = false;
-            let device_cnt = message::estimate_deletion_cnt(&context, from_server, seconds).await?;
-            println!("estimated count of messages older than {seconds} seconds: {device_cnt}");
+            let device_cnt = message::estimate_deletion_cnt(&context, false, seconds).await?;
+            let server_cnt = message::estimate_deletion_cnt(&context, true, seconds).await?;
+            println!(
+                "estimated count of messages older than {seconds} seconds:\non device: {device_cnt}\non server: {server_cnt}"
+            );
        }
        "" => (),
-        _ => bail!("Unknown command: \"{arg0}\" type ? for help."),
+        _ => bail!("Unknown command: \"{}\" type ? for help.", arg0),
    }

    Ok(())
--- a/deltachat-repl/src/main.rs
+++ b/deltachat-repl/src/main.rs
@@ -9,12 +9,14 @@ extern crate deltachat;

 use std::borrow::Cow::{self, Borrowed, Owned};

-use anyhow::{Error, bail};
-use deltachat::EventType;
+use anyhow::{bail, Error};
 use deltachat::chat::ChatId;
+use deltachat::config;
 use deltachat::context::*;
+use deltachat::oauth2::*;
 use deltachat::qr_code_generator::get_securejoin_qr_svg;
 use deltachat::securejoin::*;
+use deltachat::EventType;
 use log::{error, info, warn};
 use nu_ansi_term::Color;
 use rustyline::completion::{Completer, FilenameCompleter, Pair};
@@ -147,7 +149,10 @@ impl Completer for DcHelper {
    }
 }

-const IMEX_COMMANDS: [&str; 10] = [
+const IMEX_COMMANDS: [&str; 13] = [
+    "initiate-key-transfer",
+    "get-setupcodebegin",
+    "continue-key-transfer",
    "has-backup",
    "export-backup",
    "import-backup",
@@ -160,10 +165,11 @@ const IMEX_COMMANDS: [&str; 10] = [
    "stop",
 ];

-const DB_COMMANDS: [&str; 10] = [
+const DB_COMMANDS: [&str; 11] = [
    "info",
    "set",
    "get",
+    "oauth2",
    "configure",
    "connect",
    "disconnect",
@@ -186,14 +192,13 @@ const CHAT_COMMANDS: [&str; 39] = [
    "addmember",
    "removemember",
    "groupname",
-    "groupdescription",
    "groupimage",
    "chatinfo",
    "sendlocations",
    "setlocation",
+    "dellocations",
    "getlocations",
    "send",
-    "send-sync",
    "sendempty",
    "sendimage",
    "sendsticker",
@@ -201,6 +206,7 @@ const CHAT_COMMANDS: [&str; 39] = [
    "sendhtml",
    "sendsyncmsg",
    "sendupdate",
+    "videochat",
    "draft",
    "devicemsg",
    "listmedia",
@@ -226,7 +232,7 @@ const MESSAGE_COMMANDS: [&str; 10] = [
    "delmsg",
    "react",
 ];
-const CONTACT_COMMANDS: [&str; 9] = [
+const CONTACT_COMMANDS: [&str; 7] = [
    "listcontacts",
    "addcontact",
    "contactinfo",
@@ -234,10 +240,8 @@ const CONTACT_COMMANDS: [&str; 9] = [
    "block",
    "unblock",
    "listblocked",
-    "import-vcard",
-    "make-vcard",
 ];
-const MISC_COMMANDS: [&str; 13] = [
+const MISC_COMMANDS: [&str; 14] = [
    "getqr",
    "getqrsvg",
    "getbadqr",
@@ -245,6 +249,7 @@ const MISC_COMMANDS: [&str; 13] = [
    "joinqr",
    "setqr",
    "createqrsvg",
+    "providerinfo",
    "fileinfo",
    "estimatedeletion",
    "clear",
@@ -266,11 +271,10 @@ impl Hinter for DcHelper {
                &CONTACT_COMMANDS[..],
                &MISC_COMMANDS[..],
            ] {
-                if let Some(entry) = cmds.iter().find(|el| el.starts_with(&line[..pos]))
-                    && *entry != line
-                    && *entry != &line[..pos]
-                {
-                    return Some(entry[pos..].to_owned());
+                if let Some(entry) = cmds.iter().find(|el| el.starts_with(&line[..pos])) {
+                    if *entry != line && *entry != &line[..pos] {
+                        return Some(entry[pos..].to_owned());
+                    }
                }
            }
        }
@@ -422,6 +426,19 @@ async fn handle_cmd(
        "configure" => {
            ctx.configure().await?;
        }
+        "oauth2" => {
+            if let Some(addr) = ctx.get_config(config::Config::Addr).await? {
+                let oauth2_url =
+                    get_oauth2_url(&ctx, &addr, "chat.delta:/com.b44t.messenger").await?;
+                if oauth2_url.is_none() {
+                    println!("OAuth2 not available for {}.", &addr);
+                } else {
+                    println!("Open the following url, set mail_pw to the generated token and server_flags to 2:\n{}", oauth2_url.unwrap());
+                }
+            } else {
+                println!("oauth2: set addr first.");
+            }
+        }
        "clear" => {
            println!("\n\n\n");
            print!("\x1b[1;1H\x1b[2J");
@@ -448,7 +465,7 @@ async fn handle_cmd(
                    println!("QR code svg written to: {file:#?}");
                }
                Err(err) => {
-                    bail!("Failed to get QR code svg: {err}");
+                    bail!("Failed to get QR code svg: {}", err);
                }
            }
        }
--- a/deltachat-rpc-client/README.md
+++ b/deltachat-rpc-client/README.md
@@ -2,9 +2,6 @@

 RPC client connects to standalone Delta Chat RPC server `deltachat-rpc-server`
 and provides asynchronous interface to it.
-`rpc.start()` performs a health-check RPC call to verify the server
-started successfully and will raise an error if startup fails
-(e.g. if the accounts directory could not be used).

 ## Getting started

@@ -29,19 +26,10 @@ $ pip install .

 1. Build `deltachat-rpc-server` with `cargo build -p deltachat-rpc-server`.
 2. Install tox `pip install -U tox`
-3. Run `CHATMAIL_DOMAIN=ci-chatmail.testrun.org PATH="../target/debug:$PATH" tox`.
+3. Run `CHATMAIL_DOMAIN=nine.testrun.org PATH="../target/debug:$PATH" tox`.

 Additional arguments to `tox` are passed to pytest, e.g. `tox -- -s` does not capture test output.

-
-## Activating current checkout of deltachat-rpc-client and -server for development 
-
-Go to root repository directory and run: 
-```
-$ scripts/make-rpc-testenv.sh 
-$ source venv/bin/activate 
-```
-
 ## Using in REPL

 Setup a development environment:
--- a/deltachat-rpc-client/examples/echobot_no_hooks.py
+++ b/deltachat-rpc-client/examples/echobot_no_hooks.py
@@ -13,7 +13,7 @@ def main():
    with Rpc() as rpc:
        deltachat = DeltaChat(rpc)
        system_info = deltachat.get_system_info()
-        logging.info(f"Running deltachat core {system_info['deltachat_core_version']}")
+        logging.info("Running deltachat core %s", system_info["deltachat_core_version"])

        accounts = deltachat.get_all_accounts()
        account = accounts[0] if accounts else deltachat.add_account()
@@ -21,30 +21,36 @@ def main():
        account.set_config("bot", "1")
        if not account.is_configured():
            logging.info("Account is not configured, configuring")
-            account.add_or_update_transport({"addr": sys.argv[1], "password": sys.argv[2]})
+            account.set_config("addr", sys.argv[1])
+            account.set_config("mail_pw", sys.argv[2])
+            account.configure()
            logging.info("Configured")
        else:
            logging.info("Account is already configured")
            deltachat.start_io()

-        qr = account.get_qr_code()
-        logging.info(f"Invite link: {qr}")
-        while True:
-            event = account.wait_for_event()
-            if event.kind == EventType.INFO:
-                logging.info(event["msg"])
-            elif event.kind == EventType.WARNING:
-                logging.warning(event["msg"])
-            elif event.kind == EventType.ERROR:
-                logging.error(event["msg"])
-            elif event.kind == EventType.INCOMING_MSG:
-                logging.info("Got an incoming message")
-                message = account.get_message_by_id(event.msg_id)
+        def process_messages():
+            for message in account.get_next_messages():
                snapshot = message.get_snapshot()
                if snapshot.from_id != SpecialContactId.SELF and not snapshot.is_bot and not snapshot.is_info:
                    snapshot.chat.send_text(snapshot.text)
                snapshot.message.mark_seen()

+        # Process old messages.
+        process_messages()
+
+        while True:
+            event = account.wait_for_event()
+            if event["kind"] == EventType.INFO:
+                logging.info("%s", event["msg"])
+            elif event["kind"] == EventType.WARNING:
+                logging.warning("%s", event["msg"])
+            elif event["kind"] == EventType.ERROR:
+                logging.error("%s", event["msg"])
+            elif event["kind"] == EventType.INCOMING_MSG:
+                logging.info("Got an incoming message")
+                process_messages()
+

 if __name__ == "__main__":
    logging.basicConfig(level=logging.INFO)
--- a/deltachat-rpc-client/pyproject.toml
+++ b/deltachat-rpc-client/pyproject.toml
@@ -1,28 +1,29 @@
 [build-system]
-requires = ["setuptools>=77"]
+requires = ["setuptools>=45"]
 build-backend = "setuptools.build_meta"

 [project]
 name = "deltachat-rpc-client"
-version = "2.58.0-dev"
-license = "MPL-2.0"
+version = "2.3.0"
 description = "Python client for Delta Chat core JSON-RPC interface"
 classifiers = [
    "Development Status :: 5 - Production/Stable",
    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)",
    "Operating System :: POSIX :: Linux",
    "Operating System :: MacOS :: MacOS X",
    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
    "Programming Language :: Python :: 3.10",
    "Programming Language :: Python :: 3.11",
    "Programming Language :: Python :: 3.12",
    "Programming Language :: Python :: 3.13",
-    "Programming Language :: Python :: 3.14",
    "Topic :: Communications :: Chat",
    "Topic :: Communications :: Email"
 ]
 readme = "README.md"
-requires-python = ">=3.10"
+requires-python = ">=3.8"

 [tool.setuptools.package-data]
 deltachat_rpc_client = [
--- a/deltachat-rpc-client/src/deltachat_rpc_client/init.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/init.py
@@ -8,7 +8,7 @@ from .const import EventType, SpecialContactId
 from .contact import Contact
 from .deltachat import DeltaChat
 from .message import Message
-from .rpc import JsonRpcError, Rpc
+from .rpc import Rpc

 __all__ = [
    "Account",
@@ -19,7 +19,6 @@ __all__ = [
    "Contact",
    "DeltaChat",
    "EventType",
-    "JsonRpcError",
    "Message",
    "SpecialContactId",
    "Rpc",
--- a/deltachat-rpc-client/src/deltachat_rpc_client/_utils.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/_utils.py
@@ -1,5 +1,4 @@
 import argparse
-import functools
 import os
 import re
 import sys
@@ -45,13 +44,8 @@ class AttrDict(dict):
        super().__setattr__(attr, val)


-def _forever(_event: AttrDict) -> bool:
-    return False
-
-
 def run_client_cli(
    hooks: Optional[Iterable[Tuple[Callable, Union[type, "EventFilter"]]]] = None,
-    until: Callable[[AttrDict], bool] = _forever,
    argv: Optional[list] = None,
    **kwargs,
 ) -> None:
@@ -61,11 +55,10 @@ def run_client_cli(
    """
    from .client import Client

-    _run_cli(Client, until, hooks, argv, **kwargs)
+    _run_cli(Client, hooks, argv, **kwargs)


 def run_bot_cli(
-    until: Callable[[AttrDict], bool] = _forever,
    hooks: Optional[Iterable[Tuple[Callable, Union[type, "EventFilter"]]]] = None,
    argv: Optional[list] = None,
    **kwargs,
@@ -76,12 +69,11 @@ def run_bot_cli(
    """
    from .client import Bot

-    _run_cli(Bot, until, hooks, argv, **kwargs)
+    _run_cli(Bot, hooks, argv, **kwargs)


 def _run_cli(
    client_type: Type["Client"],
-    until: Callable[[AttrDict], bool] = _forever,
    hooks: Optional[Iterable[Tuple[Callable, Union[type, "EventFilter"]]]] = None,
    argv: Optional[list] = None,
    **kwargs,
@@ -119,7 +111,7 @@ def _run_cli(
                kwargs={"email": args.email, "password": args.password},
            )
            configure_thread.start()
-        client.run_until(until)
+        client.run_forever()


 def extract_addr(text: str) -> str:
@@ -190,6 +182,9 @@ class futuremethod:  # noqa: N801
        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)
@@ -202,7 +197,6 @@ class futuremethod:  # noqa: N801

            return f

-        @functools.wraps(self._func)
        def wrapper(*args):
            f = future(*args)
            return f()
--- a/deltachat-rpc-client/src/deltachat_rpc_client/account.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/account.py
@@ -2,9 +2,9 @@

 from __future__ import annotations

-import json
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Optional, Union
+from warnings import warn

 from ._utils import AttrDict, futuremethod
 from .chat import Chat
@@ -124,19 +124,6 @@ class Account:
        """Add a new transport."""
        yield self._rpc.add_or_update_transport.future(self.id, params)

-    @futuremethod
-    def add_transport_from_qr(self, qr: str):
-        """Add a new transport using a QR code."""
-        yield self._rpc.add_transport_from_qr.future(self.id, qr)
-
-    def delete_transport(self, addr: str):
-        """Delete a transport."""
-        self._rpc.delete_transport(self.id, addr)
-
-    def set_transport_unpublished(self, addr: str, unpublished: bool = True):
-        """Unpublish the transport."""
-        self._rpc.set_transport_unpublished(self.id, addr, unpublished)
-
    @futuremethod
    def list_transports(self):
        """Return the list of all email accounts that are used as a transport in the current profile."""
@@ -186,7 +173,7 @@ class Account:
        return [Contact(self, contact_id) for contact_id in contact_ids]

    def create_chat(self, account: "Account") -> Chat:
-        """Create a single chat with another account."""
+        """Create a 1:1 chat with another account."""
        return self.create_contact(account).create_chat()

    def get_device_chat(self) -> Chat:
@@ -198,21 +185,7 @@ class Account:
        return Contact(self, contact_id)

    def get_contact_by_addr(self, address: str) -> Optional[Contact]:
-        """Looks up a known and unblocked contact with a given e-mail address.
-        To get a list of all known and unblocked contacts, use contacts_get_contacts().
-
-        **POTENTIAL SECURITY ISSUE**: If there are multiple contacts with this address
-        (e.g. an address-contact and a key-contact),
-        this looks up the most recently seen contact,
-        i.e. which contact is returned depends on which contact last sent a message.
-        If the user just clicked on a mailto: link, then this is the best thing you can do.
-        But **DO NOT** internally represent contacts by their email address
-        and do not use this function to look them up;
-        otherwise this function will sometimes look up the wrong contact.
-        Instead, you should internally represent contacts by their ids.
-
-        To validate an e-mail address independently of the contact database
-        use check_email_validity()."""
+        """Check if an e-mail address belongs to a known and unblocked contact."""
        contact_id = self._rpc.lookup_contact_id_by_addr(self.id, address)
        return contact_id and Contact(self, contact_id)

@@ -222,7 +195,7 @@ class Account:
        return [AttrDict(contact=Contact(self, contact["id"]), **contact) for contact in contacts]

    def get_chat_by_contact(self, contact: Union[int, Contact]) -> Optional[Chat]:
-        """Return single chat for a contact if it exists."""
+        """Return 1:1 chat for a contact if it exists."""
        if isinstance(contact, Contact):
            assert contact.account == self
            contact_id = contact.id
@@ -312,7 +285,7 @@ class Account:
            chats.append(AttrDict(item))
        return chats

-    def create_group(self, name: str) -> Chat:
+    def create_group(self, name: str, protect: bool = False) -> Chat:
        """Create a new group chat.

        After creation,
@@ -329,11 +302,15 @@ class Account:
        To check, if a chat is still unpromoted, you can look at the `is_unpromoted` property of a chat
        (see `get_full_snapshot()` / `get_basic_snapshot()`).
        This may be useful if you want to show some help for just created groups.
+
+        :param protect: If set to 1 the function creates group with protection initially enabled.
+                        Only verified members are allowed in these groups
+                        and end-to-end-encryption is always enabled.
        """
-        return Chat(self, self._rpc.create_group_chat(self.id, name, False))
+        return Chat(self, self._rpc.create_group_chat(self.id, name, protect))

    def create_broadcast(self, name: str) -> Chat:
-        """Create a new, outgoing **broadcast channel**
+        """Create a new **broadcast channel**
        (called "Channel" in the UI).

        Broadcast channels are similar to groups on the sending device,
@@ -344,6 +321,9 @@ class Account:
        because the word "channel" already appears a lot in the code,
        which would make it hard to grep for it.

+        After creation, the chat contains no recipients and is in _unpromoted_ state;
+        see `create_group()` for more information on the unpromoted state.
+
        Returns the created chat.
        """
        return Chat(self, self._rpc.create_broadcast(self.id, name))
@@ -392,7 +372,8 @@ class Account:
        """Return the list of fresh messages, newest messages first.

        This call is intended for displaying notifications.
-        If you are writing a bot, process "incoming message" events instead.
+        If you are writing a bot, use `get_fresh_messages_in_arrival_order()` instead,
+        to process oldest messages first.
        """
        fresh_msg_ids = self._rpc.get_fresh_msgs(self.id)
        return [Message(self, msg_id) for msg_id in fresh_msg_ids]
@@ -402,18 +383,9 @@ class Account:
        next_msg_ids = self._rpc.get_next_msgs(self.id)
        return [Message(self, msg_id) for msg_id in next_msg_ids]

-    @futuremethod
    def wait_next_messages(self) -> list[Message]:
-        """(deprecated) Wait for new messages and return a list of them. Meant for bots.
-
-        Deprecated 2026-04: This returns the message's id as soon as the first part arrives,
-        even if it is not fully downloaded yet.
-        The bot needs to wait for the message to be fully downloaded.
-        Since this is usually not the desired behavior,
-        bots should instead use the `EventType.INCOMING_MSG`
-        event for getting notified about new messages.
-        """
-        next_msg_ids = yield self._rpc.wait_next_msgs.future(self.id)
+        """Wait for new messages and return a list of them."""
+        next_msg_ids = self._rpc.wait_next_msgs(self.id)
        return [Message(self, msg_id) for msg_id in next_msg_ids]

    def wait_for_incoming_msg_event(self):
@@ -428,21 +400,12 @@ class Account:
        """Wait for messages noticed event and return it."""
        return self.wait_for_event(EventType.MSGS_NOTICED)

-    def wait_for_msg(self, event_type) -> Message:
-        """Wait for an event about the message.
-
-        Consumes all events before the matching event.
-        Returns a message corresponding to the msg_id field of the event.
-        """
-        event = self.wait_for_event(event_type)
-        return self.get_message_by_id(event.msg_id)
-
    def wait_for_incoming_msg(self):
        """Wait for incoming message and return it.

        Consumes all events before the next incoming message event.
        """
-        return self.wait_for_msg(EventType.INCOMING_MSG)
+        return self.get_message_by_id(self.wait_for_incoming_msg_event().msg_id)

    def wait_for_securejoin_inviter_success(self):
        """Wait until SecureJoin process finishes successfully on the inviter side."""
@@ -462,6 +425,16 @@ class Account:
        """Wait for reaction change event."""
        return self.wait_for_event(EventType.REACTIONS_CHANGED)

+    def get_fresh_messages_in_arrival_order(self) -> list[Message]:
+        """Return fresh messages list sorted in the order of their arrival, with ascending IDs."""
+        warn(
+            "get_fresh_messages_in_arrival_order is deprecated, use get_next_messages instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        fresh_msg_ids = sorted(self._rpc.get_fresh_msgs(self.id))
+        return [Message(self, msg_id) for msg_id in fresh_msg_ids]
+
    def export_backup(self, path, passphrase: str = "") -> None:
        """Export backup."""
        self._rpc.export_backup(self.id, str(path), passphrase)
@@ -480,11 +453,6 @@ class Account:
        passphrase = ""  # Importing passphrase-protected keys is currently not supported.
        self._rpc.import_self_keys(self.id, str(path), passphrase)

-    def ice_servers(self) -> list:
-        """Return ICE servers for WebRTC configuration."""
-        ice_servers_json = self._rpc.ice_servers(self.id)
-        return json.loads(ice_servers_json)
-
-    def is_sending_locations(self) -> bool:
-        """Return True if sending locations to any chat."""
-        return self._rpc.is_sending_locations(self.id)
+    def initiate_autocrypt_key_transfer(self) -> None:
+        """Send Autocrypt Setup Message."""
+        return self._rpc.initiate_autocrypt_key_transfer(self.id)
--- a/deltachat-rpc-client/src/deltachat_rpc_client/chat.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/chat.py
@@ -164,15 +164,10 @@ class Chat:
        return Message(self.account, msg_id)

    def send_sticker(self, path: str) -> Message:
-        """Deprecated as of 2026-04; use `send_message` with `Viewtype.STICKER` instead."""
+        """Send an sticker and return the resulting Message instance."""
        msg_id = self._rpc.send_sticker(self.account.id, self.id, path)
        return Message(self.account, msg_id)

-    def resend_messages(self, messages: list[Message]) -> None:
-        """Resend a list of messages to this chat."""
-        msg_ids = [msg.id for msg in messages]
-        self._rpc.resend_messages(self.account.id, msg_ids)
-
    def forward_messages(self, messages: list[Message]) -> None:
        """Forward a list of messages to this chat."""
        msg_ids = [msg.id for msg in messages]
@@ -206,9 +201,9 @@ class Chat:
        snapshot["message"] = Message(self.account, snapshot.id)
        return snapshot

-    def get_messages(self, add_daymarker: bool = False) -> list[Message]:
+    def get_messages(self, info_only: bool = False, add_daymarker: bool = False) -> list[Message]:
        """Get the list of messages in this chat."""
-        msgs = self._rpc.get_message_ids(self.account.id, self.id, False, add_daymarker)
+        msgs = self._rpc.get_message_ids(self.account.id, self.id, info_only, add_daymarker)
        return [Message(self.account, msg_id) for msg_id in msgs]

    def get_fresh_message_count(self) -> int:
@@ -219,16 +214,10 @@ class Chat:
        """Mark all messages in this chat as noticed."""
        self._rpc.marknoticed_chat(self.account.id, self.id)

-    def mark_fresh(self) -> None:
-        """Mark the last incoming message in the chat as fresh."""
-        self._rpc.markfresh_chat(self.account.id, self.id)
-
-    def add_contact(self, *contact: Union[int, str, Contact, "Account"]) -> None:
+    def add_contact(self, *contact: Union[int, str, Contact]) -> None:
        """Add contacts to this group."""
-        from .account import Account
-
        for cnt in contact:
-            if isinstance(cnt, (str, Account)):
+            if isinstance(cnt, str):
                contact_id = self.account.create_contact(cnt).id
            elif not isinstance(cnt, int):
                contact_id = cnt.id
@@ -236,12 +225,10 @@ class Chat:
                contact_id = cnt
            self._rpc.add_contact_to_chat(self.account.id, self.id, contact_id)

-    def remove_contact(self, *contact: Union[int, str, Contact, "Account"]) -> None:
+    def remove_contact(self, *contact: Union[int, str, Contact]) -> None:
        """Remove members from this group."""
-        from .account import Account
-
        for cnt in contact:
-            if isinstance(cnt, (str, Account)):
+            if isinstance(cnt, str):
                contact_id = self.account.create_contact(cnt).id
            elif not isinstance(cnt, int):
                contact_id = cnt.id
@@ -252,15 +239,11 @@ class Chat:
    def get_contacts(self) -> list[Contact]:
        """Get the contacts belonging to this chat.

-        For single chats self-address is not included.
+        For single/direct chats self-address is not included.
        """
        contacts = self._rpc.get_chat_contacts(self.account.id, self.id)
        return [Contact(self.account, contact_id) for contact_id in contacts]

-    def num_contacts(self) -> int:
-        """Return number of contacts in this chat."""
-        return len(self.get_contacts())
-
    def get_past_contacts(self) -> list[Contact]:
        """Get past contacts for this chat."""
        past_contacts = self._rpc.get_past_chat_contacts(self.account.id, self.id)
@@ -277,16 +260,6 @@ class Chat:
        """Remove profile image of this chat."""
        self._rpc.set_chat_profile_image(self.account.id, self.id, None)

-    def send_locations(self, seconds) -> None:
-        """Enable location streaming in the chat for the given number of seconds.
-
-        Pass 0 to disable location streaming."""
-        self._rpc.send_locations_to_chat(self.account.id, self.id, seconds)
-
-    def is_sending_locations(self) -> bool:
-        """Return True if sending locations to this chat."""
-        return self._rpc.is_sending_locations_to_chat(self.account.id, self.id)
-
    def get_locations(
        self,
        contact: Optional[Contact] = None,
@@ -316,8 +289,3 @@ class Chat:
            f.write(vcard.encode())
            f.flush()
            self._rpc.send_msg(self.account.id, self.id, {"viewtype": ViewType.VCARD, "file": f.name})
-
-    def place_outgoing_call(self, place_call_info: str, has_video_initially: bool) -> Message:
-        """Starts an outgoing call."""
-        msg_id = self._rpc.place_outgoing_call(self.account.id, self.id, place_call_info, has_video_initially)
-        return Message(self.account, msg_id)
--- a/deltachat-rpc-client/src/deltachat_rpc_client/client.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/client.py
@@ -14,7 +14,6 @@ from typing import (

 from ._utils import (
    AttrDict,
-    _forever,
    parse_system_add_remove,
    parse_system_image_changed,
    parse_system_title_changed,
@@ -84,36 +83,28 @@ class Client:

    def configure(self, email: str, password: str, **kwargs) -> None:
        """Configure the client."""
+        self.account.set_config("addr", email)
+        self.account.set_config("mail_pw", password)
        for key, value in kwargs.items():
            self.account.set_config(key, value)
-        params = {"addr": email, "password": password}
-        self.account.add_or_update_transport(params)
+        self.account.configure()
        self.logger.debug("Account configured")

    def run_forever(self) -> None:
        """Process events forever."""
-        self.run_until(_forever)
+        self.run_until(lambda _: False)

    def run_until(self, func: Callable[[AttrDict], bool]) -> AttrDict:
-        """Start the event processing loop."""
+        """Process events until the given callable evaluates to True.
+
+        The callable should accept an AttrDict object representing the
+        last processed event. The event is returned when the callable
+        evaluates to True.
+        """
        self.logger.debug("Listening to incoming events...")
        if self.is_configured():
            self.account.start_io()
        self._process_messages()  # Process old messages.
-        return self._process_events(until_func=func)  # Loop over incoming events
-
-    def _process_events(
-        self,
-        until_func: Callable[[AttrDict], bool] = _forever,
-        until_event: EventType = False,
-    ) -> AttrDict:
-        """Process events until the given callable evaluates to True,
-        or until a certain event happens.
-
-        The until_func callable should accept an AttrDict object representing
-        the last processed event. The event is returned when the callable
-        evaluates to True.
-        """
        while True:
            event = self.account.wait_for_event()
            event["kind"] = EventType(event.kind)
@@ -122,13 +113,10 @@ class Client:
            if event.kind == EventType.INCOMING_MSG:
                self._process_messages()

-            stop = until_func(event)
+            stop = func(event)
            if stop:
                return event

-            if event.kind == until_event:
-                return event
-
    def _on_event(self, event: AttrDict, filter_type: Type[EventFilter] = RawEvent) -> None:
        for hook, evfilter in self._hooks.get(filter_type, []):
            if evfilter.filter(event):
--- a/deltachat-rpc-client/src/deltachat_rpc_client/const.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/const.py
@@ -54,7 +54,6 @@ class EventType(str, Enum):
    MSG_DELIVERED = "MsgDelivered"
    MSG_FAILED = "MsgFailed"
    MSG_READ = "MsgRead"
-    MSG_READ_COUNT_CHANGED = "MsgReadCountChanged"
    MSG_DELETED = "MsgDeleted"
    CHAT_MODIFIED = "ChatModified"
    CHAT_DELETED = "ChatDeleted"
@@ -74,14 +73,9 @@ class EventType(str, Enum):
    CHATLIST_ITEM_CHANGED = "ChatlistItemChanged"
    ACCOUNTS_CHANGED = "AccountsChanged"
    ACCOUNTS_ITEM_CHANGED = "AccountsItemChanged"
-    INCOMING_CALL = "IncomingCall"
-    INCOMING_CALL_ACCEPTED = "IncomingCallAccepted"
-    OUTGOING_CALL_ACCEPTED = "OutgoingCallAccepted"
-    CALL_ENDED = "CallEnded"
    CONFIG_SYNCED = "ConfigSynced"
    WEBXDC_REALTIME_DATA = "WebxdcRealtimeData"
    WEBXDC_REALTIME_ADVERTISEMENT_RECEIVED = "WebxdcRealtimeAdvertisementReceived"
-    TRANSPORTS_MODIFIED = "TransportsModified"


 class ChatId(IntEnum):
@@ -93,17 +87,19 @@ class ChatId(IntEnum):
    LAST_SPECIAL = 9


-class ChatType(str, Enum):
+class ChatType(IntEnum):
    """Chat type."""

-    SINGLE = "Single"
-    """Single chat (a chat with a with a single contact)"""
+    UNDEFINED = 0

-    GROUP = "Group"
+    SINGLE = 100
+    """1:1 chat, i.e. a direct chat with a single contact"""

-    MAILINGLIST = "Mailinglist"
+    GROUP = 120

-    OUT_BROADCAST = "OutBroadcast"
+    MAILINGLIST = 140
+
+    OUT_BROADCAST = 160
    """Outgoing broadcast channel, called "Channel" in the UI.

    The user can send into this channel,
@@ -115,7 +111,7 @@ class ChatType(str, Enum):
    which would make it hard to grep for it.
    """

-    IN_BROADCAST = "InBroadcast"
+    IN_BROADCAST = 165
    """Incoming broadcast channel, called "Channel" in the UI.

    This channel is read-only,
@@ -160,6 +156,7 @@ class ViewType(str, Enum):
    VOICE = "Voice"
    VIDEO = "Video"
    FILE = "File"
+    VIDEOCHAT_INVITATION = "VideochatInvitation"
    WEBXDC = "Webxdc"
    VCARD = "Vcard"

@@ -191,6 +188,7 @@ class MessageState(IntEnum):
    IN_FRESH = 10
    IN_NOTICED = 13
    IN_SEEN = 16
+    OUT_PREPARING = 18
    OUT_DRAFT = 19
    OUT_PENDING = 20
    OUT_FAILED = 24
@@ -231,6 +229,14 @@ class KeyGenType(IntEnum):
    RSA4096 = 3


+# "Lp" means "login parameters"
+class LpAuthFlag(IntEnum):
+    """Authorization flags."""
+
+    OAUTH2 = 0x2
+    NORMAL = 0x4
+
+
 class MediaQuality(IntEnum):
    """Media quality setting."""

@@ -246,6 +252,14 @@ class ProviderStatus(IntEnum):
    BROKEN = 3


+class PushNotifyState(IntEnum):
+    """Push notifications state."""
+
+    NOT_CONNECTED = 0
+    HEARTBEAT = 1
+    CONNECTED = 2
+
+
 class ShowEmails(IntEnum):
    """Show emails mode."""

@@ -261,3 +275,11 @@ class SocketSecurity(IntEnum):
    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/contact.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/contact.py
@@ -55,7 +55,7 @@ class Contact:
        return snapshot

    def create_chat(self) -> "Chat":
-        """Create or get an existing single chat for this contact."""
+        """Create or get an existing 1:1 chat for this contact."""
        from .chat import Chat

        return Chat(
--- a/deltachat-rpc-client/src/deltachat_rpc_client/deltachat.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/deltachat.py
@@ -4,7 +4,7 @@ from __future__ import annotations

 from typing import TYPE_CHECKING

-from ._utils import AttrDict, futuremethod
+from ._utils import AttrDict
 from .account import Account

 if TYPE_CHECKING:
@@ -39,15 +39,6 @@ class DeltaChat:
        """Stop the I/O of all accounts."""
        self.rpc.stop_io_for_all_accounts()

-    @futuremethod
-    def background_fetch(self, timeout_in_seconds: int) -> None:
-        """Run background fetch for all accounts."""
-        yield self.rpc.background_fetch.future(timeout_in_seconds)
-
-    def stop_background_fetch(self) -> None:
-        """Stop ongoing background fetch."""
-        self.rpc.stop_background_fetch()
-
    def maybe_network(self) -> None:
        """Indicate that the network conditions might have changed."""
        self.rpc.maybe_network()
@@ -59,11 +50,3 @@ class DeltaChat:
    def set_translations(self, translations: dict[str, str]) -> None:
        """Set stock translation strings."""
        self.rpc.set_stock_strings(translations)
-
-    def set_location(self, latitude, longitude, accuracy) -> bool:
-        """Set location, return True if location streaming should continue."""
-        return self.rpc.set_location(latitude, longitude, accuracy)
-
-    def stop_sending_locations(self) -> None:
-        """Stop sending locations to all chats."""
-        return self.rpc.stop_sending_locations()
--- a/deltachat-rpc-client/src/deltachat_rpc_client/message.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/message.py
@@ -25,14 +25,7 @@ class Message:
        return self.account._rpc

    def send_reaction(self, *reaction: str) -> "Message":
-        """
-        Sends a reaction to message.
-
-        A reaction is a string that represents an emoji.
-        You can call this function again to change the emoji;
-        the last sent reaction overrides all previously sent reactions.
-        It is possible to remove the reaction by sending an empty string.
-        """
+        """Send a reaction to this message."""
        msg_id = self._rpc.send_reaction(self.account.id, self.id, reaction)
        return Message(self.account, msg_id)

@@ -51,14 +44,6 @@ class Message:
        read_receipts = self._rpc.get_message_read_receipts(self.account.id, self.id)
        return [AttrDict(read_receipt) for read_receipt in read_receipts]

-    def get_read_receipt_count(self) -> int:
-        """
-        Returns count of read receipts on message.
-
-        This view count is meant as a feedback measure for the channel owner only.
-        """
-        return self._rpc.get_message_read_receipt_count(self.account.id, self.id)
-
    def get_reactions(self) -> Optional[AttrDict]:
        """Get message reactions."""
        reactions = self._rpc.get_message_reactions(self.account.id, self.id)
@@ -75,9 +60,13 @@ class Message:
        """Mark the message as seen."""
        self._rpc.markseen_msgs(self.account.id, [self.id])

-    def exists(self) -> bool:
-        """Return True if the message exists."""
-        return bool(self._rpc.get_existing_msg_ids(self.account.id, [self.id]))
+    def continue_autocrypt_key_transfer(self, setup_code: str) -> None:
+        """Continue the Autocrypt Setup Message key transfer.
+
+        This function can be called on received Autocrypt Setup Message
+        to import the key encrypted with the provided setup code.
+        """
+        self._rpc.continue_autocrypt_key_transfer(self.account.id, self.id, setup_code)

    def send_webxdc_status_update(self, update: Union[dict, str], description: str) -> None:
        """Send a webxdc status update. This message must be a webxdc."""
@@ -104,17 +93,6 @@ class Message:
            if event.kind == EventType.MSG_DELIVERED and event.msg_id == self.id:
                break

-    def resend(self) -> None:
-        """Resend messages and make information available for newly added chat members.
-        Resending sends out the original message, however, recipients and webxdc-status may differ.
-        Clients that already have the original message can still ignore the resent message as
-        they have tracked the state by dedicated updates.
-
-        Some messages cannot be resent, eg. info-messages, drafts, already pending messages,
-        or messages that are not sent by SELF.
-        """
-        self._rpc.resend_messages(self.account.id, [self.id])
-
    @futuremethod
    def send_webxdc_realtime_advertisement(self):
        """Send an advertisement to join the realtime channel."""
@@ -124,15 +102,3 @@ class Message:
    def send_webxdc_realtime_data(self, data) -> None:
        """Send data to the realtime channel."""
        yield self._rpc.send_webxdc_realtime_data.future(self.account.id, self.id, list(data))
-
-    def accept_incoming_call(self, accept_call_info):
-        """Accepts an incoming call."""
-        self._rpc.accept_incoming_call(self.account.id, self.id, accept_call_info)
-
-    def end_call(self):
-        """Ends incoming or outgoing call."""
-        self._rpc.end_call(self.account.id, self.id)
-
-    def get_call_info(self) -> AttrDict:
-        """Return information about the call."""
-        return AttrDict(self._rpc.call_info(self.account.id, self.id))
--- a/deltachat-rpc-client/src/deltachat_rpc_client/pytestplugin.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/pytestplugin.py
@@ -2,15 +2,11 @@

 from __future__ import annotations

-import logging
 import os
-import pathlib
-import platform
 import random
-import subprocess
-import sys
 from typing import AsyncGenerator, Optional

+import py
 import pytest

 from . import Account, AttrDict, Bot, Chat, Client, DeltaChat, EventType, Message
@@ -20,22 +16,10 @@ from .rpc import Rpc
 E2EE_INFO_MSGS = 1
 """
 The number of info messages added to new e2ee chats.
-Currently this is "Messages are end-to-end encrypted."
+Currently this is "End-to-end encryption available".
 """


-def pytest_report_header():
-    for base in os.get_exec_path():
-        fn = pathlib.Path(base).joinpath(base, "deltachat-rpc-server")
-        if fn.exists():
-            proc = subprocess.Popen([str(fn), "--version"], stderr=subprocess.PIPE)
-            proc.wait()
-            version = proc.stderr.read().decode().strip()
-            return f"deltachat-rpc-server: {fn} [{version}]"
-
-    return None
-
-
 class ACFactory:
    """Test account factory."""

@@ -44,7 +28,9 @@ class ACFactory:

    def get_unconfigured_account(self) -> Account:
        """Create a new unconfigured account."""
-        return self.deltachat.add_account()
+        account = self.deltachat.add_account()
+        account.set_config("verified_one_on_one_chats", "1")
+        return account

    def get_unconfigured_bot(self) -> Bot:
        """Create a new unconfigured bot."""
@@ -52,21 +38,17 @@ class ACFactory:

    def get_credentials(self) -> (str, str):
        """Generate new credentials for chatmail account."""
-        domain = os.environ["CHATMAIL_DOMAIN"]
+        domain = os.getenv("CHATMAIL_DOMAIN")
        username = "ci-" + "".join(random.choice("2345789acdefghjkmnpqrstuvwxyz") for i in range(6))
        return f"{username}@{domain}", f"{username}${username}"

-    def get_account_qr(self):
-        """Return "dcaccount:" QR code for testing chatmail relay."""
-        domain = os.environ["CHATMAIL_DOMAIN"]
-        return f"dcaccount:{domain}"
-
    @futuremethod
    def new_configured_account(self):
        """Create a new configured account."""
+        addr, password = self.get_credentials()
        account = self.get_unconfigured_account()
-        qr = self.get_account_qr()
-        yield account.add_transport_from_qr.future(qr)
+        params = {"addr": addr, "password": password}
+        yield account.add_or_update_transport.future(params)

        assert account.is_configured()
        return account
@@ -93,16 +75,15 @@ class ACFactory:
    def resetup_account(self, ac: Account) -> Account:
        """Resetup account from scratch, losing the encryption key."""
        ac.stop_io()
-        transports = ac.list_transports()
-        ac.remove()
        ac_clone = self.get_unconfigured_account()
-        for transport in transports:
-            ac_clone.add_or_update_transport(transport)
-        ac_clone.bring_online()
+        for i in ["addr", "mail_pw"]:
+            ac_clone.set_config(i, ac.get_config(i))
+        ac.remove()
+        ac_clone.configure()
        return ac_clone

    def get_accepted_chat(self, ac1: Account, ac2: Account) -> Chat:
-        """Create a new single chat between ac1 and ac2 accepted on both sides.
+        """Create a new 1:1 chat between ac1 and ac2 accepted on both sides.

        Returned chat is a chat with ac2 from ac1 point of view.
        """
@@ -157,15 +138,9 @@ def rpc(tmp_path) -> AsyncGenerator:


@pytest.fixture
-def dc(rpc) -> DeltaChat:
-    """Return account manager."""
-    return DeltaChat(rpc)
-
-
-@pytest.fixture
-def acfactory(dc) -> AsyncGenerator:
+def acfactory(rpc) -> AsyncGenerator:
    """Return account factory fixture."""
-    return ACFactory(dc)
+    return ACFactory(DeltaChat(rpc))


@pytest.fixture
@@ -174,9 +149,9 @@ def data():

    class Data:
        def __init__(self) -> None:
-            for path in pathlib.Path(__file__).parents:
-                datadir = path / "test-data"
-                if datadir.is_dir():
+            for path in reversed(py.path.local(__file__).parts()):
+                datadir = path.join("test-data")
+                if datadir.isdir():
                    self.path = datadir
                    return
            raise Exception("Data path cannot be found")
@@ -203,144 +178,13 @@ def log():

    class Printer:
        def section(self, msg: str) -> None:
-            logging.info("\n%s %s %s", "=" * 10, msg, "=" * 10)
+            print()
+            print("=" * 10, msg, "=" * 10)

        def step(self, msg: str) -> None:
-            logging.info("%s step %s %s", "-" * 5, msg, "-" * 5)
+            print("-" * 5, "step " + msg, "-" * 5)

        def indent(self, msg: str) -> None:
-            logging.info("  " + msg)
+            print("  " + msg)

    return Printer()
-
-
-#
-# support for testing against different deltachat-rpc-server/clients
-# installed into a temporary virtualenv and connected via 'execnet' channels
-#
-
-
-def find_path(venv, name):
-    is_windows = platform.system() == "Windows"
-    bin = venv / ("bin" if not is_windows else "Scripts")
-
-    tryadd = [""]
-    if is_windows:
-        tryadd += os.environ["PATHEXT"].split(os.pathsep)
-    for ext in tryadd:
-        p = bin.joinpath(name + ext)
-        if p.exists():
-            return str(p)
-
-    return None
-
-
-@pytest.fixture(scope="session")
-def get_core_python_env(tmp_path_factory):
-    """Return a factory to create virtualenv environments with rpc server/client packages
-    installed.
-
-    The factory takes a version and returns a (python_path, rpc_server_path) tuple
-    of the respective binaries in the virtualenv.
-    """
-
-    envs = {}
-
-    def get_versioned_venv(core_version):
-        venv = envs.get(core_version)
-        if not venv:
-            venv = tmp_path_factory.mktemp(f"temp-{core_version}")
-            subprocess.check_call([sys.executable, "-m", "venv", venv])
-
-            python = find_path(venv, "python")
-            pkgs = [f"deltachat-rpc-server=={core_version}", f"deltachat-rpc-client=={core_version}", "pytest"]
-            subprocess.check_call([python, "-m", "pip", "install"] + pkgs)
-
-            envs[core_version] = venv
-        python = find_path(venv, "python")
-        rpc_server_path = find_path(venv, "deltachat-rpc-server")
-        logging.info(f"Paths:\npython={python}\nrpc_server={rpc_server_path}")
-        return python, rpc_server_path
-
-    return get_versioned_venv
-
-
-@pytest.fixture
-def alice_and_remote_bob(tmp_path, acfactory, get_core_python_env):
-    """return local Alice account, a contact to bob, and a remote 'eval' function for bob.
-
-    The 'eval' function allows to remote-execute arbitrary expressions
-    that can use the `bob` online account, and the `bob_contact_alice`.
-    """
-    from execnet import makegateway
-
-    def factory(core_version):
-        python, rpc_server_path = get_core_python_env(core_version)
-        gw = makegateway(f"popen//python={python}")
-
-        accounts_dir = str(tmp_path.joinpath("account1_venv1"))
-        channel = gw.remote_exec(remote_bob_loop)
-        cm = os.environ.get("CHATMAIL_DOMAIN")
-
-        # trigger getting an online account on bob's side
-        channel.send((accounts_dir, str(rpc_server_path), cm))
-
-        # meanwhile get a local alice account
-        alice = acfactory.get_online_account()
-        channel.send(alice.self_contact.make_vcard())
-
-        # wait for bob to have started
-        sysinfo = channel.receive()
-        assert sysinfo == f"v{core_version}"
-        bob_vcard = channel.receive()
-        [alice_contact_bob] = alice.import_vcard(bob_vcard)
-
-        def eval(eval_str):
-            channel.send(eval_str)
-            return channel.receive()
-
-        return alice, alice_contact_bob, eval
-
-    return factory
-
-
-def remote_bob_loop(channel):
-    # This function executes with versioned
-    # deltachat-rpc-client/server packages
-    # installed into the virtualenv.
-    #
-    # The "channel" argument is a send/receive pipe
-    # to the process that runs the corresponding remote_exec(remote_bob_loop)
-
-    import os
-
-    from deltachat_rpc_client import DeltaChat, Rpc
-    from deltachat_rpc_client.pytestplugin import ACFactory
-
-    accounts_dir, rpc_server_path, chatmail_domain = channel.receive()
-    os.environ["CHATMAIL_DOMAIN"] = chatmail_domain
-
-    # older core versions don't support specifying rpc_server_path
-    # so we can't just pass `rpc_server_path` argument to Rpc constructor
-    basepath = os.path.dirname(rpc_server_path)
-    os.environ["PATH"] = os.pathsep.join([basepath, os.environ["PATH"]])
-    rpc = Rpc(accounts_dir=accounts_dir)
-
-    with rpc:
-        dc = DeltaChat(rpc)
-        channel.send(dc.rpc.get_system_info()["deltachat_core_version"])
-        acfactory = ACFactory(dc)
-        bob = acfactory.get_online_account()
-        alice_vcard = channel.receive()
-        [alice_contact] = bob.import_vcard(alice_vcard)
-        ns = {"bob": bob, "bob_contact_alice": alice_contact}
-        channel.send(bob.self_contact.make_vcard())
-
-        while 1:
-            eval_str = channel.receive()
-            res = eval(eval_str, ns)
-            try:
-                channel.send(res)
-            except Exception:
-                # some unserializable result
-                channel.send(None)
--- a/deltachat-rpc-client/src/deltachat_rpc_client/rpc.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/rpc.py
@@ -9,7 +9,7 @@ import os
 import subprocess
 import sys
 from queue import Empty, Queue
-from threading import Thread
+from threading import Event, Thread
 from typing import Any, Iterator, Optional


@@ -17,6 +17,25 @@ class JsonRpcError(Exception):
    """JSON-RPC error."""


+class RpcFuture:
+    """RPC future waiting for RPC call result."""
+
+    def __init__(self, rpc: "Rpc", request_id: int, event: Event):
+        self.rpc = rpc
+        self.request_id = request_id
+        self.event = event
+
+    def __call__(self):
+        """Wait for the future to return the result."""
+        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:
    """RPC method."""

@@ -38,31 +57,20 @@ class RpcMethod:
            "params": args,
            "id": request_id,
        }
-        self.rpc.request_results[request_id] = queue = Queue()
+        event = Event()
+        self.rpc.request_events[request_id] = event
        self.rpc.request_queue.put(request)

-        def rpc_future():
-            """Wait for the request to receive a result."""
-            response = queue.get()
-            if "error" in response:
-                raise JsonRpcError(response["error"])
-            return response.get("result", None)
-
-        return rpc_future
+        return RpcFuture(self.rpc, request_id, event)


 class Rpc:
    """RPC client."""

-    def __init__(
-        self,
-        accounts_dir: Optional[str] = None,
-        rpc_server_path="deltachat-rpc-server",
-        **kwargs,
-    ):
+    def __init__(self, accounts_dir: Optional[str] = None, **kwargs):
        """Initialize RPC client.

-        The 'kwargs' arguments will be passed to subprocess.Popen().
+        The given arguments will be passed to subprocess.Popen().
        """
        if accounts_dir:
            kwargs["env"] = {
@@ -71,12 +79,13 @@ class Rpc:
            }

        self._kwargs = kwargs
-        self.rpc_server_path = rpc_server_path
        self.process: subprocess.Popen
        self.id_iterator: Iterator[int]
        self.event_queues: dict[int, Queue]
-        # Map from request ID to a Queue which provides a single result
-        self.request_results: dict[int, Queue]
+        # Map from request ID to `threading.Event`.
+        self.request_events: dict[int, Event]
+        # Map from request ID to the result.
+        self.request_results: dict[int, Any]
        self.request_queue: Queue[Any]
        self.closing: bool
        self.reader_thread: Thread
@@ -84,27 +93,28 @@ class Rpc:
        self.events_thread: Thread

    def start(self) -> None:
-        """Start RPC server subprocess and wait for successful initialization.
-
-        This method blocks until the RPC server responds to an initial
-        health-check RPC call (get_system_info).
-        If the server fails to start
-        (e.g., due to an invalid accounts directory),
-        a JsonRpcError is raised.
-        """
-        popen_kwargs = {"stdin": subprocess.PIPE, "stdout": subprocess.PIPE, "stderr": subprocess.PIPE}
+        """Start RPC server subprocess."""
        if sys.version_info >= (3, 11):
-            # Prevent subprocess from capturing SIGINT.
-            popen_kwargs["process_group"] = 0
+            self.process = subprocess.Popen(
+                "deltachat-rpc-server",
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                # Prevent subprocess from capturing SIGINT.
+                process_group=0,
+                **self._kwargs,
+            )
        else:
-            # `process_group` is not supported before Python 3.11.
-            popen_kwargs["preexec_fn"] = os.setpgrp  # noqa: PLW1509
-
-        popen_kwargs.update(self._kwargs)
-        self.process = subprocess.Popen(self.rpc_server_path, **popen_kwargs)
-
+            self.process = subprocess.Popen(
+                "deltachat-rpc-server",
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                # `process_group` is not supported before Python 3.11.
+                preexec_fn=os.setpgrp,  # noqa: PLW1509
+                **self._kwargs,
+            )
        self.id_iterator = itertools.count(start=1)
        self.event_queues = {}
+        self.request_events = {}
        self.request_results = {}
        self.request_queue = Queue()
        self.closing = False
@@ -115,22 +125,6 @@ class Rpc:
        self.events_thread = Thread(target=self.events_loop)
        self.events_thread.start()

-        # Perform a health-check RPC call to ensure the server started
-        # successfully and the accounts directory is usable.
-        try:
-            system_info = self.get_system_info()
-        except (JsonRpcError, Exception) as e:
-            # The reader_loop already saw EOF on stdout, so the process
-            # has exited and stderr is available.
-            stderr = self.process.stderr.read().decode(errors="replace").strip()
-            if stderr:
-                raise JsonRpcError(f"RPC server failed to start: {stderr}") from e
-            raise JsonRpcError(f"RPC server startup check failed: {e}") from e
-        logging.info(
-            "RPC server ready. Core version: %s",
-            system_info.get("deltachat_core_version", "unknown"),
-        )
-
    def close(self) -> None:
        """Terminate RPC server process and wait until the reader loop finishes."""
        self.closing = True
@@ -155,16 +149,14 @@ class Rpc:
                response = json.loads(line)
                if "id" in response:
                    response_id = response["id"]
-                    self.request_results.pop(response_id).put(response)
+                    event = self.request_events.pop(response_id)
+                    self.request_results[response_id] = response
+                    event.set()
                else:
                    logging.warning("Got a response without ID: %s", response)
        except Exception:
            # Log an exception if the reader loop dies.
            logging.exception("Exception in the reader loop")
-        finally:
-            # Unblock any pending requests when the server closes stdout.
-            for _request_id, queue in self.request_results.items():
-                queue.put({"error": {"code": -32000, "message": "RPC server closed"}})

    def writer_loop(self) -> None:
        """Writer loop ensuring only a single thread writes requests."""
@@ -173,6 +165,7 @@ class Rpc:
                data = (json.dumps(request) + "\n").encode()
                self.process.stdin.write(data)
                self.process.stdin.flush()
+
        except Exception:
            # Log an exception if the writer loop dies.
            logging.exception("Exception in the writer loop")
@@ -186,15 +179,15 @@ class Rpc:
    def events_loop(self) -> None:
        """Request new events and distributes them between queues."""
        try:
-            while events := self.get_next_event_batch():
-                for event in events:
-                    account_id = event["contextId"]
-                    queue = self.get_queue(account_id)
-                    payload = event["event"]
-                    logging.debug("account_id=%d got an event %s", account_id, payload)
-                    queue.put(payload)
+            while True:
                if self.closing:
                    return
+                event = self.get_next_event()
+                account_id = event["contextId"]
+                queue = self.get_queue(account_id)
+                event = event["event"]
+                logging.debug("account_id=%d got an event %s", account_id, event)
+                queue.put(event)
        except Exception:
            # Log an exception if the event loop dies.
            logging.exception("Exception in the event loop")
--- a/deltachat-rpc-client/tests/conftest.py
+++ b/deltachat-rpc-client/tests/conftest.py
@@ -2,7 +2,6 @@ from __future__ import annotations

 import imaplib
 import io
-import logging
 import pathlib
 import ssl
 from contextlib import contextmanager
@@ -46,13 +45,13 @@ class DirectImap:
        try:
            self.conn.logout()
        except (OSError, imaplib.IMAP4.abort):
-            logging.warning("Could not logout direct_imap conn")
+            print("Could not logout direct_imap conn")

    def create_folder(self, foldername):
        try:
            self.conn.folder.create(foldername)
        except errors.MailboxFolderCreateError as e:
-            logging.warning(f"Cannot create '{foldername}', probably it already exists: {str(e)}")
+            print("Can't create", foldername, "probably it already exists:", str(e))

    def select_folder(self, foldername: str) -> tuple:
        assert not self._idling
@@ -86,17 +85,17 @@ class DirectImap:

    def get_all_messages(self) -> list[MailMessage]:
        assert not self._idling
-        return list(self.conn.fetch(mark_seen=False))
+        return list(self.conn.fetch())

    def get_unread_messages(self) -> list[str]:
        assert not self._idling
-        return [msg.uid for msg in self.conn.fetch(AND(seen=False), mark_seen=False)]
+        return [msg.uid for msg in self.conn.fetch(AND(seen=False))]

    def mark_all_read(self):
        messages = self.get_unread_messages()
        if messages:
            res = self.conn.flag(messages, MailMessageFlags.SEEN, True)
-            logging.info(f"Marked seen: {messages} {res}")
+            print("marked seen:", messages, res)

    def get_unread_cnt(self) -> int:
        return len(self.get_unread_messages())
@@ -174,6 +173,7 @@ class DirectImap:
 class IdleManager:
    def __init__(self, direct_imap) -> None:
        self.direct_imap = direct_imap
+        self.log = direct_imap.account.log
        # fetch latest messages before starting idle so that it only
        # returns messages that arrive anew
        self.direct_imap.conn.fetch("1:*")
@@ -181,11 +181,14 @@ class IdleManager:

    def check(self, timeout=None) -> list[bytes]:
        """(blocking) wait for next idle message from server."""
-        return self.direct_imap.conn.idle.poll(timeout=timeout)
+        self.log("imap-direct: calling idle_check")
+        res = self.direct_imap.conn.idle.poll(timeout=timeout)
+        self.log(f"imap-direct: idle_check returned {res!r}")
+        return res

-    def wait_for_new_message(self) -> bytes:
+    def wait_for_new_message(self, timeout=None) -> bytes:
        while True:
-            for item in self.check():
+            for item in self.check(timeout=timeout):
                if b"EXISTS" in item or b"RECENT" in item:
                    return item

@@ -193,8 +196,10 @@ class IdleManager:
        """Return first message with SEEN flag from a running idle-stream."""
        while True:
            for item in self.check(timeout=timeout):
-                if FETCH in item and FLAGS in item and rb"\Seen" in item:
-                    return int(item.split(b" ")[1])
+                if FETCH in item:
+                    self.log(str(item))
+                    if FLAGS in item and rb"\Seen" in item:
+                        return int(item.split(b" ")[1])

    def done(self):
        """send idle-done to server if we are currently in idle mode."""
--- a/deltachat-rpc-client/tests/test_calls.py
+++ b/deltachat-rpc-client/tests/test_calls.py
@@ -1,146 +0,0 @@
-from deltachat_rpc_client import EventType, Message
-
-
-def test_calls(acfactory) -> None:
-    alice, bob = acfactory.get_online_accounts(2)
-
-    place_call_info = "offer"
-    accept_call_info = "answer"
-
-    alice_contact_bob = alice.create_contact(bob, "Bob")
-    alice_chat_bob = alice_contact_bob.create_chat()
-    bob.create_chat(alice)  # Accept the chat so incoming call causes a notification.
-    outgoing_call_message = alice_chat_bob.place_outgoing_call(place_call_info, has_video_initially=True)
-    assert outgoing_call_message.get_call_info().state.kind == "Alerting"
-
-    incoming_call_event = bob.wait_for_event(EventType.INCOMING_CALL)
-    assert incoming_call_event.place_call_info == place_call_info
-    assert incoming_call_event.has_video
-    incoming_call_message = Message(bob, incoming_call_event.msg_id)
-    assert incoming_call_message.get_call_info().state.kind == "Alerting"
-    assert incoming_call_message.get_call_info().has_video
-
-    incoming_call_message.accept_incoming_call(accept_call_info)
-    assert incoming_call_message.get_call_info().sdp_offer == place_call_info
-    assert incoming_call_message.get_call_info().state.kind == "Active"
-    outgoing_call_accepted_event = alice.wait_for_event(EventType.OUTGOING_CALL_ACCEPTED)
-    assert outgoing_call_accepted_event.accept_call_info == accept_call_info
-    assert outgoing_call_message.get_call_info().state.kind == "Active"
-
-    outgoing_call_message.end_call()
-    assert outgoing_call_message.get_call_info().state.kind == "Completed"
-
-    end_call_event = bob.wait_for_event(EventType.CALL_ENDED)
-    assert end_call_event.msg_id == outgoing_call_message.id
-    assert incoming_call_message.get_call_info().state.kind == "Completed"
-
-
-def test_video_call(acfactory) -> None:
-    # Example from <https://datatracker.ietf.org/doc/rfc9143/>
-    # with `s= ` replaced with `s=-`.
-    #
-    # `s=` cannot be empty according to RFC 3264,
-    # so it is more clear as `s=-`.
-
-    alice, bob = acfactory.get_online_accounts(2)
-
-    bob.create_chat(alice)  # Accept the chat so incoming call causes a notification.
-    alice_contact_bob = alice.create_contact(bob, "Bob")
-    alice_chat_bob = alice_contact_bob.create_chat()
-    alice_chat_bob.place_outgoing_call("offer", has_video_initially=True)
-
-    incoming_call_event = bob.wait_for_event(EventType.INCOMING_CALL)
-    assert incoming_call_event.place_call_info == "offer"
-    assert incoming_call_event.has_video
-
-    incoming_call_message = Message(bob, incoming_call_event.msg_id)
-    assert incoming_call_message.get_call_info().has_video
-
-
-def test_audio_call(acfactory) -> None:
-    alice, bob = acfactory.get_online_accounts(2)
-
-    bob.create_chat(alice)  # Accept the chat so incoming call causes a notification.
-    alice_contact_bob = alice.create_contact(bob, "Bob")
-    alice_chat_bob = alice_contact_bob.create_chat()
-    alice_chat_bob.place_outgoing_call("offer", has_video_initially=False)
-
-    incoming_call_event = bob.wait_for_event(EventType.INCOMING_CALL)
-    assert incoming_call_event.place_call_info == "offer"
-    assert not incoming_call_event.has_video
-
-    incoming_call_message = Message(bob, incoming_call_event.msg_id)
-    assert not incoming_call_message.get_call_info().has_video
-
-
-def test_ice_servers(acfactory) -> None:
-    alice = acfactory.get_online_account()
-
-    ice_servers = alice.ice_servers()
-    assert len(ice_servers) == 1
-
-
-def test_no_contact_request_call(acfactory) -> None:
-    alice, bob = acfactory.get_online_accounts(2)
-
-    alice_chat_bob = alice.create_chat(bob)
-    alice_chat_bob.place_outgoing_call("offer", has_video_initially=True)
-    alice_chat_bob.send_text("Hello!")
-
-    # Notification for "Hello!" message should arrive
-    # without the call ringing.
-    while True:
-        event = bob.wait_for_event()
-
-        # There should be no incoming call notification.
-        assert event.kind != EventType.INCOMING_CALL
-
-        if event.kind == EventType.MSGS_CHANGED:
-            msg = bob.get_message_by_id(event.msg_id)
-            if msg.get_snapshot().text == "Hello!":
-                break
-
-
-def test_who_can_call_me_nobody(acfactory) -> None:
-    alice, bob = acfactory.get_online_accounts(2)
-
-    # Bob sets "who can call me" to "nobody" (2)
-    bob.set_config("who_can_call_me", "2")
-
-    # Bob even accepts Alice in advance so the chat does not appear as contact request.
-    bob.create_chat(alice)
-
-    alice_chat_bob = alice.create_chat(bob)
-    alice_chat_bob.place_outgoing_call("offer", has_video_initially=True)
-    alice_chat_bob.send_text("Hello!")
-
-    # Notification for "Hello!" message should arrive
-    # without the call ringing.
-    while True:
-        event = bob.wait_for_event()
-
-        # There should be no incoming call notification.
-        assert event.kind != EventType.INCOMING_CALL
-
-        if event.kind == EventType.INCOMING_MSG:
-            msg = bob.get_message_by_id(event.msg_id)
-            if msg.get_snapshot().text == "Hello!":
-                break
-
-
-def test_who_can_call_me_everybody(acfactory) -> None:
-    """Test that if "who can call me" setting is set to "everybody", calls arrive even in contact request chats."""
-    alice, bob = acfactory.get_online_accounts(2)
-
-    # Bob sets "who can call me" to "nobody" (0)
-    bob.set_config("who_can_call_me", "0")
-
-    alice_chat_bob = alice.create_chat(bob)
-    alice_chat_bob.place_outgoing_call("offer", has_video_initially=True)
-    incoming_call_event = bob.wait_for_event(EventType.INCOMING_CALL)
-
-    incoming_call_message = Message(bob, incoming_call_event.msg_id)
-
-    # Even with the call arriving, the chat is still in the contact request mode.
-    incoming_chat = incoming_call_message.get_snapshot().chat
-    assert incoming_chat.get_basic_snapshot().is_contact_request
--- a/deltachat-rpc-client/tests/test_chatlist_events.py
+++ b/deltachat-rpc-client/tests/test_chatlist_events.py
@@ -1,5 +1,7 @@
 from __future__ import annotations

+import base64
+import os
 from typing import TYPE_CHECKING

 from deltachat_rpc_client import Account, EventType, const
@@ -87,7 +89,6 @@ def test_delivery_status_failed(acfactory: ACFactory) -> None:
    Test change status on chatlistitem when status changes failed
    """
    (alice,) = acfactory.get_online_accounts(1)
-    alice.set_config("force_encryption", "0")

    invalid_contact = alice.create_contact("example@example.com", "invalid address")
    invalid_chat = alice.get_chat_by_id(alice._rpc.create_chat_by_contact_id(alice.id, invalid_contact.id))
@@ -128,7 +129,7 @@ def test_download_on_demand(acfactory: ACFactory) -> None:
    msg.get_snapshot().chat.accept()
    bob.get_chat_by_id(chat_id).send_message(
        "Hello World, this message is bigger than 5 bytes",
-        file="../test-data/image/screenshot.jpg",
+        html=base64.b64encode(os.urandom(300000)).decode("utf-8"),
    )

    message = alice.wait_for_incoming_msg()
@@ -168,8 +169,6 @@ def test_imap_sync_seen_msgs(acfactory: ACFactory) -> None:
    """
    alice, alice_second_device, bob, alice_chat_bob = get_multi_account_test_setup(acfactory)

-    bob.create_chat(alice)
-
    alice_chat_bob.send_text("hello")

    msg = bob.wait_for_incoming_msg()
--- a/deltachat-rpc-client/tests/test_cross_core.py
+++ b/deltachat-rpc-client/tests/test_cross_core.py
@@ -1,66 +0,0 @@
-import subprocess
-
-import pytest
-
-from deltachat_rpc_client import DeltaChat, Rpc
-
-
-def test_install_venv_and_use_other_core(tmp_path, get_core_python_env):
-    python, rpc_server_path = get_core_python_env("2.24.0")
-    subprocess.check_call([python, "-m", "pip", "install", "deltachat-rpc-server==2.24.0"])
-    rpc = Rpc(accounts_dir=tmp_path.joinpath("accounts"), rpc_server_path=rpc_server_path)
-
-    with rpc:
-        dc = DeltaChat(rpc)
-        assert dc.rpc.get_system_info()["deltachat_core_version"] == "v2.24.0"
-
-
-@pytest.mark.parametrize("version", ["2.24.0"])
-def test_qr_setup_contact(acfactory, alice_and_remote_bob, version) -> None:
-    """Test other-core Bob profile can do securejoin with Alice on current core."""
-    alice, alice_contact_bob, remote_eval = alice_and_remote_bob(version)
-
-    qr_code = alice.get_qr_code()
-    remote_eval(f"bob.secure_join({qr_code!r})")
-    alice.wait_for_securejoin_inviter_success()
-
-    # Test that Alice verified Bob's profile.
-    alice_contact_bob_snapshot = alice_contact_bob.get_snapshot()
-    assert alice_contact_bob_snapshot.is_verified
-
-    remote_eval("bob.wait_for_securejoin_joiner_success()")
-
-    # Test that Bob verified Alice's profile.
-    assert remote_eval("bob_contact_alice.get_snapshot().is_verified")
-
-    # Test that Bob can also scan a QR code
-    # of Alice for which the key is not known yet.
-    # For the test above Bob already knew the key from a vCard.
-    alice2 = acfactory.get_online_account()
-    qr_code = alice2.get_qr_code()
-    remote_eval(f"bob.secure_join({qr_code!r})")
-    remote_eval("bob.wait_for_securejoin_joiner_success()")
-    alice2.wait_for_securejoin_inviter_success()
-
-
-def test_send_and_receive_message(alice_and_remote_bob) -> None:
-    """Test other-core Bob profile can send a message to Alice on current core."""
-    alice, alice_contact_bob, remote_eval = alice_and_remote_bob("2.20.0")
-
-    remote_eval("bob_contact_alice.create_chat().send_text('hello')")
-
-    msg = alice.wait_for_incoming_msg()
-    assert msg.get_snapshot().text == "hello"
-
-
-def test_second_device(acfactory, alice_and_remote_bob) -> None:
-    """Test setting up current version as a second device for old version."""
-    _alice, alice_contact_bob, remote_eval = alice_and_remote_bob("2.20.0")
-
-    remote_eval("locals().setdefault('future', bob._rpc.provide_backup.future(bob.id))")
-    qr = remote_eval("bob._rpc.get_backup_qr(bob.id)")
-    new_account = acfactory.get_unconfigured_account()
-    new_account._rpc.get_backup(new_account.id, qr)
-    remote_eval("locals()['future']()")
-
-    assert new_account.get_config("addr") == remote_eval("bob.get_config('addr')")
--- a/deltachat-rpc-client/tests/test_folders.py
+++ b/deltachat-rpc-client/tests/test_folders.py
@@ -1,131 +0,0 @@
-import re
-
-from imap_tools import AND, U
-
-from deltachat_rpc_client import EventType
-
-
-def test_moved_markseen(acfactory, direct_imap, log):
-    """Test that message already moved to DeltaChat folder is marked as seen."""
-    ac1 = acfactory.get_online_account()
-
-    addr, password = acfactory.get_credentials()
-    ac2 = acfactory.get_unconfigured_account()
-    ac2.add_or_update_transport({"addr": addr, "password": password})
-    ac2.bring_online()
-
-    # Make sure that messages are not immediately auto-deleted on the server:
-    ac1.set_config("bcc_self", "1")
-    ac2.set_config("bcc_self", "1")
-
-    log.section("ac2: creating DeltaChat folder")
-    ac2_direct_imap = direct_imap(ac2)
-    ac2_direct_imap.create_folder("DeltaChat")
-    ac2.set_config("sync_msgs", "0")  # Do not send a sync message when accepting a contact request.
-
-    ac2.add_or_update_transport({"addr": addr, "password": password, "imapFolder": "DeltaChat"})
-    ac2.bring_online()
-
-    ac2.stop_io()
-    ac2_direct_imap = direct_imap(ac2)
-    with ac2_direct_imap.idle() as idle2:
-        ac1.create_chat(ac2).send_text("Hello!")
-        idle2.wait_for_new_message()
-
-    # Emulate moving of the message to DeltaChat folder by Sieve rule.
-    log.section("ac2: moving message into DeltaChat folder")
-    ac2_direct_imap.conn.move(["*"], "DeltaChat")
-    ac2_direct_imap.select_folder("DeltaChat")
-    assert len(list(ac2_direct_imap.conn.fetch("*", mark_seen=False))) == 1
-
-    with ac2_direct_imap.idle() as idle2:
-        ac2.start_io()
-
-        ev = ac2.wait_for_event(EventType.MSGS_CHANGED)
-        msg = ac2.get_message_by_id(ev.msg_id)
-        assert msg.get_snapshot().text == "Messages are end-to-end encrypted."
-
-        ev = ac2.wait_for_event(EventType.INCOMING_MSG)
-        msg = ac2.get_message_by_id(ev.msg_id)
-        chat = ac2.get_chat_by_id(ev.chat_id)
-
-        # Accept the contact request.
-        chat.accept()
-        msg.mark_seen()
-        idle2.wait_for_seen()
-
-    assert len(list(ac2_direct_imap.conn.fetch(AND(seen=True, uid=U(1, "*")), mark_seen=False))) == 1
-
-
-def test_markseen_message_and_mdn(acfactory, direct_imap):
-    ac1, ac2 = acfactory.get_online_accounts(2)
-
-    # Make sure that messages are not immediately auto-deleted on the server:
-    ac1.set_config("bcc_self", "1")
-    ac2.set_config("bcc_self", "1")
-
-    acfactory.get_accepted_chat(ac1, ac2).send_text("hi")
-    msg = ac2.wait_for_incoming_msg()
-    msg.mark_seen()
-
-    rex = re.compile("Marked messages ([0-9,:]+) in folder INBOX as seen.")
-
-    # Each profile flags two messages but the logged UID set
-    # covers a varying number of them, so just count UIDs mentioned.
-    # We are not processing UID ranges, here we just care for two UIDs.
-    for ac in ac1, ac2:
-        uids = set()
-        while len(uids) < 2:
-            event = ac.wait_for_event()
-            if event.kind == EventType.INFO and (match := rex.search(event.msg)):
-                uids.update(re.split("[,:]", match.group(1)))
-
-    ac1_direct_imap = direct_imap(ac1)
-    ac2_direct_imap = direct_imap(ac2)
-
-    ac1_direct_imap.select_folder("INBOX")
-    ac2_direct_imap.select_folder("INBOX")
-
-    # Check that the mdn and original message is marked as seen
-    assert len(list(ac1_direct_imap.conn.fetch(AND(seen=True), mark_seen=False))) == 2
-    assert len(list(ac2_direct_imap.conn.fetch(AND(seen=True), mark_seen=False))) == 2
-
-
-def test_trash_multiple_messages(acfactory, direct_imap, log):
-    ac1, ac2 = acfactory.get_online_accounts(2)
-    ac2.stop_io()
-
-    # Make sure that messages are not immediately auto-deleted on the server:
-    ac2.set_config("bcc_self", "1")
-
-    ac2.set_config("sync_msgs", "0")
-
-    ac2.start_io()
-    chat12 = acfactory.get_accepted_chat(ac1, ac2)
-
-    log.section("ac1: sending 3 messages")
-    texts = ["first", "second", "third"]
-    for text in texts:
-        chat12.send_text(text)
-
-    log.section("ac2: waiting for all messages on the other side")
-    to_delete = []
-    for text in texts:
-        msg = ac2.wait_for_incoming_msg().get_snapshot()
-        assert msg.text in texts
-        if text != "second":
-            to_delete.append(msg)
-
-    log.section("ac2: deleting all messages except second")
-    assert len(to_delete) == len(texts) - 1
-    ac2.delete_messages(to_delete)
-
-    log.section("ac2: test that only one message is left")
-    ac2_direct_imap = direct_imap(ac2)
-    while 1:
-        ac2.wait_for_event(EventType.IMAP_MESSAGE_DELETED)
-        ac2_direct_imap.select_config_folder("inbox")
-        nr_msgs = len(ac2_direct_imap.get_all_messages())
-        assert nr_msgs > 0
-        if nr_msgs == 1:
-            break
--- a/deltachat-rpc-client/tests/test_iroh_webxdc.py
+++ b/deltachat-rpc-client/tests/test_iroh_webxdc.py
@@ -24,13 +24,6 @@ def path_to_webxdc(request):
    return str(p)


-@pytest.fixture
-def path_to_large_webxdc(request):
-    p = request.path.parent.parent.parent.joinpath("test-data/webxdc/realtime-check.xdc")
-    assert p.exists()
-    return str(p)
-
-
 def log(msg):
    logging.info(msg)

@@ -91,7 +84,7 @@ def test_realtime_sequentially(acfactory, path_to_webxdc):

    # share a webxdc app between ac1 and ac2
    ac1_webxdc_msg = acfactory.send_message(from_account=ac1, to_account=ac2, text="play", file=path_to_webxdc)
-    ac2_webxdc_msg = ac2.wait_for_incoming_msg()
+    ac2_webxdc_msg = ac2.get_message_by_id(ac2.wait_for_incoming_msg_event().msg_id)
    snapshot = ac2_webxdc_msg.get_snapshot()
    assert snapshot.text == "play"

@@ -101,7 +94,7 @@ def test_realtime_sequentially(acfactory, path_to_webxdc):
    acfactory.send_message(from_account=ac1, to_account=ac2, text="ping1")

    log("waiting for incoming message on ac2")
-    snapshot = ac2.wait_for_incoming_msg().get_snapshot()
+    snapshot = ac2.get_message_by_id(ac2.wait_for_incoming_msg_event().msg_id).get_snapshot()
    assert snapshot.text == "ping1"

    log("sending ac2 -> ac1 realtime advertisement and additional message")
@@ -109,7 +102,7 @@ def test_realtime_sequentially(acfactory, path_to_webxdc):
    acfactory.send_message(from_account=ac2, to_account=ac1, text="ping2")

    log("waiting for incoming message on ac1")
-    snapshot = ac1.wait_for_incoming_msg().get_snapshot()
+    snapshot = ac1.get_message_by_id(ac1.wait_for_incoming_msg_event().msg_id).get_snapshot()
    assert snapshot.text == "ping2"

    log("sending realtime data ac1 -> ac2")
@@ -221,9 +214,7 @@ def test_advertisement_after_chatting(acfactory, path_to_webxdc):
    ac1_ac2_chat = ac1.create_chat(ac2)
    ac1_webxdc_msg = ac1_ac2_chat.send_message(text="WebXDC", file=path_to_webxdc)
    ac2_webxdc_msg = ac2.wait_for_incoming_msg()
-    ac2_webxdc_msg_snapshot = ac2_webxdc_msg.get_snapshot()
-    assert ac2_webxdc_msg_snapshot.text == "WebXDC"
-    ac2_webxdc_msg_snapshot.chat.accept()
+    assert ac2_webxdc_msg.get_snapshot().text == "WebXDC"

    ac1_ac2_chat.send_text("Hello!")
    ac2_hello_msg = ac2.wait_for_incoming_msg()
@@ -234,29 +225,3 @@ def test_advertisement_after_chatting(acfactory, path_to_webxdc):
    ac2_webxdc_msg.send_webxdc_realtime_advertisement()
    event = ac1.wait_for_event(EventType.WEBXDC_REALTIME_ADVERTISEMENT_RECEIVED)
    assert event.msg_id == ac1_webxdc_msg.id
-
-
-def test_realtime_large_webxdc(acfactory, path_to_large_webxdc):
-    """Tests initializing realtime channel on a large webxdc.
-
-    This is a regression test for a bug that existed in version 2.42.0.
-    Large webxdc is split into pre- and post- message,
-    and this previously resulted in failure to initialize realtime.
-    """
-    ac1, ac2 = acfactory.get_online_accounts(2)
-    ac1.set_config("webxdc_realtime_enabled", "1")
-    ac2.set_config("webxdc_realtime_enabled", "1")
-
-    ac2.create_chat(ac1)
-    ac1_ac2_chat = ac1.create_chat(ac2)
-    ac1_webxdc_msg = ac1_ac2_chat.send_message(text="realtime check", file=path_to_large_webxdc)
-
-    # Receive pre-message.
-    ac2_webxdc_msg = ac2.wait_for_incoming_msg()
-
-    # Receive post-message.
-    ac2_webxdc_msg = ac2.wait_for_msg(EventType.MSGS_CHANGED)
-
-    ac2_webxdc_msg.send_webxdc_realtime_advertisement()
-    event = ac1.wait_for_event(EventType.WEBXDC_REALTIME_ADVERTISEMENT_RECEIVED)
-    assert event.msg_id == ac1_webxdc_msg.id
--- a/deltachat-rpc-client/tests/test_key_transfer.py
+++ b/deltachat-rpc-client/tests/test_key_transfer.py
@@ -0,0 +1,53 @@
+import pytest
+
+from deltachat_rpc_client import EventType
+from deltachat_rpc_client.rpc import JsonRpcError
+
+
+def wait_for_autocrypt_setup_message(account):
+    while True:
+        event = account.wait_for_event()
+        if event.kind == EventType.MSGS_CHANGED and event.msg_id != 0:
+            msg_id = event.msg_id
+            msg = account.get_message_by_id(msg_id)
+            if msg.get_snapshot().is_setupmessage:
+                return msg
+
+
+def test_autocrypt_setup_message_key_transfer(acfactory):
+    alice1 = acfactory.get_online_account()
+
+    alice2 = acfactory.get_unconfigured_account()
+    alice2.set_config("addr", alice1.get_config("addr"))
+    alice2.set_config("mail_pw", alice1.get_config("mail_pw"))
+    alice2.configure()
+    alice2.bring_online()
+
+    setup_code = alice1.initiate_autocrypt_key_transfer()
+    msg = wait_for_autocrypt_setup_message(alice2)
+
+    # Test that entering wrong code returns an error.
+    with pytest.raises(JsonRpcError):
+        msg.continue_autocrypt_key_transfer("7037-0673-6287-3013-4095-7956-5617-6806-6756")
+
+    msg.continue_autocrypt_key_transfer(setup_code)
+
+
+def test_ac_setup_message_twice(acfactory):
+    alice1 = acfactory.get_online_account()
+
+    alice2 = acfactory.get_unconfigured_account()
+    alice2.set_config("addr", alice1.get_config("addr"))
+    alice2.set_config("mail_pw", alice1.get_config("mail_pw"))
+    alice2.configure()
+    alice2.bring_online()
+
+    # Send the first Autocrypt Setup Message and ignore it.
+    _setup_code = alice1.initiate_autocrypt_key_transfer()
+    wait_for_autocrypt_setup_message(alice2)
+
+    # Send the second Autocrypt Setup Message and import it.
+    setup_code = alice1.initiate_autocrypt_key_transfer()
+    msg = wait_for_autocrypt_setup_message(alice2)
+
+    msg.continue_autocrypt_key_transfer(setup_code)
--- a/deltachat-rpc-client/tests/test_location.py
+++ b/deltachat-rpc-client/tests/test_location.py
@@ -1,32 +0,0 @@
-def test_set_location(dc, acfactory) -> None:
-    # Try setting location without any accounts.
-    assert not dc.set_location(1.0, 2.0, 0.1)
-
-    # Create one account that does not stream,
-    # set location.
-    acfactory.new_configured_account()
-    assert not dc.set_location(3.0, 4.0, 0.1)
-
-
-def test_send_locations_to_chat(dc, acfactory):
-    alice, bob = acfactory.get_online_accounts(2)
-
-    assert not alice.is_sending_locations()
-    alice_chat_bob = alice.create_chat(bob)
-    assert not alice_chat_bob.is_sending_locations()
-
-    # Test starting and stopping location streaming in a chat.
-    alice_chat_bob.send_locations(3600)
-    assert alice.is_sending_locations()
-    assert alice_chat_bob.is_sending_locations()
-    alice_chat_bob.send_locations(0)
-    assert not alice.is_sending_locations()
-    assert not alice_chat_bob.is_sending_locations()
-
-    # Test stop_sending_locations() for all accounts and chats.
-    alice_chat_bob.send_locations(3600)
-    assert alice.is_sending_locations()
-    assert alice_chat_bob.is_sending_locations()
-    dc.stop_sending_locations()
-    assert not alice.is_sending_locations()
-    assert not alice_chat_bob.is_sending_locations()
--- a/deltachat-rpc-client/tests/test_multidevice.py
+++ b/deltachat-rpc-client/tests/test_multidevice.py
@@ -4,31 +4,6 @@ from deltachat_rpc_client import EventType
 from deltachat_rpc_client.const import MessageState


-def test_bcc_self_is_enabled_when_setting_up_second_device(acfactory):
-    ac = acfactory.get_online_account()
-
-    # Initially after getting online
-    # the setting bcc_self is set to 0 because there is only one device
-    assert ac.get_config("bcc_self") == "0"
-
-    # Setup a second device.
-    ac_clone = ac.clone()
-    ac_clone.bring_online()
-
-    # Second device setup enables bcc_self.
-    assert ac.get_config("bcc_self") == "1"
-    assert ac_clone.get_config("bcc_self") == "1"
-
-    # Test manually disabling bcc_self
-    ac.set_config("bcc_self", "0")
-    assert ac.get_config("bcc_self") == "0"
-
-    # Cloning the account again enables bcc_self again
-    # even though it was manually disabled.
-    ac_clone = ac.clone()
-    assert ac.get_config("bcc_self") == "1"
-
-
 def test_one_account_send_bcc_setting(acfactory, log, direct_imap):
    ac1, ac2 = acfactory.get_online_accounts(2)
    ac1_clone = ac1.clone()
@@ -37,14 +12,19 @@ def test_one_account_send_bcc_setting(acfactory, log, direct_imap):
    log.section("send out message without bcc to ourselves")
    ac1.set_config("bcc_self", "0")
    chat = ac1.create_chat(ac2)
+    self_addr = ac1.get_config("addr")
+    other_addr = ac2.get_config("addr")

    msg_out = chat.send_text("message1")
    assert not msg_out.get_snapshot().is_forwarded

    # wait for send out (no BCC)
-    ac1.wait_for_event(EventType.SMTP_MESSAGE_SENT)
+    ev = ac1.wait_for_event(EventType.SMTP_MESSAGE_SENT)
    assert ac1.get_config("bcc_self") == "0"

+    assert self_addr not in ev.msg
+    assert other_addr in ev.msg
+
    log.section("ac1: setting bcc_self=1")
    ac1.set_config("bcc_self", "1")

@@ -52,16 +32,20 @@ def test_one_account_send_bcc_setting(acfactory, log, direct_imap):
    msg_out = chat.send_text("message2")

    # wait for send out (BCC)
-    ac1.wait_for_event(EventType.SMTP_MESSAGE_SENT)
+    ev = ac1.wait_for_event(EventType.SMTP_MESSAGE_SENT)
    assert ac1.get_config("bcc_self") == "1"

-    # Second client receives only the second message, but not the first.
+    # Second client receives only second message, but not the first.
    ev_msg = ac1_clone.wait_for_event(EventType.MSGS_CHANGED)
    assert ac1_clone.get_message_by_id(ev_msg.msg_id).get_snapshot().text == "Messages are end-to-end encrypted."

    ev_msg = ac1_clone.wait_for_event(EventType.MSGS_CHANGED)
    assert ac1_clone.get_message_by_id(ev_msg.msg_id).get_snapshot().text == msg_out.get_snapshot().text

+    # now make sure we are sending message to ourselves too
+    assert self_addr in ev.msg
+    assert self_addr in ev.msg
+
    # BCC-self messages are marked as seen by the sender device.
    while True:
        event = ac1.wait_for_event()
--- a/deltachat-rpc-client/tests/test_multitransport.py
+++ b/deltachat-rpc-client/tests/test_multitransport.py
@@ -1,324 +0,0 @@
-import pytest
-
-from deltachat_rpc_client import EventType
-from deltachat_rpc_client.const import ChatType, DownloadState
-from deltachat_rpc_client.rpc import JsonRpcError
-
-
-def test_add_second_address(acfactory) -> None:
-    account = acfactory.new_configured_account()
-    assert len(account.list_transports()) == 1
-
-    qr = acfactory.get_account_qr()
-    account.add_transport_from_qr(qr)
-    assert len(account.list_transports()) == 2
-
-    account.add_transport_from_qr(qr)
-    assert len(account.list_transports()) == 3
-
-    first_addr = account.list_transports()[0]["addr"]
-    second_addr = account.list_transports()[1]["addr"]
-
-    # Cannot delete the first address.
-    with pytest.raises(JsonRpcError):
-        account.delete_transport(first_addr)
-
-    account.delete_transport(second_addr)
-    assert len(account.list_transports()) == 2
-
-
-def test_change_address(acfactory) -> None:
-    """Test Alice configuring a second transport and setting it as a primary one."""
-    alice, bob = acfactory.get_online_accounts(2)
-
-    bob_addr = bob.get_config("configured_addr")
-    bob.create_chat(alice)
-
-    alice_chat_bob = alice.create_chat(bob)
-    alice_chat_bob.send_text("Hello!")
-
-    msg1 = bob.wait_for_incoming_msg().get_snapshot()
-    sender_addr1 = msg1.sender.get_snapshot().address
-
-    alice.stop_io()
-    old_alice_addr = alice.get_config("configured_addr")
-    alice_vcard = alice.self_contact.make_vcard()
-    assert old_alice_addr in alice_vcard
-    qr = acfactory.get_account_qr()
-    alice.add_transport_from_qr(qr)
-    new_alice_addr = alice.list_transports()[1]["addr"]
-    with pytest.raises(JsonRpcError):
-        # Cannot use the address that is not
-        # configured for any transport.
-        alice.set_config("configured_addr", bob_addr)
-
-    # Load old address so it is cached.
-    assert alice.get_config("configured_addr") == old_alice_addr
-    alice.set_config("configured_addr", new_alice_addr)
-    # Make sure that setting `configured_addr` invalidated the cache.
-    assert alice.get_config("configured_addr") == new_alice_addr
-
-    alice_vcard = alice.self_contact.make_vcard()
-    assert old_alice_addr not in alice_vcard
-    assert new_alice_addr in alice_vcard
-    with pytest.raises(JsonRpcError):
-        alice.delete_transport(new_alice_addr)
-    alice.start_io()
-
-    alice_chat_bob.send_text("Hello again!")
-
-    msg2 = bob.wait_for_incoming_msg().get_snapshot()
-    sender_addr2 = msg2.sender.get_snapshot().address
-
-    assert msg1.sender == msg2.sender
-    assert sender_addr1 != sender_addr2
-    assert sender_addr1 == old_alice_addr
-    assert sender_addr2 == new_alice_addr
-
-
-def test_download_on_demand(acfactory) -> None:
-    alice, bob = acfactory.get_online_accounts(2)
-    alice.set_config("download_limit", "1")
-
-    alice.stop_io()
-    qr = acfactory.get_account_qr()
-    alice.add_transport_from_qr(qr)
-    alice.start_io()
-
-    alice.create_chat(bob)
-    chat_bob_alice = bob.create_chat(alice)
-    chat_bob_alice.send_message(file="../test-data/image/screenshot.jpg")
-    msg = alice.wait_for_incoming_msg()
-    snapshot = msg.get_snapshot()
-    assert snapshot.download_state == DownloadState.AVAILABLE
-    chat_id = snapshot.chat_id
-    # Actually the message isn't available yet. Wait somehow for the post-message to arrive.
-    chat_bob_alice.send_message("Now you can download my previous message")
-    alice.wait_for_incoming_msg()
-    alice._rpc.download_full_message(alice.id, msg.id)
-    for dstate in [DownloadState.IN_PROGRESS, DownloadState.DONE]:
-        event = alice.wait_for_event(EventType.MSGS_CHANGED)
-        assert event.chat_id == chat_id
-        assert event.msg_id == msg.id
-        assert msg.get_snapshot().download_state == dstate
-
-
-def test_reconfigure_transport(acfactory) -> None:
-    """Test that reconfiguring the transport works."""
-    account = acfactory.get_online_account()
-
-    [transport] = account.list_transports()
-    account.add_or_update_transport(transport)
-
-
-def test_transport_synchronization(acfactory, log) -> None:
-    """Test synchronization of transports between devices."""
-
-    def wait_for_io_started(ac):
-        while True:
-            ev = ac.wait_for_event(EventType.INFO)
-            if "scheduler is running" in ev.msg:
-                return
-
-    ac1, ac2 = acfactory.get_online_accounts(2)
-    ac1_clone = ac1.clone()
-    ac1_clone.bring_online()
-
-    qr = acfactory.get_account_qr()
-
-    ac1.add_transport_from_qr(qr)
-    ac1_clone.wait_for_event(EventType.TRANSPORTS_MODIFIED)
-    wait_for_io_started(ac1_clone)
-    assert len(ac1.list_transports()) == 2
-    assert len(ac1_clone.list_transports()) == 2
-
-    ac1_clone.add_transport_from_qr(qr)
-    ac1.wait_for_event(EventType.TRANSPORTS_MODIFIED)
-    wait_for_io_started(ac1)
-    assert len(ac1.list_transports()) == 3
-    assert len(ac1_clone.list_transports()) == 3
-
-    log.section("ac1 clone removes second transport")
-    [transport1, transport2, transport3] = ac1_clone.list_transports()
-    addr3 = transport3["addr"]
-    ac1_clone.delete_transport(transport2["addr"])
-
-    ac1.wait_for_event(EventType.TRANSPORTS_MODIFIED)
-    wait_for_io_started(ac1)
-    [transport1, transport3] = ac1.list_transports()
-
-    log.section("ac1 changes the primary transport")
-    ac1.set_config("configured_addr", transport3["addr"])
-
-    # One event for updated `add_timestamp` of the new primary transport,
-    # one event for the `configured_addr` update.
-    ac1_clone.wait_for_event(EventType.TRANSPORTS_MODIFIED)
-    ac1_clone.wait_for_event(EventType.TRANSPORTS_MODIFIED)
-    [transport1, transport3] = ac1_clone.list_transports()
-    assert ac1_clone.get_config("configured_addr") == addr3
-
-    log.section("ac1 removes the first transport")
-    ac1.delete_transport(transport1["addr"])
-
-    ac1_clone.wait_for_event(EventType.TRANSPORTS_MODIFIED)
-    wait_for_io_started(ac1_clone)
-    [transport3] = ac1_clone.list_transports()
-    assert transport3["addr"] == addr3
-    assert ac1_clone.get_config("configured_addr") == addr3
-
-    ac2_chat = ac2.create_chat(ac1)
-    ac2_chat.send_text("Hello!")
-
-    assert ac1.wait_for_incoming_msg().get_snapshot().text == "Hello!"
-    assert ac1_clone.wait_for_incoming_msg().get_snapshot().text == "Hello!"
-
-
-def test_transport_sync_new_as_primary(acfactory, log) -> None:
-    """Test synchronization of new transport as primary between devices."""
-    ac1, bob = acfactory.get_online_accounts(2)
-    ac1_clone = ac1.clone()
-    ac1_clone.bring_online()
-
-    qr = acfactory.get_account_qr()
-
-    ac1.add_transport_from_qr(qr)
-    ac1_transports = ac1.list_transports()
-    assert len(ac1_transports) == 2
-    [transport1, transport2] = ac1_transports
-    ac1_clone.wait_for_event(EventType.TRANSPORTS_MODIFIED)
-    assert len(ac1_clone.list_transports()) == 2
-    assert ac1_clone.get_config("configured_addr") == transport1["addr"]
-
-    log.section("ac1 changes the primary transport")
-    ac1.set_config("configured_addr", transport2["addr"])
-
-    ac1_clone.wait_for_event(EventType.TRANSPORTS_MODIFIED)
-    assert ac1_clone.get_config("configured_addr") == transport2["addr"]
-
-    log.section("ac1_clone receives a message via the new primary transport")
-    ac1_chat = ac1.create_chat(bob)
-    ac1_chat.send_text("Hello!")
-    bob_chat_id = bob.wait_for_incoming_msg_event().chat_id
-    bob_chat = bob.get_chat_by_id(bob_chat_id)
-    bob_chat.accept()
-    bob_chat.send_text("hello back")
-    assert ac1_clone.wait_for_incoming_msg().get_snapshot().text == "hello back"
-
-
-def test_recognize_self_address(acfactory) -> None:
-    alice, bob = acfactory.get_online_accounts(2)
-
-    bob_chat = bob.create_chat(alice)
-
-    qr = acfactory.get_account_qr()
-    alice.add_transport_from_qr(qr)
-
-    new_alice_addr = alice.list_transports()[1]["addr"]
-    alice.set_config("configured_addr", new_alice_addr)
-
-    bob_chat.send_text("Hello!")
-    msg = alice.wait_for_incoming_msg().get_snapshot()
-    assert msg.chat == alice.create_chat(bob)
-
-
-def test_transport_limit(acfactory) -> None:
-    """Test transports limit."""
-    account = acfactory.get_online_account()
-    qr = acfactory.get_account_qr()
-
-    limit = 5
-
-    for _ in range(1, limit):
-        account.add_transport_from_qr(qr)
-
-    assert len(account.list_transports()) == limit
-
-    with pytest.raises(JsonRpcError):
-        account.add_transport_from_qr(qr)
-
-    second_addr = account.list_transports()[1]["addr"]
-    third_addr = account.list_transports()[2]["addr"]
-
-    # test that adding a transport after unpublishing one works again
-    account.set_transport_unpublished(second_addr)
-    account.add_transport_from_qr(qr)
-    with pytest.raises(JsonRpcError):
-        account.add_transport_from_qr(qr)
-
-    # UIs are not expected to delete transports directly,
-    # but we still test that adding a transport
-    # after deleting one instead of unpublishing works.
-    account.delete_transport(third_addr)
-    account.add_transport_from_qr(qr)
-    with pytest.raises(JsonRpcError):
-        account.add_transport_from_qr(qr)
-
-
-def test_message_info_imap_urls(acfactory) -> None:
-    """Test that message info contains IMAP URLs of where the message was received."""
-    alice, bob = acfactory.get_online_accounts(2)
-
-    qr = acfactory.get_account_qr()
-    for i in range(3):
-        alice.add_transport_from_qr(qr)
-        # Wait for all transports to go IDLE after adding each one.
-        for _ in range(i + 1):
-            alice.bring_online()
-
-    # Enable multi-device mode so messages are not deleted immediately.
-    alice.set_config("bcc_self", "1")
-
-    # Bob creates chat, learning about Alice's currently selected transport.
-    # This is where he will send the message.
-    bob_chat = bob.create_chat(alice)
-
-    # Alice switches to another transport and removes the rest of the transports.
-    new_alice_addr = alice.list_transports()[1]["addr"]
-    alice.set_config("configured_addr", new_alice_addr)
-    removed_addrs = []
-    for transport in alice.list_transports():
-        if transport["addr"] != new_alice_addr:
-            alice.delete_transport(transport["addr"])
-            removed_addrs.append(transport["addr"])
-    alice.stop_io()
-    alice.start_io()
-
-    bob_chat.send_text("Hello!")
-
-    msg = alice.wait_for_incoming_msg()
-    msg_info = msg.get_info()
-    assert new_alice_addr in msg_info
-    for removed_addr in removed_addrs:
-        assert removed_addr not in msg_info
-    assert f"{new_alice_addr}/INBOX" in msg_info
-
-
-def test_remove_primary_transport(acfactory, log) -> None:
-    """Test that after removing the primary relay, Alice can still receive messages."""
-    alice, bob = acfactory.get_online_accounts(2)
-    qr = acfactory.get_account_qr()
-
-    alice.add_transport_from_qr(qr)
-    alice.bring_online()
-
-    bob_chat = bob.create_chat(alice)
-    alice.create_chat(bob)
-
-    log.section("Alice sets up second transport")
-    [transport1, transport2] = alice.list_transports()
-    alice.set_config("configured_addr", transport2["addr"])
-
-    bob_chat.send_text("Hello!")
-    msg1 = alice.wait_for_incoming_msg().get_snapshot()
-    assert msg1.text == "Hello!"
-
-    log.section("Alice removes the primary relay")
-    alice.delete_transport(transport1["addr"])
-    alice.stop_io()
-    alice.start_io()
-
-    bob_chat.send_text("Hello again!")
-    msg2 = alice.wait_for_incoming_msg().get_snapshot()
-    assert msg2.text == "Hello again!"
-    assert msg2.chat.get_basic_snapshot().chat_type == ChatType.SINGLE
-    assert msg2.chat == alice.create_chat(bob)
--- a/deltachat-rpc-client/tests/test_securejoin.py
+++ b/deltachat-rpc-client/tests/test_securejoin.py
@@ -3,7 +3,6 @@ import logging
 import pytest

 from deltachat_rpc_client import Chat, EventType, SpecialContactId
-from deltachat_rpc_client.const import ChatType
 from deltachat_rpc_client.rpc import JsonRpcError


@@ -59,7 +58,8 @@ def test_qr_setup_contact_svg(acfactory) -> None:
    assert "Alice" in svg


-def test_qr_securejoin(acfactory):
+@pytest.mark.parametrize("protect", [True, False])
+def test_qr_securejoin(acfactory, protect):
    alice, bob, fiona = acfactory.get_online_accounts(3)

    # Setup second device for Alice
@@ -67,7 +67,8 @@ def test_qr_securejoin(acfactory):
    alice2 = alice.clone()

    logging.info("Alice creates a group")
-    alice_chat = alice.create_group("Group")
+    alice_chat = alice.create_group("Group", protect=protect)
+    assert alice_chat.get_basic_snapshot().is_protected == protect

    logging.info("Bob joins the group")
    qr_code = alice_chat.get_qr_code()
@@ -86,8 +87,9 @@ def test_qr_securejoin(acfactory):
    alice_contact_bob_snapshot = alice_contact_bob.get_snapshot()
    assert alice_contact_bob_snapshot.is_verified

-    snapshot = bob.wait_for_incoming_msg().get_snapshot()
+    snapshot = bob.get_message_by_id(bob.wait_for_incoming_msg_event().msg_id).get_snapshot()
    assert snapshot.text == "Member Me added by {}.".format(alice.get_config("addr"))
+    assert snapshot.chat.get_basic_snapshot().is_protected == protect

    # Test that Bob verified Alice's profile.
    bob_contact_alice = bob.create_contact(alice)
@@ -110,148 +112,6 @@ def test_qr_securejoin(acfactory):
    fiona.wait_for_securejoin_joiner_success()


-@pytest.mark.parametrize("all_devices_online", [True, False])
-def test_qr_securejoin_broadcast(acfactory, all_devices_online):
-    alice, bob, fiona = acfactory.get_online_accounts(3)
-
-    alice2 = alice.clone()
-    bob2 = bob.clone()
-
-    if all_devices_online:
-        alice2.start_io()
-        bob2.start_io()
-
-    logging.info("===================== Alice creates a broadcast =====================")
-    alice_chat = alice.create_broadcast("Broadcast channel!")
-    snapshot = alice_chat.get_basic_snapshot()
-    assert not snapshot.is_unpromoted  # Broadcast channels are never unpromoted
-
-    logging.info("===================== Bob joins the broadcast =====================")
-
-    qr_code = alice_chat.get_qr_code()
-    bob.secure_join(qr_code)
-    alice.wait_for_securejoin_inviter_success()
-    bob.wait_for_securejoin_joiner_success()
-    alice_chat.send_text("Hello everyone!")
-
-    def get_broadcast(ac):
-        chat = ac.get_chatlist(query="Broadcast channel!")[0]
-        assert chat.get_basic_snapshot().name == "Broadcast channel!"
-        return chat
-
-    def wait_for_broadcast_messages(ac):
-        snapshot1 = ac.wait_for_incoming_msg().get_snapshot()
-        assert snapshot1.text == "You joined the channel."
-
-        snapshot2 = ac.wait_for_incoming_msg().get_snapshot()
-        assert snapshot2.text == "Hello everyone!"
-
-        chat = get_broadcast(ac)
-        assert snapshot1.chat_id == chat.id
-        assert snapshot2.chat_id == chat.id
-
-    def check_account(ac, contact, inviter_side, please_wait_info_msg=False):
-        # Check that the chat partner is verified.
-        contact_snapshot = contact.get_snapshot()
-        assert contact_snapshot.is_verified
-
-        chat = get_broadcast(ac)
-        chat_msgs = chat.get_messages()
-
-        encrypted_msg = chat_msgs.pop(0).get_snapshot()
-        assert encrypted_msg.text == "Messages are end-to-end encrypted."
-        assert encrypted_msg.is_info
-
-        if please_wait_info_msg:
-            first_msg = chat_msgs.pop(0).get_snapshot()
-            assert "invited you to join this channel" in first_msg.text
-            assert first_msg.is_info
-
-        if inviter_side:
-            member_added_msg = chat_msgs.pop(0).get_snapshot()
-            assert member_added_msg.text == f"Member {contact_snapshot.display_name} added."
-            assert member_added_msg.info_contact_id == contact_snapshot.id
-        else:
-            if chat_msgs[0].get_snapshot().text == "You joined the channel.":
-                member_added_msg = chat_msgs.pop(0).get_snapshot()
-            else:
-                member_added_msg = chat_msgs.pop(1).get_snapshot()
-                assert member_added_msg.text == "You joined the channel."
-        assert member_added_msg.is_info
-
-        hello_msg = chat_msgs.pop(0).get_snapshot()
-        assert hello_msg.text == "Hello everyone!"
-        assert not hello_msg.is_info
-        assert hello_msg.show_padlock
-        assert hello_msg.error is None
-
-        assert len(chat_msgs) == 0
-
-        chat_snapshot = chat.get_full_snapshot()
-        assert chat_snapshot.is_encrypted
-        assert chat_snapshot.name == "Broadcast channel!"
-        if inviter_side:
-            assert chat_snapshot.chat_type == ChatType.OUT_BROADCAST
-        else:
-            assert chat_snapshot.chat_type == ChatType.IN_BROADCAST
-        assert chat_snapshot.can_send == inviter_side
-
-        chat_contacts = chat_snapshot.contact_ids
-        assert contact.id in chat_contacts
-        if inviter_side:
-            assert len(chat_contacts) == 1
-        else:
-            assert len(chat_contacts) == 2
-            assert SpecialContactId.SELF in chat_contacts
-            assert chat_snapshot.self_in_group
-
-    wait_for_broadcast_messages(bob)
-
-    check_account(alice, alice.create_contact(bob), inviter_side=True)
-    check_account(bob, bob.create_contact(alice), inviter_side=False, please_wait_info_msg=True)
-
-    logging.info("===================== Test Alice's second device =====================")
-
-    # Start second Alice device, if it wasn't started already.
-    alice2.start_io()
-
-    while True:
-        msg_id = alice2.wait_for_msgs_changed_event().msg_id
-        if msg_id:
-            snapshot = alice2.get_message_by_id(msg_id).get_snapshot()
-            if snapshot.text == "Hello everyone!":
-                break
-
-    check_account(alice2, alice2.create_contact(bob), inviter_side=True)
-
-    logging.info("===================== Test Bob's second device =====================")
-
-    # Start second Bob device, if it wasn't started already.
-    bob2.start_io()
-    bob2.wait_for_securejoin_joiner_success()
-    wait_for_broadcast_messages(bob2)
-    check_account(bob2, bob2.create_contact(alice), inviter_side=False)
-
-    # The QR code token is synced, so alice2 must be able to handle join requests.
-    logging.info("===================== Fiona joins the group via alice2 =====================")
-    alice.stop_io()
-    fiona.secure_join(qr_code)
-    alice2.wait_for_securejoin_inviter_success()
-    fiona.wait_for_securejoin_joiner_success()
-
-    snapshot = fiona.wait_for_incoming_msg().get_snapshot()
-    assert snapshot.text == "You joined the channel."
-
-    get_broadcast(alice2).get_messages()[2].resend()
-    snapshot = fiona.wait_for_incoming_msg().get_snapshot()
-    assert snapshot.text == "Hello everyone!"
-
-    check_account(fiona, fiona.create_contact(alice), inviter_side=False, please_wait_info_msg=True)
-
-    # For Bob, the channel must not have changed:
-    check_account(bob, bob.create_contact(alice), inviter_side=False, please_wait_info_msg=True)
-
-
 def test_qr_securejoin_contact_request(acfactory) -> None:
    """Alice invites Bob to a group when Bob's chat with Alice is in a contact request mode."""
    alice, bob = acfactory.get_online_accounts(2)
@@ -260,13 +120,13 @@ def test_qr_securejoin_contact_request(acfactory) -> None:
    alice_chat_bob = alice_contact_bob.create_chat()
    alice_chat_bob.send_text("Hello!")

-    snapshot = bob.wait_for_incoming_msg().get_snapshot()
+    snapshot = bob.get_message_by_id(bob.wait_for_incoming_msg_event().msg_id).get_snapshot()
    assert snapshot.text == "Hello!"
    bob_chat_alice = snapshot.chat
    assert bob_chat_alice.get_basic_snapshot().is_contact_request

-    alice_chat = alice.create_group("Group")
-    logging.info("Bob joins the group")
+    alice_chat = alice.create_group("Verified group", protect=True)
+    logging.info("Bob joins verified group")
    qr_code = alice_chat.get_qr_code()
    bob.secure_join(qr_code)
    while True:
@@ -290,8 +150,8 @@ def test_qr_readreceipt(acfactory) -> None:
    for joiner in [bob, charlie]:
        joiner.wait_for_securejoin_joiner_success()

-    logging.info("Alice creates a group")
-    group = alice.create_group("Group")
+    logging.info("Alice creates a verified group")
+    group = alice.create_group("Group", protect=True)

    alice_contact_bob = alice.create_contact(bob, "Bob")
    alice_contact_charlie = alice.create_contact(charlie, "Charlie")
@@ -304,7 +164,8 @@ def test_qr_readreceipt(acfactory) -> None:

    logging.info("Bob and Charlie receive a group")

-    bob_message = bob.wait_for_incoming_msg()
+    bob_msg_id = bob.wait_for_incoming_msg_event().msg_id
+    bob_message = bob.get_message_by_id(bob_msg_id)
    bob_snapshot = bob_message.get_snapshot()
    assert bob_snapshot.text == "Hello"

@@ -315,7 +176,8 @@ def test_qr_readreceipt(acfactory) -> None:

    bob_out_message = bob_snapshot.chat.send_message(text="Hi from Bob!")

-    charlie_message = charlie.wait_for_incoming_msg()
+    charlie_msg_id = charlie.wait_for_incoming_msg_event().msg_id
+    charlie_message = charlie.get_message_by_id(charlie_msg_id)
    charlie_snapshot = charlie_message.get_snapshot()
    assert charlie_snapshot.text == "Hi from Bob!"

@@ -354,10 +216,11 @@ def test_verified_group_member_added_recovery(acfactory) -> None:
    """Tests verified group recovery by reverifying then removing and adding a member back."""
    ac1, ac2, ac3 = acfactory.get_online_accounts(3)

-    logging.info("ac1 creates a group")
-    chat = ac1.create_group("Group")
+    logging.info("ac1 creates verified group")
+    chat = ac1.create_group("Verified group", protect=True)
+    assert chat.get_basic_snapshot().is_protected

-    logging.info("ac2 joins the group")
+    logging.info("ac2 joins verified group")
    qr_code = chat.get_qr_code()
    ac2.secure_join(qr_code)
    ac2.wait_for_securejoin_joiner_success()
@@ -390,7 +253,7 @@ def test_verified_group_member_added_recovery(acfactory) -> None:
    ac3_contact_ac2 = ac3.create_contact(ac2)
    ac3_chat.remove_contact(ac3_contact_ac2_old)

-    snapshot = ac1.wait_for_incoming_msg().get_snapshot()
+    snapshot = ac1.get_message_by_id(ac1.wait_for_incoming_msg_event().msg_id).get_snapshot()
    assert "removed" in snapshot.text

    ac3_chat.add_contact(ac3_contact_ac2)
@@ -403,26 +266,25 @@ def test_verified_group_member_added_recovery(acfactory) -> None:
    logging.info("ac2 got event message: %s", snapshot.text)
    assert "added" in snapshot.text

-    snapshot = ac1.wait_for_incoming_msg().get_snapshot()
+    snapshot = ac1.get_message_by_id(ac1.wait_for_incoming_msg_event().msg_id).get_snapshot()
    assert "added" in snapshot.text

    chat = Chat(ac2, chat_id)
    chat.send_text("Works again!")

-    message = ac3.wait_for_incoming_msg()
+    msg_id = ac3.wait_for_incoming_msg_event().msg_id
+    message = ac3.get_message_by_id(msg_id)
    snapshot = message.get_snapshot()
    assert snapshot.text == "Works again!"

-    snapshot = ac1.wait_for_incoming_msg().get_snapshot()
+    snapshot = ac1.get_message_by_id(ac1.wait_for_incoming_msg_event().msg_id).get_snapshot()
    assert snapshot.text == "Works again!"

    ac1_contact_ac2 = ac1.create_contact(ac2)
    ac1_contact_ac3 = ac1.create_contact(ac3)
    ac1_contact_ac2_snapshot = ac1_contact_ac2.get_snapshot()
-    # Until we reset verifications and then send the _verified header,
-    # verification is not gossiped here:
-    assert not ac1_contact_ac2_snapshot.is_verified
-    assert ac1_contact_ac2_snapshot.verifier_id != ac1_contact_ac3.id
+    assert ac1_contact_ac2_snapshot.is_verified
+    assert ac1_contact_ac2_snapshot.verifier_id == ac1_contact_ac3.id


 def test_qr_join_chat_with_pending_bobstate_issue4894(acfactory):
@@ -440,8 +302,8 @@ def test_qr_join_chat_with_pending_bobstate_issue4894(acfactory):
    # we first create a fully joined verified group, and then start
    # joining a second time but interrupt it, to create pending bob state

-    logging.info("ac1: create a group that ac2 fully joins")
-    ch1 = ac1.create_group("Group")
+    logging.info("ac1: create verified group that ac2 fully joins")
+    ch1 = ac1.create_group("Group", protect=True)
    qr_code = ch1.get_qr_code()
    ac2.secure_join(qr_code)
    ac1.wait_for_securejoin_inviter_success()
@@ -449,8 +311,9 @@ def test_qr_join_chat_with_pending_bobstate_issue4894(acfactory):
    # ensure ac1 can write and ac2 receives messages in verified chat
    ch1.send_text("ac1 says hello")
    while 1:
-        snapshot = ac2.wait_for_incoming_msg().get_snapshot()
+        snapshot = ac2.get_message_by_id(ac2.wait_for_incoming_msg_event().msg_id).get_snapshot()
        if snapshot.text == "ac1 says hello":
+            assert snapshot.chat.get_basic_snapshot().is_protected
            break

    logging.info("ac1: let ac2 join again but shutoff ac1 in the middle of securejoin")
@@ -464,14 +327,15 @@ def test_qr_join_chat_with_pending_bobstate_issue4894(acfactory):
    assert ac2.create_contact(ac3).get_snapshot().is_verified

    logging.info("ac3: create a verified group VG with ac2")
-    vg = ac3.create_group("ac3-created")
+    vg = ac3.create_group("ac3-created", protect=True)
    vg.add_contact(ac3.create_contact(ac2))

    # ensure ac2 receives message in VG
    vg.send_text("hello")
    while 1:
-        msg = ac2.wait_for_incoming_msg().get_snapshot()
+        msg = ac2.get_message_by_id(ac2.wait_for_incoming_msg_event().msg_id).get_snapshot()
        if msg.text == "hello":
+            assert msg.chat.get_basic_snapshot().is_protected
            break

    logging.info("ac3: create a join-code for group VG and let ac4 join, check that ac2 got it")
@@ -487,7 +351,7 @@ def test_qr_join_chat_with_pending_bobstate_issue4894(acfactory):
 def test_qr_new_group_unblocked(acfactory):
    """Regression test for a bug introduced in core v1.113.0.
    ac2 scans a verified group QR code created by ac1.
-    This results in creation of a blocked single chat with ac1 on ac2,
+    This results in creation of a blocked 1:1 chat with ac1 on ac2,
    but ac1 contact is not blocked on ac2.
    Then ac1 creates a group, adds ac2 there and promotes it by sending a message.
    ac2 should receive a message and create a contact request for the group.
@@ -495,7 +359,7 @@ def test_qr_new_group_unblocked(acfactory):
    """

    ac1, ac2 = acfactory.get_online_accounts(2)
-    ac1_chat = ac1.create_group("Group for joining")
+    ac1_chat = ac1.create_group("Group for joining", protect=True)
    qr_code = ac1_chat.get_qr_code()
    ac2.secure_join(qr_code)

@@ -507,7 +371,7 @@ def test_qr_new_group_unblocked(acfactory):
    ac2.wait_for_incoming_msg_event()

    ac1_new_chat.send_text("Hello!")
-    ac2_msg = ac2.wait_for_incoming_msg().get_snapshot()
+    ac2_msg = ac2.get_message_by_id(ac2.wait_for_incoming_msg_event().msg_id).get_snapshot()
    assert ac2_msg.text == "Hello!"
    assert ac2_msg.chat.get_basic_snapshot().is_contact_request

@@ -520,7 +384,8 @@ def test_aeap_flow_verified(acfactory):
    addr, password = acfactory.get_credentials()

    logging.info("ac1: create verified-group QR, ac2 scans and joins")
-    chat = ac1.create_group("hello")
+    chat = ac1.create_group("hello", protect=True)
+    assert chat.get_basic_snapshot().is_protected
    qr_code = chat.get_qr_code()
    logging.info("ac2: start QR-code based join-group protocol")
    ac2.secure_join(qr_code)
@@ -532,7 +397,7 @@ def test_aeap_flow_verified(acfactory):

    logging.info("receiving first message")
    ac2.wait_for_incoming_msg_event()  # member added message
-    msg_in_1 = ac2.wait_for_incoming_msg().get_snapshot()
+    msg_in_1 = ac2.get_message_by_id(ac2.wait_for_incoming_msg_event().msg_id).get_snapshot()
    assert msg_in_1.text == msg_out.text

    logging.info("changing email account")
@@ -546,7 +411,7 @@ def test_aeap_flow_verified(acfactory):
    msg_out = chat.send_text("changed address").get_snapshot()

    logging.info("receiving second message")
-    msg_in_2 = ac2.wait_for_incoming_msg()
+    msg_in_2 = ac2.get_message_by_id(ac2.wait_for_incoming_msg_event().msg_id)
    msg_in_2_snapshot = msg_in_2.get_snapshot()
    assert msg_in_2_snapshot.text == msg_out.text
    assert msg_in_2_snapshot.chat.id == msg_in_1.chat.id
@@ -574,35 +439,33 @@ def test_gossip_verification(acfactory) -> None:

    logging.info("Bob creates an Autocrypt group")
    bob_group_chat = bob.create_group("Autocrypt Group")
+    assert not bob_group_chat.get_basic_snapshot().is_protected
    bob_group_chat.add_contact(bob_contact_alice)
    bob_group_chat.add_contact(bob_contact_carol)
    bob_group_chat.send_message(text="Hello Autocrypt group")

-    snapshot = carol.wait_for_incoming_msg().get_snapshot()
+    snapshot = carol.get_message_by_id(carol.wait_for_incoming_msg_event().msg_id).get_snapshot()
    assert snapshot.text == "Hello Autocrypt group"
    assert snapshot.show_padlock

-    # Group propagates verification using Autocrypt-Gossip header.
+    # Autocrypt group does not propagate verification.
    carol_contact_alice_snapshot = carol_contact_alice.get_snapshot()
-    # Until we reset verifications and then send the _verified header,
-    # verification is not gossiped here:
    assert not carol_contact_alice_snapshot.is_verified

    logging.info("Bob creates a Securejoin group")
-    bob_group_chat = bob.create_group("Securejoin Group")
+    bob_group_chat = bob.create_group("Securejoin Group", protect=True)
+    assert bob_group_chat.get_basic_snapshot().is_protected
    bob_group_chat.add_contact(bob_contact_alice)
    bob_group_chat.add_contact(bob_contact_carol)
    bob_group_chat.send_message(text="Hello Securejoin group")

-    snapshot = carol.wait_for_incoming_msg().get_snapshot()
+    snapshot = carol.get_message_by_id(carol.wait_for_incoming_msg_event().msg_id).get_snapshot()
    assert snapshot.text == "Hello Securejoin group"
    assert snapshot.show_padlock

    # Securejoin propagates verification.
    carol_contact_alice_snapshot = carol_contact_alice.get_snapshot()
-    # Until we reset verifications and then send the _verified header,
-    # verification is not gossiped here:
-    assert not carol_contact_alice_snapshot.is_verified
+    assert carol_contact_alice_snapshot.is_verified


 def test_securejoin_after_contact_resetup(acfactory) -> None:
@@ -614,7 +477,7 @@ def test_securejoin_after_contact_resetup(acfactory) -> None:
    ac1, ac2, ac3 = acfactory.get_online_accounts(3)

    # ac3 creates protected group with ac1.
-    ac3_chat = ac3.create_group("Group")
+    ac3_chat = ac3.create_group("Verified group", protect=True)

    # ac1 joins ac3 group.
    ac3_qr_code = ac3_chat.get_qr_code()
@@ -622,7 +485,7 @@ def test_securejoin_after_contact_resetup(acfactory) -> None:
    ac1.wait_for_securejoin_joiner_success()

    # ac1 waits for member added message and creates a QR code.
-    snapshot = ac1.wait_for_incoming_msg().get_snapshot()
+    snapshot = ac1.get_message_by_id(ac1.wait_for_incoming_msg_event().msg_id).get_snapshot()
    assert snapshot.text == "Member Me added by {}.".format(ac3.get_config("addr"))
    ac1_qr_code = snapshot.chat.get_qr_code()

@@ -659,9 +522,10 @@ def test_securejoin_after_contact_resetup(acfactory) -> None:

    # Wait for member added.
    logging.info("ac2 waits for member added message")
-    snapshot = ac2.wait_for_incoming_msg().get_snapshot()
+    snapshot = ac2.get_message_by_id(ac2.wait_for_incoming_msg_event().msg_id).get_snapshot()
    assert snapshot.is_info
    ac2_chat = snapshot.chat
+    assert ac2_chat.get_basic_snapshot().is_protected
    assert len(ac2_chat.get_contacts()) == 3

    # ac1 is still "not verified" for ac2 due to inconsistent state.
@@ -671,8 +535,9 @@ def test_securejoin_after_contact_resetup(acfactory) -> None:
 def test_withdraw_securejoin_qr(acfactory):
    alice, bob = acfactory.get_online_accounts(2)

-    logging.info("Alice creates a group")
-    alice_chat = alice.create_group("Group")
+    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 = alice_chat.get_qr_code()
@@ -681,8 +546,9 @@ def test_withdraw_securejoin_qr(acfactory):

    alice.clear_all_events()

-    snapshot = bob.wait_for_incoming_msg().get_snapshot()
+    snapshot = bob.get_message_by_id(bob.wait_for_incoming_msg_event().msg_id).get_snapshot()
    assert snapshot.text == "Member Me added by {}.".format(alice.get_config("addr"))
+    assert snapshot.chat.get_basic_snapshot().is_protected
    bob_chat.leave()

    snapshot = alice.get_message_by_id(alice.wait_for_msgs_changed_event().msg_id).get_snapshot()
@@ -701,28 +567,6 @@ def test_withdraw_securejoin_qr(acfactory):
        event = alice.wait_for_event()
        if (
            event.kind == EventType.WARNING
-            and "Ignoring RequestWithAuth message because of invalid auth code." in event.msg
+            and "Ignoring vg-request-with-auth message because of invalid auth code." in event.msg
        ):
            break
-
-
-def test_qr_scan_updates_new_relay_address(acfactory):
-    alice, bob = acfactory.get_online_accounts(2)
-
-    bob_alice_chat = bob.secure_join(alice.get_qr_code())
-    alice.wait_for_securejoin_inviter_success()
-    bob.wait_for_securejoin_joiner_success()
-
-    for ac in [alice, bob]:
-        old_addr = ac.get_config("configured_addr")
-        ac.add_transport_from_qr(acfactory.get_account_qr())
-        ac.set_config("configured_addr", ac.list_transports()[1]["addr"])
-        ac.delete_transport(old_addr)
-
-    bob.secure_join(alice.get_qr_code())
-    alice.wait_for_securejoin_inviter_success()
-    bob.wait_for_securejoin_joiner_success()
-
-    bob_alice_chat.send_text("hi")
-    snapshot = alice.wait_for_incoming_msg().get_snapshot()
-    assert snapshot.text == "hi"
--- a/deltachat-rpc-client/tests/test_something.py
+++ b/deltachat-rpc-client/tests/test_something.py
--- a/deltachat-rpc-client/tests/test_vcard.py
+++ b/deltachat-rpc-client/tests/test_vcard.py
@@ -1,12 +1,8 @@
 def test_vcard(acfactory) -> None:
-    alice, bob, fiona = acfactory.get_online_accounts(3)
+    alice, bob = acfactory.get_online_accounts(2)

-    bob.create_chat(alice)
    alice_contact_bob = alice.create_contact(bob, "Bob")
    alice_contact_charlie = alice.create_contact("charlie@example.org", "Charlie")
-    alice_contact_charlie_snapshot = alice_contact_charlie.get_snapshot()
-    alice_contact_fiona = alice.create_contact(fiona, "Fiona")
-    alice_contact_fiona_snapshot = alice_contact_fiona.get_snapshot()

    alice_chat_bob = alice_contact_bob.create_chat()
    alice_chat_bob.send_contact(alice_contact_charlie)
@@ -16,12 +12,3 @@ def test_vcard(acfactory) -> None:
    snapshot = message.get_snapshot()
    assert snapshot.vcard_contact
    assert snapshot.vcard_contact.addr == "charlie@example.org"
-    assert snapshot.vcard_contact.color == alice_contact_charlie_snapshot.color
-
-    alice_chat_bob.send_contact(alice_contact_fiona)
-    event = bob.wait_for_incoming_msg_event()
-    message = bob.get_message_by_id(event.msg_id)
-    snapshot = message.get_snapshot()
-    assert snapshot.vcard_contact
-    assert snapshot.vcard_contact.key
-    assert snapshot.vcard_contact.color == alice_contact_fiona_snapshot.color
--- a/deltachat-rpc-client/tests/test_webxdc.py
+++ b/deltachat-rpc-client/tests/test_webxdc.py
@@ -18,8 +18,6 @@ def test_webxdc(acfactory) -> None:
        "sourceCodeUrl": None,
        "summary": None,
        "selfAddr": webxdc_info["selfAddr"],
-        "isAppSender": False,
-        "isBroadcast": False,
        "sendUpdateInterval": 1000,
        "sendUpdateMaxSize": 18874368,
    }
--- a/deltachat-rpc-server/Cargo.toml
+++ b/deltachat-rpc-server/Cargo.toml
@@ -1,8 +1,8 @@
 [package]
 name = "deltachat-rpc-server"
-version = "2.58.0-dev"
+version = "2.3.0"
 description = "DeltaChat JSON-RPC server"
-edition = "2024"
+edition = "2021"
 readme = "README.md"
 license = "MPL-2.0"

--- a/deltachat-rpc-server/npm-package/README.md
+++ b/deltachat-rpc-server/npm-package/README.md
@@ -18,7 +18,7 @@ import { startDeltaChat } from "@deltachat/stdio-rpc-server";
 import { C } from "@deltachat/jsonrpc-client";

 async function main() {
-    const dc = startDeltaChat("deltachat-data");
+    const dc = await startDeltaChat("deltachat-data");
    console.log(await dc.rpc.getSystemInfo());
    dc.close()
 }
--- a/deltachat-rpc-server/npm-package/index.d.ts
+++ b/deltachat-rpc-server/npm-package/index.d.ts
@@ -15,7 +15,7 @@ export interface SearchOptions {
 */
 export function getRPCServerPath(
  options?: Partial<SearchOptions>
-): string;
+): Promise<string>;



@@ -33,15 +33,8 @@ export interface StartOptions {
 * @param directory directory for accounts folder
 * @param options 
 */
-export function startDeltaChat(directory: string, options?: Partial<SearchOptions & StartOptions> ): DeltaChatOverJsonRpcServer
+export function startDeltaChat(directory: string, options?: Partial<SearchOptions & StartOptions> ): Promise<DeltaChatOverJsonRpcServer>

-export class DeltaChatOverJsonRpc extends StdioDeltaChat {
-  constructor(
-    directory: string,
-    options?: Partial<SearchOptions & StartOptions>
-  );
-  readonly pathToServerBinary: string;
-}

 export namespace FnTypes {
    export type getRPCServerPath = typeof getRPCServerPath
--- a/deltachat-rpc-server/npm-package/index.js
+++ b/deltachat-rpc-server/npm-package/index.js
@@ -1,6 +1,6 @@
 //@ts-check
 import { spawn } from "node:child_process";
-import { statSync } from "node:fs";
+import { stat } from "node:fs/promises";
 import os from "node:os";
 import process from "node:process";
 import { ENV_VAR_NAME, PATH_EXECUTABLE_NAME } from "./src/const.js";
@@ -36,7 +36,7 @@ function findRPCServerInNodeModules() {
 }

 /** @type {import("./index").FnTypes.getRPCServerPath} */
-export function getRPCServerPath(options = {}) {
+export async function getRPCServerPath(options = {}) {
  const { takeVersionFromPATH, disableEnvPath } = {
    takeVersionFromPATH: false,
    disableEnvPath: false,
@@ -45,7 +45,7 @@ export function getRPCServerPath(options = {}) {
  // 1. check if it is set as env var
  if (process.env[ENV_VAR_NAME] && !disableEnvPath) {
    try {
-      if (!statSync(process.env[ENV_VAR_NAME]).isFile()) {
+      if (!(await stat(process.env[ENV_VAR_NAME])).isFile()) {
        throw new Error(
          `expected ${ENV_VAR_NAME} to point to the deltachat-rpc-server executable`
        );
@@ -68,49 +68,41 @@ export function getRPCServerPath(options = {}) {
 import { StdioDeltaChat } from "@deltachat/jsonrpc-client";

 /** @type {import("./index").FnTypes.startDeltaChat} */
-export function startDeltaChat(directory, options = {}) {
-  return new DeltaChatOverJsonRpc(directory, options);
-}
-
-export class DeltaChatOverJsonRpc extends StdioDeltaChat {
-  /**
-   *
-   * @param {string} directory
-   * @param {Partial<import("./index").SearchOptions & import("./index").StartOptions>} options
-   */
-  constructor(directory, options = {}) {
-    const pathToServerBinary = getRPCServerPath(options);
-    const server = spawn(pathToServerBinary, {
-      env: {
-        RUST_LOG: process.env.RUST_LOG,
-        DC_ACCOUNTS_PATH: directory,
-      },
-      stdio: ["pipe", "pipe", options.muteStdErr ? "ignore" : "inherit"],
-    });
-
-    server.on("error", (err) => {
-      throw new Error(
-        FAILED_TO_START_SERVER_EXECUTABLE(pathToServerBinary, err)
-      );
-    });
-    let shouldClose = false;
-
-    server.on("exit", () => {
-      if (shouldClose) {
-        return;
-      }
-      throw new Error("Server quit");
-    });
-
-    super(server.stdin, server.stdout, true);
-
-    this.close = () => {
-      shouldClose = true;
-      if (!server.kill()) {
-        console.log("server termination failed");
-      }
-    };
-
-    this.pathToServerBinary = pathToServerBinary;
-  }
+export async function startDeltaChat(directory, options = {}) {
+  const pathToServerBinary = await getRPCServerPath(options);
+  const server = spawn(pathToServerBinary, {
+    env: {
+      RUST_LOG: process.env.RUST_LOG,
+      DC_ACCOUNTS_PATH: directory,
+    },
+    stdio: ["pipe", "pipe", options.muteStdErr ? "ignore" : "inherit"],
+  });
+
+  server.on("error", (err) => {
+    throw new Error(FAILED_TO_START_SERVER_EXECUTABLE(pathToServerBinary, err));
+  });
+  let shouldClose = false;
+
+  server.on("exit", () => {
+    if (shouldClose) {
+      return;
+    }
+    throw new Error("Server quit");
+  });
+
+  /** @type {import('./index').DeltaChatOverJsonRpcServer} */
+  //@ts-expect-error
+  const dc = new StdioDeltaChat(server.stdin, server.stdout, true);
+
+  dc.close = () => {
+    shouldClose = true;
+    if (!server.kill()) {
+      console.log("server termination failed");
+    }
+  };
+
+  //@ts-expect-error
+  dc.pathToServerBinary = pathToServerBinary;
+
+  return dc;
 }
--- a/deltachat-rpc-server/npm-package/package.json
+++ b/deltachat-rpc-server/npm-package/package.json
@@ -15,5 +15,5 @@
  },
  "type": "module",
  "types": "index.d.ts",
-  "version": "2.58.0-dev"
+  "version": "2.3.0"
 }
--- a/deltachat-rpc-server/src/main.rs
+++ b/deltachat-rpc-server/src/main.rs
@@ -6,7 +6,7 @@ use std::env;
 use std::path::PathBuf;
 use std::sync::Arc;

-use anyhow::{Context as _, Result, anyhow};
+use anyhow::{anyhow, Context as _, Result};
 use deltachat::constants::DC_VERSION_STR;
 use deltachat_jsonrpc::api::{Accounts, CommandApi};
 use futures_lite::stream::StreamExt;
@@ -24,14 +24,6 @@ use yerpc::{RpcClient, RpcSession};

 #[tokio::main(flavor = "multi_thread")]
 async fn main() {
-    // Logs from `log` crate and traces from `tracing` crate
-    // are configurable with `RUST_LOG` environment variable
-    // and go to stderr to avoid interfering with JSON-RPC using stdout.
-    tracing_subscriber::fmt()
-        .with_env_filter(EnvFilter::from_default_env())
-        .with_writer(std::io::stderr)
-        .init();
-
    let r = main_impl().await;
    // From tokio documentation:
    // "For technical reasons, stdin is implemented by using an ordinary blocking read on a separate
@@ -49,22 +41,22 @@ async fn main_impl() -> Result<()> {
    if let Some(first_arg) = args.next() {
        if first_arg.to_str() == Some("--version") {
            if let Some(arg) = args.next() {
-                return Err(anyhow!("Unrecognized argument {arg:?}"));
+                return Err(anyhow!("Unrecognized argument {:?}", arg));
            }
-            eprintln!("{DC_VERSION_STR}");
+            eprintln!("{}", &*DC_VERSION_STR);
            return Ok(());
        } else if first_arg.to_str() == Some("--openrpc") {
            if let Some(arg) = args.next() {
-                return Err(anyhow!("Unrecognized argument {arg:?}"));
+                return Err(anyhow!("Unrecognized argument {:?}", arg));
            }
            println!("{}", CommandApi::openrpc_specification()?);
            return Ok(());
        } else {
-            return Err(anyhow!("Unrecognized option {first_arg:?}"));
+            return Err(anyhow!("Unrecognized option {:?}", first_arg));
        }
    }
    if let Some(arg) = args.next() {
-        return Err(anyhow!("Unrecognized argument {arg:?}"));
+        return Err(anyhow!("Unrecognized argument {:?}", arg));
    }

    // Install signal handlers early so that the shutdown is graceful starting from here.
@@ -72,6 +64,14 @@ async fn main_impl() -> Result<()> {
    #[cfg(target_family = "unix")]
    let mut sigterm = signal_unix::signal(signal_unix::SignalKind::terminate())?;

+    // Logs from `log` crate and traces from `tracing` crate
+    // are configurable with `RUST_LOG` environment variable
+    // and go to stderr to avoid interfering with JSON-RPC using stdout.
+    tracing_subscriber::fmt()
+        .with_env_filter(EnvFilter::from_default_env())
+        .with_writer(std::io::stderr)
+        .init();
+
    let path = std::env::var("DC_ACCOUNTS_PATH").unwrap_or_else(|_| "accounts".to_string());
    log::info!("Starting with accounts directory `{path}`.");
    let writable = true;
--- a/deltachat-time/Cargo.toml
+++ b/deltachat-time/Cargo.toml
@@ -2,7 +2,7 @@
 name = "deltachat-time"
 version = "1.0.0"
 description = "Time-related tools"
-edition = "2024"
+edition = "2021"
 license = "MPL-2.0"

 [dependencies]
--- a/deltachat-time/src/lib.rs
+++ b/deltachat-time/src/lib.rs
@@ -20,11 +20,6 @@ impl SystemTimeTools {
    pub fn shift(duration: Duration) {
        *SYSTEM_TIME_SHIFT.write().unwrap() += duration;
    }
-
-    /// Simulates the system clock being rewound by `duration`.
-    pub fn shift_back(duration: Duration) {
-        *SYSTEM_TIME_SHIFT.write().unwrap() -= duration;
-    }
 }

 #[cfg(test)]
--- a/deltachat_derive/Cargo.toml
+++ b/deltachat_derive/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "deltachat_derive"
 version = "2.0.0"
-edition = "2024"
+edition = "2018"
 license = "MPL-2.0"

 [lib]
 proc-macro = true

 [dependencies]
-syn = "3"
+syn = "2"
 quote = "1"
--- a/deltachat_derive/src/lib.rs
+++ b/deltachat_derive/src/lib.rs
@@ -14,7 +14,7 @@ pub fn to_sql_derive(input: TokenStream) -> TokenStream {
    let ast: syn::DeriveInput = syn::parse(input).unwrap();
    let name = &ast.ident;

-    let q = quote! {
+    let gen = quote! {
        impl rusqlite::types::ToSql for #name {
            fn to_sql(&self) -> rusqlite::Result<rusqlite::types::ToSqlOutput> {
                let num = *self as i64;
@@ -24,7 +24,7 @@ pub fn to_sql_derive(input: TokenStream) -> TokenStream {
            }
        }
    };
-    q.into()
+    gen.into()
 }

 #[proc_macro_derive(FromSql)]
@@ -32,7 +32,7 @@ pub fn from_sql_derive(input: TokenStream) -> TokenStream {
    let ast: syn::DeriveInput = syn::parse(input).unwrap();
    let name = &ast.ident;

-    let q = quote! {
+    let gen = quote! {
        impl rusqlite::types::FromSql for #name {
            fn column_result(col: rusqlite::types::ValueRef) -> rusqlite::types::FromSqlResult<Self> {
                let inner = rusqlite::types::FromSql::column_result(col)?;
@@ -44,5 +44,5 @@ pub fn from_sql_derive(input: TokenStream) -> TokenStream {
            }
        }
    };
-    q.into()
+    gen.into()
 }
--- a/deny.toml
+++ b/deny.toml
@@ -12,48 +12,6 @@ ignore = [

    # Unmaintained paste
    "RUSTSEC-2024-0436",
-
-    # Unmaintained rustls-pemfile
-    # It is a transitive dependency of iroh 0.35.0,
-    # this should be fixed by upgrading to iroh 1.0 once it is released.
-    "RUSTSEC-2025-0134",
-
-    # Unmaintained proc-macro-error2
-    # Transitive dependency of typescript-type-def 0.5.13.
-    # <https://rustsec.org/advisories/RUSTSEC-2026-0173>
-    "RUSTSEC-2026-0173",
-
-    # rustls-webpki v0.102.8
-    # We cannot upgrade to >=0.103.10 because
-    # it is a transitive dependency of iroh 0.35.0
-    # which depends on ^0.102.
-    # <https://rustsec.org/advisories/RUSTSEC-2026-0049>
-    # <https://rustsec.org/advisories/RUSTSEC-2026-0098>
-    # <https://rustsec.org/advisories/RUSTSEC-2026-0099>
-    "RUSTSEC-2026-0049",
-    "RUSTSEC-2026-0098",
-    "RUSTSEC-2026-0099",
-
-    # Panic in CRL signature checks.
-    # We do not check CRL and cannot update rustls-webpki 0.102.8 
-    # which is a dependency of iroh 0.35.0.
-    # <https://rustsec.org/advisories/RUSTSEC-2026-0104>
-    "RUSTSEC-2026-0104",
-
-    # hickory-proto 0.25.2 unbounded loop in DNSSEC code.
-    # Dependency of iroh 0.35.0, cannot be updated as of 2026-05-02.
-    # <https://rustsec.org/advisories/RUSTSEC-2026-0118>
-    "RUSTSEC-2026-0118",
-
-    # hickory-proto 0.25.2 quadratic complexity issue.
-    # Dependency of iroh 0.35.0, cannot be updated as of 2026-05-02.
-    # <https://rustsec.org/advisories/RUSTSEC-2026-0119>
-    "RUSTSEC-2026-0119",
-
-    # Timing side channel in ml-dsa dependency of rPGP.
-    # We enable PQC for encryption rather than signatures.
-    # <https://rustsec.org/advisories/RUSTSEC-2025-0144>
-    "RUSTSEC-2025-0144",
 ]

 [bans]
@@ -64,36 +22,34 @@ ignore = [
 skip = [
     { name = "async-channel", version = "1.9.0" },
     { name = "bitflags", version = "1.3.2" },
-     { name = "constant_time_eq", version = "0.3.1" },
-     { name = "cpufeatures", version = "0.2.17" },
     { name = "derive_more-impl", version = "1.0.0" },
     { name = "derive_more", version = "1.0.0" },
     { name = "event-listener", version = "2.5.3" },
     { name = "getrandom", version = "0.2.12" },
+     { name = "hashbrown", version = "0.14.5" },
     { name = "heck", version = "0.4.1" },
     { name = "http", version = "0.2.12" },
-     { name = "hybrid-array", version = "0.2.3" },
     { name = "linux-raw-sys", version = "0.4.14" },
-     { name = "lru", version = "0.12.5" },
+     { name = "lru", version = "0.12.3" },
     { name = "netlink-packet-route", version = "0.17.1" },
     { name = "nom", version = "7.1.3" },
+     { name = "proc-macro-crate", version = "2.0.0" },
     { name = "rand_chacha", version = "0.3.1" },
     { name = "rand_core", version = "0.6.4" },
     { name = "rand", version = "0.8.5" },
+     { name = "redox_syscall", version = "0.3.5" },
+     { name = "redox_syscall", version = "0.4.1" },
+     { name = "regex-automata", version = "0.1.10" },
+     { name = "regex-syntax", version = "0.6.29" },
     { name = "rustix", version = "0.38.44" },
-     { name = "rustls-webpki", version = "0.102.8" },
     { name = "serdect", version = "0.2.0" },
-     { name = "snafu-derive", version = "0.8.5" },
-     { name = "snafu", version = "0.8.5" },
-     { name = "socket2", version = "0.5.9" },
     { name = "spin", version = "0.9.8" },
     { name = "strum_macros", version = "0.26.2" },
     { name = "strum", version = "0.26.2" },
     { name = "syn", version = "1.0.109" },
-     { name = "syn", version = "2.0.118" },
     { name = "thiserror-impl", version = "1.0.69" },
     { name = "thiserror", version = "1.0.69" },
-     { name = "toml_datetime", version = "0.6.11" },
+     { name = "toml_edit", version = "0.20.7" },
     { name = "wasi", version = "0.11.0+wasi-snapshot-preview1" },
     { name = "windows" },
     { name = "windows_aarch64_gnullvm" },
@@ -111,6 +67,8 @@ skip = [
     { name = "windows_x86_64_gnu" },
     { name = "windows_x86_64_gnullvm" },
     { name = "windows_x86_64_msvc" },
+     { name = "winnow", version = "0.5.40" },
+     { name = "zerocopy", version = "0.7.32" },
 ]


--- a/Show More
+++ b/Show More