refactor(deltachat-jsonrpc): enable verbatimModuleSyntax

feat: Multi-device broadcast lists (#4953 )
feat: Sync Chat::name across devices (#4953 )
2026-07-08 00:15:13 +03:00 · 2023-11-13 09:24:55 +00:00 · 2023-11-13 05:00:57 -03:00 · 2023-11-13 05:00:57 -03:00 · 2023-11-13 05:00:57 -03:00 · 2023-11-13 05:00:57 -03:00
126 changed files with 5547 additions and 2813 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -14,8 +14,7 @@ on:
  pull_request:
  push:
    branches:
-      - master
-      - stable
+      - main

 env:
  RUSTFLAGS: -Dwarnings
@@ -39,10 +38,6 @@ jobs:
      - name: Check
        run: cargo check --workspace --all-targets --all-features

-      # Check with musl libc target which is used for `deltachat-rpc-server` releases.
-      - name: Check musl
-        run: scripts/zig-musl-check.sh
-
  cargo_deny:
    name: cargo deny
    runs-on: ubuntu-latest
@@ -87,9 +82,9 @@ jobs:
          - os: macos-latest
            rust: 1.73.0

-          # Minimum Supported Rust Version = 1.67.0
+          # Minimum Supported Rust Version = 1.70.0
          - os: ubuntu-latest
-            rust: 1.67.0
+            rust: 1.70.0
    runs-on: ${{ matrix.os }}
    steps:
      - uses: actions/checkout@v3
@@ -135,7 +130,7 @@ jobs:
    name: Build deltachat-rpc-server
    strategy:
      matrix:
-        os: [ubuntu-latest, macos-latest]
+        os: [ubuntu-latest, macos-latest, windows-latest]
    runs-on: ${{ matrix.os }}
    steps:
      - uses: actions/checkout@v3
@@ -150,7 +145,7 @@ jobs:
        uses: actions/upload-artifact@v3
        with:
          name: ${{ matrix.os }}-deltachat-rpc-server
-          path: target/debug/deltachat-rpc-server
+          path: ${{ matrix.os == 'windows-latest' && 'target/debug/deltachat-rpc-server.exe' || 'target/debug/deltachat-rpc-server' }}
          retention-days: 1

  python_lint:
@@ -171,8 +166,8 @@ jobs:
        working-directory: deltachat-rpc-client
        run: tox -e lint

-  python_tests:
-    name: Python tests
+  cffi_python_tests:
+    name: CFFI Python tests
    needs: ["c_library", "python_lint"]
    strategy:
      fail-fast: false
@@ -216,14 +211,14 @@ jobs:

      - name: Run python tests
        env:
-          DCC_NEW_TMP_EMAIL: ${{ secrets.DCC_NEW_TMP_EMAIL }}
+          CHATMAIL_DOMAIN: ${{ secrets.CHATMAIL_DOMAIN }}
          DCC_RS_TARGET: debug
          DCC_RS_DEV: ${{ github.workspace }}
        working-directory: python
        run: tox -e mypy,doc,py

-  aysnc_python_tests:
-    name: Async Python tests
+  rpc_python_tests:
+    name: JSON-RPC Python tests
    needs: ["python_lint", "rpc_server"]
    strategy:
      fail-fast: false
@@ -233,6 +228,8 @@ jobs:
            python: 3.12
          - os: macos-latest
            python: 3.12
+          - os: windows-latest
+            python: 3.12

          # PyPy tests
          - os: ubuntu-latest
@@ -263,13 +260,20 @@ jobs:
          path: target/debug

      - name: Make deltachat-rpc-server executable
+        if: ${{ matrix.os != 'windows-latest' }}
        run: chmod +x target/debug/deltachat-rpc-server

      - name: Add deltachat-rpc-server to path
+        if: ${{ matrix.os != 'windows-latest' }}
        run: echo ${{ github.workspace }}/target/debug >> $GITHUB_PATH

+      - name: Add deltachat-rpc-server to path
+        if: ${{ matrix.os == 'windows-latest' }}
+        run: |
+          "${{ github.workspace }}/target/debug" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
+
      - name: Run deltachat-rpc-client tests
        env:
-          DCC_NEW_TMP_EMAIL: ${{ secrets.DCC_NEW_TMP_EMAIL }}
+          CHATMAIL_DOMAIN: ${{ secrets.CHATMAIL_DOMAIN }}
        working-directory: deltachat-rpc-client
        run: tox -e py
--- a/.github/workflows/deltachat-rpc-server.yml
+++ b/.github/workflows/deltachat-rpc-server.yml
@@ -26,35 +26,17 @@ jobs:
    steps:
      - uses: actions/checkout@v3

-      - name: Build
+      - name: Install ziglang
+        run: pip install wheel ziglang==0.11.0
+
+      - name: Build deltachat-rpc-server binaries
        run: sh scripts/zig-rpc-server.sh

-      - name: Upload x86_64 binary
+      - name: Upload dist directory with Linux binaries
        uses: actions/upload-artifact@v3
        with:
-          name: deltachat-rpc-server-x86_64
-          path: target/x86_64-unknown-linux-musl/release/deltachat-rpc-server
-          if-no-files-found: error
-
-      - name: Upload i686 binary
-        uses: actions/upload-artifact@v3
-        with:
-          name: deltachat-rpc-server-i686
-          path: target/i686-unknown-linux-musl/release/deltachat-rpc-server
-          if-no-files-found: error
-
-      - name: Upload aarch64 binary
-        uses: actions/upload-artifact@v3
-        with:
-          name: deltachat-rpc-server-aarch64
-          path: target/aarch64-unknown-linux-musl/release/deltachat-rpc-server
-          if-no-files-found: error
-
-      - name: Upload armv7 binary
-        uses: actions/upload-artifact@v3
-        with:
-          name: deltachat-rpc-server-armv7
-          path: target/armv7-unknown-linux-musleabihf/release/deltachat-rpc-server
+          name: linux
+          path: dist/
          if-no-files-found: error

  build_windows:
@@ -92,39 +74,87 @@ jobs:

  build_macos:
    name: Build deltachat-rpc-server for macOS
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - arch: x86_64
+          - arch: aarch64
+
    runs-on: macos-latest
    steps:
      - uses: actions/checkout@v3

      - name: Setup rust target
-        run: rustup target add x86_64-apple-darwin
+        run: rustup target add ${{ matrix.arch }}-apple-darwin

      - name: Build
-        run: cargo build --release --package deltachat-rpc-server --target x86_64-apple-darwin --features vendored
+        run: cargo build --release --package deltachat-rpc-server --target ${{ matrix.arch }}-apple-darwin --features vendored

      - name: Upload binary
        uses: actions/upload-artifact@v3
        with:
-          name: deltachat-rpc-server-x86_64-macos
-          path: target/x86_64-apple-darwin/release/deltachat-rpc-server
+          name: deltachat-rpc-server-${{ matrix.arch }}-macos
+          path: target/${{ matrix.arch }}-apple-darwin/release/deltachat-rpc-server
          if-no-files-found: error

  publish:
-    name: Upload binaries to the release
+    name: Build wheels and upload binaries to the release
    needs: ["build_linux", "build_windows", "build_macos"]
    permissions:
      contents: write
    runs-on: "ubuntu-latest"
    steps:
-      - name: Download built binaries
-        uses: "actions/download-artifact@v3"
+      - uses: actions/checkout@v3

-      - name: Compose dist/ directory
+      - name: Download Linux binaries
+        uses: actions/download-artifact@v3
+        with:
+          name: linux
+          path: dist/
+
+      - name: Download win32 binary
+        uses: actions/download-artifact@v3
+        with:
+          name: deltachat-rpc-server-win32.exe
+          path: deltachat-rpc-server-win32.exe.d
+
+      - name: Download win64 binary
+        uses: actions/download-artifact@v3
+        with:
+          name: deltachat-rpc-server-win64.exe
+          path: deltachat-rpc-server-win64.exe.d
+
+      - name: Download macOS binary for x86_64
+        uses: actions/download-artifact@v3
+        with:
+          name: deltachat-rpc-server-x86_64-macos
+          path: deltachat-rpc-server-x86_64-macos.d
+
+      - name: Download macOS binary for aarch64
+        uses: actions/download-artifact@v3
+        with:
+          name: deltachat-rpc-server-aarch64-macos
+          path: deltachat-rpc-server-aarch64-macos.d
+
+      - name: Flatten dist/ directory
        run: |
-          mkdir dist
-          for x in x86_64 i686 aarch64 armv7 win32.exe win64.exe x86_64-macos; do
-            mv "deltachat-rpc-server-$x"/* "dist/deltachat-rpc-server-$x"
-          done
+          mv deltachat-rpc-server-win32.exe.d/deltachat-rpc-server.exe dist/deltachat-rpc-server-win32.exe
+          mv deltachat-rpc-server-win64.exe.d/deltachat-rpc-server.exe dist/deltachat-rpc-server-win64.exe
+          mv deltachat-rpc-server-x86_64-macos.d/deltachat-rpc-server dist/deltachat-rpc-server-x86_64-macos
+          mv deltachat-rpc-server-aarch64-macos.d/deltachat-rpc-server dist/deltachat-rpc-server-aarch64-macos
+
+      # Python 3.11 is needed for tomllib used in scripts/wheel-rpc-server.py
+      - name: Install python 3.12
+        uses: actions/setup-python@v4
+        with:
+          python-version: 3.12
+
+      - name: Install wheel
+        run: pip install wheel
+
+      - name: Build deltachat-rpc-server Python wheels and source package
+        run: scripts/wheel-rpc-server.py

      - name: List downloaded artifacts
        run: ls -l dist/
--- a/.github/workflows/jsonrpc-client-npm-package.yml
+++ b/.github/workflows/jsonrpc-client-npm-package.yml
@@ -17,7 +17,7 @@ jobs:
        uses: actions/checkout@v3
      - uses: actions/setup-node@v3
        with:
-          node-version: "16"
+          node-version: "18"
      - name: Get tag
        id: tag
        uses: dawidd6/action-get-tag@v1
--- a/.github/workflows/jsonrpc.yml
+++ b/.github/workflows/jsonrpc.yml
@@ -2,9 +2,9 @@ name: JSON-RPC API Test

 on:
  push:
-    branches: [master]
+    branches: [main]
  pull_request:
-    branches: [master]
+    branches: [main]

 env:
  CARGO_TERM_COLOR: always
@@ -15,10 +15,10 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
-      - name: Use Node.js 16.x
+      - name: Use Node.js 18.x
        uses: actions/setup-node@v3
        with:
-          node-version: 16.x
+          node-version: 18.x
      - name: Add Rust cache
        uses: Swatinem/rust-cache@v2
      - name: npm install
@@ -31,7 +31,7 @@ jobs:
        working-directory: deltachat-jsonrpc/typescript
        run: npm run test
        env:
-          DCC_NEW_TMP_EMAIL: ${{ secrets.DCC_NEW_TMP_EMAIL }}
+          CHATMAIL_DOMAIN: ${{ secrets.CHATMAIL_DOMAIN }}
      - name: make sure websocket server version still builds
        working-directory: deltachat-jsonrpc
        run: cargo build --bin deltachat-jsonrpc-server --features webserver
--- a/.github/workflows/node-docs.yml
+++ b/.github/workflows/node-docs.yml
@@ -8,7 +8,7 @@ name: Generate & upload node.js documentation
 on:
  push:
    branches:
-      - master
+      - main

 jobs:
  generate:
@@ -16,10 +16,10 @@ jobs:
    steps:
      - uses: actions/checkout@v3

-      - name: Use Node.js 16.x
+      - name: Use Node.js 18.x
        uses: actions/setup-node@v3
        with:
-          node-version: 16.x
+          node-version: 18.x

      - name: npm install and generate documentation
        working-directory: node
--- a/.github/workflows/node-package.yml
+++ b/.github/workflows/node-package.yml
@@ -18,7 +18,7 @@ jobs:
        uses: actions/checkout@v3
      - uses: actions/setup-node@v3
        with:
-          node-version: "16"
+          node-version: "18"
      - name: System info
        run: |
          rustc -vV
@@ -66,10 +66,8 @@ jobs:
    runs-on: ubuntu-latest

    # Build Linux prebuilds inside a container with old glibc for backwards compatibility.
-    # Debian 10 contained glibc 2.28 at the time of the writing (2023-06-04): https://packages.debian.org/buster/libc6
-    # Ubuntu 18.04 is at the End of Standard Support since June 2023, but it contains glibc 2.27,
-    # so we are using it to support Ubuntu 18.04 setups that are still not upgraded.
-    container: ubuntu:18.04
+    # Debian 10 contained glibc 2.28: https://packages.debian.org/buster/libc6
+    container: debian:10
    steps:
      # Working directory is owned by 1001:1001 by default.
      # Change it to our user.
@@ -80,7 +78,7 @@ jobs:
        uses: actions/checkout@v3
      - uses: actions/setup-node@v3
        with:
-          node-version: "16"
+          node-version: "18"
      - run: apt-get update

      # Python is needed for node-gyp
@@ -143,7 +141,7 @@ jobs:
        uses: actions/checkout@v3
      - uses: actions/setup-node@v2
        with:
-          node-version: "16"
+          node-version: "18"
      - name: Get tag
        id: tag
        uses: dawidd6/action-get-tag@v1
--- a/.github/workflows/node-tests.yml
+++ b/.github/workflows/node-tests.yml
@@ -13,7 +13,7 @@ on:
  pull_request:
  push:
    branches:
-      - master
+      - main

 jobs:
  tests:
@@ -27,7 +27,7 @@ jobs:
        uses: actions/checkout@v3
      - uses: actions/setup-node@v3
        with:
-          node-version: "16"
+          node-version: "18"
      - name: System info
        run: |
          rustc -vV
@@ -63,5 +63,5 @@ jobs:
        working-directory: node
        run: npm run test
        env:
-          DCC_NEW_TMP_EMAIL: ${{ secrets.DCC_NEW_TMP_EMAIL }}
+          CHATMAIL_DOMAIN: ${{ secrets.CHATMAIL_DOMAIN }}
          NODE_OPTIONS: "--force-node-api-uncaught-exceptions-policy=true"
--- a/.github/workflows/upload-docs.yml
+++ b/.github/workflows/upload-docs.yml
@@ -3,8 +3,7 @@ name: Build & Deploy Documentation on rs.delta.chat
 on:
  push:
    branches:
-      - master
-      - docs-gh-action
+      - main

 jobs:
  build:
--- a/.github/workflows/upload-ffi-docs.yml
+++ b/.github/workflows/upload-ffi-docs.yml
@@ -7,8 +7,7 @@ name: Build & Deploy Documentation on cffi.delta.chat
 on:
  push:
    branches:
-      - master
-      - docs-gh-action
+      - main

 jobs:
  build:
--- a/.gitignore
+++ b/.gitignore
@@ -1,6 +1,7 @@
 /target
 **/*.rs.bk
 /build
+/dist

 # ignore vi temporaries
 *~
@@ -18,6 +19,9 @@ python/.eggs
 __pycache__
 python/src/deltachat/capi*.so
 python/.venv/
+python/venv/
+venv/
+env/

 python/liveconfig*

--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,272 @@
 # Changelog

+## [1.130.0] - 2023-11-10
+
+### API-Changes
+
+- Emit JoinerProgress(1000) event when Bob verifies Alice.
+- JSON-RPC: add `ContactObject.is_profile_verified` property.
+- Hide `ChatId::get_for_contact()` from public API.
+
+### Features / Changes
+
+- Add secondary verified key.
+- Add info messages about implicitly added members.
+- Treat reset state as encryption not preferred.
+- Grow sleep durations on errors in Imap::fake_idle() ([#4424](https://github.com/deltachat/deltachat-core-rust/pull/4424)).
+
+### Fixes
+
+- Mark 1:1 chat as protected when joining a group.
+- Raise lower auto-download limit to 160k.
+- Remove `Reporting-UA` from read receipts.
+- Do not apply group changes to special chats. Avoid adding members to the trash chat.
+- imap: make `UidGrouper` robust against duplicate UIDs.
+- Do not return hidden chat from `dc_get_chat_id_by_contact_id`.
+- Smtp_loop(): Don't grow timeout if interrupted early ([#4833](https://github.com/deltachat/deltachat-core-rust/pull/4833)).
+
+### Refactor
+
+- imap: Do not FETCH right after `scan_folders()`.
+- deltachat-rpc-client: Use `itertools` instead of `Lock` for thread-safe request ID generation.
+
+### Tests
+
+- Remove unused `--liveconfig` option.
+- Test chatlist can load for corrupted chats ([#4979](https://github.com/deltachat/deltachat-core-rust/pull/4979)).
+
+### Miscellaneous Tasks
+
+- Update provider-db ([#4949](https://github.com/deltachat/deltachat-core-rust/pull/4949)).
+
+## [1.129.1] - 2023-11-06
+
+### Fixes
+
+- Update tokio-imap to fix Outlook STATUS parsing bug.
+- deltachat-rpc-client: Add the Lock around request ID.
+- `apply_group_changes`: Don't implicitly delete members locally, add absent ones instead ([#4934](https://github.com/deltachat/deltachat-core-rust/pull/4934)).
+- Partial messages do not change group state ([#4900](https://github.com/deltachat/deltachat-core-rust/pull/4900)).
+
+### Tests
+
+- Group chats device synchronisation.
+
+## [1.129.0] - 2023-11-06
+
+### API-Changes
+
+- Add JSON-RPC `get_chat_id_by_contact_id` API ([#4918](https://github.com/deltachat/deltachat-core-rust/pull/4918)).
+- [**breaking**] Remove deprecated `get_verifier_addr`.
+
+### Features / Changes
+
+- Sync chat `Blocked` state, chat visibility, chat mute duration and contact blocked status across devices ([#4817](https://github.com/deltachat/deltachat-core-rust/pull/4817)).
+- Add 'group created instructions' as info message ([#4916](https://github.com/deltachat/deltachat-core-rust/pull/4916)).
+- Add hardcoded fallback DNS cache.
+
+### Fixes
+
+- Switch to `EncryptionPreference::Mutual` on a receipt of encrypted+signed message ([#4707](https://github.com/deltachat/deltachat-core-rust/pull/4707)).
+- imap: Check UIDNEXT with a STATUS command before going IDLE.
+- Allow to change verified key via "member added" message.
+- json-rpc: Return verifier even if the contact is not "verified" (Autocrypt key does not equal Secure-Join key).
+
+### Documentation
+
+- Refine `Contact::get_verifier_id` and `Contact::is_verified` documentation ([#4922](https://github.com/deltachat/deltachat-core-rust/pull/4922)).
+- Contact profile view should not use `dc_contact_is_verified()`.
+- Remove documentation for non-existing `dc_accounts_new` `os_name` param.
+
+### Refactor
+
+- Remove unused or useless code paths in Secure-Join ([#4897](https://github.com/deltachat/deltachat-core-rust/pull/4897)).
+- Improve error handling in Secure-Join code.
+- Add hostname to "no DNS resolution results" error message.
+- Accept `&str` instead of `Option<String>` in idle().
+
+## [1.128.0] - 2023-11-02
+
+### Build system
+- [**breaking**] Upgrade nodejs version to 18 ([#4903](https://github.com/deltachat/deltachat-core-rust/pull/4903)).
+
+### Features / Changes
+
+- deltachat-rpc-client: Add `Account.wait_for_incoming_msg_event()`.
+- Decrease ratelimit for .testrun.org subdomains.
+
+### Fixes
+
+- Do not fail securejoin due to unrelated pending bobstate  ([#4896](https://github.com/deltachat/deltachat-core-rust/pull/4896)).
+- Allow other verified group recipients to be unverified, only check the sender verification.
+- Remove not working attempt to recover from verified key changes.
+
+## [1.127.2] - 2023-10-29
+
+### API-Changes
+
+- [**breaking**] Jsonrpc `misc_set_draft` now requires setting the viewtype.
+- jsonrpc: Add `get_message_info_object`.
+
+### Tests
+
+- deltachat-rpc-client: Move pytest option from pyproject.toml to tox.ini and set log level.
+- deltachat-rpc-client: Test securejoin.
+- Increase pytest timeout to 10 minutes.
+- Compile deltachat-rpc-server in debug mode for tests.
+
+## [1.127.1] - 2023-10-27
+
+### API-Changes
+
+- jsonrpc: add `.is_protection_broken` to `FullChat` and `BasicChat`.
+- jsonrpc: Add `id` to `ProviderInfo`.
+
+## [1.127.0] - 2023-10-26
+
+### API-Changes
+
+- [**breaking**] `dc_accounts_new` API is changed. Unused `os_name` argument is removed and `writable` argument is added.
+- jsonrpc: Add `resend_messages`.
+- [**breaking**] Remove unused function `is_verified_ex()` ([#4551](https://github.com/deltachat/deltachat-core-rust/pull/4551))
+- [**breaking**] Make `MsgId.delete_from_db()` private.
+- [**breaking**] deltachat-jsonrpc: use `kind` as a tag for all union types
+- json-rpc: Force stickers to be sent as stickers ([#4819](https://github.com/deltachat/deltachat-core-rust/pull/4819)).
+- Add mailto parse api ([#4829](https://github.com/deltachat/deltachat-core-rust/pull/4829)).
+- [**breaking**] Remove unused `DC_STR_PROTECTION_(EN)ABLED` strings
+- [**breaking**] Remove unused `dc_set_chat_protection()`
+- Hide `DcSecretKey` trait from the API.
+- Verified 1:1 chats ([#4315](https://github.com/deltachat/deltachat-core-rust/pull/4315)). Disabled by default, enable with `verified_one_on_one_chats` config.
+- Add api `chat::Chat::is_protection_broken`
+- Add `dc_chat_is_protection_broken()` C API.
+
+### CI
+
+- Run Rust tests with `RUST_BACKTRACE` set.
+- Replace `master` branch with `main`.  Run CI only on `main` branch pushes.
+- Test `deltachat-rpc-client` on Windows.
+
+### Documentation
+
+- Document how logs and error messages should be formatted in `CONTRIBUTING.md`.
+- Clarify transitive behaviour of `dc_contact_is_verfified()`.
+- Document `configured_addr`.
+
+### Features / Changes
+
+- Add lockfile to account manager ([#4314](https://github.com/deltachat/deltachat-core-rust/pull/4314)). 
+- Don't show a contact as verified if their key changed since the verification ([#4574](https://github.com/deltachat/deltachat-core-rust/pull/4574)).
+- deltachat-rpc-server: Add `--openrpc` option to print OpenRPC specification for JSON-RPC API. This specification can be used to generate JSON-RPC API clients.
+- Track whether contact is a bot or not ([#4821](https://github.com/deltachat/deltachat-core-rust/pull/4821)).
+- Replace `Config::SendSyncMsgs` with `SyncMsgs` ([#4817](https://github.com/deltachat/deltachat-core-rust/pull/4817)).
+
+### Fixes
+
+- Don't create 1:1 chat as protected for contact who doesn't prefer to encrypt ([#4538](https://github.com/deltachat/deltachat-core-rust/pull/4538)).
+- Allow to save a draft if the verification is broken ([#4542](https://github.com/deltachat/deltachat-core-rust/pull/4542)).
+- Fix info-message orderings of verified 1:1 chats ([#4545](https://github.com/deltachat/deltachat-core-rust/pull/4545)).
+- Fix example; this was changed some time ago, see https://docs.webxdc.org/spec.html#sendupdate
+- `receive_imf`: Update peerstate from db after handling Securejoin handshake ([#4600](https://github.com/deltachat/deltachat-core-rust/pull/4600)).
+- Sort old incoming messages below all outgoing ones ([#4621](https://github.com/deltachat/deltachat-core-rust/pull/4621)).
+- Do not mark non-verified group chats as verified when using securejoin.
+- `receive_imf`: Set protection only for Chattype::Single ([#4597](https://github.com/deltachat/deltachat-core-rust/pull/4597)).
+- Return from `dc_get_chatlist(DC_GCL_FOR_FORWARDING)` only chats where we can send ([#4616](https://github.com/deltachat/deltachat-core-rust/pull/4616)).
+- Clear VerifiedOneOnOneChats config on backup ([#4615](https://github.com/deltachat/deltachat-core-rust/pull/4615)).
+- Try removal of accounts multiple times with timeouts in case the database file is blocked (restore `try_many_times` workaround).
+
+### Build system
+
+- Remove examples/simple.rs.
+- Increase MSRV to 1.70.0.
+- Update dependencies.
+- Switch to iroh 0.4.x fork with updated dependencies.
+
+## [1.126.1] - 2023-10-24
+
+### Fixes
+
+- Do not hardcode version in deltachat-rpc-server source package.
+- Do not interrupt IMAP loop from `get_connectivity_html()`.
+
+### Features / Changes
+
+- imap: Buffer `STARTTLS` command.
+
+### Build system
+
+- Build `deltachat-rpc-server` binary for aarch64 macOS.
+- Build `deltachat-rpc-server` wheels for macOS and Windows.
+
+### Refactor
+
+- Remove job queue.
+
+### Miscellaneous Tasks
+
+- cargo: Update `ahash` to make `cargo-deny` happy.
+
+## [1.126.0] - 2023-10-22
+
+### API-Changes
+
+- Allow to filter by unread in `chatlist:try_load` ([#4824](https://github.com/deltachat/deltachat-core-rust/pull/4824)).
+- Add `misc_send_draft()` to JSON-RPC API ([#4839](https://github.com/deltachat/deltachat-core-rust/pull/4839)).
+
+### Features / Changes
+
+- [**breaking**] Make broadcast lists create their own chat ([#4644](https://github.com/deltachat/deltachat-core-rust/pull/4644)).
+  - This means that UIs need to ask for the name when creating a broadcast list, similar to <https://github.com/deltachat/deltachat-android/pull/2653>.
+- Add self-address to backup filename ([#4820](https://github.com/deltachat/deltachat-core-rust/pull/4820))
+
+### CI
+
+- Build Python wheels for deltachat-rpc-server.
+
+### Build system
+
+- Strip release binaries.
+- Workaround OpenSSL crate expecting libatomic to be available.
+
+### Fixes
+
+- Set `soft_heap_limit` on SQLite database.
+- imap: Fallback to `STATUS` if `SELECT` did not return UIDNEXT.
+
+## [1.125.0] - 2023-10-14
+
+### API-Changes
+
+- [**breaking**] deltachat-rpc-client: Replace `asyncio` with threads.
+- Validate boolean values passed to `set_config`. Attempts to set values other than `0` and `1` will result in an error.
+
+### CI
+
+- Reduce required Python version for deltachat-rpc-client from 3.8 to 3.7.
+
+### Features / Changes
+
+- Add developer option to disable IDLE.
+
+### Fixes
+
+- `deltachat-rpc-client`: Run `deltachat-rpc-server` in its own process group. This prevents reception of `SIGINT` by the server when the bot is terminated with `^C`.
+- python: Don't automatically set the displayname to "bot" when setting log level.
+- Don't update `timestamp`, `timestamp_rcvd`, `state` when replacing partially downloaded message ([#4700](https://github.com/deltachat/deltachat-core-rust/pull/4700)).
+- Assign encrypted partially downloaded group messages to 1:1 chat ([#4757](https://github.com/deltachat/deltachat-core-rust/pull/4757)).
+- Return all contacts from `Contact::get_all` for bots ([#4811](https://github.com/deltachat/deltachat-core-rust/pull/4811)).
+- Set connectivity status to "connected" during fake idle.
+- Return verifier contacts regardless of their origin.
+- Don't try to send more MDNs if there's a temporary SMTP error ([#4534](https://github.com/deltachat/deltachat-core-rust/pull/4534)).
+
+### Refactor
+
+- deltachat-rpc-client: Close stdin instead of sending `SIGTERM`.
+- deltachat-rpc-client: Remove print() calls. Standard `logging` package is for logging instead.
+
+### Tests
+
+- deltachat-rpc-client: Enable logs in pytest.
+
 ## [1.124.1] - 2023-10-05

 ### Fixes
@@ -928,7 +1195,7 @@ Bugfix release attempting to fix the [iOS build error](https://github.com/deltac

 ### Changes
 - Look at Authentication-Results. Don't accept Autocrypt key changes
-  if they come with negative authentiation results while this contact
+  if they come with negative authentication results while this contact
  sent emails with positive authentication results in the past. #3583
 - jsonrpc in cffi also sends events now #3662
 - jsonrpc: new format for events and better typescript autocompletion
@@ -2514,7 +2781,7 @@ Bugfix release attempting to fix the [iOS build error](https://github.com/deltac

 - delete all consumed secure-join handshake messagess #1209 #1212

- rust-level cleanups #1218 #1217 #1210 #1205
+- Rust-level cleanups #1218 #1217 #1210 #1205

 - python-level cleanups #1204 #1202 #1201

@@ -2879,3 +3146,13 @@ https://github.com/deltachat/deltachat-core-rust/pulls?q=is%3Apr+is%3Aclosed
 [1.123.0]: https://github.com/deltachat/deltachat-core-rust/compare/v1.122.0...v1.123.0
 [1.124.0]: https://github.com/deltachat/deltachat-core-rust/compare/v1.123.0...v1.124.0
 [1.124.1]: https://github.com/deltachat/deltachat-core-rust/compare/v1.124.0...v1.124.1
+[1.125.0]: https://github.com/deltachat/deltachat-core-rust/compare/v1.124.1...v1.125.0
+[1.126.0]: https://github.com/deltachat/deltachat-core-rust/compare/v1.125.0...v1.126.0
+[1.126.1]: https://github.com/deltachat/deltachat-core-rust/compare/v1.126.0...v1.126.1
+[1.127.0]: https://github.com/deltachat/deltachat-core-rust/compare/v1.126.1...v1.127.0
+[1.127.1]: https://github.com/deltachat/deltachat-core-rust/compare/v1.127.0...v1.127.1
+[1.127.2]: https://github.com/deltachat/deltachat-core-rust/compare/v1.127.1...v1.127.2
+[1.128.0]: https://github.com/deltachat/deltachat-core-rust/compare/v1.127.2...v1.128.0
+[1.129.0]: https://github.com/deltachat/deltachat-core-rust/compare/v1.128.0...v1.129.0
+[1.129.1]: https://github.com/deltachat/deltachat-core-rust/compare/v1.129.0...v1.129.1
+[1.130.0]: https://github.com/deltachat/deltachat-core-rust/compare/v1.129.1...v1.130.0
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,9 +1,9 @@
 [package]
 name = "deltachat"
-version = "1.124.1"
+version = "1.130.0"
 edition = "2021"
 license = "MPL-2.0"
-rust-version = "1.67"
+rust-version = "1.70"

 [profile.dev]
 debug = 0
@@ -24,10 +24,7 @@ lto = true
 panic = 'abort'
 opt-level = "z"
 codegen-units = 1
-
-[patch.crates-io]
-quinn-udp = { git = "https://github.com/quinn-rs/quinn", branch="main" }
-quinn-proto = { git = "https://github.com/quinn-rs/quinn", branch="main" }
+strip = true

 [dependencies]
 deltachat_derive = { path = "./deltachat_derive" }
@@ -35,7 +32,7 @@ format-flowed = { path = "./format-flowed" }
 ratelimit = { path = "./deltachat-ratelimit" }

 anyhow = "1"
-async-channel = "1.8.0"
+async-channel = "2.0.0"
 async-imap = { version = "0.9.1", default-features = false, features = ["runtime-tokio"] }
 async-native-tls = { version = "0.5", default-features = false, features = ["runtime-tokio"] }
 async-smtp = { version = "0.9", default-features = false, features = ["runtime-tokio"] }
@@ -50,11 +47,12 @@ escaper = "0.1"
 fast-socks5 = "0.8"
 fd-lock = "3.0.11"
 futures = "0.3"
-futures-lite = "1.13.0"
+futures-lite = "2.0.0"
 hex = "0.4.0"
+hickory-resolver = "0.24"
 humansize = "2"
 image = { version = "0.24.7", default-features=false, features = ["gif", "jpeg", "ico", "png", "pnm", "webp", "bmp"] }
-iroh = { version = "0.4.1", default-features = false }
+iroh = { git = "https://github.com/deltachat/iroh", branch = "0.4-update-quic", default-features = false }
 kamadak-exif = "0.5"
 lettre_email = { git = "https://github.com/deltachat/lettre", branch = "master" }
 libc = "0.2"
@@ -67,13 +65,14 @@ once_cell = "1.18.0"
 percent-encoding = "2.3"
 parking_lot = "0.12"
 pgp = { version = "0.10", default-features = false }
+pin-project = "1"
 pretty_env_logger = { version = "0.5", optional = true }
 qrcodegen = "1.7.0"
-quick-xml = "0.30"
+quick-xml = "0.31"
 rand = "0.8"
 regex = "1.9"
 reqwest = { version = "0.11.20", features = ["json"] }
-rusqlite = { version = "0.29", features = ["sqlcipher"] }
+rusqlite = { version = "0.30", features = ["sqlcipher"] }
 rust-hsluv = "0.1"
 sanitize-filename = "0.5"
 serde_json = "1.0"
@@ -91,15 +90,14 @@ tokio-io-timeout = "1.2.0"
 tokio-stream = { version = "0.1.14", features = ["fs"] }
 tokio-tar = { version = "0.3" } # TODO: integrate tokio into async-tar
 tokio-util = "0.7.9"
-toml = "0.7"
-trust-dns-resolver = "0.23"
+toml = "0.8"
 url = "2"
 uuid = { version = "1", features = ["serde", "v4"] }

 [dev-dependencies]
 ansi_term = "0.12.0"
 criterion = { version = "0.5.1", features = ["async_tokio"] }
-futures-lite = "1.13"
+futures-lite = "2.0.0"
 log = "0.4"
 pretty_env_logger = "0.5"
 proptest = { version = "1", default-features = false, features = ["std"] }
--- a/README.md
+++ b/README.md
@@ -3,8 +3,8 @@
 </p>

 <p align="center">
-  <a href="https://github.com/yoav-lavi/melody/actions/workflows/rust.yml">
-    <img alt="Rust CI" src="https://github.com/yoav-lavi/melody/actions/workflows/rust.yml/badge.svg">
+  <a href="https://github.com/deltachat/deltachat-core-rust/actions/workflows/ci.yml">
+    <img alt="Rust CI" src="https://github.com/deltachat/deltachat-core-rust/actions/workflows/ci.yml/badge.svg">
  </a>
 </p>

--- a/deltachat-ffi/Cargo.toml
+++ b/deltachat-ffi/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "deltachat_ffi"
-version = "1.124.1"
+version = "1.130.0"
 description = "Deltachat FFI"
 edition = "2018"
 readme = "README.md"
--- a/deltachat-ffi/deltachat.h
+++ b/deltachat-ffi/deltachat.h
@@ -384,7 +384,12 @@ char*           dc_get_blobdir               (const dc_context_t* context);
 /**
 * Configure the context. The configuration is handled by key=value pairs as:
 *
- * - `addr`         = address to display (always needed)
+ * - `addr`         = Email address to use for configuration.
+ *                    If dc_configure() fails this is not the email address actually in use.
+ *                    Use `configured_addr` to find out the email address actually in use.
+ * - `configured_addr` = Email address actually in use.
+ *                    Unless for testing, do not set this value using dc_set_config().
+ *                    Instead, set `addr` and call dc_configure().
 * - `mail_server`  = IMAP-server, guessed if left out
 * - `mail_user`    = IMAP-username, guessed if left out
 * - `mail_pw`      = IMAP-password (always needed)
@@ -492,6 +497,9 @@ char*           dc_get_blobdir               (const dc_context_t* context);
 * - `fetch_existing_msgs` = 1=fetch most recent existing messages on configure (default),
 *                    0=do not fetch existing messages on configure.
 *                    In both cases, existing recipients are added to the contact database.
+ * - `disable_idle` = 1=disable IMAP IDLE even if the server supports it,
+ *                    0=use IMAP IDLE if the server supports it.
+ *                    This is a developer option used for testing polling used as an IDLE fallback.
 * - `download_limit` = Messages up to this number of bytes are downloaded automatically.
 *                    For larger messages, only the header is downloaded and a placeholder is shown.
 *                    These messages can be downloaded fully using dc_download_full_msg() later.
@@ -500,6 +508,9 @@ char*           dc_get_blobdir               (const dc_context_t* context);
 *                    to not mess up with non-delivery-reports or read-receipts.
 *                    0=no limit (default).
 *                    Changes affect future messages only.
+ * - `gossip_period` = How often to gossip Autocrypt keys in chats with multiple recipients, in
+ *                    seconds. 2 days by default.
+ *                    This is not supposed to be changed by UIs and only used for testing.
 * - `verified_one_on_one_chats` = Feature flag for verified 1:1 chats; the UI should set it
 *                    to 1 if it supports verified 1:1 chats.
 *                    Regardless of this setting, `dc_chat_is_protected()` returns true while the key is verified,
@@ -885,7 +896,8 @@ int             dc_preconfigure_keypair        (dc_context_t* context, const cha
 *     - if the flag DC_GCL_ADD_ALLDONE_HINT is set, DC_CHAT_ID_ALLDONE_HINT
 *       is added as needed.
 * @param query_str An optional query for filtering the list. Only chats matching this query
- *     are returned. Give NULL for no filtering.
+ *     are returned. Give NULL for no filtering. When `is:unread` is contained in the query,
+ *     the chatlist is filtered such that only chats with unread messages show up.
 * @param query_id An optional contact ID for filtering the list. Only chats including this contact ID
 *     are returned. Give 0 for no filtering.
 * @return A chatlist as an dc_chatlist_t object.
@@ -1700,24 +1712,12 @@ uint32_t        dc_create_group_chat         (dc_context_t* context, int protect
 * Create a new broadcast list.
 *
 * Broadcast lists are similar to groups on the sending device,
- * however, recipients get the messages in normal one-to-one chats
- * and will not be aware of other members.
+ * however, recipients get the messages in a read-only chat
+ * and will see who the other members are.
 *
- * Replies to broadcasts go only to the sender
- * and not to all broadcast recipients.
- * Moreover, replies will not appear in the broadcast list
- * but in the one-to-one chat with the person answering.
- *
- * The name and the image of the broadcast list is set automatically
- * and is visible to the sender only.
- * Not asking for these data allows more focused creation
- * and we bypass the question who will get which data.
- * Also, many users will have at most one broadcast list
- * so, a generic name and image is sufficient at the first place.
- *
- * Later on, however, the name can be changed using dc_set_chat_name().
- * The image cannot be changed to have a unique, recognizable icon in the chat lists.
- * All in all, this is also what other messengers are doing here.
+ * For historical reasons, this function does not take a name directly,
+ * instead you have to set the name using dc_set_chat_name()
+ * after creating the broadcast list.
 *
 * @memberof dc_context_t
 * @param context The context object.
@@ -2260,8 +2260,7 @@ dc_contact_t*   dc_get_contact               (dc_context_t* context, uint32_t co
 *   the backup is not encrypted.
 *   The backup contains all contacts, chats, images and other data and device independent settings.
 *   The backup does not contain device dependent settings as ringtones or LED notification settings.
- *   The name of the backup is typically `delta-chat-<day>.tar`, if more than one backup is create on a day,
- *   the format is `delta-chat-<day>-<number>.tar`
+ *   The name of the backup is `delta-chat-backup-<day>-<number>-<addr>.tar`.
 *
 * - **DC_IMEX_IMPORT_BACKUP** (12) - `param1` is the file (not: directory) to import. `param2` is the passphrase.
 *   The file is normally created by DC_IMEX_EXPORT_BACKUP and detected by dc_imex_has_backup(). Importing a backup
@@ -2942,7 +2941,6 @@ int dc_receive_backup (dc_context_t* context, const char* qr);
 * use dc_accounts_remove_account().
 *
 * @memberof dc_accounts_t
- * @param os_name
 * @param dir The directory to create the context-databases in.
 *     If the directory does not exist,
 *     dc_accounts_new() will try to create it.
@@ -3733,8 +3731,22 @@ int             dc_chat_can_send              (const dc_chat_t* chat);

 /**
 * Check if a chat is protected.
- * Protected chats contain only verified members and encryption is always enabled.
- * Protected chats are created using dc_create_group_chat() by setting the 'protect' parameter to 1.
+ *
+ * End-to-end encryption is guaranteed in protected chats
+ * and only verified contacts
+ * as determined by dc_contact_is_verified()
+ * can be added to protected chats.
+ *
+ * Protected chats are created using dc_create_group_chat()
+ * by setting the 'protect' parameter to 1.
+ * 1:1 chats become protected or unprotected automatically
+ * if `verified_one_on_one_chats` setting is enabled.
+ *
+ * UI should display a green checkmark
+ * in the chat title,
+ * in the chatlist item
+ * and in the chat profile
+ * if chat protection is enabled.
 *
 * @memberof dc_chat_t
 * @param chat The chat object.
@@ -3967,7 +3979,7 @@ int64_t          dc_msg_get_received_timestamp (const dc_msg_t* msg);
 * Get the message time used for sorting.
 * This function returns the timestamp that is used for sorting the message
 * into lists as returned e.g. by dc_get_chat_msgs().
- * This may be the reveived time, the sending time or another time.
+ * This may be the received time, the sending time or another time.
 *
 * To get the receiving time, use dc_msg_get_received_timestamp().
 * To get the sending time, use dc_msg_get_timestamp().
@@ -5034,10 +5046,16 @@ int             dc_contact_is_blocked        (const dc_contact_t* contact);


 /**
- * Check if a contact was verified. E.g. by a secure-join QR code scan
- * and if the key has not changed since this verification.
+ * Check if the contact
+ * can be added to verified chats,
+ * i.e. has a verified key
+ * and Autocrypt key matches the verified key.
 *
- * The UI may draw a checkbox or something like that beside verified contacts.
+ * If contact is verified
+ * 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 (otherwise, use dc_chat_is_protected()).
 *
 * @memberof dc_contact_t
 * @param contact The contact object.
@@ -5047,32 +5065,19 @@ int             dc_contact_is_blocked        (const dc_contact_t* contact);
 int             dc_contact_is_verified       (dc_contact_t* contact);


-
 /**
- * Return the address that verified a contact
+ * Return the contact ID that verified a contact.
 *
- * The UI may use this in addition to a checkmark showing the verification status.
- * In case of verification chains,
- * the last contact in the chain is shown.
- * This is because of privacy reasons, but also as it would not help the user
- * to see a unknown name here - where one can mostly always ask the shown name
- * as it is directly known.
+ * If the function returns non-zero result,
+ * display green checkmark in the profile and "Introduced by ..." line
+ * with the name and address of the contact
+ * formatted by dc_contact_get_name_n_addr.
 *
- * @memberof dc_contact_t
- * @param contact The contact object.
- * @return 
- *    A string containing the verifiers address. If it is the same address as the contact itself,
- *    we verified the contact ourself. If it is an empty string, we don't have verifier 
- *    information or the contact is not verified.
- * @deprecated 2023-09-28, use dc_contact_get_verifier_id instead
- */
-char*           dc_contact_get_verifier_addr       (dc_contact_t* contact);
-
-
-/**
- * Return the `ContactId` that verified a contact
- *
- * The UI may use this in addition to a checkmark showing the verification status
+ * If this function returns a verifier,
+ * this does not necessarily mean
+ * you can add the contact to verified chats.
+ * Use dc_contact_is_verified() to check
+ * if a contact can be added to a verified chat instead.
 *
 * @memberof dc_contact_t
 * @param contact The contact object.
@@ -6235,6 +6240,7 @@ void dc_event_unref(dc_event_t* event);
 * @param data2 (int) The progress as:
 *     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
 */
 #define DC_EVENT_SECUREJOIN_JOINER_PROGRESS       2061

@@ -7261,6 +7267,11 @@ void dc_event_unref(dc_event_t* event);
 /// Used in info messages.
 #define DC_STR_CHAT_PROTECTION_DISABLED 171

+/// "Others will only see this group after you sent a first message."
+///
+/// Used as the first info messages in newly created groups.
+#define DC_STR_NEW_GROUP_SEND_FIRST_MESSAGE 172
+
 /**
 * @}
 */
--- a/deltachat-ffi/src/lib.rs
+++ b/deltachat-ffi/src/lib.rs
@@ -489,7 +489,7 @@ pub unsafe extern "C" fn dc_start_io(context: *mut dc_context_t) {
    if context.is_null() {
        return;
    }
-    let ctx = &*context;
+    let ctx = &mut *context;

    block_on(ctx.start_io())
 }
@@ -4119,23 +4119,6 @@ pub unsafe extern "C" fn dc_contact_is_verified(contact: *mut dc_contact_t) -> l
        .unwrap_or_default() as libc::c_int
 }

-#[no_mangle]
-pub unsafe extern "C" fn dc_contact_get_verifier_addr(
-    contact: *mut dc_contact_t,
-) -> *mut libc::c_char {
-    if contact.is_null() {
-        eprintln!("ignoring careless call to dc_contact_get_verifier_addr()");
-        return "".strdup();
-    }
-    let ffi_contact = &*contact;
-    let ctx = &*ffi_contact.context;
-    block_on(ffi_contact.contact.get_verifier_addr(ctx))
-        .context("failed to get verifier for contact")
-        .log_err(ctx)
-        .unwrap_or_default()
-        .strdup()
-}
-
 #[no_mangle]
 pub unsafe extern "C" fn dc_contact_get_verifier_id(contact: *mut dc_contact_t) -> u32 {
    if contact.is_null() {
@@ -4946,8 +4929,8 @@ pub unsafe extern "C" fn dc_accounts_start_io(accounts: *mut dc_accounts_t) {
        return;
    }

-    let accounts = &*accounts;
-    block_on(async move { accounts.read().await.start_io().await });
+    let accounts = &mut *accounts;
+    block_on(async move { accounts.write().await.start_io().await });
 }

 #[no_mangle]
--- a/deltachat-jsonrpc/Cargo.toml
+++ b/deltachat-jsonrpc/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "deltachat-jsonrpc"
-version = "1.124.1"
+version = "1.130.0"
 description = "DeltaChat JSON-RPC API"
 edition = "2021"
 default-run = "deltachat-jsonrpc-server"
@@ -19,12 +19,12 @@ schemars = "0.8.13"
 serde = { version = "1.0", features = ["derive"] }
 tempfile = "3.8.0"
 log = "0.4"
-async-channel = { version = "1.8.0" }
+async-channel = { version = "2.0.0" }
 futures = { version = "0.3.28" }
 serde_json = "1.0.105"
 yerpc = { version = "0.5.2", features = ["anyhow_expose", "openrpc"] }
 typescript-type-def = { version = "0.5.8", features = ["json_value"] }
-tokio = { version = "1.32.0" }
+tokio = { version = "1.33.0" }
 sanitize-filename = "0.5"
 walkdir = "2.3.3"
 base64 = "0.21"
@@ -34,7 +34,7 @@ axum = { version = "0.6.20", optional = true, features = ["ws"] }
 env_logger = { version = "0.10.0", optional = true }

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


 [features]
--- a/deltachat-jsonrpc/README.md
+++ b/deltachat-jsonrpc/README.md
@@ -108,10 +108,10 @@ This will build the `deltachat-jsonrpc-server` binary and then run a test suite

 The test suite includes some tests that need online connectivity and a way to create test email accounts. To run these tests, talk to DeltaChat developers to get a token for the `testrun.org` service, or use a local instance of [`mailadm`](https://github.com/deltachat/docker-mailadm).

-Then, set the `DCC_NEW_TMP_EMAIL` environment variable to your mailadm token before running the tests.
+Then, set the `CHATMAIL_DOMAIN` environment variable to your testing email server domain.

 ```
-DCC_NEW_TMP_EMAIL=https://testrun.org/new_email?t=yourtoken npm run test
+CHATMAIL_DOMAIN=chat.example.org npm run test
 ```

 #### Test Coverage
--- a/deltachat-jsonrpc/src/api/mod.rs
+++ b/deltachat-jsonrpc/src/api/mod.rs
@@ -47,7 +47,7 @@ use types::provider_info::ProviderInfo;
 use types::reactions::JSONRPCReactions;
 use types::webxdc::WebxdcMessageInfo;

-use self::types::message::MessageLoadResult;
+use self::types::message::{MessageInfo, MessageLoadResult};
 use self::types::{
    chat::{BasicChat, JSONRPCChatVisibility, MuteDuration},
    location::JsonrpcLocation,
@@ -221,13 +221,13 @@ impl CommandApi {

    /// Starts background tasks for all accounts.
    async fn start_io_for_all_accounts(&self) -> Result<()> {
-        self.accounts.read().await.start_io().await;
+        self.accounts.write().await.start_io().await;
        Ok(())
    }

    /// Stops background tasks for all accounts.
    async fn stop_io_for_all_accounts(&self) -> Result<()> {
-        self.accounts.read().await.stop_io().await;
+        self.accounts.write().await.stop_io().await;
        Ok(())
    }

@@ -237,7 +237,7 @@ impl CommandApi {

    /// Starts background tasks for a single account.
    async fn start_io(&self, account_id: u32) -> Result<()> {
-        let ctx = self.get_context(account_id).await?;
+        let mut ctx = self.get_context(account_id).await?;
        ctx.start_io().await;
        Ok(())
    }
@@ -383,7 +383,7 @@ impl CommandApi {
    /// Configures this account with the currently set parameters.
    /// Setup the credential config before calling this.
    async fn configure(&self, account_id: u32) -> Result<()> {
-        let ctx = self.get_context(account_id).await?;
+        let mut ctx = self.get_context(account_id).await?;
        ctx.stop_io().await;
        let result = ctx.configure().await;
        if result.is_err() {
@@ -815,24 +815,12 @@ impl CommandApi {
    /// Create a new broadcast list.
    ///
    /// Broadcast lists are similar to groups on the sending device,
-    /// however, recipients get the messages in normal one-to-one chats
-    /// and will not be aware of other members.
+    /// however, recipients get the messages in a read-only chat
+    /// and will see who the other members are.
    ///
-    /// Replies to broadcasts go only to the sender
-    /// and not to all broadcast recipients.
-    /// Moreover, replies will not appear in the broadcast list
-    /// but in the one-to-one chat with the person answering.
-    ///
-    /// The name and the image of the broadcast list is set automatically
-    /// and is visible to the sender only.
-    /// Not asking for these data allows more focused creation
-    /// and we bypass the question who will get which data.
-    /// Also, many users will have at most one broadcast list
-    /// so, a generic name and image is sufficient at the first place.
-    ///
-    /// Later on, however, the name can be changed using dc_set_chat_name().
-    /// The image cannot be changed to have a unique, recognizable icon in the chat lists.
-    /// All in all, this is also what other messengers are doing here.
+    /// For historical reasons, this function does not take a name directly,
+    /// instead you have to set the name using dc_set_chat_name()
+    /// after creating the broadcast list.
    async fn create_broadcast_list(&self, account_id: u32) -> Result<u32> {
        let ctx = self.get_context(account_id).await?;
        chat::create_broadcast_list(&ctx)
@@ -1138,6 +1126,16 @@ impl CommandApi {
        MsgId::new(message_id).get_info(&ctx).await
    }

+    /// Returns additional information for single message.
+    async fn get_message_info_object(
+        &self,
+        account_id: u32,
+        message_id: u32,
+    ) -> Result<MessageInfo> {
+        let ctx = self.get_context(account_id).await?;
+        MessageInfo::from_msg_id(&ctx, MsgId::new(message_id)).await
+    }
+
    /// Returns contacts that sent read receipts and the time of reading.
    async fn get_message_read_receipts(
        &self,
@@ -1393,6 +1391,19 @@ impl CommandApi {
    //                   chat
    // ---------------------------------------------

+    /// Returns the [`ChatId`] for the 1:1 chat with `contact_id` if it exists.
+    ///
+    /// If it does not exist, `None` is returned.
+    async fn get_chat_id_by_contact_id(
+        &self,
+        account_id: u32,
+        contact_id: u32,
+    ) -> Result<Option<u32>> {
+        let ctx = self.get_context(account_id).await?;
+        let chat_id = ChatId::lookup_by_contact(&ctx, ContactId::new(contact_id)).await?;
+        Ok(chat_id.map(|id| id.to_u32()))
+    }
+
    /// Returns all message IDs of the given types in a chat.
    /// Typically used to show a gallery.
    ///
@@ -1756,6 +1767,9 @@ impl CommandApi {
        let mut msg = Message::new(Viewtype::Sticker);
        msg.set_file(&sticker_path, None);

+        // JSON-rpc does not need heuristics to turn [Viewtype::Sticker] into [Viewtype::Image]
+        msg.force_sticker();
+
        let message_id = deltachat::chat::send_msg(&ctx, ChatId::new(chat_id), &mut msg).await?;
        Ok(message_id.to_u32())
    }
@@ -2042,13 +2056,19 @@ impl CommandApi {
        text: Option<String>,
        file: Option<String>,
        quoted_message_id: Option<u32>,
+        view_type: Option<MessageViewtype>,
    ) -> Result<()> {
        let ctx = self.get_context(account_id).await?;
-        let mut draft = Message::new(if file.is_some() {
-            Viewtype::File
-        } else {
-            Viewtype::Text
-        });
+        let mut draft = Message::new(view_type.map_or_else(
+            || {
+                if file.is_some() {
+                    Viewtype::File
+                } else {
+                    Viewtype::Text
+                }
+            },
+            |v| v.into(),
+        ));
        draft.set_text(text.unwrap_or_default());
        if let Some(file) = file {
            draft.set_file(file, None);
@@ -2068,6 +2088,23 @@ impl CommandApi {

        ChatId::new(chat_id).set_draft(&ctx, Some(&mut draft)).await
    }
+
+    // send the chat's current set draft
+    async fn misc_send_draft(&self, account_id: u32, chat_id: u32) -> Result<u32> {
+        let ctx = self.get_context(account_id).await?;
+        if let Some(draft) = ChatId::new(chat_id).get_draft(&ctx).await? {
+            let mut draft = draft;
+            let msg_id = chat::send_msg(&ctx, ChatId::new(chat_id), &mut draft)
+                .await?
+                .to_u32();
+            Ok(msg_id)
+        } else {
+            Err(anyhow!(
+                "chat with id {} doesn't have draft message",
+                chat_id
+            ))
+        }
+    }
 }

 // Helper functions (to prevent code duplication)
--- a/deltachat-jsonrpc/src/api/types/chat.rs
+++ b/deltachat-jsonrpc/src/api/types/chat.rs
@@ -18,6 +18,17 @@ use super::contact::ContactObject;
 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,
    profile_image: Option<String>, //BLOBS ?
    archived: bool,
@@ -31,6 +42,7 @@ 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,
    self_in_group: bool,
    is_muted: bool,
@@ -100,6 +112,7 @@ impl FullChat {
            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(),
@@ -126,6 +139,17 @@ impl FullChat {
 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,
    profile_image: Option<String>, //BLOBS ?
    archived: bool,
@@ -134,6 +158,7 @@ pub struct BasicChat {
    is_self_talk: bool,
    color: String,
    is_contact_request: bool,
+    is_protection_broken: bool,
    is_device_chat: bool,
    is_muted: bool,
 }
@@ -160,6 +185,7 @@ impl BasicChat {
            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(),
        })
--- a/deltachat-jsonrpc/src/api/types/contact.rs
+++ b/deltachat-jsonrpc/src/api/types/contact.rs
@@ -19,11 +19,30 @@ pub struct ContactObject {
    profile_image: Option<String>, // BLOBS
    name_and_addr: String,
    is_blocked: bool,
+
+    /// True if the contact can be added to verified groups.
+    ///
+    /// 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 address that verified this contact
-    verifier_addr: Option<String>,
-    /// the id of the contact that verified this contact
+
+    /// True if the contact profile title should have a green checkmark.
+    ///
+    /// 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.
+    ///
+    /// 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
    last_seen: i64,
    was_seen_recently: bool,
@@ -39,18 +58,12 @@ impl ContactObject {
            None => None,
        };
        let is_verified = contact.is_verified(context).await? == VerifiedStatus::BidirectVerified;
+        let is_profile_verified = contact.is_profile_verified(context).await?;

-        let (verifier_addr, verifier_id) = if is_verified {
-            (
-                contact.get_verifier_addr(context).await?,
-                contact
-                    .get_verifier_id(context)
-                    .await?
-                    .map(|contact_id| contact_id.to_u32()),
-            )
-        } else {
-            (None, None)
-        };
+        let verifier_id = contact
+            .get_verifier_id(context)
+            .await?
+            .map(|contact_id| contact_id.to_u32());

        Ok(ContactObject {
            address: contact.get_addr().to_owned(),
@@ -64,7 +77,7 @@ impl ContactObject {
            name_and_addr: contact.get_name_n_addr(),
            is_blocked: contact.is_blocked(),
            is_verified,
-            verifier_addr,
+            is_profile_verified,
            verifier_id,
            last_seen: contact.last_seen(),
            was_seen_recently: contact.was_seen_recently(),
--- a/deltachat-jsonrpc/src/api/types/message.rs
+++ b/deltachat-jsonrpc/src/api/types/message.rs
@@ -552,3 +552,71 @@ pub struct MessageReadReceipt {
    pub contact_id: u32,
    pub timestamp: i64,
 }
+
+#[derive(Serialize, TypeDef, schemars::JsonSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct MessageInfo {
+    rawtext: String,
+    ephemeral_timer: EphemeralTimer,
+    /// When message is ephemeral this contains the timestamp of the message expiry
+    ephemeral_timestamp: Option<i64>,
+    error: Option<String>,
+    rfc724_mid: String,
+    server_urls: Vec<String>,
+    hop_info: Option<String>,
+}
+
+impl MessageInfo {
+    pub async fn from_msg_id(context: &Context, msg_id: MsgId) -> Result<Self> {
+        let message = Message::load_from_db(context, msg_id).await?;
+        let rawtext = msg_id.rawtext(context).await?;
+        let ephemeral_timer = message.get_ephemeral_timer().into();
+        let ephemeral_timestamp = match message.get_ephemeral_timer() {
+            deltachat::ephemeral::Timer::Disabled => None,
+            deltachat::ephemeral::Timer::Enabled { .. } => Some(message.get_ephemeral_timestamp()),
+        };
+
+        let server_urls =
+            MsgId::get_info_server_urls(context, message.rfc724_mid().to_owned()).await?;
+
+        let hop_info = msg_id.hop_info(context).await?;
+
+        Ok(Self {
+            rawtext,
+            ephemeral_timer,
+            ephemeral_timestamp,
+            error: message.error(),
+            rfc724_mid: message.rfc724_mid().to_owned(),
+            server_urls,
+            hop_info,
+        })
+    }
+}
+
+#[derive(
+    Debug, PartialEq, Eq, Copy, Clone, Serialize, Deserialize, TypeDef, schemars::JsonSchema,
+)]
+#[serde(rename_all = "camelCase", tag = "variant")]
+pub enum EphemeralTimer {
+    /// Timer is disabled.
+    Disabled,
+
+    /// Timer is enabled.
+    Enabled {
+        /// Timer duration in seconds.
+        ///
+        /// The value cannot be 0.
+        duration: u32,
+    },
+}
+
+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 }
+            }
+        }
+    }
+}
--- a/deltachat-jsonrpc/src/api/types/provider_info.rs
+++ b/deltachat-jsonrpc/src/api/types/provider_info.rs
@@ -6,6 +6,8 @@ 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.
@@ -14,6 +16,7 @@ pub struct ProviderInfo {
 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/lib.rs
+++ b/deltachat-jsonrpc/src/lib.rs
@@ -17,7 +17,7 @@ mod tests {
        let accounts = Accounts::new(tmp_dir, writable).await?;
        let api = CommandApi::new(accounts);

-        let (sender, mut receiver) = unbounded::<String>();
+        let (sender, receiver) = unbounded::<String>();

        let (client, mut rx) = RpcClient::new();
        let session = RpcSession::new(client, api);
@@ -36,17 +36,17 @@ mod tests {
            let request = r#"{"jsonrpc":"2.0","method":"add_account","params":[],"id":1}"#;
            let response = r#"{"jsonrpc":"2.0","id":1,"result":1}"#;
            session.handle_incoming(request).await;
-            let result = receiver.next().await;
+            let result = receiver.recv().await?;
            println!("{result:?}");
-            assert_eq!(result, Some(response.to_owned()));
+            assert_eq!(result, response.to_owned());
        }
        {
            let request = r#"{"jsonrpc":"2.0","method":"get_all_account_ids","params":[],"id":2}"#;
            let response = r#"{"jsonrpc":"2.0","id":2,"result":[1]}"#;
            session.handle_incoming(request).await;
-            let result = receiver.next().await;
+            let result = receiver.recv().await?;
            println!("{result:?}");
-            assert_eq!(result, Some(response.to_owned()));
+            assert_eq!(result, response.to_owned());
        }

        Ok(())
@@ -59,7 +59,7 @@ mod tests {
        let accounts = Accounts::new(tmp_dir, writable).await?;
        let api = CommandApi::new(accounts);

-        let (sender, mut receiver) = unbounded::<String>();
+        let (sender, receiver) = unbounded::<String>();

        let (client, mut rx) = RpcClient::new();
        let session = RpcSession::new(client, api);
@@ -78,15 +78,15 @@ mod tests {
            let request = r#"{"jsonrpc":"2.0","method":"add_account","params":[],"id":1}"#;
            let response = r#"{"jsonrpc":"2.0","id":1,"result":1}"#;
            session.handle_incoming(request).await;
-            let result = receiver.next().await;
-            assert_eq!(result, Some(response.to_owned()));
+            let result = receiver.recv().await?;
+            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":"","smtp_certificate_checks":"","socks5_enabled":"0","socks5_host":"","socks5_port":"","socks5_user":"","socks5_password":""}]}"#;
            let response = r#"{"jsonrpc":"2.0","id":2,"result":null}"#;
            session.handle_incoming(request).await;
-            let result = receiver.next().await;
-            assert_eq!(result, Some(response.to_owned()));
+            let result = receiver.recv().await?;
+            assert_eq!(result, response.to_owned());
        }

        Ok(())
--- a/deltachat-jsonrpc/src/webserver.rs
+++ b/deltachat-jsonrpc/src/webserver.rs
@@ -28,7 +28,7 @@ async fn main() -> Result<(), std::io::Error> {
        .layer(Extension(state.clone()));

    tokio::spawn(async move {
-        state.accounts.read().await.start_io().await;
+        state.accounts.write().await.start_io().await;
    });

    let addr = SocketAddr::from(([127, 0, 0, 1], port));
--- a/deltachat-jsonrpc/typescript/example/example.ts
+++ b/deltachat-jsonrpc/typescript/example/example.ts
@@ -1,4 +1,5 @@
-import { DcEvent, DeltaChat } from "../deltachat.js";
+import type { DcEvent } from "../deltachat.js";
+import { DeltaChat } from "../deltachat.js";

 var SELECTED_ACCOUNT = 0;

--- a/deltachat-jsonrpc/typescript/package.json
+++ b/deltachat-jsonrpc/typescript/package.json
@@ -9,7 +9,6 @@
    "@types/chai": "^4.2.21",
    "@types/chai-as-promised": "^7.1.5",
    "@types/mocha": "^9.0.0",
-    "@types/node-fetch": "^2.5.7",
    "@types/ws": "^7.2.4",
    "c8": "^7.10.0",
    "chai": "^4.3.4",
@@ -17,7 +16,6 @@
    "esbuild": "^0.17.9",
    "http-server": "^14.1.1",
    "mocha": "^9.1.1",
-    "node-fetch": "^2.6.1",
    "npm-run-all": "^4.1.5",
    "prettier": "^2.6.2",
    "typedoc": "^0.23.2",
@@ -55,5 +53,5 @@
  },
  "type": "module",
  "types": "dist/deltachat.d.ts",
-  "version": "1.124.1"
+  "version": "1.130.0"
 }
--- a/deltachat-jsonrpc/typescript/src/client.ts
+++ b/deltachat-jsonrpc/typescript/src/client.ts
@@ -1,8 +1,9 @@
 import * as T from "../generated/types.js";
-import { EventType } from "../generated/types.js";
+import type { EventType } from "../generated/types.js";
 import * as RPC from "../generated/jsonrpc.js";
 import { RawClient } from "../generated/client.js";
-import { WebsocketTransport, BaseTransport, Request } from "yerpc";
+import type { Request } from "yerpc";
+import { WebsocketTransport, BaseTransport } from "yerpc";
 import { TinyEmitter } from "@deltachat/tiny-emitter";

 type Events = { ALL: (accountId: number, event: EventType) => void } & {
--- a/deltachat-jsonrpc/typescript/test/basic.ts
+++ b/deltachat-jsonrpc/typescript/test/basic.ts
@@ -4,7 +4,8 @@ import chaiAsPromised from "chai-as-promised";
 chai.use(chaiAsPromised);
 import { StdioDeltaChat as DeltaChat } from "../deltachat.js";

-import { RpcServerHandle, startServer } from "./test_base.js";
+import type { RpcServerHandle } from "./test_base.js";
+import { startServer } from "./test_base.js";

 describe("basic tests", () => {
  let serverHandle: RpcServerHandle;
@@ -79,6 +80,9 @@ describe("basic tests", () => {
      accountId = await dc.rpc.addAccount();
    });
    it("should block and unblock contact", async function () {
+      // Cannot send sync messages to self as we do not have a self address.
+      await dc.rpc.setConfig(accountId, "sync_msgs", "0");
+
      const contactId = await dc.rpc.createContact(
        accountId,
        "example@delta.chat",
--- a/deltachat-jsonrpc/typescript/test/online.ts
+++ b/deltachat-jsonrpc/typescript/test/online.ts
@@ -1,6 +1,8 @@
 import { assert, expect } from "chai";
-import { StdioDeltaChat as DeltaChat, DcEvent } from "../deltachat.js";
-import { RpcServerHandle, createTempUser, startServer } from "./test_base.js";
+import { StdioDeltaChat as DeltaChat } from "../deltachat.js";
+import type { DcEvent } from "../deltachat.js";
+import type { RpcServerHandle } from "./test_base.js";
+import { createTempUser, startServer } from "./test_base.js";

 const EVENT_TIMEOUT = 20000;

@@ -13,16 +15,16 @@ describe("online tests", function () {

  before(async function () {
    this.timeout(60000);
-    if (!process.env.DCC_NEW_TMP_EMAIL) {
+    if (!process.env.CHATMAIL_DOMAIN) {
      if (process.env.COVERAGE && !process.env.COVERAGE_OFFLINE) {
        console.error(
-          "CAN NOT RUN COVERAGE correctly: Missing DCC_NEW_TMP_EMAIL environment variable!\n\n",
+          "CAN NOT RUN COVERAGE correctly: Missing CHATMAIL_DOMAIN environment variable!\n\n",
          "You can set COVERAGE_OFFLINE=1 to circumvent this check and skip the online tests, but those coverage results will be wrong, because some functions can only be tested in the online test"
        );
        process.exit(1);
      }
      console.log(
-        "Missing DCC_NEW_TMP_EMAIL environment variable!, skip integration tests"
+        "Missing CHATMAIL_DOMAIN environment variable!, skip integration tests"
      );
      this.skip();
    }
@@ -33,7 +35,7 @@ describe("online tests", function () {
      if (kind !== "Info") console.log(contextId, kind);
    });

-    account1 = await createTempUser(process.env.DCC_NEW_TMP_EMAIL);
+    account1 = createTempUser(process.env.CHATMAIL_DOMAIN);
    if (!account1 || !account1.email || !account1.password) {
      console.log(
        "We didn't got back an account from the api, skip integration tests"
@@ -41,7 +43,7 @@ describe("online tests", function () {
      this.skip();
    }

-    account2 = await createTempUser(process.env.DCC_NEW_TMP_EMAIL);
+    account2 = createTempUser(process.env.CHATMAIL_DOMAIN);
    if (!account2 || !account2.email || !account2.password) {
      console.log(
        "We didn't got back an account2 from the api, skip integration tests"
@@ -148,7 +150,7 @@ describe("online tests", function () {
      waitForEvent(dc, "IncomingMsg", accountId1),
    ]);
    dc.rpc.miscSendTextMessage(accountId2, chatId, "super secret message");
-    // Check if answer arives at A and if it is encrypted
+    // Check if answer arrives at A and if it is encrypted
    await eventPromise2;

    const messageId = (
--- a/deltachat-jsonrpc/typescript/test/test_base.ts
+++ b/deltachat-jsonrpc/typescript/test/test_base.ts
@@ -2,7 +2,6 @@ import { tmpdir } from "os";
 import { join, resolve } from "path";
 import { mkdtemp, rm } from "fs/promises";
 import { spawn, exec } from "child_process";
-import fetch from "node-fetch";
 import { Readable, Writable } from "node:stream";

 export type RpcServerHandle = {
@@ -57,15 +56,14 @@ export async function startServer(): Promise<RpcServerHandle> {
  };
 }

-export async function createTempUser(url: string) {
-  const response = await fetch(url, {
-    method: "POST",
-    headers: {
-      "cache-control": "no-cache",
-    },
-  });
-  if (!response.ok) throw new Error("Received invalid response");
-  return response.json();
+export function createTempUser(chatmailDomain: String) {
+  const charset = "2345789acdefghjkmnpqrstuvwxyz";
+  let user = "ci-";
+  for (let i = 0; i < 6; i++) {
+    user += charset[Math.floor(Math.random() * charset.length)];
+  }
+  const email = user + "@" + chatmailDomain;
+  return { email: email, password: user + "$" + user };
 }

 function getTargetDir(): Promise<string> {
--- a/deltachat-jsonrpc/typescript/tsconfig.json
+++ b/deltachat-jsonrpc/typescript/tsconfig.json
@@ -10,6 +10,7 @@
    "target": "ES2017",
    "module": "es2020",
    "declaration": true,
+    "verbatimModuleSyntax": true,
    "esModuleInterop": true,
    "moduleResolution": "node",
    "noImplicitAny": true,
--- a/deltachat-repl/Cargo.toml
+++ b/deltachat-repl/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "deltachat-repl"
-version = "1.124.1"
+version = "1.130.0"
 license = "MPL-2.0"
 edition = "2021"

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

--- a/deltachat-repl/src/main.rs
+++ b/deltachat-repl/src/main.rs
@@ -401,7 +401,7 @@ enum ExitResult {

 async fn handle_cmd(
    line: &str,
-    ctx: Context,
+    mut ctx: Context,
    selected_chat: &mut ChatId,
 ) -> Result<ExitResult, Error> {
    let mut args = line.splitn(2, ' ');
--- a/deltachat-rpc-client/README.md
+++ b/deltachat-rpc-client/README.md
@@ -25,7 +25,7 @@ $ pip install .
 ## Testing

 1. Build `deltachat-rpc-server` with `cargo build -p deltachat-rpc-server`.
-2. Run `PATH="../target/debug:$PATH" tox`.
+2. 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.

--- a/deltachat-rpc-client/pyproject.toml
+++ b/deltachat-rpc-client/pyproject.toml
@@ -7,7 +7,6 @@ name = "deltachat-rpc-client"
 description = "Python client for Delta Chat core JSON-RPC interface"
 classifiers = [
    "Development Status :: 5 - Production/Stable",
-    "Framework :: AsyncIO",
    "Intended Audience :: Developers",
    "License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)",
    "Operating System :: POSIX :: Linux",
--- a/deltachat-rpc-client/src/deltachat_rpc_client/account.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/account.py
@@ -4,7 +4,7 @@ from warnings import warn

 from ._utils import AttrDict
 from .chat import Chat
-from .const import ChatlistFlag, ContactFlag, SpecialContactId
+from .const import ChatlistFlag, ContactFlag, EventType, SpecialContactId
 from .contact import Contact
 from .message import Message

@@ -250,6 +250,13 @@ class Account:
        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):
+        """Wait for incoming message event and return it."""
+        while True:
+            event = self.wait_for_event()
+            if event.kind == EventType.INCOMING_MSG:
+                return event
+
    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(
--- a/deltachat-rpc-client/src/deltachat_rpc_client/chat.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/chat.py
@@ -160,11 +160,12 @@ class Chat:
        text: Optional[str] = None,
        file: Optional[str] = None,
        quoted_msg: Optional[int] = None,
+        viewtype: Optional[str] = None,
    ) -> None:
        """Set draft message."""
        if isinstance(quoted_msg, Message):
            quoted_msg = quoted_msg.id
-        self._rpc.misc_set_draft(self.account.id, self.id, text, file, quoted_msg)
+        self._rpc.misc_set_draft(self.account.id, self.id, text, file, quoted_msg, viewtype)

    def remove_draft(self) -> None:
        """Remove draft message."""
--- a/deltachat-rpc-client/src/deltachat_rpc_client/client.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/client.py
@@ -3,7 +3,6 @@ import logging
 from typing import (
    TYPE_CHECKING,
    Callable,
-    Coroutine,
    Dict,
    Iterable,
    Optional,
@@ -92,7 +91,7 @@ class Client:
        """Process events forever."""
        self.run_until(lambda _: False)

-    def run_until(self, func: Callable[[AttrDict], Union[bool, Coroutine]]) -> AttrDict:
+    def run_until(self, func: Callable[[AttrDict], bool]) -> AttrDict:
        """Process events until the given callable evaluates to True.

        The callable should accept an AttrDict object representing the
--- a/deltachat-rpc-client/src/deltachat_rpc_client/pytestplugin.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/pytestplugin.py
@@ -1,6 +1,5 @@
-import json
 import os
-import urllib.request
+import random
 from typing import AsyncGenerator, List, Optional

 import pytest
@@ -10,12 +9,11 @@ from .rpc import Rpc


 def get_temp_credentials() -> dict:
-    url = os.getenv("DCC_NEW_TMP_EMAIL")
-    assert url, "Failed to get online account, DCC_NEW_TMP_EMAIL is not set"
-
-    request = urllib.request.Request(url, method="POST")
-    with urllib.request.urlopen(request, timeout=60) as f:
-        return json.load(f)
+    domain = os.getenv("CHATMAIL_DOMAIN")
+    username = "ci-" + "".join(random.choice("2345789acdefghjkmnpqrstuvwxyz") for i in range(6))
+    password = f"{username}${username}"
+    addr = f"{username}@{domain}"
+    return {"email": addr, "password": password}


 class ACFactory:
@@ -23,7 +21,9 @@ class ACFactory:
        self.deltachat = deltachat

    def get_unconfigured_account(self) -> 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:
        return Bot(self.get_unconfigured_account())
@@ -61,6 +61,16 @@ class ACFactory:
    def get_online_accounts(self, num: int) -> List[Account]:
        return [self.get_online_account() for _ in range(num)]

+    def resetup_account(self, ac: Account) -> Account:
+        """Resetup account from scratch, losing the encryption key."""
+        ac.stop_io()
+        ac_clone = self.get_unconfigured_account()
+        for i in ["addr", "mail_pw"]:
+            ac_clone.set_config(i, ac.get_config(i))
+        ac.remove()
+        ac_clone.configure()
+        return ac_clone
+
    def send_message(
        self,
        to_account: Account,
--- a/deltachat-rpc-client/src/deltachat_rpc_client/rpc.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/rpc.py
@@ -1,3 +1,4 @@
+import itertools
 import json
 import logging
 import os
@@ -5,7 +6,7 @@ import subprocess
 import sys
 from queue import Queue
 from threading import Event, Thread
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Iterator, Optional


 class JsonRpcError(Exception):
@@ -23,7 +24,7 @@ class Rpc:

        self._kwargs = kwargs
        self.process: subprocess.Popen
-        self.id: int
+        self.id_iterator: Iterator[int]
        self.event_queues: Dict[int, Queue]
        # Map from request ID to `threading.Event`.
        self.request_events: Dict[int, Event]
@@ -54,7 +55,7 @@ class Rpc:
                preexec_fn=os.setpgrp,  # noqa: PLW1509
                **self._kwargs,
            )
-        self.id = 0
+        self.id_iterator = itertools.count(start=1)
        self.event_queues = {}
        self.request_events = {}
        self.request_results = {}
@@ -131,7 +132,9 @@ class Rpc:
                event = self.get_next_event()
                account_id = event["contextId"]
                queue = self.get_queue(account_id)
-                queue.put(event["event"])
+                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")
@@ -143,14 +146,12 @@ class Rpc:

    def __getattr__(self, attr: str):
        def method(*args) -> Any:
-            self.id += 1
-            request_id = self.id
-
+            request_id = next(self.id_iterator)
            request = {
                "jsonrpc": "2.0",
                "method": attr,
                "params": args,
-                "id": self.id,
+                "id": request_id,
            }
            event = Event()
            self.request_events[request_id] = event
--- a/deltachat-rpc-client/tests/test_securejoin.py
+++ b/deltachat-rpc-client/tests/test_securejoin.py
@@ -0,0 +1,249 @@
+import logging
+
+from deltachat_rpc_client import Chat, SpecialContactId
+
+
+def test_qr_setup_contact(acfactory) -> None:
+    alice, bob = acfactory.get_online_accounts(2)
+
+    qr_code, _svg = alice.get_qr_code()
+    bob.secure_join(qr_code)
+
+    while True:
+        event = alice.wait_for_event()
+        if event["kind"] == "SecurejoinInviterProgress" and event["progress"] == 1000:
+            break
+
+    # Test that Alice verified Bob's profile.
+    alice_contact_bob = alice.get_contact_by_addr(bob.get_config("addr"))
+    alice_contact_bob_snapshot = alice_contact_bob.get_snapshot()
+    assert alice_contact_bob_snapshot.is_verified
+
+    while True:
+        event = bob.wait_for_event()
+        if event["kind"] == "SecurejoinJoinerProgress" and event["progress"] == 1000:
+            break
+
+    # Test that Bob verified Alice's profile.
+    bob_contact_alice = bob.get_contact_by_addr(alice.get_config("addr"))
+    bob_contact_alice_snapshot = bob_contact_alice.get_snapshot()
+    assert bob_contact_alice_snapshot.is_verified
+
+
+def test_qr_securejoin(acfactory):
+    alice, bob = acfactory.get_online_accounts(2)
+
+    logging.info("Alice creates a verified group")
+    alice_chat = alice.create_group("Verified group", protect=True)
+
+    logging.info("Bob joins verified group")
+    qr_code, _svg = alice_chat.get_qr_code()
+    bob.secure_join(qr_code)
+    while True:
+        event = alice.wait_for_event()
+        if event.kind == "SecurejoinInviterProgress" and event["progress"] == 1000:
+            break
+
+    # Test that Alice verified Bob's profile.
+    alice_contact_bob = alice.get_contact_by_addr(bob.get_config("addr"))
+    alice_contact_bob_snapshot = alice_contact_bob.get_snapshot()
+    assert alice_contact_bob_snapshot.is_verified
+
+    while True:
+        event = bob.wait_for_event()
+        if event["kind"] == "SecurejoinJoinerProgress" and event["progress"] == 1000:
+            break
+
+    # Test that Bob verified Alice's profile.
+    bob_contact_alice = bob.get_contact_by_addr(alice.get_config("addr"))
+    bob_contact_alice_snapshot = bob_contact_alice.get_snapshot()
+    assert bob_contact_alice_snapshot.is_verified
+
+
+def test_verified_group_recovery(acfactory, rpc) -> None:
+    ac1, ac2, ac3 = acfactory.get_online_accounts(3)
+
+    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 verified group")
+    qr_code, _svg = chat.get_qr_code()
+    ac2.secure_join(qr_code)
+    while True:
+        event = ac1.wait_for_event()
+        if event.kind == "SecurejoinInviterProgress" and event["progress"] == 1000:
+            break
+
+    # ac1 has ac2 directly verified.
+    ac1_contact_ac2 = ac1.get_contact_by_addr(ac2.get_config("addr"))
+    assert ac1_contact_ac2.get_snapshot().verifier_id == SpecialContactId.SELF
+
+    logging.info("ac3 joins verified group")
+    ac3_chat = ac3.secure_join(qr_code)
+    while True:
+        event = ac1.wait_for_event()
+        if event.kind == "SecurejoinInviterProgress" and event["progress"] == 1000:
+            break
+
+    logging.info("ac2 logs in on a new device")
+    ac2 = acfactory.resetup_account(ac2)
+
+    logging.info("ac2 reverifies with ac3")
+    qr_code, _svg = ac3.get_qr_code()
+    ac2.secure_join(qr_code)
+
+    while True:
+        event = ac3.wait_for_event()
+        if event.kind == "SecurejoinInviterProgress" and event["progress"] == 1000:
+            break
+
+    logging.info("ac3 sends a message to the group")
+    assert len(ac3_chat.get_contacts()) == 3
+    ac3_chat.send_text("Hi!")
+
+    msg_id = ac2.wait_for_incoming_msg_event().msg_id
+    message = ac2.get_message_by_id(msg_id)
+    snapshot = message.get_snapshot()
+    logging.info("Received message %s", snapshot.text)
+    assert snapshot.text == "Hi!"
+
+    # ac1 contact cannot be verified by ac2 because ac3 did not gossip ac1 key in the "Hi!" message.
+    ac1_contact = ac2.get_contact_by_addr(ac1.get_config("addr"))
+    assert not ac1_contact.get_snapshot().is_verified
+
+    ac3_contact_id_ac1 = rpc.lookup_contact_id_by_addr(ac3.id, ac1.get_config("addr"))
+    ac3_chat.remove_contact(ac3_contact_id_ac1)
+    ac3_chat.add_contact(ac3_contact_id_ac1)
+
+    msg_id = ac2.wait_for_incoming_msg_event().msg_id
+    message = ac2.get_message_by_id(msg_id)
+    snapshot = message.get_snapshot()
+    logging.info("ac2 got event message: %s", snapshot.text)
+    assert "removed" in snapshot.text
+
+    event = ac2.wait_for_incoming_msg_event()
+    msg_id = event.msg_id
+    chat_id = event.chat_id
+    message = ac2.get_message_by_id(msg_id)
+    snapshot = message.get_snapshot()
+    logging.info("ac2 got event message: %s", snapshot.text)
+    assert "added" in snapshot.text
+
+    assert ac1_contact.get_snapshot().is_verified
+
+    chat = Chat(ac2, chat_id)
+    chat.send_text("Works again!")
+
+    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!"
+
+    ac1.wait_for_incoming_msg_event()  # Hi!
+    ac1.wait_for_incoming_msg_event()  # Member removed
+    ac1.wait_for_incoming_msg_event()  # Member added
+    snapshot = ac1.get_message_by_id(ac1.wait_for_incoming_msg_event().msg_id).get_snapshot()
+    assert snapshot.text == "Works again!"
+
+    # ac2 is now verified by ac3 for ac1
+    ac1_contact_ac3 = ac1.get_contact_by_addr(ac3.get_config("addr"))
+    assert ac1_contact_ac2.get_snapshot().verifier_id == ac1_contact_ac3.id
+
+    ac1_chat_messages = snapshot.chat.get_messages()
+    ac2_addr = ac2.get_config("addr")
+    assert ac1_chat_messages[-1].get_snapshot().text == f"Changed setup for {ac2_addr}"
+
+
+def test_verified_group_member_added_recovery(acfactory) -> None:
+    ac1, ac2, ac3 = acfactory.get_online_accounts(3)
+
+    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 verified group")
+    qr_code, _svg = chat.get_qr_code()
+    ac2.secure_join(qr_code)
+    while True:
+        event = ac1.wait_for_event()
+        if event.kind == "SecurejoinInviterProgress" and event["progress"] == 1000:
+            break
+
+    # ac1 has ac2 directly verified.
+    ac1_contact_ac2 = ac1.get_contact_by_addr(ac2.get_config("addr"))
+    assert ac1_contact_ac2.get_snapshot().verifier_id == SpecialContactId.SELF
+
+    logging.info("ac3 joins verified group")
+    ac3_chat = ac3.secure_join(qr_code)
+    while True:
+        event = ac1.wait_for_event()
+        if event.kind == "SecurejoinInviterProgress" and event["progress"] == 1000:
+            break
+
+    logging.info("ac2 logs in on a new device")
+    ac2 = acfactory.resetup_account(ac2)
+
+    logging.info("ac2 reverifies with ac3")
+    qr_code, _svg = ac3.get_qr_code()
+    ac2.secure_join(qr_code)
+
+    while True:
+        event = ac3.wait_for_event()
+        if event.kind == "SecurejoinInviterProgress" and event["progress"] == 1000:
+            break
+
+    logging.info("ac3 sends a message to the group")
+    assert len(ac3_chat.get_contacts()) == 3
+    ac3_chat.send_text("Hi!")
+
+    msg_id = ac2.wait_for_incoming_msg_event().msg_id
+    message = ac2.get_message_by_id(msg_id)
+    snapshot = message.get_snapshot()
+    logging.info("Received message %s", snapshot.text)
+    assert snapshot.text == "Hi!"
+
+    ac1.wait_for_incoming_msg_event()  # Hi!
+
+    ac3_contact_ac2 = ac3.get_contact_by_addr(ac2.get_config("addr"))
+    ac3_chat.remove_contact(ac3_contact_ac2)
+    ac3_chat.add_contact(ac3_contact_ac2)
+
+    msg_id = ac2.wait_for_incoming_msg_event().msg_id
+    message = ac2.get_message_by_id(msg_id)
+    snapshot = message.get_snapshot()
+    assert "removed" in snapshot.text
+
+    snapshot = ac1.get_message_by_id(ac1.wait_for_incoming_msg_event().msg_id).get_snapshot()
+    assert "removed" in snapshot.text
+
+    event = ac2.wait_for_incoming_msg_event()
+    msg_id = event.msg_id
+    chat_id = event.chat_id
+    message = ac2.get_message_by_id(msg_id)
+    snapshot = message.get_snapshot()
+    logging.info("ac2 got event message: %s", snapshot.text)
+    assert "added" in snapshot.text
+
+    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!")
+
+    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.get_message_by_id(ac1.wait_for_incoming_msg_event().msg_id).get_snapshot()
+    assert snapshot.text == "Works again!"
+
+    ac1_contact_ac2 = ac1.get_contact_by_addr(ac2.get_config("addr"))
+    ac1_contact_ac2_snapshot = ac1_contact_ac2.get_snapshot()
+    assert ac1_contact_ac2_snapshot.is_verified
+    assert ac1_contact_ac2_snapshot.verifier_id == ac1.get_contact_by_addr(ac3.get_config("addr")).id
+
+    # ac2 is now verified by ac3 for ac1
+    ac1_contact_ac3 = ac1.get_contact_by_addr(ac3.get_config("addr"))
+    assert ac1_contact_ac2.get_snapshot().verifier_id == ac1_contact_ac3.id
--- a/deltachat-rpc-client/tests/test_something.py
+++ b/deltachat-rpc-client/tests/test_something.py
@@ -358,3 +358,22 @@ def test_openrpc_command_line() -> None:
    openrpc = json.loads(out)
    assert "openrpc" in openrpc
    assert "methods" in openrpc
+
+
+def test_provider_info(rpc) -> None:
+    account_id = rpc.add_account()
+
+    provider_info = rpc.get_provider_info(account_id, "example.org")
+    assert provider_info["id"] == "example.com"
+
+    provider_info = rpc.get_provider_info(account_id, "uep7oiw4ahtaizuloith.org")
+    assert provider_info is None
+
+    # Test MX record resolution.
+    provider_info = rpc.get_provider_info(account_id, "github.com")
+    assert provider_info["id"] == "gmail"
+
+    # Disable MX record resolution.
+    rpc.set_config(account_id, "socks5_enabled", "1")
+    provider_info = rpc.get_provider_info(account_id, "github.com")
+    assert provider_info is None
--- a/deltachat-rpc-client/tox.ini
+++ b/deltachat-rpc-client/tox.ini
@@ -11,7 +11,7 @@ setenv =
 # Avoid stack overflow when Rust core is built without optimizations.
    RUST_MIN_STACK=8388608
 passenv =
-    DCC_NEW_TMP_EMAIL
+    CHATMAIL_DOMAIN
 deps =
    pytest
    pytest-timeout
@@ -28,4 +28,6 @@ commands =
    ruff src/ examples/ tests/

 [pytest]
-timeout = 60
+timeout = 300
+log_cli = true
+log_level = debug
--- a/deltachat-rpc-server/Cargo.toml
+++ b/deltachat-rpc-server/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "deltachat-rpc-server"
-version = "1.124.1"
+version = "1.130.0"
 description = "DeltaChat JSON-RPC server"
 edition = "2021"
 readme = "README.md"
@@ -15,11 +15,11 @@ deltachat = { path = "..", default-features = false }

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

--- a/deny.toml
+++ b/deny.toml
@@ -11,6 +11,7 @@ ignore = [
 # when upgrading.
 # Please keep this list alphabetically sorted.
 skip = [
+     { name = "async-channel", version = "1.9.0" },
     { name = "base16ct", version = "0.1.1" },
     { name = "base64", version = "<0.21" },
     { name = "bitflags", version = "1.3.2" },
@@ -24,7 +25,7 @@ skip = [
     { name = "digest", version = "<0.10" },
     { name = "ed25519-dalek", version = "1.0.1" },
     { name = "ed25519", version = "1.5.3" },
-     { name = "fastrand", version = "1.9.0" },
+     { name = "event-listener", version = "2.5.3" },
     { name = "getrandom", version = "<0.2" },
     { name = "hashbrown", version = "<0.14.0" },
     { name = "indexmap", version = "<2.0.0" },
@@ -34,9 +35,10 @@ skip = [
     { name = "rand_chacha", version = "<0.3" },
     { name = "rand_core", version = "<0.6" },
     { name = "rand", version = "<0.8" },
-     { name = "redox_syscall", version = "0.2.16" },
+     { name = "redox_syscall", version = "0.3.5" },
     { name = "regex-automata", version = "0.1.10" },
     { name = "regex-syntax", version = "0.6.29" },
+     { name = "ring", version = "0.16.20" },
     { name = "sec1", version = "0.3.0" },
     { name = "sha2", version = "<0.10" },
     { name = "signature", version = "1.6.4" },
@@ -45,15 +47,12 @@ skip = [
     { name = "spki", version = "0.6.0" },
     { name = "syn", version = "1.0.109" },
     { name = "time", version = "<0.3" },
+     { name = "untrusted", version = "0.7.1" },
     { name = "wasi", version = "<0.11" },
-     { name = "windows_aarch64_gnullvm", version = "<0.48" },
     { name = "windows_aarch64_msvc", version = "<0.48" },
     { name = "windows_i686_gnu", version = "<0.48" },
     { name = "windows_i686_msvc", version = "<0.48" },
-     { name = "windows-sys", version = "<0.48" },
-     { name = "windows-targets", version = "<0.48" },
     { name = "windows", version = "0.32.0" },
-     { name = "windows_x86_64_gnullvm", version = "<0.48" },
     { name = "windows_x86_64_gnu", version = "<0.48" },
     { name = "windows_x86_64_msvc", version = "<0.48" },
 ]
@@ -87,5 +86,4 @@ license-files = [
 github = [
       "async-email",
       "deltachat",
-       "quinn-rs",
 ]
--- a/draft/aeap-mvp.md
+++ b/draft/aeap-mvp.md
@@ -57,7 +57,7 @@ Note that usually a mail is signed by a key that has a UID matching the from add
 ### Notes:
  
 - We treat protected and non-protected chats the same
- We leave the aeap transition statement away since it seems not to be needed, makes things harder on the sending side, wastes some network traffic, and is worse for privacy (since more pepole know what old addresses you had).
+- We leave the aeap transition statement away since it seems not to be needed, makes things harder on the sending side, wastes some network traffic, and is worse for privacy (since more people know what old addresses you had).
 - As soon as we encrypt read receipts, sending a read receipt will be enough to tell a lot of people that you transitioned
 - AEAP will make the problem of inconsistent group state worse, both because it doesn't work if the message is unencrypted (even if the design allowed it, it would be problematic security-wise) and because some chat partners may have gotten the transition and some not. We should do something against this at some point in the future, like asking the user whether they want to add/remove the members to restore consistent group state.

@@ -108,7 +108,7 @@ The most obvious alternative would be to create a new contact with the new addre
 #### Upsides:
 - With this approach, it's easier to switch to a model where the info about the transition is encoded in the PGP key. Since the key is gossiped, the information about the transition will spread virally.
 - (Also, less important: Slightly faster transition: If you send a message to e.g. "Delta Chat Dev", all members of the "sub-group" "delta android" will know of your transition.)
- It's easier to implement (if too many problems turn up, we can still switch to another approach and didn't wast that much development time.)
+- It's easier to implement (if too many problems turn up, we can still switch to another approach and didn't waste that much development time.)

 [full messages](https://github.com/deltachat/deltachat-core-rust/pull/2896#discussion_r852002161)
  
--- a/node/README.md
+++ b/node/README.md
@@ -40,7 +40,7 @@ npm install deltachat-node

 ## Dependencies

- Nodejs >= `v16.0.0`
+- Nodejs >= `v18.0.0`
 - rustup (optional if you can't use the prebuilds)

 > On Windows, you may need to also install **Perl** to be able to compile deltachat-core.
@@ -113,8 +113,8 @@ Then, in the `deltachat-desktop` repository, run:
 deltachat doesn't support universal (fat) binaries (that contain builds for both cpu architectures) yet, until it does you can use the following workaround to get x86_64 builds:

 ```
-$ fnm install 17 --arch x64
-$ fnm use 17
+$ fnm install 19 --arch x64
+$ fnm use 19
 $ node -p process.arch
 # result should be x64
 $ rustup target add x86_64-apple-darwin
@@ -127,8 +127,8 @@ $ npm run test
 If your node and electron are already build for arm64 you can also try building for arm:

 ```
-$ fnm install 16 --arch arm64
-$ fnm use 16
+$ fnm install 18 --arch arm64
+$ fnm use 18
 $ node -p process.arch
 # result should be arm64
 $ npm_config_arch=arm64 npm run build
@@ -204,10 +204,10 @@ Running `npm test` ends with showing a code coverage report, which is produced b

 The coverage report from `nyc` in the console is rather limited. To get a more detailed coverage report you can run `npm run coverage-html-report`. This will produce a html report from the `nyc` data and display it in a browser on your local machine.

-To run the integration tests you need to set the `DCC_NEW_TMP_EMAIL` environment variables. E.g.:
+To run the integration tests you need to set the `CHATMAIL_DOMAIN` environment variables. E.g.:

 ```
-$ export DCC_NEW_TMP_EMAIL=https://testrun.org/new_email?t=[token]
+$ export CHATMAIL_DOMAIN=chat.example.org
 $ npm run test
 ```

--- a/node/constants.js
+++ b/node/constants.js
@@ -239,6 +239,7 @@ module.exports = {
  DC_STR_MSGGRPNAME: 15,
  DC_STR_MSGLOCATIONDISABLED: 65,
  DC_STR_MSGLOCATIONENABLED: 64,
+  DC_STR_NEW_GROUP_SEND_FIRST_MESSAGE: 172,
  DC_STR_NOMESSAGES: 1,
  DC_STR_NOT_CONNECTED: 121,
  DC_STR_NOT_SUPPORTED_BY_PROVIDER: 113,
--- a/node/lib/constants.ts
+++ b/node/lib/constants.ts
@@ -239,6 +239,7 @@ export enum C {
  DC_STR_MSGGRPNAME = 15,
  DC_STR_MSGLOCATIONDISABLED = 65,
  DC_STR_MSGLOCATIONENABLED = 64,
+  DC_STR_NEW_GROUP_SEND_FIRST_MESSAGE = 172,
  DC_STR_NOMESSAGES = 1,
  DC_STR_NOT_CONNECTED = 121,
  DC_STR_NOT_SUPPORTED_BY_PROVIDER = 113,
--- a/node/lib/context.ts
+++ b/node/lib/context.ts
@@ -36,7 +36,7 @@ export class Context extends EventEmitter {
    }
  }

-  /** Opens a stanalone context (without an account manager)
+  /** Opens a standalone context (without an account manager)
   * automatically starts the event handler */
  static open(cwd: string): Context {
    const dbFile = join(cwd, 'db.sqlite')
--- a/node/test/test.js
+++ b/node/test/test.js
@@ -8,26 +8,17 @@ import { EventId2EventName, C } from '../dist/constants'
 import { join } from 'path'
 import { statSync } from 'fs'
 import { Context } from '../dist/context'
-import fetch from 'node-fetch'
 chai.use(chaiAsPromised)
 chai.config.truncateThreshold = 0 // Do not truncate assertion errors.

-async function createTempUser(url) {
-  async function postData(url = '') {
-    // Default options are marked with *
-    const response = await fetch(url, {
-      method: 'POST', // *GET, POST, PUT, DELETE, etc.
-      headers: {
-        'cache-control': 'no-cache',
-      },
-    })
-    if (!response.ok) {
-      throw new Error('request failed: ' + response.body.read())
-    }
-    return response.json() // parses JSON response into native JavaScript objects
+function createTempUser(chatmailDomain) {
+  const charset = "2345789acdefghjkmnpqrstuvwxyz";
+  let user = "ci-";
+  for (let i = 0; i < 6; i++) {
+    user += charset[Math.floor(Math.random() * charset.length)];
  }
-
-  return await postData(url)
+  const email = user + "@" + chatmailDomain;
+  return { email: email, password: user + "$" + user };
 }

 describe('static tests', function () {
@@ -270,7 +261,7 @@ describe('Basic offline Tests', function () {
      'quota_exceeding',
      'scan_all_folders_debounce_secs',
      'selfavatar',
-      'send_sync_msgs',
+      'sync_msgs',
      'sentbox_watch',
      'show_emails',
      'socks5_enabled',
@@ -676,9 +667,9 @@ describe('Offline Tests with unconfigured account', function () {

    const lot = chatList.getSummary(0)
    strictEqual(lot.getId(), 0, 'lot has no id')
-    strictEqual(lot.getState(), C.DC_STATE_UNDEFINED, 'correct state')
+    strictEqual(lot.getState(), C.DC_STATE_IN_NOTICED, 'correct state')

-    const text = 'No messages.'
+    const text = 'Others will only see this group after you sent a first message.'
    context.createGroupChat('groupchat1111')
    chatList = context.getChatList(0, 'groupchat1111', null)
    strictEqual(
@@ -768,14 +759,7 @@ describe('Integration tests', function () {
  })

  this.beforeAll(async function () {
-    if (!process.env.DCC_NEW_TMP_EMAIL) {
-      console.log(
-        'Missing DCC_NEW_TMP_EMAIL environment variable!, skip integration tests'
-      )
-      this.skip()
-    }
-
-    account = await createTempUser(process.env.DCC_NEW_TMP_EMAIL)
+    account = createTempUser(process.env.CHATMAIL_DOMAIN)
    if (!account || !account.email || !account.password) {
      console.log(
        "We didn't got back an account from the api, skip integration tests"
--- a/node/tsconfig.json
+++ b/node/tsconfig.json
@@ -13,10 +13,10 @@
    },
    "exclude": ["node_modules", "deltachat-core-rust", "dist", "scripts"],
    "typedocOptions": {
-        "mode": "file",
        "out": "docs",
-        "excludeNotExported": true,
+        "excludePrivate": true,
        "defaultCategory": "index",
-        "includeVersion": true
+        "includeVersion": true,
+        "entryPoints": ["lib/index.ts"]
    }
 }
--- a/node/windows.md
+++ b/node/windows.md
@@ -6,7 +6,7 @@ E.g via <https://git-scm.com/download/win>

 ## install node

-Download and install `v16` from <https://nodejs.org/en/>
+Download and install `v18` from <https://nodejs.org/en/>

 ## install rust

--- a/package.json
+++ b/package.json
@@ -2,28 +2,25 @@
  "dependencies": {
    "debug": "^4.1.1",
    "napi-macros": "^2.0.0",
-    "node-gyp-build": "^4.1.0"
+    "node-gyp-build": "^4.6.1"
  },
  "description": "node.js bindings for deltachat-core",
  "devDependencies": {
    "@types/debug": "^4.1.7",
-    "@types/node": "^16.11.26",
+    "@types/node": "^20.8.10",
    "chai": "^4.2.0",
    "chai-as-promised": "^7.1.1",
    "esm": "^3.2.25",
-    "hallmark": "^2.0.0",
    "mocha": "^8.2.1",
-    "node-fetch": "^2.6.7",
-    "node-gyp": "^9.0.0",
-    "opn-cli": "^5.0.0",
-    "prebuildify": "^3.0.0",
-    "prebuildify-ci": "^1.0.4",
-    "prettier": "^2.0.5",
-    "typedoc": "^0.17.0",
-    "typescript": "^3.9.10"
+    "node-gyp": "^10.0.0",
+    "prebuildify": "^5.0.1",
+    "prebuildify-ci": "^1.0.5",
+    "prettier": "^3.0.3",
+    "typedoc": "^0.25.3",
+    "typescript": "^5.2.2"
  },
  "engines": {
-    "node": ">=16.0.0"
+    "node": ">=18.0.0"
  },
  "files": [
    "node/scripts/*",
@@ -49,16 +46,15 @@
    "build:core:rust": "node node/scripts/rebuild-core.js",
    "clean": "rm -rf node/dist node/build node/prebuilds node/node_modules ./target",
    "download-prebuilds": "prebuildify-ci download",
-    "hallmark": "hallmark --fix",
    "install": "node node/scripts/install.js",
    "install:prebuilds": "cd node && node-gyp-build \"npm run build:core\" \"npm run build:bindings:c:postinstall\"",
    "lint": "prettier --check \"node/lib/**/*.{ts,tsx}\"",
    "lint-fix": "prettier --write \"node/lib/**/*.{ts,tsx}\" \"node/test/**/*.js\"",
-    "prebuildify": "cd node && prebuildify -t 16.13.0 --napi --strip --postinstall \"node scripts/postinstall.js --prebuild\"",
+    "prebuildify": "cd node && prebuildify -t 18.0.0 --napi --strip --postinstall \"node scripts/postinstall.js --prebuild\"",
    "test": "npm run test:lint && npm run test:mocha",
    "test:lint": "npm run lint",
    "test:mocha": "mocha -r esm node/test/test.js --growl --reporter=spec --bail --exit"
  },
  "types": "node/dist/index.d.ts",
-  "version": "1.124.1"
+  "version": "1.130.0"
 }
--- a/python/README.rst
+++ b/python/README.rst
@@ -53,14 +53,14 @@ end-to-end tests that require accounts on real e-mail servers.
 Running "live" tests with temporary accounts
 --------------------------------------------

-If you want to run live functional tests you can set ``DCC_NEW_TMP_EMAIL`` to a URL that creates e-mail accounts.  Most developers use https://testrun.org URLs created and managed by `mailadm <https://mailadm.readthedocs.io/>`_.
+If you want to run live functional tests
+you can set ``CHATMAIL_DOMAIN`` to a domain of the email server
+that creates e-mail accounts like this::

-Please feel free to contact us through a github issue or by e-mail and we'll send you a URL that you can then use for functional tests like this::
+    export CHATMAIL_DOMAIN=nine.testrun.org

-    export DCC_NEW_TMP_EMAIL=<URL you got from us>
-
-With this account-creation setting, pytest runs create ephemeral e-mail accounts on the http://testrun.org server.
-These accounts are removed automatically as they expire.
+With this account-creation setting, pytest runs create ephemeral e-mail accounts on the server.
+These accounts have the pattern `ci-{6 characters}@{CHATMAIL_DOMAIN}`.
 After setting the variable, either rerun `scripts/run-python-test.sh`
 or run offline and online tests with `tox` directly::

@@ -159,6 +159,6 @@ find it with::

 This docker image can be used to run tests and build Python wheels for all interpreters::

-    $ docker run -e DCC_NEW_TMP_EMAIL \
+    $ docker run -e CHATMAIL_DOMAIN \
       --rm -it -v $(pwd):/mnt -w /mnt \
       deltachat/coredeps scripts/run_all.sh
--- a/python/src/deltachat/account.py
+++ b/python/src/deltachat/account.py
@@ -571,11 +571,11 @@ class Account:
        return ScannedQRCode(lot)

    def qr_setup_contact(self, qr):
-        """setup contact and return a Chat after contact is established.
+        """setup contact and return a `Chat` instance after contact is established.
+
+        This function triggers a network protocol in the background between
+        the emitter of the QR code and this account.

-        Note that this function may block for a long time as messages are exchanged
-        with the emitter of the QR code.  On success a :class:`deltachat.chat.Chat` instance
-        is returned.
        :param qr: valid "setup contact" QR code (all other QR codes will result in an exception)
        """
        assert self.check_qr(qr).is_ask_verifycontact()
@@ -585,11 +585,11 @@ class Account:
        return Chat(self, chat_id)

    def qr_join_chat(self, qr):
-        """join a chat group through a QR code.
+        """return a `Chat` instance for which the securejoin network
+        protocol has been started.

-        Note that this function may block for a long time as messages are exchanged
-        with the emitter of the QR code.  On success a :class:`deltachat.chat.Chat` instance
-        is returned which is the chat that we just joined.
+        This function triggers a network protocol in the background between
+        the emitter of the QR code and this account.

        :param qr: valid "join-group" QR code (all other QR codes will result in an exception)
        """
@@ -617,18 +617,18 @@ class Account:
    # meta API for start/stop and event based processing
    #

-    def run_account(self, addr=None, password=None, account_plugins=None, show_ffi=False):
-        from .events import FFIEventLogger
-
+    def run_account(self, addr=None, password=None, account_plugins=None, show_ffi=False, displayname=None):
        """get the account running, configure it if necessary. add plugins if provided.

        :param addr: the email address of the account
        :param password: the password of the account
        :param account_plugins: a list of plugins to add
        :param show_ffi: show low level ffi events
+        :param displayname: the display name of the account
        """
+        from .events import FFIEventLogger
+
        if show_ffi:
-            self.set_config("displayname", "bot")
            log = FFIEventLogger(self)
            self.add_account_plugin(log)

@@ -644,6 +644,8 @@ class Account:
            configtracker = self.configure()
            configtracker.wait_finish()

+        if displayname:
+            self.set_config("displayname", displayname)
        # start IO threads and configure if necessary
        self.start_io()

--- a/python/src/deltachat/testplugin.py
+++ b/python/src/deltachat/testplugin.py
@@ -8,11 +8,11 @@ import sys
 import threading
 import time
 import weakref
+import random
 from queue import Queue
 from typing import Callable, Dict, List, Optional, Set

 import pytest
-import requests
 from _pytest._code import Source

 import deltachat
@@ -24,10 +24,10 @@ from .events import FFIEventLogger, FFIEventTracker
 def pytest_addoption(parser):
    group = parser.getgroup("deltachat testplugin options")
    group.addoption(
-        "--liveconfig",
+        "--chatmail",
        action="store",
        default=None,
-        help="a file with >=2 lines where each line contains NAME=VALUE config settings for one account",
+        help="chatmail server domain name",
    )
    group.addoption(
        "--ignored",
@@ -52,11 +52,11 @@ def pytest_addoption(parser):


 def pytest_configure(config):
-    cfg = config.getoption("--liveconfig")
+    cfg = config.getoption("--chatmail")
    if not cfg:
-        cfg = os.getenv("DCC_NEW_TMP_EMAIL")
+        cfg = os.getenv("CHATMAIL_DOMAIN")
        if cfg:
-            config.option.liveconfig = cfg
+            config.option.chatmail = cfg

    # Make sure we don't get garbled output because threads keep running
    # collect all ever created accounts in a weakref-set (so we don't
@@ -125,13 +125,10 @@ def pytest_report_header(config, startdir):
        ),
    ]

-    cfg = config.option.liveconfig
-    if cfg:
-        if "?" in cfg:
-            url, token = cfg.split("?", 1)
-            summary.append(f"Liveconfig provider: {url}?<token omitted>")
-        else:
-            summary.append(f"Liveconfig file: {cfg}")
+    chatmail_opt = config.getoption("--chatmail")
+    if chatmail_opt:
+        summary.append(f"Chatmail account provider: {chatmail_opt}")
+
    return summary


@@ -156,38 +153,29 @@ class TestProcess:
    def get_liveconfig_producer(self):
        """provide live account configs, cached on a per-test-process scope
        so that test functions can re-use already known live configs.
-        Depending on the --liveconfig option this comes from
-        a HTTP provider or a file with a line specifying each accounts config.
        """
-        liveconfig_opt = self.pytestconfig.getoption("--liveconfig")
-        if not liveconfig_opt:
-            pytest.skip("specify DCC_NEW_TMP_EMAIL or --liveconfig to provide live accounts")
-
-        if not liveconfig_opt.startswith("http"):
-            for line in open(liveconfig_opt):
-                if line.strip() and not line.strip().startswith("#"):
-                    d = {}
-                    for part in line.split():
-                        name, value = part.split("=")
-                        d[name] = value
-                    self._configlist.append(d)
-
-            yield from iter(self._configlist)
-        else:
+        chatmail_opt = self.pytestconfig.getoption("--chatmail")
+        if chatmail_opt:
+            # Use a chatmail instance.
+            domain = chatmail_opt
            MAX_LIVE_CREATED_ACCOUNTS = 10
            for index in range(MAX_LIVE_CREATED_ACCOUNTS):
                try:
                    yield self._configlist[index]
                except IndexError:
-                    res = requests.post(liveconfig_opt, timeout=60)
-                    if res.status_code != 200:
-                        pytest.fail(f"newtmpuser count={index} code={res.status_code}: '{res.text}'")
-                    d = res.json()
-                    config = {"addr": d["email"], "mail_pw": d["password"]}
+                    part = "".join(random.choices("2345789acdefghjkmnpqrstuvwxyz", k=6))
+                    username = f"ci-{part}"
+                    password = f"{username}${username}"
+                    addr = f"{username}@{domain}"
+                    config = {"addr": addr, "mail_pw": password}
                    print("newtmpuser {}: addr={}".format(index, config["addr"]))
                    self._configlist.append(config)
                    yield config
            pytest.fail(f"more than {MAX_LIVE_CREATED_ACCOUNTS} live accounts requested.")
+        else:
+            pytest.skip(
+                "specify CHATMAIL_DOMAIN or --chatmail to provide live accounts",
+            )

    def cache_maybe_retrieve_configured_db_files(self, cache_addr, db_target_path):
        db_target_path = pathlib.Path(db_target_path)
@@ -533,6 +521,7 @@ class ACFactory:
        configdict.setdefault("bcc_self", False)
        configdict.setdefault("mvbox_move", False)
        configdict.setdefault("sentbox_watch", False)
+        configdict.setdefault("sync_msgs", False)
        ac.update_config(configdict)
        self._preconfigure_key(ac, configdict["addr"])
        return ac
--- a/python/tests/test_0_complex_or_slow.py
+++ b/python/tests/test_0_complex_or_slow.py
@@ -140,6 +140,10 @@ def test_qr_verified_group_and_chatting(acfactory, lp):
    assert msg.is_system_message()
    assert "added" in msg.text.lower()

+    assert any(
+        m.is_system_message() and m.text == "Messages are guaranteed to be end-to-end encrypted from now on."
+        for m in msg.chat.get_messages()
+    )
    lp.sec("ac1: send message")
    msg_out = chat1.send_text("hello")
    assert msg_out.is_encrypted()
@@ -542,8 +546,6 @@ def test_see_new_verified_member_after_going_online(acfactory, tmp_path, lp):
    assert msg_in.text == msg_out.text
    assert msg_in.get_sender_contact().addr == ac2_addr

-    ac1.set_config("bcc_self", "0")
-

 def test_use_new_verified_group_after_going_online(acfactory, tmp_path, lp):
    """Another test for the bug #3836:
@@ -582,6 +584,7 @@ def test_use_new_verified_group_after_going_online(acfactory, tmp_path, lp):
    assert msg_in.get_sender_contact().addr == ac1.get_config("addr")
    chat2 = msg_in.chat
    assert chat2.is_protected()
+    assert chat2.get_messages()[0].text == "Messages are guaranteed to be end-to-end encrypted from now on."

    lp.sec("ac2_offl: sending message")
    msg_out = chat2.send_text("hello")
@@ -592,4 +595,76 @@ def test_use_new_verified_group_after_going_online(acfactory, tmp_path, lp):
    assert msg_in.get_sender_contact().addr == ac2.get_config("addr")
    assert msg_in.text == msg_out.text

-    ac2.set_config("bcc_self", "0")
+
+def test_verified_group_vs_delete_server_after(acfactory, tmp_path, lp):
+    """Test for the issue #4346:
+    - User is added to a verified group.
+    - First device of the user downloads "member added" from the group.
+    - First device removes "member added" from the server.
+    - Some new messages are sent to the group.
+    - Second device comes online, receives these new messages. The result is a verified group with unverified members.
+    - First device re-gossips Autocrypt keys to the group.
+    - Now the seconds device has all members verified.
+    """
+    ac1, ac2 = acfactory.get_online_accounts(2)
+    ac2_offl = acfactory.new_online_configuring_account(cloned_from=ac2)
+    for ac in [ac2, ac2_offl]:
+        ac.set_config("bcc_self", "1")
+    ac2.set_config("delete_server_after", "1")
+    ac2.set_config("gossip_period", "0")  # Re-gossip in every message
+    acfactory.bring_accounts_online()
+    dir = tmp_path / "exportdir"
+    dir.mkdir()
+    ac2.export_self_keys(str(dir))
+    ac2_offl.import_self_keys(str(dir))
+    ac2_offl.stop_io()
+
+    lp.sec("ac1: create verified-group QR, ac2 scans and joins")
+    chat1 = ac1.create_group_chat("hello", verified=True)
+    assert chat1.is_protected()
+    qr = chat1.get_join_qr()
+    lp.sec("ac2: start QR-code based join-group protocol")
+    chat2 = ac2.qr_join_chat(qr)
+    ac1._evtracker.wait_securejoin_inviter_progress(1000)
+    # Wait for "Member Me (<addr>) added by <addr>." message.
+    msg_in = ac2._evtracker.wait_next_incoming_message()
+    assert msg_in.is_system_message()
+
+    lp.sec("ac2: waiting for 'member added' to be deleted on the server")
+    ac2._evtracker.get_matching("DC_EVENT_IMAP_MESSAGE_DELETED")
+
+    lp.sec("ac1: sending 'hi' to the group")
+    ac2.set_config("delete_server_after", "0")
+    chat1.send_text("hi")
+
+    lp.sec("ac2_offl: going online, checking the 'hi' message")
+    ac2_offl.start_io()
+    msg_in = ac2_offl._evtracker.wait_next_incoming_message()
+    assert not msg_in.is_system_message()
+    assert msg_in.text.startswith("[The message was sent with non-verified encryption")
+    ac2_offl_ac1_contact = msg_in.get_sender_contact()
+    assert ac2_offl_ac1_contact.addr == ac1.get_config("addr")
+    assert not ac2_offl_ac1_contact.is_verified()
+    chat2_offl = msg_in.chat
+    assert chat2_offl.is_protected()
+
+    lp.sec("ac2: sending message re-gossiping Autocrypt keys")
+    chat2.send_text("hi2")
+
+    lp.sec("ac2_offl: receiving message")
+    ev = ac2_offl._evtracker.get_matching("DC_EVENT_INCOMING_MSG|DC_EVENT_MSGS_CHANGED")
+    msg_in = ac2_offl.get_message_by_id(ev.data2)
+    assert msg_in.is_system_message()
+    assert msg_in.text == "Messages are guaranteed to be end-to-end encrypted from now on."
+
+    # We need to consume one event that has data2=0
+    ev = ac2_offl._evtracker.get_matching("DC_EVENT_INCOMING_MSG|DC_EVENT_MSGS_CHANGED")
+    assert ev.data2 == 0
+
+    ev = ac2_offl._evtracker.get_matching("DC_EVENT_INCOMING_MSG|DC_EVENT_MSGS_CHANGED")
+    msg_in = ac2_offl.get_message_by_id(ev.data2)
+    assert not msg_in.is_system_message()
+    assert msg_in.text == "hi2"
+    assert msg_in.chat == chat2_offl
+    assert msg_in.get_sender_contact().addr == ac2.get_config("addr")
+    assert ac2_offl_ac1_contact.is_verified()
--- a/python/tests/test_1_online.py
+++ b/python/tests/test_1_online.py
@@ -367,7 +367,7 @@ def test_webxdc_download_on_demand(acfactory, data, lp):

    lp.sec("ac2 sets download limit")
    ac2.set_config("download_limit", "100")
-    assert msg1.send_status_update({"payload": base64.b64encode(os.urandom(50000))}, "some test data")
+    assert msg1.send_status_update({"payload": base64.b64encode(os.urandom(300000))}, "some test data")
    ac2_update = ac2._evtracker.wait_next_incoming_message()
    assert ac2_update.download_state == dc.const.DC_DOWNLOAD_AVAILABLE
    assert not msg2.get_status_updates()
@@ -489,7 +489,7 @@ def test_forward_messages(acfactory, lp):
    lp.sec("ac2: check new chat has a forwarded message")
    assert chat3.is_promoted()
    messages = chat3.get_messages()
-    assert len(messages) == 1
+    assert len(messages) == 2
    msg = messages[-1]
    assert msg.is_forwarded()
    ac2.delete_messages(messages)
@@ -1445,7 +1445,7 @@ def test_reaction_to_partially_fetched_msg(acfactory, lp, tmp_path):
      message, then processes a partially downloaded message.
    - As a result, Bob does not see a reaction
    """
-    download_limit = 32768
+    download_limit = 300000
    ac1, ac2 = acfactory.get_online_accounts(2)
    ac1_addr = ac1.get_config("addr")
    chat = ac1.create_chat(ac2)
@@ -1699,6 +1699,59 @@ def test_qr_join_chat(acfactory, lp, verified_one_on_one_chats):
    assert not ch.is_protected()


+def test_qr_join_chat_with_pending_bobstate_issue4894(acfactory, lp):
+    ac1, ac2, ac3, ac4 = acfactory.get_online_accounts(4)
+
+    lp.sec("ac3: verify with ac2")
+    ac3.qr_setup_contact(ac2.get_setup_contact_qr())
+    ac2._evtracker.wait_securejoin_inviter_progress(1000)
+
+    # in order for ac2 to have pending bobstate with a verified group
+    # we first create a fully joined verified group, and then start
+    # joining a second time but interrupt it, to create pending bob state
+
+    lp.sec("ac1: create verified group that ac2 fully joins")
+    ch1 = ac1.create_group_chat("ac1-shutoff group", verified=True)
+    ac2.qr_join_chat(ch1.get_join_qr())
+    ac1._evtracker.wait_securejoin_inviter_progress(1000)
+
+    # ensure ac1 can write and ac2 receives messages in verified chat
+    ch1.send_text("ac1 says hello")
+    while 1:
+        msg = ac2.wait_next_incoming_message()
+        if msg.text == "ac1 says hello":
+            assert msg.chat.is_protected()
+            break
+
+    lp.sec("ac1: let ac2 join again but shutoff ac1 in the middle of securejoin")
+    ac2.qr_join_chat(ch1.get_join_qr())
+    ac1.shutdown()
+    lp.sec("ac2 now has pending bobstate but ac1 is shutoff")
+
+    # we meanwhile expect ac3/ac2 verification started in the beginning to have completed
+    assert ac3.get_contact(ac2).is_verified()
+    assert ac2.get_contact(ac3).is_verified()
+
+    lp.sec("ac3: create a verified group VG with ac2")
+    vg = ac3.create_group_chat("ac3-created", [ac2], verified=True)
+
+    # ensure ac2 receives message in VG
+    vg.send_text("hello")
+    while 1:
+        msg = ac2.wait_next_incoming_message()
+        if msg.text == "hello":
+            assert msg.chat.is_protected()
+            break
+
+    lp.sec("ac3: create a join-code for group VG and let ac4 join, check that ac2 got it")
+    ac4.qr_join_chat(vg.get_join_qr())
+    ac3._evtracker.wait_securejoin_inviter_progress(1000)
+    while 1:
+        ev = ac2._evtracker.get()
+        if "added by unrelated SecureJoin" in str(ev):
+            return
+
+
 def test_qr_new_group_unblocked(acfactory, lp):
    """Regression test for a bug intoduced in core v1.113.0.
    ac2 scans a verified group QR code created by ac1.
@@ -1718,12 +1771,10 @@ def test_qr_new_group_unblocked(acfactory, lp):

    ac1_new_chat = ac1.create_group_chat("Another group")
    ac1_new_chat.add_contact(ac2)
-    ac1_new_chat.send_text("Hello!")
-
    # Receive "Member added" message.
    ac2._evtracker.wait_next_incoming_message()

-    # Receive "Hello!" message.
+    ac1_new_chat.send_text("Hello!")
    ac2_msg = ac2._evtracker.wait_next_incoming_message()
    assert ac2_msg.text == "Hello!"
    assert ac2_msg.chat.is_contact_request()
@@ -1906,7 +1957,7 @@ def test_system_group_msg_from_blocked_user(acfactory, lp):
    chat_on_ac2.send_text("This will arrive")
    msg = ac1._evtracker.wait_next_incoming_message()
    assert msg.text == "This will arrive"
-    message_texts = [m.text for m in chat_on_ac1.get_messages()]
+    message_texts = [m.text for m in chat_on_ac1.get_messages() if not m.is_system_message()]
    assert len(message_texts) == 2
    assert "First group message" in message_texts
    assert "This will arrive" in message_texts
@@ -1946,13 +1997,15 @@ def test_set_get_group_image(acfactory, data, lp):
    lp.sec("ac1: add ac2 to promoted group chat")
    chat.add_contact(ac2)  # sends one message

+    lp.sec("ac2: wait for receiving member added message from ac1")
+    msg1 = ac2._evtracker.wait_next_incoming_message()
+    assert msg1.is_system_message()  # Member added
+
    lp.sec("ac1: send a first message to ac2")
    chat.send_text("hi")  # sends another message
    assert chat.is_promoted()

    lp.sec("ac2: wait for receiving message from ac1")
-    msg1 = ac2._evtracker.wait_next_incoming_message()
-    assert msg1.is_system_message()  # Member added
    msg2 = ac2._evtracker.wait_next_incoming_message()
    assert msg2.text == "hi"
    assert msg1.chat.id == msg2.chat.id
@@ -2208,7 +2261,17 @@ def test_delete_multiple_messages(acfactory, lp):

 def test_trash_multiple_messages(acfactory, lp):
    ac1, ac2 = acfactory.get_online_accounts(2)
+
+    # Create the Trash folder on IMAP server
+    # and recreate the account so Trash folder is configured.
+    lp.sec("Creating trash folder")
+    ac2.direct_imap.create_folder("Trash")
+    lp.sec("Creating new accounts")
+    ac2 = acfactory.new_online_configuring_account(cloned_from=ac2)
+    acfactory.bring_accounts_online()
+
    ac2.set_config("delete_to_trash", "1")
+    assert ac2.get_config("configured_trash_folder")
    chat12 = acfactory.get_accepted_chat(ac1, ac2)

    lp.sec("ac1: sending 3 messages")
@@ -2239,13 +2302,15 @@ def test_trash_multiple_messages(acfactory, lp):


 def test_configure_error_msgs_wrong_pw(acfactory):
-    configdict = acfactory.get_next_liveconfig()
-    ac1 = acfactory.get_unconfigured_account()
-    ac1.update_config(configdict)
-    ac1.set_config("mail_pw", "abc")  # Wrong mail pw
-    ac1.configure()
+    (ac1,) = acfactory.get_online_accounts(1)
+
+    ac2 = acfactory.get_unconfigured_account()
+    ac2.set_config("addr", ac1.get_config("addr"))
+    ac2.set_config("mail_pw", "abc")  # Wrong mail pw
+    ac2.configure()
    while True:
-        ev = ac1._evtracker.get_matching("DC_EVENT_CONFIGURE_PROGRESS")
+        ev = ac2._evtracker.get_matching("DC_EVENT_CONFIGURE_PROGRESS")
+        print(f"Configuration progress: {ev.data1}")
        if ev.data1 == 0:
            break
    # Password is wrong so it definitely has to say something about "password"
@@ -2548,7 +2613,7 @@ class TestOnlineConfigureFails:
    def test_invalid_user(self, acfactory):
        configdict = acfactory.get_next_liveconfig()
        ac1 = acfactory.get_unconfigured_account()
-        configdict["addr"] = "x" + configdict["addr"]
+        configdict["addr"] = "$" + configdict["addr"]
        ac1.update_config(configdict)
        configtracker = ac1.configure()
        configtracker.wait_progress(500)
@@ -2557,7 +2622,7 @@ class TestOnlineConfigureFails:
    def test_invalid_domain(self, acfactory):
        configdict = acfactory.get_next_liveconfig()
        ac1 = acfactory.get_unconfigured_account()
-        configdict["addr"] += "x"
+        configdict["addr"] += "$"
        ac1.update_config(configdict)
        configtracker = ac1.configure()
        configtracker.wait_progress(500)
--- a/python/tests/test_2_increation.py
+++ b/python/tests/test_2_increation.py
@@ -26,7 +26,7 @@ def wait_msgs_changed(account, msgs_list):
                    break
        else:
            account.log(f"waiting mismatch data1={data1} data2={data2}")
-    return ev.data1, ev.data2
+    return ev.data2


 class TestOnlineInCreation:
@@ -68,14 +68,17 @@ class TestOnlineInCreation:
        assert prepared_original.is_out_preparing()
        wait_msgs_changed(ac1, [(chat.id, prepared_original.id)])

-        lp.sec("forward the message while still in creation")
+        lp.sec("create a new group")
        chat2 = ac1.create_group_chat("newgroup")
+        wait_msgs_changed(ac1, [(0, 0)])
+
+        lp.sec("add a contact to new group")
        chat2.add_contact(ac2)
-        wait_msgs_changed(ac1, [(0, 0)])  # why not chat id?
+        wait_msgs_changed(ac1, [(chat2.id, None)])
+
+        lp.sec("forward the message while still in creation")
        ac1.forward_messages([prepared_original], chat2)
-        # XXX there might be two EVENT_MSGS_CHANGED and only one of them
-        # is the one caused by forwarding
-        _, forwarded_id = wait_msgs_changed(ac1, [(chat2.id, None)])
+        forwarded_id = wait_msgs_changed(ac1, [(chat2.id, None)])
        forwarded_msg = ac1.get_message_by_id(forwarded_id)
        assert forwarded_msg.is_out_preparing()

--- a/python/tests/test_3_offline.py
+++ b/python/tests/test_3_offline.py
@@ -5,8 +5,6 @@ from datetime import datetime, timedelta, timezone
 import pytest

 import deltachat as dc
-from deltachat.capi import ffi, lib
-from deltachat.cutil import iter_array
 from deltachat.tracker import ImexFailed
 from deltachat import Account, account_hookimpl, Message

@@ -802,6 +800,7 @@ class TestOfflineChat:
    def test_audit_log_view_without_daymarker(self, ac1, lp):
        lp.sec("ac1: test audit log (show only system messages)")
        chat = ac1.create_group_chat(name="audit log sample data")
+
        # promote chat
        chat.send_text("hello")
        assert chat.is_promoted()
@@ -811,12 +810,6 @@ class TestOfflineChat:
        chat.set_name("audit log test group")
        chat.send_text("a message in between")

-        lp.sec("check message count of all messages")
-        assert len(chat.get_messages()) == 4
-
        lp.sec("check message count of only system messages (without daymarkers)")
-        dc_array = ffi.gc(
-            lib.dc_get_chat_msgs(ac1._dc_context, chat.id, dc.const.DC_GCM_INFO_ONLY, 0),
-            lib.dc_array_unref,
-        )
-        assert len(list(iter_array(dc_array, lambda x: x))) == 2
+        sysmessages = [x for x in chat.get_messages() if x.is_system_message()]
+        assert len(sysmessages) == 3
--- a/python/tox.ini
+++ b/python/tox.ini
@@ -16,7 +16,7 @@ setenv =
 passenv = 
    DCC_RS_DEV
    DCC_RS_TARGET
-    DCC_NEW_TMP_EMAIL 
+    CHATMAIL_DOMAIN
    CARGO_TARGET_DIR
    RUSTC_WRAPPER
 deps = 
@@ -85,7 +85,7 @@ commands =
 addopts = -v -ra --strict-markers
 norecursedirs = .tox 
 xfail_strict=true
-timeout = 150
+timeout = 300
 timeout_func_only = True
 markers = 
    ignored: ignore this test in default test runs, use --ignored to run.
--- a/release-date.in
+++ b/release-date.in
@@ -1 +1 @@
-2023-10-05
+2023-11-10
--- a/scripts/README.md
+++ b/scripts/README.md
@@ -6,30 +6,31 @@ and an own build machine.

 ## Description of scripts 

-Scripts should be ran from the root of the repository,
-for example:
-```
-$ scripts/clippy.sh
-```
-
 - `clippy.sh` runs `cargo clippy` for all Rust code in the project.

 - `deny.sh` runs `cargo deny` for all Rust code in the project.

- `benchmark-tests.sh`
+- `codespell.sh` spellchecks the source code using `codespell` tool.

 - `../.github/workflows` contains jobs run by GitHub Actions.

+- `run-python-test.sh` runs CFFI Python tests.
+
+- `run-rpc-test.sh` runs JSON-RPC Python tests.
+
+- `make-python-testenv.sh` creates a local python test development environment with CFFI bindings.
+  Reusing the same environment is faster than running `run-python-test.sh` which always
+  recreates environment from scratch and runs additional lints.
+
+- `make-rpc-testenv.sh` creates a local python development environment with JSON-RPC bindings,
+   i.e. `deltachat-rpc-client` and `deltachat-rpc-server`.
+
 - `remote_tests_python.sh` rsyncs to a build machine and runs
  `run-python-test.sh` remotely on the build machine. 

 - `remote_tests_rust.sh` rsyncs to the build machine and runs
  `run-rust-test.sh` remotely on the build machine. 

- `make-python-testenv.sh` creates or updates local python test development environment.
-  Reusing the same environment is faster than running `run-python-test.sh` which always
-  recreates environment from scratch and runs additional lints.
-
 - `run-doxygen.sh` generates C-docs which are then uploaded to https://c.delta.chat/

 - `run_all.sh` builds Python wheels
--- a/scripts/benchmark-tests.sh
+++ b/scripts/benchmark-tests.sh
@@ -1,8 +0,0 @@
-#!/bin/sh
-# Benchmark the tests with `hyperfine`.
-
-set -e
-
-# `--tests` selects unit tests but not the documentation tests.
-# `--skip` arguments skip online tests.
-hyperfine --warmup 1 --min-runs 20 "cargo test --tests --release -- --skip imex::transfer::tests::test_drop_provider --skip imex::transfer::tests::test_send_receive --skip oauth2::tests::test_oauth_from_mx --skip oauth2::tests::test_get_oauth2_token --skip oauth2::tests::test_get_oauth2_addr --skip configure::tests::test_no_panic_on_bad_credentials --skip qr_code_generator::tests::test_generate_backup_qr"
--- a/scripts/concourse/docs_wheels.yml
+++ b/scripts/concourse/docs_wheels.yml
@@ -3,14 +3,14 @@ resources:
    type: git
    icon: github
    source:
-      branch: master
+      branch: main
      uri: https://github.com/deltachat/deltachat-core-rust.git

  - name: deltachat-core-rust-release
    type: git
    icon: github
    source:
-      branch: master
+      branch: main
      uri: https://github.com/deltachat/deltachat-core-rust.git
      tag_filter: "v*"

--- a/scripts/make-python-testenv.sh
+++ b/scripts/make-python-testenv.sh
@@ -4,8 +4,8 @@
 # It rebuilds the core and bindings as needed.
 #
 # After running the script, you can either
-# run `pytest` directly with `env/bin/pytest python/`
-# or activate the environment with `. env/bin/activacte`
+# run `pytest` directly with `venv/bin/pytest python/`
+# or activate the environment with `. venv/bin/activate`
 # and run `pytest` from there.
 set -euo pipefail

@@ -13,9 +13,5 @@ export DCC_RS_TARGET=debug
 export DCC_RS_DEV="$PWD"
 cargo build -p deltachat_ffi --features jsonrpc

-if test -d env; then
-	env/bin/pip install -e python --force-reinstall
-else
-	tox -e py --devenv env
-	env/bin/pip install --upgrade pip
-fi
+tox -c python -e py --devenv venv
+venv/bin/pip install --upgrade pip
--- a/scripts/make-rpc-testenv.sh
+++ b/scripts/make-rpc-testenv.sh
@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+tox -c deltachat-rpc-client -e py --devenv venv
+venv/bin/pip install --upgrade pip
+cargo install --path deltachat-rpc-server/ --root "$PWD/venv" --debug
--- a/scripts/remote_tests_python.sh
+++ b/scripts/remote_tests_python.sh
@@ -28,7 +28,7 @@ ssh $SSHTARGET <<_HERE
    export RUSTC_WRAPPER=\`which sccache\`
    cd $BUILDDIR
    export TARGET=release
-    export DCC_NEW_TMP_EMAIL=$DCC_NEW_TMP_EMAIL
+    export CHATMAIL_DOMAIN=$CHATMAIL_DOMAIN

    #we rely on tox/virtualenv being available in the host
    #rm -rf virtualenv venv
--- a/scripts/run-rpc-test.sh
+++ b/scripts/run-rpc-test.sh
@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+set -euo pipefail
+cargo install --path deltachat-rpc-server/ --root "$PWD/venv" --debug
+PATH="$PWD/venv/bin:$PATH" tox -c deltachat-rpc-client
--- a/scripts/run_all.sh
+++ b/scripts/run_all.sh
@@ -27,7 +27,7 @@ mkdir -p $TOXWORKDIR
 # XXX we may switch on some live-tests on for better ensurances 
 # Note that the independent remote_tests_python step does all kinds of
 # live-testing already. 
-unset DCC_NEW_TMP_EMAIL
+unset CHATMAIL_DOMAIN

 # Try to build wheels for a range of interpreters, but don't fail if they are not available.
 # E.g. musllinux_1_1 does not have PyPy interpreters as of 2022-07-10
--- a/scripts/update-provider-database.sh
+++ b/scripts/update-provider-database.sh
@@ -6,7 +6,7 @@ set -euo pipefail
 export TZ=UTC

 # Provider database revision.
-REV=3c8f7e846c915a183dc44536fb5480d1f25d7c42
+REV=18f714cf73d0bdfb8b013fa344494ab80c92b477

 CORE_ROOT="$PWD"
 TMP="$(mktemp -d)"
--- a/scripts/wheel-rpc-server.py
+++ b/scripts/wheel-rpc-server.py
@@ -0,0 +1,197 @@
+#!/usr/bin/env python3
+"""Build Python wheels for deltachat-rpc-server.
+Run scripts/zig-rpc-server.sh first."""
+from pathlib import Path
+from wheel.wheelfile import WheelFile
+import tomllib
+import tarfile
+from io import BytesIO
+
+
+def metadata_contents(version):
+    return f"""Metadata-Version: 2.1
+Name: deltachat-rpc-server
+Version: {version}
+Summary: Delta Chat JSON-RPC server
+"""
+
+
+def build_source_package(version):
+    filename = f"dist/deltachat-rpc-server-{version}.tar.gz"
+
+    with tarfile.open(filename, "w:gz") as pkg:
+
+        def pack(name, contents):
+            contents = contents.encode()
+            tar_info = tarfile.TarInfo(f"deltachat-rpc-server-{version}/{name}")
+            tar_info.mode = 0o644
+            tar_info.size = len(contents)
+            pkg.addfile(tar_info, BytesIO(contents))
+
+        pack("PKG-INFO", metadata_contents(version))
+        pack(
+            "pyproject.toml",
+            f"""[build-system]
+requires = ["setuptools==68.2.2", "pip"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "deltachat-rpc-server"
+version = "{version}"
+
+[project.scripts]
+deltachat-rpc-server = "deltachat_rpc_server:main"
+""",
+        )
+        pack(
+            "setup.py",
+            f"""
+import sys
+from setuptools import setup, find_packages
+from distutils.cmd import Command
+from setuptools.command.install import install
+from setuptools.command.build import build
+import subprocess
+import platform
+import tempfile
+from zipfile import ZipFile
+from pathlib import Path
+import shutil
+
+
+class BuildCommand(build):
+    def run(self):
+        tmpdir = tempfile.mkdtemp()
+        subprocess.run(
+            [
+                sys.executable,
+                "-m",
+                "pip",
+                "download",
+                "--no-input",
+                "--timeout",
+                "1000",
+                "--platform",
+                "musllinux_1_1_" + platform.machine(),
+                "--only-binary=:all:",
+                "deltachat-rpc-server=={version}",
+            ],
+            cwd=tmpdir,
+        )
+
+        wheel_path = next(Path(tmpdir).glob("*.whl"))
+        with ZipFile(wheel_path, "r") as wheel:
+            exe_path = wheel.extract("deltachat_rpc_server/deltachat-rpc-server", "src")
+            Path(exe_path).chmod(0o700)
+            wheel.extract("deltachat_rpc_server/__init__.py", "src")
+
+        shutil.rmtree(tmpdir)
+        return super().run()
+
+
+setup(
+    cmdclass={{"build": BuildCommand}},
+    package_data={{"deltachat_rpc_server": ["deltachat-rpc-server"]}},
+)
+""",
+        )
+        pack("src/deltachat_rpc_server/__init__.py", "")
+
+
+def build_wheel(version, binary, tag, windows=False):
+    filename = f"dist/deltachat_rpc_server-{version}-{tag}.whl"
+
+    with WheelFile(filename, "w") as wheel:
+        wheel.write("LICENSE", "deltachat_rpc_server/LICENSE")
+        wheel.write("deltachat-rpc-server/README.md", "deltachat_rpc_server/README.md")
+        if windows:
+            wheel.writestr(
+                "deltachat_rpc_server/__init__.py",
+                """import os, sys, subprocess
+def main():
+    argv = [os.path.join(os.path.dirname(__file__), "deltachat-rpc-server.exe"), *sys.argv[1:]]
+    sys.exit(subprocess.call(argv))
+""",
+            )
+        else:
+            wheel.writestr(
+                "deltachat_rpc_server/__init__.py",
+                """import os, sys
+def main():
+    argv = [os.path.join(os.path.dirname(__file__), "deltachat-rpc-server"), *sys.argv[1:]]
+    os.execv(argv[0], argv)
+""",
+            )
+
+        Path(binary).chmod(0o755)
+        wheel.write(
+            binary,
+            "deltachat_rpc_server/deltachat-rpc-server.exe"
+            if windows
+            else "deltachat_rpc_server/deltachat-rpc-server",
+        )
+        wheel.writestr(
+            f"deltachat_rpc_server-{version}.dist-info/METADATA",
+            metadata_contents(version),
+        )
+        wheel.writestr(
+            f"deltachat_rpc_server-{version}.dist-info/WHEEL",
+            "Wheel-Version: 1.0\nRoot-Is-Purelib: false\nTag: {tag}",
+        )
+        wheel.writestr(
+            f"deltachat_rpc_server-{version}.dist-info/entry_points.txt",
+            "[console_scripts]\ndeltachat-rpc-server = deltachat_rpc_server:main",
+        )
+
+
+def main():
+    with open("deltachat-rpc-server/Cargo.toml", "rb") as f:
+        cargo_toml = tomllib.load(f)
+        version = cargo_toml["package"]["version"]
+    Path("dist").mkdir(exist_ok=True)
+    build_source_package(version)
+    build_wheel(
+        version,
+        "dist/deltachat-rpc-server-x86_64-linux",
+        "py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.musllinux_1_1_x86_64",
+    )
+    build_wheel(
+        version,
+        "dist/deltachat-rpc-server-armv7-linux",
+        "py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.musllinux_1_1_armv7l",
+    )
+    build_wheel(
+        version,
+        "dist/deltachat-rpc-server-aarch64-linux",
+        "py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.musllinux_1_1_aarch64",
+    )
+    build_wheel(
+        version,
+        "dist/deltachat-rpc-server-i686-linux",
+        "py3-none-manylinux_2_12_i686.manylinux2010_i686.musllinux_1_1_i686",
+    )
+
+    # macOS versions for platform compatibility tags are taken from https://doc.rust-lang.org/rustc/platform-support.html
+    build_wheel(
+        version,
+        "dist/deltachat-rpc-server-x86_64-macos",
+        "py3-none-macosx_10_7_x86_64",
+    )
+    build_wheel(
+        version,
+        "dist/deltachat-rpc-server-aarch64-macos",
+        "py3-none-macosx_11_0_arm64",
+    )
+
+    build_wheel(
+        version, "dist/deltachat-rpc-server-win32.exe", "py3-none-win32", windows=True
+    )
+    build_wheel(
+        version,
+        "dist/deltachat-rpc-server-win64.exe",
+        "py3-none-win_amd64",
+        windows=True,
+    )
+
+
+main()
--- a/scripts/zig-cc
+++ b/scripts/zig-cc
@@ -1,10 +1,20 @@
 #!/usr/bin/env python
+# /// pyproject
+# [run]
+# dependencies = [
+#   "ziglang==0.11.0"
+# ]
+# ///
+import os
 import subprocess
 import sys
-import os


 def flag_filter(flag: str) -> bool:
+    # Workaround for <https://github.com/sfackler/rust-openssl/issues/2043>.
+    if flag == "-latomic":
+        return False
+
    if flag == "-lc":
        return False
    if flag == "-Wl,-melf_i386":
@@ -24,8 +34,23 @@ def main():
    else:
        zig_cpu_args = []

+    # Disable atomics and use locks instead in OpenSSL.
+    # Zig toolchains do not provide atomics.
+    # This is a workaround for <https://github.com/deltachat/deltachat-core-rust/issues/4799>
+    args += ["-DBROKEN_CLANG_ATOMICS"]
+
    subprocess.run(
-        ["zig", "cc", "-target", zig_target, *zig_cpu_args, *args], check=True
+        [
+            sys.executable,
+            "-m",
+            "ziglang",
+            "cc",
+            "-target",
+            zig_target,
+            *zig_cpu_args,
+            *args,
+        ],
+        check=True,
    )


--- a/scripts/zig-musl-check.sh
+++ b/scripts/zig-musl-check.sh
@@ -1,28 +0,0 @@
-#!/bin/sh
-#
-# Run `cargo check` with musl libc.
-# This requires `zig` to compile vendored openssl.
-
-set -x
-set -e
-
-unset RUSTFLAGS
-
-# Pin Rust version to avoid uncontrolled changes in the compiler and linker flags.
-export RUSTUP_TOOLCHAIN=1.72.0
-
-ZIG_VERSION=0.11.0
-
-# Download Zig
-rm -fr "$ZIG_VERSION" "zig-linux-x86_64-$ZIG_VERSION.tar.xz"
-wget "https://ziglang.org/builds/zig-linux-x86_64-$ZIG_VERSION.tar.xz"
-tar xf "zig-linux-x86_64-$ZIG_VERSION.tar.xz"
-export PATH="$PWD/zig-linux-x86_64-$ZIG_VERSION:$PATH"
-
-rustup target add x86_64-unknown-linux-musl
-CC="$PWD/scripts/zig-cc" \
-TARGET_CC="$PWD/scripts/zig-cc" \
-CARGO_TARGET_X86_64_UNKNOWN_LINUX_MUSL_LINKER="$PWD/scripts/zig-cc" \
-LD="$PWD/scripts/zig-cc" \
-ZIG_TARGET="x86_64-linux-musl" \
-cargo check --release --target x86_64-unknown-linux-musl -p deltachat_ffi --features jsonrpc
--- a/scripts/zig-rpc-server.sh
+++ b/scripts/zig-rpc-server.sh
@@ -10,14 +10,6 @@ unset RUSTFLAGS
 # Pin Rust version to avoid uncontrolled changes in the compiler and linker flags.
 export RUSTUP_TOOLCHAIN=1.72.0

-ZIG_VERSION=0.11.0
-
-# Download Zig
-rm -fr "$ZIG_VERSION" "zig-linux-x86_64-$ZIG_VERSION.tar.xz"
-wget "https://ziglang.org/builds/zig-linux-x86_64-$ZIG_VERSION.tar.xz"
-tar xf "zig-linux-x86_64-$ZIG_VERSION.tar.xz"
-export PATH="$PWD/zig-linux-x86_64-$ZIG_VERSION:$PATH"
-
 rustup target add i686-unknown-linux-musl
 CC="$PWD/scripts/zig-cc" \
 TARGET_CC="$PWD/scripts/zig-cc" \
@@ -50,3 +42,9 @@ CARGO_TARGET_AARCH64_UNKNOWN_LINUX_MUSL_LINKER="$PWD/scripts/zig-cc" \
 LD="$PWD/scripts/zig-cc" \
 ZIG_TARGET="aarch64-linux-musl" \
 cargo build --release --target aarch64-unknown-linux-musl -p deltachat-rpc-server --features vendored
+
+mkdir -p dist
+cp target/x86_64-unknown-linux-musl/release/deltachat-rpc-server dist/deltachat-rpc-server-x86_64-linux
+cp target/i686-unknown-linux-musl/release/deltachat-rpc-server dist/deltachat-rpc-server-i686-linux
+cp target/aarch64-unknown-linux-musl/release/deltachat-rpc-server dist/deltachat-rpc-server-aarch64-linux
+cp target/armv7-unknown-linux-musleabihf/release/deltachat-rpc-server dist/deltachat-rpc-server-armv7-linux
--- a/spec.md
+++ b/spec.md
@@ -43,7 +43,7 @@ the `Subject` header SHOULD be `Message from <sender name>`.
 Replies to messages MAY follow the typical `Re:`-format.

 The body MAY contain text which MUST have the content type `text/plain`
-or `mulipart/alternative` containing `text/plain`.
+or `multipart/alternative` containing `text/plain`.

 The text MAY be divided into a user-text-part and a footer-part using the
 line `-- ` (minus, minus, space, lineend).
@@ -192,7 +192,7 @@ in different orders, esp. on creating new groups.
 To remove a member, a `Chat-Group-Member-Removed` header must be sent
 with the value set to the email-address of the member to remove.
 When receiving a `Chat-Group-Member-Removed` header,
-only exaxtly the given member has to be removed from the member list.
+only exactly the given member has to be removed from the member list.

 Messenger clients MUST NOT construct the member list
 on other group messages
@@ -339,7 +339,7 @@ only on image changes.

 In older specs, the profile-image was sent as an attachment
 and `Chat-User-Avatar:` specified its name.
-However, it turned out that these attachments are kind of unuexpected to users,
+However, it turned out that these attachments are kind of unexpected to users,
 therefore the profile-image go to the header now.


--- a/src/accounts.rs
+++ b/src/accounts.rs
@@ -1,6 +1,7 @@
 //! # Account manager module.

 use std::collections::BTreeMap;
+use std::future::Future;
 use std::path::{Path, PathBuf};

 use anyhow::{ensure, Context as _, Result};
@@ -155,7 +156,7 @@ impl Accounts {
        if let Some(cfg) = self.config.get_account(id) {
            let account_path = self.dir.join(cfg.dir);

-            fs::remove_dir_all(&account_path)
+            try_many_times(|| fs::remove_dir_all(&account_path))
                .await
                .context("failed to remove account data")?;
        }
@@ -191,10 +192,10 @@ impl Accounts {
            fs::create_dir_all(self.dir.join(&account_config.dir))
                .await
                .context("failed to create dir")?;
-            fs::rename(&dbfile, &new_dbfile)
+            try_many_times(|| fs::rename(&dbfile, &new_dbfile))
                .await
                .context("failed to rename dbfile")?;
-            fs::rename(&blobdir, &new_blobdir)
+            try_many_times(|| fs::rename(&blobdir, &new_blobdir))
                .await
                .context("failed to rename blobdir")?;
            if walfile.exists() {
@@ -219,7 +220,7 @@ impl Accounts {
            }
            Err(err) => {
                let account_path = std::path::PathBuf::from(&account_config.dir);
-                fs::remove_dir_all(&account_path)
+                try_many_times(|| fs::remove_dir_all(&account_path))
                    .await
                    .context("failed to remove account data")?;
                self.config.remove_account(account_config.id).await?;
@@ -257,8 +258,8 @@ impl Accounts {
    }

    /// Starts background tasks such as IMAP and SMTP loops for all accounts.
-    pub async fn start_io(&self) {
-        for account in self.accounts.values() {
+    pub async fn start_io(&mut self) {
+        for account in self.accounts.values_mut() {
            account.start_io().await;
        }
    }
@@ -560,6 +561,37 @@ impl Config {
    }
 }

+/// Spend up to 1 minute trying to do the operation.
+///
+/// Even if Delta Chat itself does not hold the file lock,
+/// there may be other processes such as antivirus,
+/// or the filesystem may be network-mounted.
+///
+/// Without this workaround removing account may fail on Windows with an error
+/// "The process cannot access the file because it is being used by another process. (os error 32)".
+async fn try_many_times<F, Fut, T>(f: F) -> std::result::Result<(), T>
+where
+    F: Fn() -> Fut,
+    Fut: Future<Output = std::result::Result<(), T>>,
+{
+    let mut counter = 0;
+    loop {
+        counter += 1;
+
+        if let Err(err) = f().await {
+            if counter > 60 {
+                return Err(err);
+            }
+
+            // Wait 1 second and try again.
+            tokio::time::sleep(std::time::Duration::from_millis(1000)).await;
+        } else {
+            break;
+        }
+    }
+    Ok(())
+}
+
 /// Configuration of a single account.
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
 struct AccountConfig {
--- a/src/chat.rs
+++ b/src/chat.rs
--- a/src/chatlist.rs
+++ b/src/chatlist.rs
@@ -1,6 +1,7 @@
 //! # Chat list module.

 use anyhow::{ensure, Context as _, Result};
+use once_cell::sync::Lazy;

 use crate::chat::{update_special_chat_names, Chat, ChatId, ChatVisibility};
 use crate::constants::{
@@ -15,6 +16,10 @@ use crate::stock_str;
 use crate::summary::Summary;
 use crate::tools::IsNoneOrEmpty;

+/// Regex to find out if a query should filter by unread messages.
+pub static IS_UNREAD_FILTER: Lazy<regex::Regex> =
+    Lazy::new(|| regex::Regex::new(r"\bis:unread\b").unwrap());
+
 /// An object representing a single chatlist in memory.
 ///
 /// Chatlist objects contain chat IDs and, if possible, message IDs belonging to them.
@@ -78,7 +83,8 @@ impl Chatlist {
    /// - if the flag DC_GCL_ADD_ALLDONE_HINT is set, DC_CHAT_ID_ALLDONE_HINT
    ///   is added as needed.
    /// `query`: An optional query for filtering the list. Only chats matching this query
-    ///     are returned.
+    ///     are returned. When `is:unread` is contained in the query, the chatlist is
+    ///     filtered such that only chats with unread messages show up.
    /// `query_contact_id`: An optional contact ID for filtering the list. Only chats including this contact ID
    ///     are returned.
    pub async fn try_load(
@@ -172,8 +178,10 @@ impl Chatlist {
                )
                .await?
        } else if let Some(query) = query {
-            let query = query.trim().to_string();
-            ensure!(!query.is_empty(), "missing query");
+            let mut query = query.trim().to_string();
+            ensure!(!query.is_empty(), "query mustn't be empty");
+            let only_unread = IS_UNREAD_FILTER.find(&query).is_some();
+            query = IS_UNREAD_FILTER.replace(&query, "").trim().to_string();

            // allow searching over special names that may change at any time
            // when the ui calls set_stock_translation()
@@ -198,9 +206,10 @@ impl Chatlist {
                 WHERE c.id>9 AND c.id!=?2
                   AND c.blocked!=1
                   AND c.name LIKE ?3
+                   AND (NOT ?4 OR EXISTS (SELECT 1 FROM msgs m WHERE m.chat_id = c.id AND m.state == ?5 AND hidden=0))
                 GROUP BY c.id
                 ORDER BY IFNULL(m.timestamp,c.created_timestamp) DESC, m.id DESC;",
-                    (MessageState::OutDraft, skip_id, str_like_cmd),
+                    (MessageState::OutDraft, skip_id, str_like_cmd, only_unread, MessageState::InFresh),
                    process_row,
                    process_rows,
                )
@@ -462,7 +471,8 @@ pub async fn get_last_message_for_chat(
 mod tests {
    use super::*;
    use crate::chat::{
-        create_group_chat, get_chat_contacts, remove_contact_from_chat, ProtectionStatus,
+        add_contact_to_chat, create_group_chat, get_chat_contacts, remove_contact_from_chat,
+        send_text_msg, ProtectionStatus,
    };
    use crate::message::Viewtype;
    use crate::receive_imf::receive_imf;
@@ -471,7 +481,7 @@ mod tests {

    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
    async fn test_try_load() {
-        let t = TestContext::new().await;
+        let t = TestContext::new_bob().await;
        let chat_id1 = create_group_chat(&t, ProtectionStatus::Unprotected, "a chat")
            .await
            .unwrap();
@@ -510,6 +520,31 @@ mod tests {
        let chats = Chatlist::try_load(&t, 0, Some("b"), None).await.unwrap();
        assert_eq!(chats.len(), 1);

+        // receive a message from alice
+        let alice = TestContext::new_alice().await;
+        let alice_chat_id = create_group_chat(&alice, ProtectionStatus::Unprotected, "alice chat")
+            .await
+            .unwrap();
+        add_contact_to_chat(
+            &alice,
+            alice_chat_id,
+            Contact::create(&alice, "bob", "bob@example.net")
+                .await
+                .unwrap(),
+        )
+        .await
+        .unwrap();
+        send_text_msg(&alice, alice_chat_id, "hi".into())
+            .await
+            .unwrap();
+        let sent_msg = alice.pop_sent_msg().await;
+
+        t.recv_msg(&sent_msg).await;
+        let chats = Chatlist::try_load(&t, 0, Some("is:unread"), None)
+            .await
+            .unwrap();
+        assert!(chats.len() == 1);
+
        let chats = Chatlist::try_load(&t, DC_GCL_ARCHIVED_ONLY, None, None)
            .await
            .unwrap();
@@ -726,4 +761,40 @@ mod tests {
        let summary = chats.get_summary(&t, 0, None).await.unwrap();
        assert_eq!(summary.text, "foo: bar test"); // the linebreak should be removed from summary
    }
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn test_load_broken() {
+        let t = TestContext::new_bob().await;
+        let chat_id1 = create_group_chat(&t, ProtectionStatus::Unprotected, "a chat")
+            .await
+            .unwrap();
+        create_group_chat(&t, ProtectionStatus::Unprotected, "b chat")
+            .await
+            .unwrap();
+        create_group_chat(&t, ProtectionStatus::Unprotected, "c chat")
+            .await
+            .unwrap();
+
+        // check that the chatlist starts with the most recent message
+        let chats = Chatlist::try_load(&t, 0, None, None).await.unwrap();
+        assert_eq!(chats.len(), 3);
+
+        // obfuscated one chat
+        t.sql
+            .execute("UPDATE chats SET type=10 WHERE id=?", (chat_id1,))
+            .await
+            .unwrap();
+
+        // obfuscated chat can't be loaded
+        assert!(Chat::load_from_db(&t, chat_id1).await.is_err());
+
+        // chatlist loads fine
+        let chats = Chatlist::try_load(&t, 0, None, None).await.unwrap();
+
+        // only corrupted chat fails to create summary
+        assert!(chats.get_summary(&t, 0, None).await.is_ok());
+        assert!(chats.get_summary(&t, 1, None).await.is_ok());
+        assert!(chats.get_summary(&t, 2, None).await.is_err());
+        assert_eq!(chats.get_index_for_id(chat_id1).unwrap(), 2);
+    }
 }
--- a/src/config.rs
+++ b/src/config.rs
@@ -266,6 +266,10 @@ pub enum Config {
    /// True if it is a bot account.
    Bot,

+    /// True when to skip initial start messages in groups.
+    #[strum(props(default = "0"))]
+    SkipStartMessages,
+
    /// Whether we send a warning if the password is wrong (set to false when we send a warning
    /// because we do not want to send a second warning)
    #[strum(props(default = "0"))]
@@ -286,15 +290,20 @@ pub enum Config {
    #[strum(props(default = "60"))]
    ScanAllFoldersDebounceSecs,

+    /// Whether to avoid using IMAP IDLE even if the server supports it.
+    ///
+    /// This is a developer option for testing "fake idle".
+    #[strum(props(default = "0"))]
+    DisableIdle,
+
    /// Defines the max. size (in bytes) of messages downloaded automatically.
    /// 0 = no limit.
    #[strum(props(default = "0"))]
    DownloadLimit,

-    /// Send sync messages, requires `BccSelf` to be set as well.
-    /// In a future versions, this switch may be removed.
-    #[strum(props(default = "0"))]
-    SendSyncMsgs,
+    /// Enable sending and executing (applying) sync messages. Sending requires `BccSelf` to be set.
+    #[strum(props(default = "1"))]
+    SyncMsgs,

    /// Space-separated list of all the authserv-ids which we believe
    /// may be the one of our email server.
@@ -313,6 +322,13 @@ pub enum Config {
    /// Last message processed by the bot.
    LastMsgId,

+    /// How often to gossip Autocrypt keys in chats with multiple recipients, in seconds. 2 days by
+    /// default.
+    ///
+    /// This is not supposed to be changed by UIs and only used for testing.
+    #[strum(props(default = "172800"))]
+    GossipPeriod,
+
    /// Feature flag for verified 1:1 chats; the UI should set it
    /// to 1 if it supports verified 1:1 chats.
    /// Regardless of this setting, `chat.is_protected()` returns true while the key is verified,
@@ -475,6 +491,28 @@ impl Context {
                    .set_raw_config(key.as_ref(), value.as_deref())
                    .await?;
            }
+            Config::Socks5Enabled
+            | Config::BccSelf
+            | Config::E2eeEnabled
+            | Config::MdnsEnabled
+            | Config::SentboxWatch
+            | Config::MvboxMove
+            | Config::OnlyFetchMvbox
+            | Config::FetchExistingMsgs
+            | Config::DeleteToTrash
+            | Config::SaveMimeHeaders
+            | Config::Configured
+            | Config::Bot
+            | Config::NotifyAboutWrongPw
+            | Config::SyncMsgs
+            | Config::SignUnencrypted
+            | Config::DisableIdle => {
+                ensure!(
+                    matches!(value, None | Some("0") | Some("1")),
+                    "Boolean value must be either 0 or 1"
+                );
+                self.sql.set_raw_config(key.as_ref(), value).await?;
+            }
            _ => {
                self.sql.set_raw_config(key.as_ref(), value).await?;
            }
@@ -624,6 +662,18 @@ mod tests {
        );
    }

+    /// Tests that "bot" config can only be set to "0" or "1".
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn test_set_config_bot() {
+        let t = TestContext::new().await;
+
+        assert!(t.set_config(Config::Bot, None).await.is_ok());
+        assert!(t.set_config(Config::Bot, Some("0")).await.is_ok());
+        assert!(t.set_config(Config::Bot, Some("1")).await.is_ok());
+        assert!(t.set_config(Config::Bot, Some("2")).await.is_err());
+        assert!(t.set_config(Config::Bot, Some("Foobar")).await.is_err());
+    }
+
    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
    async fn test_media_quality_config_option() {
        let t = TestContext::new().await;
--- a/src/configure.rs
+++ b/src/configure.rs
@@ -26,13 +26,11 @@ use crate::config::Config;
 use crate::contact::addr_cmp;
 use crate::context::Context;
 use crate::imap::Imap;
-use crate::job;
 use crate::log::LogExt;
 use crate::login_param::{CertificateChecks, LoginParam, ServerLoginParam};
 use crate::message::{Message, Viewtype};
 use crate::oauth2::get_oauth2_addr;
 use crate::provider::{Protocol, Socket, UsernamePattern};
-use crate::scheduler::InterruptInfo;
 use crate::smtp::Smtp;
 use crate::socks::Socks5Config;
 use crate::stock_str;
@@ -466,7 +464,7 @@ async fn configure(ctx: &Context, param: &mut LoginParam) -> Result<()> {
        if configured_addr != param.addr {
            // Switched account, all server UIDs we know are invalid
            info!(ctx, "Scheduling resync because the address has changed.");
-            job::schedule_resync(ctx).await?;
+            ctx.schedule_resync().await?;
        }
    }

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

    ctx.set_config_bool(Config::FetchedExistingMsgs, false)
        .await?;
-    ctx.scheduler
-        .interrupt_inbox(InterruptInfo::new(false))
-        .await;
+    ctx.scheduler.interrupt_inbox().await;

    progress!(ctx, 940);
    update_device_chats_handle.await??;
--- a/src/contact.rs
+++ b/src/contact.rs
@@ -19,7 +19,7 @@ use tokio::task;
 use tokio::time::{timeout, Duration};

 use crate::aheader::EncryptPreference;
-use crate::chat::ChatId;
+use crate::chat::{ChatId, ProtectionStatus};
 use crate::color::str_to_color;
 use crate::config::Config;
 use crate::constants::{Blocked, Chattype, DC_GCL_ADD_SELF, DC_GCL_VERIFIED_ONLY};
@@ -32,6 +32,7 @@ use crate::mimeparser::AvatarAction;
 use crate::param::{Param, Params};
 use crate::peerstate::{Peerstate, PeerstateVerifiedStatus};
 use crate::sql::{self, params_iter};
+use crate::sync::{self, Sync::*, SyncData};
 use crate::tools::{
    duration_to_str, get_abs_path, improve_single_line_input, strip_rtlo_characters, time,
    EmailAddress,
@@ -139,6 +140,15 @@ impl ContactId {
    pub const fn to_u32(&self) -> u32 {
        self.0
    }
+
+    /// Mark contact as bot.
+    pub(crate) async fn mark_bot(&self, context: &Context, is_bot: bool) -> Result<()> {
+        context
+            .sql
+            .execute("UPDATE contacts SET is_bot=? WHERE id=?;", (is_bot, self.0))
+            .await?;
+        Ok(())
+    }
 }

 impl fmt::Display for ContactId {
@@ -223,6 +233,9 @@ pub struct Contact {

    /// Last seen message signature for this contact, to be displayed in the profile.
    status: String,
+
+    /// If the contact is a bot.
+    is_bot: bool,
 }

 /// Possible origins of a contact.
@@ -366,7 +379,7 @@ impl Contact {
            .sql
            .query_row_optional(
                "SELECT c.name, c.addr, c.origin, c.blocked, c.last_seen,
-                c.authname, c.param, c.status
+                c.authname, c.param, c.status, c.is_bot
               FROM contacts c
              WHERE c.id=?;",
                (contact_id,),
@@ -379,6 +392,7 @@ impl Contact {
                    let authname: String = row.get(5)?;
                    let param: String = row.get(6)?;
                    let status: Option<String> = row.get(7)?;
+                    let is_bot: bool = row.get(8)?;
                    let contact = Self {
                        id: contact_id,
                        name,
@@ -389,6 +403,7 @@ impl Contact {
                        origin,
                        param: param.parse().unwrap_or_default(),
                        status: status.unwrap_or_default(),
+                        is_bot,
                    };
                    Ok(contact)
                },
@@ -445,12 +460,12 @@ impl Contact {

    /// Block the given contact.
    pub async fn block(context: &Context, id: ContactId) -> Result<()> {
-        set_block_contact(context, id, true).await
+        set_blocked(context, Sync, id, true).await
    }

    /// Unblock the given contact.
    pub async fn unblock(context: &Context, id: ContactId) -> Result<()> {
-        set_block_contact(context, id, false).await
+        set_blocked(context, Sync, id, false).await
    }

    /// Add a single contact as a result of an _explicit_ user action.
@@ -480,7 +495,7 @@ impl Contact {
            }
        }
        if blocked {
-            Contact::unblock(context, contact_id).await?;
+            set_blocked(context, Nosync, contact_id, false).await?;
        }

        Ok(contact_id)
@@ -498,16 +513,35 @@ impl Contact {
        Ok(())
    }

+    /// Returns whether contact is a bot.
+    pub fn is_bot(&self) -> bool {
+        self.is_bot
+    }
+
    /// Check if an e-mail address belongs to a known and unblocked contact.
    ///
    /// Known and unblocked contacts will be returned by `get_contacts()`.
    ///
    /// To validate an e-mail address independently of the contact database
    /// use `may_be_valid_addr()`.
+    ///
+    /// Returns the contact ID of the contact belonging to the e-mail address or 0 if there is no
+    /// contact that is or was introduced by an accepted contact.
    pub async fn lookup_id_by_addr(
        context: &Context,
        addr: &str,
        min_origin: Origin,
+    ) -> Result<Option<ContactId>> {
+        Self::lookup_id_by_addr_ex(context, addr, min_origin, Some(Blocked::Not)).await
+    }
+
+    /// The same as `lookup_id_by_addr()`, but internal function. Currently also allows looking up
+    /// not unblocked contacts.
+    pub(crate) async fn lookup_id_by_addr_ex(
+        context: &Context,
+        addr: &str,
+        min_origin: Origin,
+        blocked: Option<Blocked>,
    ) -> Result<Option<ContactId>> {
        if addr.is_empty() {
            bail!("lookup_id_by_addr: empty address");
@@ -524,8 +558,14 @@ impl Contact {
            .query_get_value(
                "SELECT id FROM contacts \
            WHERE addr=?1 COLLATE NOCASE \
-            AND id>?2 AND origin>=?3 AND blocked=0;",
-                (&addr_normalized, ContactId::LAST_SPECIAL, min_origin as u32),
+            AND id>?2 AND origin>=?3 AND (? OR blocked=?)",
+                (
+                    &addr_normalized,
+                    ContactId::LAST_SPECIAL,
+                    min_origin as u32,
+                    blocked.is_none(),
+                    blocked.unwrap_or_default(),
+                ),
            )
            .await?;
        Ok(id)
@@ -812,7 +852,11 @@ impl Contact {
        let mut ret = Vec::new();
        let flag_verified_only = (listflags & DC_GCL_VERIFIED_ONLY) != 0;
        let flag_add_self = (listflags & DC_GCL_ADD_SELF) != 0;
-
+        let minimal_origin = if context.get_config_bool(Config::Bot).await? {
+            Origin::Unknown
+        } else {
+            Origin::IncomingReplyTo
+        };
        if flag_verified_only || query.is_some() {
            let s3str_like_cmd = format!("%{}%", query.unwrap_or(""));
            context
@@ -832,7 +876,7 @@ impl Contact {
                    ),
                    rusqlite::params_from_iter(params_iter(&self_addrs).chain(params_slice![
                        ContactId::LAST_SPECIAL,
-                        Origin::IncomingReplyTo,
+                        minimal_origin,
                        s3str_like_cmd,
                        s3str_like_cmd,
                        if flag_verified_only { 0i32 } else { 1i32 }
@@ -882,10 +926,10 @@ impl Contact {
                 ORDER BY last_seen DESC, id DESC;",
                        sql::repeat_vars(self_addrs.len())
                    ),
-                    rusqlite::params_from_iter(params_iter(&self_addrs).chain(params_slice![
-                        ContactId::LAST_SPECIAL,
-                        Origin::IncomingReplyTo
-                    ])),
+                    rusqlite::params_from_iter(
+                        params_iter(&self_addrs)
+                            .chain(params_slice![ContactId::LAST_SPECIAL, minimal_origin]),
+                    ),
                    |row| row.get::<_, ContactId>(0),
                    |ids| {
                        for id in ids {
@@ -1207,10 +1251,20 @@ impl Contact {
        self.status.as_str()
    }

-    /// Check if a contact was verified. E.g. by a secure-join QR code scan
-    /// and if the key has not changed since this verification.
+    /// Returns true if the contact
+    /// can be added to verified chats,
+    /// i.e. has a verified key
+    /// and Autocrypt key matches the verified key.
    ///
-    /// The UI may draw a checkbox or something like that beside verified contacts.
+    /// If contact is verified
+    /// UI should display green checkmark after the contact name
+    /// in contact list items and
+    /// in chat member list items.
+    ///
+    /// In contact profile view, us this function only if there is no chat with the contact,
+    /// otherwise use is_chat_protected().
+    /// Use [Self::get_verifier_id] to display the verifier contact
+    /// in the info section of the contact profile.
    pub async fn is_verified(&self, context: &Context) -> Result<VerifiedStatus> {
        // We're always sort of secured-verified as we could verify the key on this device any time with the key
        // on this device
@@ -1227,16 +1281,23 @@ impl Contact {
        Ok(VerifiedStatus::Unverified)
    }

-    /// Returns the address that verified the contact.
-    pub async fn get_verifier_addr(&self, context: &Context) -> Result<Option<String>> {
-        Ok(Peerstate::from_addr(context, self.get_addr())
-            .await?
-            .and_then(|peerstate| peerstate.get_verifier().map(|addr| addr.to_owned())))
-    }
-
-    /// Returns the ContactId that verified the contact.
+    /// Returns the `ContactId` that verified the contact.
+    ///
+    /// If the function returns non-zero result,
+    /// display green checkmark in the profile and "Introduced by ..." line
+    /// with the name and address of the contact
+    /// formatted by [Self::get_name_n_addr].
+    ///
+    /// If this function returns a verifier,
+    /// this does not necessarily mean
+    /// you can add the contact to verified chats.
+    /// Use [Self::is_verified] to check
+    /// if a contact can be added to a verified chat instead.
    pub async fn get_verifier_id(&self, context: &Context) -> Result<Option<ContactId>> {
-        let Some(verifier_addr) = self.get_verifier_addr(context).await? else {
+        let Some(verifier_addr) = Peerstate::from_addr(context, self.get_addr())
+            .await?
+            .and_then(|peerstate| peerstate.get_verifier().map(|addr| addr.to_owned()))
+        else {
            return Ok(None);
        };

@@ -1245,7 +1306,7 @@ impl Contact {
            return Ok(Some(ContactId::SELF));
        }

-        match Contact::lookup_id_by_addr(context, &verifier_addr, Origin::AddressBook).await? {
+        match Contact::lookup_id_by_addr(context, &verifier_addr, Origin::Unknown).await? {
            Some(contact_id) => Ok(Some(contact_id)),
            None => {
                let addr = &self.addr;
@@ -1255,6 +1316,27 @@ impl Contact {
        }
    }

+    /// Returns if the contact profile title should display a green checkmark.
+    ///
+    /// This generally should be consistent with the 1:1 chat with the contact
+    /// so 1:1 chat with the contact and the contact profile
+    /// either both display the green checkmark or both don't display a green checkmark.
+    ///
+    /// UI often knows beforehand if a chat exists and can also call
+    /// `chat.is_protected()` (if there is a chat)
+    /// or `contact.is_verified()` (if there is no chat) directly.
+    /// This is often easier and also skips some database calls.
+    pub async fn is_profile_verified(&self, context: &Context) -> Result<bool> {
+        let contact_id = self.id;
+
+        if let Some(chat_id) = ChatId::lookup_by_contact(context, contact_id).await? {
+            Ok(chat_id.is_protected(context).await? == ProtectionStatus::Protected)
+        } else {
+            // 1:1 chat does not exist.
+            Ok(self.is_verified(context).await? == VerifiedStatus::BidirectVerified)
+        }
+    }
+
    /// Returns the number of real (i.e. non-special) contacts in the database.
    pub async fn get_real_cnt(context: &Context) -> Result<usize> {
        if !context.sql.is_open().await {
@@ -1340,8 +1422,9 @@ fn sanitize_name_and_addr(name: &str, addr: &str) -> (String, String) {
    }
 }

-async fn set_block_contact(
+pub(crate) async fn set_blocked(
    context: &Context,
+    sync: sync::Sync,
    contact_id: ContactId,
    new_blocking: bool,
 ) -> Result<()> {
@@ -1350,7 +1433,6 @@ async fn set_block_contact(
        "Can't block special contact {}",
        contact_id
    );
-
    let contact = Contact::get_by_id(context, contact_id).await?;

    if contact.blocked != new_blocking {
@@ -1392,9 +1474,23 @@ WHERE type=? AND id IN (
            if let Some((chat_id, _, _)) =
                chat::get_chat_id_by_grpid(context, &contact.addr).await?
            {
-                chat_id.unblock(context).await?;
+                chat_id.unblock_ex(context, Nosync).await?;
            }
        }
+
+        if sync.into() {
+            let action = match new_blocking {
+                true => chat::SyncAction::Block,
+                false => chat::SyncAction::Unblock,
+            };
+            context
+                .add_sync_item(SyncData::AlterChat {
+                    id: chat::SyncId::ContactAddr(contact.addr.clone()),
+                    action,
+                })
+                .await?;
+            context.send_sync_msg().await?;
+        }
    }

    Ok(())
@@ -2687,7 +2783,6 @@ Hi."#;

        let contact_id = Contact::create(&alice, "Bob", "bob@example.net").await?;
        let contact = Contact::get_by_id(&alice, contact_id).await?;
-        assert!(contact.get_verifier_addr(&alice).await?.is_none());
        assert!(contact.get_verifier_id(&alice).await?.is_none());

        // Receive a message from Bob to create a peerstate.
@@ -2696,7 +2791,6 @@ Hi."#;
        alice.recv_msg(&sent_msg).await;

        let contact = Contact::get_by_id(&alice, contact_id).await?;
-        assert!(contact.get_verifier_addr(&alice).await?.is_none());
        assert!(contact.get_verifier_id(&alice).await?.is_none());

        Ok(())
--- a/src/context.rs
+++ b/src/context.rs
@@ -4,7 +4,7 @@ use std::collections::{BTreeMap, HashMap};
 use std::ffi::OsString;
 use std::ops::Deref;
 use std::path::{Path, PathBuf};
-use std::sync::atomic::AtomicBool;
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
 use std::time::{Duration, Instant, SystemTime};

@@ -38,7 +38,7 @@ use crate::tools::{duration_to_str, time};
 ///
 /// # Examples
 ///
-/// Creating a new unecrypted database:
+/// Creating a new unencrypted database:
 ///
 /// ```
 /// # let rt = tokio::runtime::Runtime::new().unwrap();
@@ -211,9 +211,6 @@ pub struct InnerContext {
    /// Set to `None` if quota was never tried to load.
    pub(crate) quota: RwLock<Option<QuotaInfo>>,

-    /// Set to true if quota update is requested.
-    pub(crate) quota_update_request: AtomicBool,
-
    /// IMAP UID resync request.
    pub(crate) resync_request: AtomicBool,

@@ -384,7 +381,6 @@ impl Context {
            scheduler: SchedulerState::new(),
            ratelimit: RwLock::new(Ratelimit::new(Duration::new(60, 0), 6.0)), // Allow at least 1 message every 10 seconds + a burst of 6.
            quota: RwLock::new(None),
-            quota_update_request: AtomicBool::new(false),
            resync_request: AtomicBool::new(false),
            new_msgs_notify,
            server_id: RwLock::new(None),
@@ -402,11 +398,24 @@ impl Context {
    }

    /// Starts the IO scheduler.
-    pub async fn start_io(&self) {
-        if let Ok(false) = self.is_configured().await {
+    pub async fn start_io(&mut self) {
+        if !self.is_configured().await.unwrap_or_default() {
            warn!(self, "can not start io on a context that is not configured");
            return;
        }
+
+        {
+            if self
+                .get_config(Config::ConfiguredAddr)
+                .await
+                .unwrap_or_default()
+                .filter(|s| s.ends_with(".testrun.org"))
+                .is_some()
+            {
+                let mut lock = self.ratelimit.write().await;
+                *lock = Ratelimit::new(Duration::new(40, 0), 6.0);
+            }
+        }
        self.scheduler.start(self.clone()).await;
    }

@@ -426,6 +435,12 @@ impl Context {
        self.scheduler.maybe_network().await;
    }

+    pub(crate) async fn schedule_resync(&self) -> Result<()> {
+        self.resync_request.store(true, Ordering::Relaxed);
+        self.scheduler.interrupt_inbox().await;
+        Ok(())
+    }
+
    /// Returns a reference to the underlying SQL instance.
    ///
    /// Warning: this is only here for testing, not part of the public API.
@@ -578,7 +593,8 @@ impl Context {
        let e2ee_enabled = self.get_config_int(Config::E2eeEnabled).await?;
        let mdns_enabled = self.get_config_int(Config::MdnsEnabled).await?;
        let bcc_self = self.get_config_int(Config::BccSelf).await?;
-        let send_sync_msgs = self.get_config_int(Config::SendSyncMsgs).await?;
+        let sync_msgs = self.get_config_int(Config::SyncMsgs).await?;
+        let disable_idle = self.get_config_bool(Config::DisableIdle).await?;

        let prv_key_cnt = self.sql.count("SELECT COUNT(*) FROM keypairs;", ()).await?;

@@ -690,7 +706,8 @@ impl Context {
            self.get_config_int(Config::KeyGenType).await?.to_string(),
        );
        res.insert("bcc_self", bcc_self.to_string());
-        res.insert("send_sync_msgs", send_sync_msgs.to_string());
+        res.insert("sync_msgs", sync_msgs.to_string());
+        res.insert("disable_idle", disable_idle.to_string());
        res.insert("private_key_count", prv_key_cnt.to_string());
        res.insert("public_key_count", pub_key_cnt.to_string());
        res.insert("fingerprint", fingerprint_str);
@@ -752,7 +769,6 @@ impl Context {
                .await?
                .to_string(),
        );
-
        res.insert(
            "debug_logging",
            self.get_config_int(Config::DebugLogging).await?.to_string(),
@@ -761,6 +777,10 @@ impl Context {
            "last_msg_id",
            self.get_config_int(Config::LastMsgId).await?.to_string(),
        );
+        res.insert(
+            "gossip_period",
+            self.get_config_int(Config::GossipPeriod).await?.to_string(),
+        );
        res.insert(
            "verified_one_on_one_chats",
            self.get_config_bool(Config::VerifiedOneOnOneChats)
@@ -1291,6 +1311,7 @@ mod tests {
            "send_port",
            "send_security",
            "server_flags",
+            "skip_start_messages",
            "smtp_certificate_checks",
            "socks5_host",
            "socks5_port",
--- a/src/download.rs
+++ b/src/download.rs
@@ -10,20 +10,18 @@ use serde::{Deserialize, Serialize};
 use crate::config::Config;
 use crate::context::Context;
 use crate::imap::{Imap, ImapActionResult};
-use crate::job::{self, Action, Job, Status};
 use crate::message::{Message, MsgId, Viewtype};
 use crate::mimeparser::{MimeMessage, Part};
 use crate::tools::time;
-use crate::{job_try, stock_str, EventType};
+use crate::{stock_str, EventType};

 /// Download limits should not be used below `MIN_DOWNLOAD_LIMIT`.
 ///
-/// Some messages as non-delivery-reports (NDN) or read-receipts (MDN)
-/// need to be downloaded completely to handle them correctly,
-/// eg. to assign them to the correct chat.
-/// As these messages are typically small,
-/// they're caught by `MIN_DOWNLOAD_LIMIT`.
-const MIN_DOWNLOAD_LIMIT: u32 = 32768;
+/// For better UX, some messages as add-member, non-delivery-reports (NDN) or read-receipts (MDN)
+/// should always be downloaded completely to handle them correctly,
+/// also in larger groups and if group and contact avatar are attached.
+/// Most of these cases are caught by `MIN_DOWNLOAD_LIMIT`.
+pub(crate) const MIN_DOWNLOAD_LIMIT: u32 = 163840;

 /// If a message is downloaded only partially
 /// and `delete_server_after` is set to small timeouts (eg. "at once"),
@@ -90,7 +88,11 @@ impl MsgId {
            DownloadState::Available | DownloadState::Failure => {
                self.update_download_state(context, DownloadState::InProgress)
                    .await?;
-                job::add(context, Job::new(Action::DownloadMsg, self.to_u32())).await?;
+                context
+                    .sql
+                    .execute("INSERT INTO download (msg_id) VALUES (?)", (self,))
+                    .await?;
+                context.scheduler.interrupt_inbox().await;
            }
        }
        Ok(())
@@ -124,59 +126,49 @@ impl Message {
    }
 }

-impl Job {
-    /// Actually download a message.
-    /// Called in response to `Action::DownloadMsg`.
-    pub(crate) async fn download_msg(&self, context: &Context, imap: &mut Imap) -> Status {
-        if let Err(err) = imap.prepare(context).await {
-            warn!(context, "download: could not connect: {:#}", err);
-            return Status::RetryNow;
-        }
+/// Actually download a message partially downloaded before.
+///
+/// Most messages are downloaded automatically on fetch instead.
+pub(crate) async fn download_msg(context: &Context, msg_id: MsgId, imap: &mut Imap) -> Result<()> {
+    imap.prepare(context).await?;

-        let msg = job_try!(Message::load_from_db(context, MsgId::new(self.foreign_id)).await);
-        let row = job_try!(
-            context
-                .sql
-                .query_row_optional(
-                    "SELECT uid, folder FROM imap WHERE rfc724_mid=? AND target=folder",
-                    (&msg.rfc724_mid,),
-                    |row| {
-                        let server_uid: u32 = row.get(0)?;
-                        let server_folder: String = row.get(1)?;
-                        Ok((server_uid, server_folder))
-                    }
-                )
-                .await
-        );
+    let msg = Message::load_from_db(context, msg_id).await?;
+    let row = context
+        .sql
+        .query_row_optional(
+            "SELECT uid, folder FROM imap WHERE rfc724_mid=? AND target!=''",
+            (&msg.rfc724_mid,),
+            |row| {
+                let server_uid: u32 = row.get(0)?;
+                let server_folder: String = row.get(1)?;
+                Ok((server_uid, server_folder))
+            },
+        )
+        .await?;

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

--- a/src/e2ee.rs
+++ b/src/e2ee.rs
@@ -67,13 +67,8 @@ impl EncryptHelper {
                        "peerstate for {:?} is {}", addr, peerstate.prefer_encrypt
                    );
                    match peerstate.prefer_encrypt {
-                        EncryptPreference::NoPreference => {}
+                        EncryptPreference::NoPreference | EncryptPreference::Reset => {}
                        EncryptPreference::Mutual => prefer_encrypt_count += 1,
-                        EncryptPreference::Reset => {
-                            if !e2ee_guaranteed {
-                                return Ok(false);
-                            }
-                        }
                    };
                }
                None => {
@@ -105,16 +100,39 @@ impl EncryptHelper {
    ) -> Result<String> {
        let mut keyring: Vec<SignedPublicKey> = Vec::new();

+        let mut verifier_addresses: Vec<&str> = Vec::new();
+
        for (peerstate, addr) in peerstates
-            .into_iter()
-            .filter_map(|(state, addr)| state.map(|s| (s, addr)))
+            .iter()
+            .filter_map(|(state, addr)| state.clone().map(|s| (s, addr)))
        {
            let key = peerstate
                .take_key(min_verified)
                .with_context(|| format!("proper enc-key for {addr} missing, cannot encrypt"))?;
            keyring.push(key);
+            verifier_addresses.push(addr);
        }
+
+        // Encrypt to self.
        keyring.push(self.public_key.clone());
+
+        // Encrypt to secondary verified keys
+        // if we also encrypt to the introducer ("verifier") of the key.
+        if min_verified == PeerstateVerifiedStatus::BidirectVerified {
+            for (peerstate, _addr) in peerstates {
+                if let Some(peerstate) = peerstate {
+                    if let (Some(key), Some(verifier)) = (
+                        peerstate.secondary_verified_key.as_ref(),
+                        peerstate.secondary_verifier.as_deref(),
+                    ) {
+                        if verifier_addresses.contains(&verifier) {
+                            keyring.push(key.clone());
+                        }
+                    }
+                }
+            }
+        }
+
        let sign_key = load_self_secret_key(context).await?;

        let raw_message = mail_to_encrypt.build().as_string().into_bytes();
@@ -301,8 +319,11 @@ Sent with my Delta Chat Messenger: https://delta.chat";
            gossip_key_fingerprint: Some(pub_key.fingerprint()),
            verified_key: Some(pub_key.clone()),
            verified_key_fingerprint: Some(pub_key.fingerprint()),
-            fingerprint_changed: false,
            verifier: None,
+            secondary_verified_key: None,
+            secondary_verified_key_fingerprint: None,
+            secondary_verifier: None,
+            fingerprint_changed: false,
        };
        vec![(Some(peerstate), addr)]
    }
--- a/src/events.rs
+++ b/src/events.rs
@@ -1,6 +1,7 @@
 //! # Events specification.

 use async_channel::{self as channel, Receiver, Sender, TrySendError};
+use pin_project::pin_project;

 mod payload;

@@ -64,7 +65,8 @@ impl Events {
 /// [`Context::get_event_emitter`]: crate::context::Context::get_event_emitter
 /// [`Stream`]: futures::stream::Stream
 #[derive(Debug, Clone)]
-pub struct EventEmitter(Receiver<Event>);
+#[pin_project]
+pub struct EventEmitter(#[pin] Receiver<Event>);

 impl EventEmitter {
    /// Async recv of an event. Return `None` if the `Sender` has been dropped.
@@ -77,10 +79,10 @@ impl futures::stream::Stream for EventEmitter {
    type Item = Event;

    fn poll_next(
-        mut self: std::pin::Pin<&mut Self>,
+        self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
-        std::pin::Pin::new(&mut self.0).poll_next(cx)
+        self.project().0.poll_next(cx)
    }
 }

--- a/src/events/payload.rs
+++ b/src/events/payload.rs
@@ -250,6 +250,7 @@ pub enum EventType {
        /// Progress as:
        /// 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: usize,
    },

--- a/src/imap.rs
+++ b/src/imap.rs
@@ -26,7 +26,6 @@ use crate::contact::{normalize_name, Contact, ContactAddress, ContactId, Modifie
 use crate::context::Context;
 use crate::events::EventType;
 use crate::headerdef::{HeaderDef, HeaderDefMap};
-use crate::job;
 use crate::login_param::{CertificateChecks, LoginParam, ServerLoginParam};
 use crate::message::{self, Message, MessageState, MessengerMessage, MsgId, Viewtype};
 use crate::mimeparser;
@@ -36,7 +35,6 @@ use crate::receive_imf::{
    from_field_to_contact_id, get_prefetch_parent_message, receive_imf_inner, ReceivedMsg,
 };
 use crate::scheduler::connectivity::ConnectivityStore;
-use crate::scheduler::InterruptInfo;
 use crate::socks::Socks5Config;
 use crate::sql;
 use crate::stock_str;
@@ -82,13 +80,12 @@ const RFC724MID_UID: &str = "(UID BODY.PEEK[HEADER.FIELDS (\
                             MESSAGE-ID \
                             X-MICROSOFT-ORIGINAL-MESSAGE-ID\
                             )])";
-const JUST_UID: &str = "(UID)";
 const BODY_FULL: &str = "(FLAGS BODY.PEEK[])";
 const BODY_PARTIAL: &str = "(FLAGS RFC822.SIZE BODY.PEEK[HEADER])";

 #[derive(Debug)]
 pub struct Imap {
-    pub(crate) idle_interrupt_receiver: Receiver<InterruptInfo>,
+    pub(crate) idle_interrupt_receiver: Receiver<()>,
    config: ImapConfig,
    pub(crate) session: Option<Session>,
    login_failed_once: bool,
@@ -197,7 +194,7 @@ impl<T: Iterator<Item = (i64, u32, String)>> Iterator for UidGrouper<T> {

                while let Some((next_rowid, next_uid, _)) =
                    self.inner.next_if(|(_, next_uid, next_folder)| {
-                        next_folder == &folder && *next_uid == end_uid + 1
+                        next_folder == &folder && (*next_uid == end_uid + 1 || *next_uid == end_uid)
                    })
                {
                    end_uid = next_uid;
@@ -230,7 +227,7 @@ impl Imap {
        socks5_config: Option<Socks5Config>,
        addr: &str,
        provider_strict_tls: bool,
-        idle_interrupt_receiver: Receiver<InterruptInfo>,
+        idle_interrupt_receiver: Receiver<()>,
    ) -> Result<Self> {
        if lp.server.is_empty() || lp.user.is_empty() || lp.password.is_empty() {
            bail!("Incomplete IMAP connection parameters");
@@ -263,7 +260,7 @@ impl Imap {
    /// Creates new disconnected IMAP client using configured parameters.
    pub async fn new_configured(
        context: &Context,
-        idle_interrupt_receiver: Receiver<InterruptInfo>,
+        idle_interrupt_receiver: Receiver<()>,
    ) -> Result<Self> {
        if !context.is_configured().await? {
            bail!("IMAP Connect without configured params");
@@ -391,6 +388,7 @@ impl Imap {
                    "IMAP-LOGIN as {}",
                    self.config.lp.user
                )));
+                self.connectivity.set_connected(context).await;
                info!(context, "Successfully logged into IMAP server");
                Ok(())
            }
@@ -569,9 +567,14 @@ impl Imap {
        Ok(())
    }

-    /// Select a folder and take care of uidvalidity changes.
-    /// Also, when selecting a folder for the first time, sets the uid_next to the current
+    /// Selects a folder and takes care of UIDVALIDITY changes.
+    ///
+    /// When selecting a folder for the first time, sets the uid_next to the current
    /// mailbox.uid_next so that no old emails are fetched.
+    ///
+    /// Makes sure that UIDNEXT is known for `selected_mailbox`
+    /// and errors out if UIDNEXT cannot be determined.
+    ///
    /// Returns Result<new_emails> (i.e. whether new emails arrived),
    /// if in doubt, returns new_emails=true so emails are fetched.
    pub(crate) async fn select_with_uidvalidity(
@@ -592,6 +595,37 @@ impl Imap {
        let new_uid_validity = mailbox
            .uid_validity
            .with_context(|| format!("No UIDVALIDITY for folder {folder}"))?;
+        let new_uid_next = if let Some(uid_next) = mailbox.uid_next {
+            uid_next
+        } else {
+            warn!(
+                context,
+                "SELECT response for IMAP folder {folder:?} has no UIDNEXT, fall back to STATUS command."
+            );
+
+            // RFC 3501 says STATUS command SHOULD NOT be used
+            // on the currently selected mailbox because the same
+            // information can be obtained by other means,
+            // such as reading SELECT response.
+            //
+            // However, it also says that UIDNEXT is REQUIRED
+            // in the SELECT response and if we are here,
+            // it is actually not returned.
+            //
+            // In particular, Winmail Pro Mail Server 5.1.0616
+            // never returns UIDNEXT in SELECT response,
+            // but responds to "STATUS INBOX (UIDNEXT)" command.
+            let status = session
+                .inner
+                .status(folder, "(UIDNEXT)")
+                .await
+                .context("STATUS (UIDNEXT) error for {folder:?}")?;
+
+            status
+                .uid_next
+                .context("STATUS {folder} (UIDNEXT) did not return UIDNEXT")?
+        };
+        mailbox.uid_next = Some(new_uid_next);

        let old_uid_validity = get_uidvalidity(context, folder)
            .await
@@ -607,18 +641,16 @@ impl Imap {
                // the caller tries to fetch new messages (we could of course run a SELECT command now, but trying to fetch
                // new messages is only one command, just as a SELECT command)
                true
-            } else if let Some(uid_next) = mailbox.uid_next {
-                if uid_next < old_uid_next {
+            } else {
+                if new_uid_next < old_uid_next {
                    warn!(
                        context,
-                        "The server illegally decreased the uid_next of folder {folder:?} from {old_uid_next} to {uid_next} without changing validity ({new_uid_validity}), resyncing UIDs...",
+                        "The server illegally decreased the uid_next of folder {folder:?} from {old_uid_next} to {new_uid_next} without changing validity ({new_uid_validity}), resyncing UIDs...",
                    );
-                    set_uid_next(context, folder, uid_next).await?;
-                    job::schedule_resync(context).await?;
+                    set_uid_next(context, folder, new_uid_next).await?;
+                    context.schedule_resync().await?;
                }
-                uid_next != old_uid_next // If uid_next changed, there are new emails
-            } else {
-                true // We have no uid_next and if in doubt, return true
+                new_uid_next != old_uid_next // If UIDNEXT changed, there are new emails
            };
            return Ok(new_emails);
        }
@@ -626,47 +658,8 @@ impl Imap {
        // UIDVALIDITY is modified, reset highest seen MODSEQ.
        set_modseq(context, folder, 0).await?;

-        if mailbox.exists == 0 {
-            info!(context, "Folder {folder:?} is empty.");
-
-            // set uid_next=1 for empty folders.
-            // If we do not do this here, we'll miss the first message
-            // as we will get in here again and fetch from uid_next then.
-            // Also, the "fall back to fetching" below would need a non-zero mailbox.exists to work.
-            set_uid_next(context, folder, 1).await?;
-            set_uidvalidity(context, folder, new_uid_validity).await?;
-            return Ok(false);
-        }
-
        // ==============  uid_validity has changed or is being set the first time.  ==============

-        let new_uid_next = match mailbox.uid_next {
-            Some(uid_next) => uid_next,
-            None => {
-                warn!(
-                    context,
-                    "IMAP folder {folder:?} has no uid_next, fall back to fetching."
-                );
-                // note that we use fetch by sequence number
-                // and thus we only need to get exactly the
-                // last-index message.
-                let set = format!("{}", mailbox.exists);
-                let mut list = session
-                    .inner
-                    .fetch(set, JUST_UID)
-                    .await
-                    .context("Error fetching UID")?;
-
-                let mut new_last_seen_uid = None;
-                while let Some(fetch) = list.try_next().await? {
-                    if fetch.message == mailbox.exists && fetch.uid.is_some() {
-                        new_last_seen_uid = fetch.uid;
-                    }
-                }
-                new_last_seen_uid.context("select: failed to fetch")? + 1
-            }
-        };
-
        set_uid_next(context, folder, new_uid_next).await?;
        set_uidvalidity(context, folder, new_uid_validity).await?;

@@ -680,7 +673,7 @@ impl Imap {
            .await?;

        if old_uid_validity != 0 || old_uid_next != 0 {
-            job::schedule_resync(context).await?;
+            context.schedule_resync().await?;
        }
        info!(
            context,
@@ -870,14 +863,28 @@ impl Imap {
            uids_fetch_in_batch.push(uid);
        }

-        // determine which uid_next to use to update to
-        // receive_imf() returns an `Err` value only on recoverable errors, otherwise it just logs an error.
-        // `largest_uid_processed` is the largest uid where receive_imf() did NOT return an error.
-
-        // So: Update the uid_next to the largest uid that did NOT recoverably fail. Not perfect because if there was
-        // another message afterwards that succeeded, we will not retry. The upside is that we will not retry an infinite amount of times.
-        let largest_uid_without_errors = max(largest_uid_fetched, largest_uid_skipped.unwrap_or(0));
-        let new_uid_next = largest_uid_without_errors + 1;
+        // Advance uid_next to the maximum of the largest known UID plus 1
+        // and mailbox UIDNEXT.
+        // Largest known UID is normally less than UIDNEXT,
+        // but a message may have arrived between determining UIDNEXT
+        // and executing the FETCH command.
+        let mailbox_uid_next = self
+            .session
+            .as_ref()
+            .context("No IMAP session")?
+            .selected_mailbox
+            .as_ref()
+            .with_context(|| format!("Expected {folder:?} to be selected"))?
+            .uid_next
+            .with_context(|| {
+                format!(
+                    "Expected UIDNEXT to be determined for {folder:?} by select_with_uidvalidity"
+                )
+            })?;
+        let new_uid_next = max(
+            max(largest_uid_fetched, largest_uid_skipped.unwrap_or(0)) + 1,
+            mailbox_uid_next,
+        );

        if new_uid_next > old_uid_next {
            set_uid_next(context, folder, new_uid_next).await?;
@@ -2282,10 +2289,7 @@ pub(crate) async fn markseen_on_imap_table(context: &Context, message_id: &str)
            (message_id,),
        )
        .await?;
-    context
-        .scheduler
-        .interrupt_inbox(InterruptInfo::new(false))
-        .await;
+    context.scheduler.interrupt_inbox().await;

    Ok(())
 }
@@ -2833,4 +2837,31 @@ mod tests {

        Ok(())
    }
+
+    #[test]
+    fn test_uid_grouper() {
+        // Input: sequence of (rowid: i64, uid: u32, target: String)
+        // Output: sequence of (target: String, rowid_set: Vec<i64>, uid_set: String)
+        let grouper = UidGrouper::from([(1, 2, "INBOX".to_string())]);
+        let res: Vec<(String, Vec<i64>, String)> = grouper.into_iter().collect();
+        assert_eq!(res, vec![("INBOX".to_string(), vec![1], "2".to_string())]);
+
+        let grouper = UidGrouper::from([(1, 2, "INBOX".to_string()), (2, 3, "INBOX".to_string())]);
+        let res: Vec<(String, Vec<i64>, String)> = grouper.into_iter().collect();
+        assert_eq!(
+            res,
+            vec![("INBOX".to_string(), vec![1, 2], "2:3".to_string())]
+        );
+
+        let grouper = UidGrouper::from([
+            (1, 2, "INBOX".to_string()),
+            (2, 2, "INBOX".to_string()),
+            (3, 3, "INBOX".to_string()),
+        ]);
+        let res: Vec<(String, Vec<i64>, String)> = grouper.into_iter().collect();
+        assert_eq!(
+            res,
+            vec![("INBOX".to_string(), vec![1, 2, 3], "2:3".to_string())]
+        );
+    }
 }
--- a/src/imap/client.rs
+++ b/src/imap/client.rs
@@ -15,6 +15,7 @@ use crate::net::connect_tcp;
 use crate::net::session::SessionStream;
 use crate::net::tls::wrap_tls;
 use crate::socks::Socks5Config;
+use fast_socks5::client::Socks5Stream;

 /// IMAP write and read timeout.
 pub(crate) const IMAP_TIMEOUT: Duration = Duration::from_secs(30);
@@ -64,6 +65,12 @@ async fn determine_capabilities(
 }

 impl Client {
+    fn new(stream: Box<dyn SessionStream>) -> Self {
+        Self {
+            inner: ImapClient::new(stream),
+        }
+    }
+
    pub(crate) async fn login(self, username: &str, password: &str) -> Result<Session> {
        let Client { inner, .. } = self;
        let mut session = inner
@@ -98,27 +105,24 @@ impl Client {
        let tls_stream = wrap_tls(strict_tls, hostname, tcp_stream).await?;
        let buffered_stream = BufWriter::new(tls_stream);
        let session_stream: Box<dyn SessionStream> = Box::new(buffered_stream);
-        let mut client = ImapClient::new(session_stream);
-
+        let mut client = Client::new(session_stream);
        let _greeting = client
            .read_response()
            .await
            .context("failed to read greeting")??;
-
-        Ok(Client { inner: client })
+        Ok(client)
    }

    pub async fn connect_insecure(context: &Context, hostname: &str, port: u16) -> Result<Self> {
        let tcp_stream = connect_tcp(context, hostname, port, IMAP_TIMEOUT, false).await?;
        let buffered_stream = BufWriter::new(tcp_stream);
        let session_stream: Box<dyn SessionStream> = Box::new(buffered_stream);
-        let mut client = ImapClient::new(session_stream);
+        let mut client = Client::new(session_stream);
        let _greeting = client
            .read_response()
            .await
            .context("failed to read greeting")??;
-
-        Ok(Client { inner: client })
+        Ok(client)
    }

    pub async fn connect_starttls(
@@ -130,7 +134,8 @@ impl Client {
        let tcp_stream = connect_tcp(context, hostname, port, IMAP_TIMEOUT, strict_tls).await?;

        // Run STARTTLS command and convert the client back into a stream.
-        let mut client = ImapClient::new(tcp_stream);
+        let buffered_tcp_stream = BufWriter::new(tcp_stream);
+        let mut client = ImapClient::new(buffered_tcp_stream);
        let _greeting = client
            .read_response()
            .await
@@ -139,7 +144,8 @@ impl Client {
            .run_command_and_check_ok("STARTTLS", None)
            .await
            .context("STARTTLS command failed")?;
-        let tcp_stream = client.into_inner();
+        let buffered_tcp_stream = client.into_inner();
+        let tcp_stream = buffered_tcp_stream.into_inner();

        let tls_stream = wrap_tls(strict_tls, hostname, tcp_stream)
            .await
@@ -147,9 +153,8 @@ impl Client {

        let buffered_stream = BufWriter::new(tls_stream);
        let session_stream: Box<dyn SessionStream> = Box::new(buffered_stream);
-        let client = ImapClient::new(session_stream);
-
-        Ok(Client { inner: client })
+        let client = Client::new(session_stream);
+        Ok(client)
    }

    pub async fn connect_secure_socks5(
@@ -165,13 +170,12 @@ impl Client {
        let tls_stream = wrap_tls(strict_tls, domain, socks5_stream).await?;
        let buffered_stream = BufWriter::new(tls_stream);
        let session_stream: Box<dyn SessionStream> = Box::new(buffered_stream);
-        let mut client = ImapClient::new(session_stream);
+        let mut client = Client::new(session_stream);
        let _greeting = client
            .read_response()
            .await
            .context("failed to read greeting")??;
-
-        Ok(Client { inner: client })
+        Ok(client)
    }

    pub async fn connect_insecure_socks5(
@@ -185,13 +189,12 @@ impl Client {
            .await?;
        let buffered_stream = BufWriter::new(socks5_stream);
        let session_stream: Box<dyn SessionStream> = Box::new(buffered_stream);
-        let mut client = ImapClient::new(session_stream);
+        let mut client = Client::new(session_stream);
        let _greeting = client
            .read_response()
            .await
            .context("failed to read greeting")??;
-
-        Ok(Client { inner: client })
+        Ok(client)
    }

    pub async fn connect_starttls_socks5(
@@ -206,7 +209,8 @@ impl Client {
            .await?;

        // Run STARTTLS command and convert the client back into a stream.
-        let mut client = ImapClient::new(socks5_stream);
+        let buffered_socks5_stream = BufWriter::new(socks5_stream);
+        let mut client = ImapClient::new(buffered_socks5_stream);
        let _greeting = client
            .read_response()
            .await
@@ -215,15 +219,15 @@ impl Client {
            .run_command_and_check_ok("STARTTLS", None)
            .await
            .context("STARTTLS command failed")?;
-        let socks5_stream = client.into_inner();
+        let buffered_socks5_stream = client.into_inner();
+        let socks5_stream: Socks5Stream<_> = buffered_socks5_stream.into_inner();

        let tls_stream = wrap_tls(strict_tls, hostname, socks5_stream)
            .await
            .context("STARTTLS upgrade failed")?;
        let buffered_stream = BufWriter::new(tls_stream);
        let session_stream: Box<dyn SessionStream> = Box::new(buffered_stream);
-        let client = ImapClient::new(session_stream);
-
-        Ok(Client { inner: client })
+        let client = Client::new(session_stream);
+        Ok(client)
    }
 }
--- a/src/imap/idle.rs
+++ b/src/imap/idle.rs
@@ -7,8 +7,10 @@ use futures_lite::FutureExt;

 use super::session::Session;
 use super::Imap;
-use crate::imap::{client::IMAP_TIMEOUT, FolderMeaning};
-use crate::{context::Context, scheduler::InterruptInfo};
+use crate::config::Config;
+use crate::context::Context;
+use crate::imap::{client::IMAP_TIMEOUT, get_uid_next, FolderMeaning};
+use crate::log::LogExt;

 const IDLE_TIMEOUT: Duration = Duration::from_secs(23 * 60);

@@ -16,26 +18,43 @@ impl Session {
    pub async fn idle(
        mut self,
        context: &Context,
-        idle_interrupt_receiver: Receiver<InterruptInfo>,
-        watch_folder: Option<String>,
-    ) -> Result<(Self, InterruptInfo)> {
+        idle_interrupt_receiver: Receiver<()>,
+        folder: &str,
+    ) -> Result<Self> {
        use futures::future::FutureExt;

-        if !self.can_idle() {
-            bail!("IMAP server does not have IDLE capability");
-        }
-
-        let mut info = Default::default();
-
-        self.select_folder(context, watch_folder.as_deref()).await?;
+        self.select_folder(context, Some(folder)).await?;

        if self.server_sent_unsolicited_exists(context)? {
-            return Ok((self, info));
+            return Ok(self);
        }

-        if let Ok(info) = idle_interrupt_receiver.try_recv() {
-            info!(context, "skip idle, got interrupt {:?}", info);
-            return Ok((self, info));
+        // Despite checking for unsolicited EXISTS above,
+        // we may have missed EXISTS if the message was
+        // received when the folder was not selected.
+        let status = self
+            .status(folder, "(UIDNEXT)")
+            .await
+            .context("STATUS (UIDNEXT) error for {folder:?}")?;
+        if let Some(uid_next) = status.uid_next {
+            let expected_uid_next = get_uid_next(context, folder)
+                .await
+                .with_context(|| format!("failed to get old UID NEXT for folder {folder}"))?;
+            if uid_next > expected_uid_next {
+                info!(
+                    context,
+                    "Skipping IDLE on {folder:?} because UIDNEXT {uid_next}>{expected_uid_next} indicates there are new messages."
+                );
+                return Ok(self);
+            }
+        } else {
+            warn!(context, "STATUS {folder} (UIDNEXT) did not return UIDNEXT");
+            // Go to IDLE anyway if STATUS is broken.
+        }
+
+        if let Ok(()) = idle_interrupt_receiver.try_recv() {
+            info!(context, "skip idle, got interrupt");
+            return Ok(self);
        }

        let mut handle = self.inner.idle();
@@ -52,59 +71,45 @@ impl Session {

        enum Event {
            IdleResponse(IdleResponse),
-            Interrupt(InterruptInfo),
+            Interrupt,
        }

-        let folder_name = watch_folder.as_deref().unwrap_or("None");
-        info!(
-            context,
-            "{}: Idle entering wait-on-remote state", folder_name
-        );
+        info!(context, "{folder}: Idle entering wait-on-remote state");
        let fut = idle_wait.map(|ev| ev.map(Event::IdleResponse)).race(async {
-            let info = idle_interrupt_receiver.recv().await;
+            idle_interrupt_receiver.recv().await.ok();

            // cancel imap idle connection properly
            drop(interrupt);

-            Ok(Event::Interrupt(info.unwrap_or_default()))
+            Ok(Event::Interrupt)
        });

        match fut.await {
            Ok(Event::IdleResponse(IdleResponse::NewData(x))) => {
-                info!(context, "{}: Idle has NewData {:?}", folder_name, x);
+                info!(context, "{folder}: Idle has NewData {:?}", x);
            }
            Ok(Event::IdleResponse(IdleResponse::Timeout)) => {
-                info!(
-                    context,
-                    "{}: Idle-wait timeout or interruption", folder_name
-                );
+                info!(context, "{folder}: Idle-wait timeout or interruption");
            }
            Ok(Event::IdleResponse(IdleResponse::ManualInterrupt)) => {
-                info!(
-                    context,
-                    "{}: Idle wait was interrupted manually", folder_name
-                );
+                info!(context, "{folder}: Idle wait was interrupted manually");
            }
-            Ok(Event::Interrupt(i)) => {
-                info!(
-                    context,
-                    "{}: Idle wait was interrupted: {:?}", folder_name, &i
-                );
-                info = i;
+            Ok(Event::Interrupt) => {
+                info!(context, "{folder}: Idle wait was interrupted");
            }
            Err(err) => {
-                warn!(context, "{}: Idle wait errored: {:?}", folder_name, err);
+                warn!(context, "{folder}: Idle wait errored: {err:?}");
            }
        }

        let mut session = tokio::time::timeout(Duration::from_secs(15), handle.done())
            .await
-            .with_context(|| format!("{folder_name}: IMAP IDLE protocol timed out"))?
-            .with_context(|| format!("{folder_name}: IMAP IDLE failed"))?;
+            .with_context(|| format!("{folder}: IMAP IDLE protocol timed out"))?
+            .with_context(|| format!("{folder}: IMAP IDLE failed"))?;
        session.as_mut().set_read_timeout(Some(IMAP_TIMEOUT));
        self.inner = session;

-        Ok((self, info))
+        Ok(self)
    }
 }

@@ -114,7 +119,7 @@ impl Imap {
        context: &Context,
        watch_folder: Option<String>,
        folder_meaning: FolderMeaning,
-    ) -> InterruptInfo {
+    ) {
        // Idle using polling. This is also needed if we're not yet configured -
        // in this case, we're waiting for a configure job (and an interrupt).

@@ -125,32 +130,33 @@ impl Imap {
            watch_folder
        } else {
            info!(context, "IMAP-fake-IDLE: no folder, waiting for interrupt");
-            return self
-                .idle_interrupt_receiver
-                .recv()
-                .await
-                .unwrap_or_default();
+            self.idle_interrupt_receiver.recv().await.ok();
+            return;
        };
        info!(context, "IMAP-fake-IDLEing folder={:?}", watch_folder);

-        // check every minute if there are new messages
-        // TODO: grow sleep durations / make them more flexible
-        let mut interval = tokio::time::interval(Duration::from_secs(60));
-
+        const TIMEOUT_INIT_MS: u64 = 60_000;
+        let mut timeout_ms: u64 = TIMEOUT_INIT_MS;
        enum Event {
            Tick,
-            Interrupt(InterruptInfo),
+            Interrupt,
        }
        // loop until we are interrupted or if we fetched something
-        let info = loop {
+        loop {
            use futures::future::FutureExt;
+            use rand::Rng;
+
+            let mut interval = tokio::time::interval(Duration::from_millis(timeout_ms));
+            timeout_ms = timeout_ms
+                .saturating_add(rand::thread_rng().gen_range((timeout_ms / 2)..=timeout_ms));
+            interval.tick().await; // The first tick completes immediately.
            match interval
                .tick()
                .map(|_| Event::Tick)
                .race(
                    self.idle_interrupt_receiver
                        .recv()
-                        .map(|probe_network| Event::Interrupt(probe_network.unwrap_or_default())),
+                        .map(|_| Event::Interrupt),
                )
                .await
            {
@@ -163,9 +169,16 @@ impl Imap {
                        continue;
                    }
                    if let Some(session) = &self.session {
-                        if session.can_idle() {
+                        if session.can_idle()
+                            && !context
+                                .get_config_bool(Config::DisableIdle)
+                                .await
+                                .context("Failed to get disable_idle config")
+                                .log_err(context)
+                                .unwrap_or_default()
+                        {
                            // we only fake-idled because network was gone during IDLE, probably
-                            break InterruptInfo::new(false);
+                            break;
                        }
                    }
                    info!(context, "fake_idle is connected");
@@ -179,8 +192,9 @@ impl Imap {
                    {
                        Ok(res) => {
                            info!(context, "fetch_new_messages returned {:?}", res);
+                            timeout_ms = TIMEOUT_INIT_MS;
                            if res {
-                                break InterruptInfo::new(false);
+                                break;
                            }
                        }
                        Err(err) => {
@@ -189,13 +203,12 @@ impl Imap {
                        }
                    }
                }
-                Event::Interrupt(info) => {
-                    // Interrupt
+                Event::Interrupt => {
                    info!(context, "Fake IDLE interrupted");
-                    break info;
+                    break;
                }
            }
-        };
+        }

        info!(
            context,
@@ -206,7 +219,5 @@ impl Imap {
                .as_millis() as f64
                / 1000.,
        );
-
-        info
    }
 }
--- a/src/imex.rs
+++ b/src/imex.rs
@@ -60,8 +60,7 @@ pub enum ImexMode {
    /// Export a backup to the directory given as `path` with the given `passphrase`.
    /// The backup contains all contacts, chats, images and other data and device independent settings.
    /// The backup does not contain device dependent settings as ringtones or LED notification settings.
-    /// The name of the backup is typically `delta-chat-<day>.tar`, if more than one backup is create on a day,
-    /// the format is `delta-chat-<day>-<number>.tar`
+    /// The name of the backup is `delta-chat-backup-<day>-<number>-<addr>.tar`.
    ExportBackup = 11,

    /// `path` is the file (not: directory) to import. The file is normally
@@ -130,7 +129,7 @@ pub async fn has_backup(_context: &Context, dir_name: &Path) -> Result<String> {
            && (newest_backup_name.is_empty() || name > newest_backup_name)
        {
            // We just use string comparison to determine which backup is newer.
-            // This works fine because the filenames have the form ...delta-chat-backup-2020-07-24-00.tar
+            // This works fine because the filenames have the form `delta-chat-backup-2023-10-18-00-foo@example.com.tar`
            newest_backup_path = Some(path);
            newest_backup_name = name;
        }
@@ -486,7 +485,11 @@ async fn import_backup(
 /// Returns Ok((temp_db_path, temp_path, dest_path)) on success. Unencrypted database can be
 /// written to temp_db_path. The backup can then be written to temp_path. If the backup succeeded,
 /// it can be renamed to dest_path. This guarantees that the backup is complete.
-fn get_next_backup_path(folder: &Path, backup_time: i64) -> Result<(PathBuf, PathBuf, PathBuf)> {
+fn get_next_backup_path(
+    folder: &Path,
+    addr: &str,
+    backup_time: i64,
+) -> Result<(PathBuf, PathBuf, PathBuf)> {
    let folder = PathBuf::from(folder);
    let stem = chrono::NaiveDateTime::from_timestamp_opt(backup_time, 0)
        .context("can't get next backup path")?
@@ -497,13 +500,13 @@ fn get_next_backup_path(folder: &Path, backup_time: i64) -> Result<(PathBuf, Pat
    // 64 backup files per day should be enough for everyone
    for i in 0..64 {
        let mut tempdbfile = folder.clone();
-        tempdbfile.push(format!("{stem}-{i:02}.db"));
+        tempdbfile.push(format!("{stem}-{i:02}-{addr}.db"));

        let mut tempfile = folder.clone();
-        tempfile.push(format!("{stem}-{i:02}.tar.part"));
+        tempfile.push(format!("{stem}-{i:02}-{addr}.tar.part"));

        let mut destfile = folder.clone();
-        destfile.push(format!("{stem}-{i:02}.tar"));
+        destfile.push(format!("{stem}-{i:02}-{addr}.tar"));

        if !tempdbfile.exists() && !tempfile.exists() && !destfile.exists() {
            return Ok((tempdbfile, tempfile, destfile));
@@ -518,7 +521,8 @@ fn get_next_backup_path(folder: &Path, backup_time: i64) -> Result<(PathBuf, Pat
 async fn export_backup(context: &Context, dir: &Path, passphrase: String) -> Result<()> {
    // get a fine backup file name (the name includes the date so that multiple backup instances are possible)
    let now = time();
-    let (temp_db_path, temp_path, dest_path) = get_next_backup_path(dir, now)?;
+    let self_addr = context.get_primary_self_addr().await?;
+    let (temp_db_path, temp_path, dest_path) = get_next_backup_path(dir, &self_addr, now)?;
    let _d1 = DeleteOnDrop(temp_db_path.clone());
    let _d2 = DeleteOnDrop(temp_path.clone());

--- a/src/job.rs
+++ b/src/job.rs
@@ -1,390 +0,0 @@
-//! # Job module.
-//!
-//! This module implements a job queue maintained in the SQLite database
-//! and job types.
-
-#![allow(missing_docs)]
-
-use std::fmt;
-use std::sync::atomic::Ordering;
-
-use anyhow::{Context as _, Result};
-use deltachat_derive::{FromSql, ToSql};
-use rand::{thread_rng, Rng};
-
-use crate::context::Context;
-use crate::imap::Imap;
-use crate::scheduler::InterruptInfo;
-use crate::tools::time;
-
-// results in ~3 weeks for the last backoff timespan
-const JOB_RETRIES: u32 = 17;
-
-/// Job try result.
-#[derive(Debug, Display)]
-pub enum Status {
-    Finished(Result<()>),
-    RetryNow,
-}
-
-#[macro_export]
-macro_rules! job_try {
-    ($expr:expr) => {
-        match $expr {
-            std::result::Result::Ok(val) => val,
-            std::result::Result::Err(err) => {
-                return $crate::job::Status::Finished(Err(err.into()));
-            }
-        }
-    };
-    ($expr:expr,) => {
-        $crate::job_try!($expr)
-    };
-}
-
-#[derive(
-    Debug,
-    Display,
-    Copy,
-    Clone,
-    PartialEq,
-    Eq,
-    PartialOrd,
-    FromPrimitive,
-    ToPrimitive,
-    FromSql,
-    ToSql,
-)]
-#[repr(u32)]
-pub enum Action {
-    // This job will download partially downloaded messages completely
-    // and is added when download_full() is called.
-    // Most messages are downloaded automatically on fetch
-    // and do not go through this job.
-    DownloadMsg = 250,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct Job {
-    pub job_id: u32,
-    pub action: Action,
-    pub foreign_id: u32,
-    pub desired_timestamp: i64,
-    pub added_timestamp: i64,
-    pub tries: u32,
-}
-
-impl fmt::Display for Job {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "#{}, action {}", self.job_id, self.action)
-    }
-}
-
-impl Job {
-    pub fn new(action: Action, foreign_id: u32) -> Self {
-        let timestamp = time();
-
-        Self {
-            job_id: 0,
-            action,
-            foreign_id,
-            desired_timestamp: timestamp,
-            added_timestamp: timestamp,
-            tries: 0,
-        }
-    }
-
-    /// Deletes the job from the database.
-    async fn delete(self, context: &Context) -> Result<()> {
-        if self.job_id != 0 {
-            context
-                .sql
-                .execute("DELETE FROM jobs WHERE id=?;", (self.job_id as i32,))
-                .await?;
-        }
-
-        Ok(())
-    }
-
-    /// Saves the job to the database, creating a new entry if necessary.
-    ///
-    /// The Job is consumed by this method.
-    pub(crate) async fn save(self, context: &Context) -> Result<()> {
-        info!(context, "saving job {:?}", self);
-
-        if self.job_id != 0 {
-            context
-                .sql
-                .execute(
-                    "UPDATE jobs SET desired_timestamp=?, tries=? WHERE id=?;",
-                    (
-                        self.desired_timestamp,
-                        i64::from(self.tries),
-                        self.job_id as i32,
-                    ),
-                )
-                .await?;
-        } else {
-            context.sql.execute(
-                "INSERT INTO jobs (added_timestamp, action, foreign_id, desired_timestamp) VALUES (?,?,?,?);",
-                (
-                    self.added_timestamp,
-                    self.action,
-                    self.foreign_id,
-                    self.desired_timestamp
-                )
-            ).await?;
-        }
-
-        Ok(())
-    }
-}
-
-pub(crate) enum Connection<'a> {
-    Inbox(&'a mut Imap),
-}
-
-impl<'a> Connection<'a> {
-    fn inbox(&mut self) -> &mut Imap {
-        match self {
-            Connection::Inbox(imap) => imap,
-        }
-    }
-}
-
-pub(crate) async fn perform_job(context: &Context, mut connection: Connection<'_>, mut job: Job) {
-    info!(context, "Job {} started...", &job);
-
-    let try_res = match perform_job_action(context, &job, &mut connection, 0).await {
-        Status::RetryNow => perform_job_action(context, &job, &mut connection, 1).await,
-        x => x,
-    };
-
-    match try_res {
-        Status::RetryNow => {
-            let tries = job.tries + 1;
-
-            if tries < JOB_RETRIES {
-                info!(context, "Increase job {job} tries to {tries}.");
-                job.tries = tries;
-                let time_offset = get_backoff_time_offset(tries);
-                job.desired_timestamp = time() + time_offset;
-                info!(
-                    context,
-                    "job #{} not succeeded on try #{}, retry in {} seconds.",
-                    job.job_id,
-                    tries,
-                    time_offset
-                );
-                job.save(context).await.unwrap_or_else(|err| {
-                    error!(context, "Failed to save job: {err:#}.");
-                });
-            } else {
-                info!(
-                    context,
-                    "Remove job {job} as it exhausted {JOB_RETRIES} retries."
-                );
-                job.delete(context).await.unwrap_or_else(|err| {
-                    error!(context, "Failed to delete job: {err:#}.");
-                });
-            }
-        }
-        Status::Finished(res) => {
-            if let Err(err) = res {
-                warn!(context, "Remove job {job} as it failed with error {err:#}.");
-            } else {
-                info!(context, "Remove job {job} as it succeeded.");
-            }
-
-            job.delete(context).await.unwrap_or_else(|err| {
-                error!(context, "failed to delete job: {:#}", err);
-            });
-        }
-    }
-}
-
-async fn perform_job_action(
-    context: &Context,
-    job: &Job,
-    connection: &mut Connection<'_>,
-    tries: u32,
-) -> Status {
-    info!(context, "Begin immediate try {tries} of job {job}.");
-
-    let try_res = match job.action {
-        Action::DownloadMsg => job.download_msg(context, connection.inbox()).await,
-    };
-
-    info!(context, "Finished immediate try {tries} of job {job}.");
-
-    try_res
-}
-
-fn get_backoff_time_offset(tries: u32) -> i64 {
-    // Exponential backoff
-    let n = 2_i32.pow(tries - 1) * 60;
-    let mut rng = thread_rng();
-    let r: i32 = rng.gen();
-    let mut seconds = r % (n + 1);
-    if seconds < 1 {
-        seconds = 1;
-    }
-    i64::from(seconds)
-}
-
-pub(crate) async fn schedule_resync(context: &Context) -> Result<()> {
-    context.resync_request.store(true, Ordering::Relaxed);
-    context
-        .scheduler
-        .interrupt_inbox(InterruptInfo {
-            probe_network: false,
-        })
-        .await;
-    Ok(())
-}
-
-/// Adds a job to the database, scheduling it.
-pub async fn add(context: &Context, job: Job) -> Result<()> {
-    job.save(context).await.context("failed to save job")?;
-
-    info!(context, "Interrupt: IMAP.");
-    context
-        .scheduler
-        .interrupt_inbox(InterruptInfo::new(false))
-        .await;
-    Ok(())
-}
-
-/// Load jobs from the database.
-///
-/// The `probe_network` parameter decides how to query
-/// jobs, this is tricky and probably wrong currently. Look at the
-/// SQL queries for details.
-pub(crate) async fn load_next(context: &Context, info: &InterruptInfo) -> Result<Option<Job>> {
-    info!(context, "Loading job.");
-
-    let query;
-    let params;
-    let t = time();
-
-    if !info.probe_network {
-        // processing for first-try and after backoff-timeouts:
-        // process jobs in the order they were added.
-        query = r#"
-SELECT id, action, foreign_id, param, added_timestamp, desired_timestamp, tries
-FROM jobs
-WHERE desired_timestamp<=?
-ORDER BY action DESC, added_timestamp
-LIMIT 1;
-"#;
-        params = vec![t];
-    } else {
-        // processing after call to dc_maybe_network():
-        // process _all_ pending jobs that failed before
-        // in the order of their backoff-times.
-        query = r#"
-SELECT id, action, foreign_id, param, added_timestamp, desired_timestamp, tries
-FROM jobs
-WHERE tries>0
-ORDER BY desired_timestamp, action DESC
-LIMIT 1;
-"#;
-        params = vec![];
-    };
-
-    loop {
-        let job_res = context
-            .sql
-            .query_row_optional(query, rusqlite::params_from_iter(params.clone()), |row| {
-                let job = Job {
-                    job_id: row.get("id")?,
-                    action: row.get("action")?,
-                    foreign_id: row.get("foreign_id")?,
-                    desired_timestamp: row.get("desired_timestamp")?,
-                    added_timestamp: row.get("added_timestamp")?,
-                    tries: row.get("tries")?,
-                };
-
-                Ok(job)
-            })
-            .await;
-
-        match job_res {
-            Ok(job) => return Ok(job),
-            Err(err) => {
-                // Remove invalid job from the DB
-                info!(context, "Cleaning up job, because of {err:#}.");
-
-                // TODO: improve by only doing a single query
-                let id = context
-                    .sql
-                    .query_row(query, rusqlite::params_from_iter(params.clone()), |row| {
-                        row.get::<_, i32>(0)
-                    })
-                    .await
-                    .context("failed to retrieve invalid job ID from the database")?;
-                context
-                    .sql
-                    .execute("DELETE FROM jobs WHERE id=?;", (id,))
-                    .await
-                    .with_context(|| format!("failed to delete invalid job {id}"))?;
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::test_utils::TestContext;
-
-    async fn insert_job(context: &Context, foreign_id: i64, valid: bool) {
-        let now = time();
-        context
-            .sql
-            .execute(
-                "INSERT INTO jobs
-                   (added_timestamp, action, foreign_id, desired_timestamp)
-                 VALUES (?, ?, ?, ?);",
-                (
-                    now,
-                    if valid {
-                        Action::DownloadMsg as i32
-                    } else {
-                        -1
-                    },
-                    foreign_id,
-                    now,
-                ),
-            )
-            .await
-            .unwrap();
-    }
-
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_load_next_job_two() -> Result<()> {
-        // We want to ensure that loading jobs skips over jobs which
-        // fails to load from the database instead of failing to load
-        // all jobs.
-        let t = TestContext::new().await;
-        insert_job(&t, 1, false).await; // This can not be loaded into Job struct.
-        let jobs = load_next(&t, &InterruptInfo::new(false)).await?;
-        assert!(jobs.is_none());
-
-        insert_job(&t, 1, true).await;
-        let jobs = load_next(&t, &InterruptInfo::new(false)).await?;
-        assert!(jobs.is_some());
-        Ok(())
-    }
-
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_load_next_job_one() -> Result<()> {
-        let t = TestContext::new().await;
-
-        insert_job(&t, 1, true).await;
-
-        let jobs = load_next(&t, &InterruptInfo::new(false)).await?;
-        assert!(jobs.is_some());
-        Ok(())
-    }
-}
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -65,10 +65,6 @@ mod e2ee;
 pub mod ephemeral;
 mod imap;
 pub mod imex;
-pub mod release;
-mod scheduler;
-#[macro_use]
-mod job;
 pub mod key;
 pub mod location;
 mod login_param;
@@ -83,6 +79,8 @@ pub mod provider;
 pub mod qr;
 pub mod qr_code_generator;
 pub mod quota;
+pub mod release;
+mod scheduler;
 pub mod securejoin;
 mod simplify;
 mod smtp;
--- a/src/message.rs
+++ b/src/message.rs
@@ -24,7 +24,6 @@ use crate::mimeparser::{parse_message_id, SystemMessage};
 use crate::param::{Param, Params};
 use crate::pgp::split_armored_data;
 use crate::reaction::get_msg_reactions;
-use crate::scheduler::InterruptInfo;
 use crate::sql;
 use crate::summary::Summary;
 use crate::tools::{
@@ -150,21 +149,53 @@ WHERE id=?;
        self.0
    }

+    /// Returns raw text of a message, used for message info
+    pub async fn rawtext(self, context: &Context) -> Result<String> {
+        Ok(context
+            .sql
+            .query_get_value("SELECT txt_raw FROM msgs WHERE id=?", (self,))
+            .await?
+            .unwrap_or_default())
+    }
+
+    /// Returns server foldernames and UIDs of a message, used for message info
+    pub async fn get_info_server_urls(
+        context: &Context,
+        rfc724_mid: String,
+    ) -> Result<Vec<String>> {
+        context
+            .sql
+            .query_map(
+                "SELECT folder, uid FROM imap WHERE rfc724_mid=?",
+                (rfc724_mid,),
+                |row| {
+                    let folder: String = row.get("folder")?;
+                    let uid: u32 = row.get("uid")?;
+                    Ok(format!("</{folder}/;UID={uid}>"))
+                },
+                |rows| {
+                    rows.collect::<std::result::Result<Vec<_>, _>>()
+                        .map_err(Into::into)
+                },
+            )
+            .await
+    }
+
+    /// Returns information about hops of a message, used for message info
+    pub async fn hop_info(self, context: &Context) -> Result<Option<String>> {
+        context
+            .sql
+            .query_get_value("SELECT hop_info FROM msgs WHERE id=?", (self,))
+            .await
+    }
+
    /// Returns detailed message information in a multi-line text form.
    pub async fn get_info(self, context: &Context) -> Result<String> {
        let msg = Message::load_from_db(context, self).await?;
-        let rawtxt: Option<String> = context
-            .sql
-            .query_get_value("SELECT txt_raw FROM msgs WHERE id=?", (self,))
-            .await?;
+        let rawtxt: String = self.rawtext(context).await?;

        let mut ret = String::new();

-        if rawtxt.is_none() {
-            ret += &format!("Cannot load message {self}.");
-            return Ok(ret);
-        }
-        let rawtxt = rawtxt.unwrap_or_default();
        let rawtxt = truncate(rawtxt.trim(), DC_DESIRED_TEXT_LEN);

        let fts = timestamp_to_str(msg.get_timestamp());
@@ -282,32 +313,13 @@ WHERE id=?;
        if !msg.rfc724_mid.is_empty() {
            ret += &format!("\nMessage-ID: {}", msg.rfc724_mid);

-            let server_uids = context
-                .sql
-                .query_map(
-                    "SELECT folder, uid FROM imap WHERE rfc724_mid=?",
-                    (msg.rfc724_mid,),
-                    |row| {
-                        let folder: String = row.get("folder")?;
-                        let uid: u32 = row.get("uid")?;
-                        Ok((folder, uid))
-                    },
-                    |rows| {
-                        rows.collect::<std::result::Result<Vec<_>, _>>()
-                            .map_err(Into::into)
-                    },
-                )
-                .await?;
-
-            for (folder, uid) in server_uids {
+            let server_urls = Self::get_info_server_urls(context, msg.rfc724_mid).await?;
+            for server_url in server_urls {
                // Format as RFC 5092 relative IMAP URL.
-                ret += &format!("\n</{folder}/;UID={uid}>");
+                ret += &format!("\n{server_url}");
            }
        }
-        let hop_info: Option<String> = context
-            .sql
-            .query_get_value("SELECT hop_info FROM msgs WHERE id=?;", (self,))
-            .await?;
+        let hop_info = self.hop_info(context).await?;

        ret += "\n\n";
        ret += &hop_info.unwrap_or_else(|| "No Hop Info".to_owned());
@@ -649,6 +661,12 @@ impl Message {
        self.id
    }

+    /// Returns the rfc724 message ID
+    /// May be empty
+    pub fn rfc724_mid(&self) -> &str {
+        &self.rfc724_mid
+    }
+
    /// Returns the ID of the contact who wrote the message.
    pub fn get_from_id(&self) -> ContactId {
        self.from_id
@@ -664,6 +682,12 @@ impl Message {
        self.viewtype
    }

+    /// Forces the message to **keep** [Viewtype::Sticker]
+    /// e.g the message will not be converted to a [Viewtype::Image].
+    pub fn force_sticker(&mut self) {
+        self.param.set_int(Param::ForceSticker, 1);
+    }
+
    /// Returns the state of the message.
    pub fn get_state(&self) -> MessageState {
        self.state
@@ -1502,10 +1526,7 @@ pub async fn delete_msgs(context: &Context, msg_ids: &[MsgId]) -> Result<()> {
    }

    // Interrupt Inbox loop to start message deletion and run housekeeping.
-    context
-        .scheduler
-        .interrupt_inbox(InterruptInfo::new(false))
-        .await;
+    context.scheduler.interrupt_inbox().await;
    Ok(())
 }

@@ -1623,10 +1644,7 @@ pub async fn markseen_msgs(context: &Context, msg_ids: Vec<MsgId>) -> Result<()>
                        )
                        .await
                        .context("failed to insert into smtp_mdns")?;
-                    context
-                        .scheduler
-                        .interrupt_smtp(InterruptInfo::new(false))
-                        .await;
+                    context.scheduler.interrupt_smtp().await;
                }
            }
            updated_chat_ids.insert(curr_chat_id);
@@ -1793,6 +1811,14 @@ pub async fn estimate_deletion_cnt(
 pub(crate) async fn rfc724_mid_exists(
    context: &Context,
    rfc724_mid: &str,
+) -> Result<Option<MsgId>> {
+    rfc724_mid_exists_and(context, rfc724_mid, "1").await
+}
+
+pub(crate) async fn rfc724_mid_exists_and(
+    context: &Context,
+    rfc724_mid: &str,
+    cond: &str,
 ) -> Result<Option<MsgId>> {
    let rfc724_mid = rfc724_mid.trim_start_matches('<').trim_end_matches('>');
    if rfc724_mid.is_empty() {
@@ -1803,7 +1829,7 @@ pub(crate) async fn rfc724_mid_exists(
    let res = context
        .sql
        .query_row_optional(
-            "SELECT id FROM msgs WHERE rfc724_mid=?",
+            &("SELECT id FROM msgs WHERE rfc724_mid=? AND ".to_string() + cond),
            (rfc724_mid,),
            |row| {
                let msg_id: MsgId = row.get(0)?;
@@ -2333,6 +2359,8 @@ mod tests {
        let msg = alice.get_last_msg().await;
        assert_eq!(msg.get_text(), "hello".to_string());
        assert!(msg.is_bot());
+        let contact = Contact::get_by_id(&alice, msg.from_id).await?;
+        assert!(contact.is_bot());

        // Alice receives a message from Bob who is not the bot anymore.
        receive_imf(
@@ -2350,6 +2378,8 @@ mod tests {
        let msg = alice.get_last_msg().await;
        assert_eq!(msg.get_text(), "hello again".to_string());
        assert!(!msg.is_bot());
+        let contact = Contact::get_by_id(&alice, msg.from_id).await?;
+        assert!(!contact.is_bot());

        Ok(())
    }
--- a/src/mimefactory.rs
+++ b/src/mimefactory.rs
@@ -14,7 +14,7 @@ use crate::chat::Chat;
 use crate::config::Config;
 use crate::constants::{Chattype, DC_FROM_HANDSHAKE};
 use crate::contact::Contact;
-use crate::context::{get_version_str, Context};
+use crate::context::Context;
 use crate::e2ee::EncryptHelper;
 use crate::ephemeral::Timer as EphemeralTimer;
 use crate::html::new_html_mimepart;
@@ -316,7 +316,15 @@ impl<'a> MimeFactory<'a> {
        match &self.loaded {
            Loaded::Message { chat } => {
                if chat.is_protected() {
-                    PeerstateVerifiedStatus::BidirectVerified
+                    if self.msg.get_info_type() == SystemMessage::SecurejoinMessage {
+                        // Securejoin messages are supposed to verify a key.
+                        // In order to do this, it is necessary that they can be sent
+                        // to a key that is not yet verified.
+                        // This has to work independently of whether the chat is protected right now.
+                        PeerstateVerifiedStatus::Unverified
+                    } else {
+                        PeerstateVerifiedStatus::BidirectVerified
+                    }
                } else {
                    PeerstateVerifiedStatus::Unverified
                }
@@ -359,9 +367,10 @@ impl<'a> MimeFactory<'a> {
    async fn should_do_gossip(&self, context: &Context) -> Result<bool> {
        match &self.loaded {
            Loaded::Message { chat } => {
-                // beside key- and member-changes, force re-gossip every 48 hours
+                // beside key- and member-changes, force a periodic re-gossip.
                let gossiped_timestamp = chat.id.get_gossiped_timestamp(context).await?;
-                if time() > gossiped_timestamp + (2 * 24 * 60 * 60) {
+                let gossip_period = context.get_config_i64(Config::GossipPeriod).await?;
+                if time() >= gossiped_timestamp + gossip_period {
                    Ok(true)
                } else {
                    let cmd = self.msg.param.get_cmd();
@@ -414,7 +423,9 @@ impl<'a> MimeFactory<'a> {
                    return Ok(self.msg.subject.clone());
                }

-                if chat.typ == Chattype::Group && quoted_msg_subject.is_none_or_empty() {
+                if (chat.typ == Chattype::Group || chat.typ == Chattype::Broadcast)
+                    && quoted_msg_subject.is_none_or_empty()
+                {
                    let re = if self.in_reply_to.is_empty() {
                        ""
                    } else {
@@ -423,15 +434,13 @@ impl<'a> MimeFactory<'a> {
                    return Ok(format!("{}{}", re, chat.name));
                }

-                if chat.typ != Chattype::Broadcast {
-                    let parent_subject = if quoted_msg_subject.is_none_or_empty() {
-                        chat.param.get(Param::LastSubject)
-                    } else {
-                        quoted_msg_subject.as_deref()
-                    };
-                    if let Some(last_subject) = parent_subject {
-                        return Ok(format!("Re: {}", remove_subject_prefix(last_subject)));
-                    }
+                let parent_subject = if quoted_msg_subject.is_none_or_empty() {
+                    chat.param.get(Param::LastSubject)
+                } else {
+                    quoted_msg_subject.as_deref()
+                };
+                if let Some(last_subject) = parent_subject {
+                    return Ok(format!("Re: {}", remove_subject_prefix(last_subject)));
                }

                let self_name = &match context.get_config(Config::Displayname).await? {
@@ -593,6 +602,16 @@ impl<'a> MimeFactory<'a> {
            ));
        }

+        if let Loaded::Message { chat } = &self.loaded {
+            if chat.typ == Chattype::Broadcast {
+                let encoded_chat_name = encode_words(&chat.name);
+                headers.protected.push(Header::new(
+                    "List-ID".into(),
+                    format!("{encoded_chat_name} <{}>", chat.grpid),
+                ));
+            }
+        }
+
        // Non-standard headers.
        headers
            .unprotected
@@ -1347,14 +1366,12 @@ impl<'a> MimeFactory<'a> {
        );

        // second body part: machine-readable, always REQUIRED by RFC 6522
-        let version = get_version_str();
        let message_text2 = format!(
-            "Reporting-UA: Delta Chat {}\r\n\
-             Original-Recipient: rfc822;{}\r\n\
+            "Original-Recipient: rfc822;{}\r\n\
             Final-Recipient: rfc822;{}\r\n\
             Original-Message-ID: <{}>\r\n\
             Disposition: manual-action/MDN-sent-automatically; displayed\r\n",
-            version, self.from_addr, self.from_addr, self.msg.rfc724_mid
+            self.from_addr, self.from_addr, self.msg.rfc724_mid
        );

        let extension_fields = if additional_msg_ids.is_empty() {
@@ -2340,7 +2357,7 @@ mod tests {
        // Now Bob can send an encrypted message to Alice.
        let mut msg = Message::new(Viewtype::File);
        // Long messages are truncated and MimeMessage::decoded_data is set for them. We need
-        // decoded_data to check presense of the necessary headers.
+        // decoded_data to check presence of the necessary headers.
        msg.set_text("a".repeat(constants::DC_DESIRED_TEXT_LEN + 1));
        msg.set_file_from_bytes(&bob, "foo.bar", "content".as_bytes(), None)
            .await?;
--- a/src/mimeparser.rs
+++ b/src/mimeparser.rs
@@ -59,7 +59,7 @@ pub(crate) struct MimeMessage {
    /// Message headers.
    headers: HashMap<String, String>,

-    /// Addresses are normalized and lowercased:
+    /// Addresses are normalized and lowercase
    pub recipients: Vec<SingleInfo>,

    /// `From:` address.
@@ -109,11 +109,15 @@ pub(crate) struct MimeMessage {

    /// The decrypted, raw mime structure.
    ///
-    /// This is non-empty only if the message was actually encrypted.  It is used
+    /// This is non-empty iff `is_mime_modified` and the message was actually encrypted. It is used
    /// for e.g. late-parsing HTML.
    pub decoded_data: Vec<u8>,

+    /// Hop info for debugging.
    pub(crate) hop_info: String,
+
+    /// Whether the contact sending this should be marked as bot.
+    pub(crate) is_bot: bool,
 }

 #[derive(Debug, PartialEq)]
@@ -122,23 +126,6 @@ pub(crate) enum AvatarAction {
    Change(String),
 }

-#[derive(Debug, PartialEq)]
-pub(crate) enum MailinglistType {
-    /// The message belongs to a mailing list and has a `ListId:`-header
-    /// that should be used to get a unique id.
-    ListIdBased,
-
-    /// The message belongs to a mailing list, but there is no `ListId:`-header;
-    /// `Sender:`-header should be used to get a unique id.
-    /// This method is used by implementations as Majordomo.
-    /// Note, that the `Sender:` header alone is not sufficient to detect these lists,
-    /// `get_mailinglist_type()` check additional conditions therefore.
-    SenderBased,
-
-    /// The message does not belong to a mailing list.
-    None,
-}
-
 /// System message type.
 #[derive(
    Debug, Default, Display, Clone, Copy, PartialEq, Eq, FromPrimitive, ToPrimitive, ToSql, FromSql,
@@ -176,10 +163,10 @@ pub enum SystemMessage {
    /// Chat ephemeral message timer is changed.
    EphemeralTimerChanged = 10,

-    /// Chat protection is enabled.
+    /// "Messages are guaranteed to be end-to-end encrypted from now on."
    ChatProtectionEnabled = 11,

-    /// Chat protection is disabled.
+    /// "%1$s sent a message from another device."
    ChatProtectionDisabled = 12,

    /// Self-sent-message that contains only json used for multi-device-sync;
@@ -389,6 +376,15 @@ impl MimeMessage {
        if !encrypted {
            signatures.clear();
        }
+        if let Some(peerstate) = &mut decryption_info.peerstate {
+            if peerstate.prefer_encrypt != EncryptPreference::Mutual && !signatures.is_empty() {
+                peerstate.prefer_encrypt = EncryptPreference::Mutual;
+                peerstate.save_to_db(&context.sql).await?;
+            }
+        }
+
+        // Auto-submitted is also set by holiday-notices so we also check `chat-version`
+        let is_bot = headers.contains_key("auto-submitted") && headers.contains_key("chat-version");

        let mut parser = MimeMessage {
            parts: Vec::new(),
@@ -418,6 +414,7 @@ impl MimeMessage {
            is_mime_modified: false,
            decoded_data: Vec::new(),
            hop_info,
+            is_bot,
        };

        match partial {
@@ -1217,6 +1214,9 @@ impl MimeMessage {
            }
            msg_type
        } else if filename == "multi-device-sync.json" {
+            if !context.get_config_bool(Config::SyncMsgs).await? {
+                return Ok(());
+            }
            let serialized = String::from_utf8_lossy(decoded_data)
                .parse()
                .unwrap_or_default();
@@ -1340,29 +1340,31 @@ impl MimeMessage {
        self.parts.push(part);
    }

-    pub(crate) fn get_mailinglist_type(&self) -> MailinglistType {
-        if self.get_header(HeaderDef::ListId).is_some() {
-            return MailinglistType::ListIdBased;
-        } else if self.get_header(HeaderDef::Sender).is_some() {
+    pub(crate) fn get_mailinglist_header(&self) -> Option<&str> {
+        if let Some(list_id) = self.get_header(HeaderDef::ListId) {
+            // The message belongs to a mailing list and has a `ListId:`-header
+            // that should be used to get a unique id.
+            return Some(list_id);
+        } else if let Some(sender) = self.get_header(HeaderDef::Sender) {
            // the `Sender:`-header alone is no indicator for mailing list
            // as also used for bot-impersonation via `set_override_sender_name()`
            if let Some(precedence) = self.get_header(HeaderDef::Precedence) {
                if precedence == "list" || precedence == "bulk" {
-                    return MailinglistType::SenderBased;
+                    // The message belongs to a mailing list, but there is no `ListId:`-header;
+                    // `Sender:`-header is be used to get a unique id.
+                    // This method is used by implementations as Majordomo.
+                    return Some(sender);
                }
            }
        }
-        MailinglistType::None
+        None
    }

    pub(crate) fn is_mailinglist_message(&self) -> bool {
-        match self.get_mailinglist_type() {
-            MailinglistType::ListIdBased | MailinglistType::SenderBased => true,
-            MailinglistType::None => false,
-        }
+        self.get_mailinglist_header().is_some()
    }

-    pub fn repl_msg_by_error(&mut self, error_msg: &str) {
+    pub fn replace_msg_by_error(&mut self, error_msg: &str) {
        self.is_system_message = SystemMessage::Unknown;
        if let Some(part) = self.parts.first_mut() {
            part.typ = Viewtype::Text;
--- a/src/net.rs
+++ b/src/net.rs
@@ -1,10 +1,11 @@
 //! # Common network utilities.
+use std::net::Ipv4Addr;
 use std::net::{IpAddr, SocketAddr};
 use std::pin::Pin;
 use std::str::FromStr;
 use std::time::Duration;

-use anyhow::{Context as _, Error, Result};
+use anyhow::{format_err, Context as _, Result};
 use tokio::net::{lookup_host, TcpStream};
 use tokio::time::timeout;
 use tokio_io_timeout::TimeoutStream;
@@ -119,6 +120,22 @@ async fn lookup_host_with_cache(
                }
            }
        }
+
+        if resolved_addrs.is_empty() {
+            // Load hardcoded cache if everything else fails.
+            //
+            // See <https://support.delta.chat/t/no-dns-resolution-result/2778> and
+            // <https://github.com/deltachat/deltachat-core-rust/issues/4920> for reasons.
+            //
+            // In the future we may pre-resolve all provider database addresses
+            // and build them in.
+            if hostname == "mail.sangham.net" {
+                resolved_addrs.push(SocketAddr::new(
+                    IpAddr::V4(Ipv4Addr::new(159, 69, 186, 85)),
+                    port,
+                ));
+            }
+        }
    }

    Ok(resolved_addrs)
@@ -178,7 +195,9 @@ pub(crate) async fn connect_tcp(
    let tcp_stream = match tcp_stream {
        Some(tcp_stream) => tcp_stream,
        None => {
-            return Err(last_error.unwrap_or_else(|| Error::msg("no DNS resolution results")));
+            return Err(
+                last_error.unwrap_or_else(|| format_err!("no DNS resolution results for {host}"))
+            );
        }
    };

--- a/Show More
+++ b/Show More
@@ -1 +1 @@
 -10-05
 -11-10