try to reproduce (#4707 )

test: use instant accounts instead of mailadm
2026-04-02 05:22:14 +03:00 · 2023-10-31 02:12:33 -03:00 · 2023-10-31 02:11:30 -03:00 · 2023-10-30 00:15:22 +00:00 · 2023-10-29 23:36:26 +00:00 · 2023-10-29 17:09:59 +00:00
177 changed files with 10278 additions and 5531 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -14,7 +14,7 @@ on:
  pull_request:
  push:
    branches:
-      - master
+      - main

 env:
  RUSTFLAGS: -Dwarnings
@@ -24,7 +24,7 @@ jobs:
    name: Lint Rust
    runs-on: ubuntu-latest
    env:
-      RUSTUP_TOOLCHAIN: 1.70.0
+      RUSTUP_TOOLCHAIN: 1.73.0
    steps:
      - uses: actions/checkout@v3
      - name: Install rustfmt and clippy
@@ -38,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
@@ -80,19 +76,15 @@ jobs:
      matrix:
        include:
          - os: ubuntu-latest
-            rust: 1.68.2
+            rust: 1.73.0
          - os: windows-latest
-            rust: 1.68.2
+            rust: 1.73.0
          - os: macos-latest
-            rust: 1.68.2
+            rust: 1.73.0

-          # Minimum Supported Rust Version = 1.65.0
-          #
-          # Minimum Supported Python Version = 3.7
-          # This is the minimum version for which manylinux Python wheels are
-          # built.
+          # Minimum Supported Rust Version = 1.70.0
          - os: ubuntu-latest
-            rust: 1.65.0
+            rust: 1.70.0
    runs-on: ${{ matrix.os }}
    steps:
      - uses: actions/checkout@v3
@@ -105,6 +97,8 @@ jobs:
        uses: swatinem/rust-cache@v2

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

      - name: Test cargo vendor
@@ -136,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
@@ -151,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:
@@ -172,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
@@ -181,15 +175,15 @@ jobs:
        include:
          # Currently used Rust version.
          - os: ubuntu-latest
-            python: 3.11
+            python: 3.12
          - os: macos-latest
-            python: 3.11
+            python: 3.12

          # PyPy tests
          - os: ubuntu-latest
-            python: pypy3.9
+            python: pypy3.10
          - os: macos-latest
-            python: pypy3.9
+            python: pypy3.10

          # Minimum Supported Python Version = 3.7
          # This is the minimum version for which manylinux Python wheels are
@@ -217,36 +211,35 @@ 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
      matrix:
        include:
          - os: ubuntu-latest
-            python: 3.11
+            python: 3.12
          - os: macos-latest
-            python: 3.11
+            python: 3.12
+          - os: windows-latest
+            python: 3.12

          # PyPy tests
          - os: ubuntu-latest
-            python: pypy3.9
+            python: pypy3.10
          - os: macos-latest
-            python: pypy3.9
+            python: pypy3.10

-          # Minimum Supported Python Version = 3.8
-          #
-          # Python 3.7 has at least one known bug related to starting subprocesses
-          # in asyncio programs: <https://bugs.python.org/issue35621>
+          # Minimum Supported Python Version = 3.7
          - os: ubuntu-latest
-            python: 3.8
+            python: 3.7

    runs-on: ${{ matrix.os }}
    steps:
@@ -267,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.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
@@ -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:
--- a/.github/workflows/node-package.yml
+++ b/.github/workflows/node-package.yml
@@ -67,7 +67,9 @@ jobs:

    # 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
-    container: debian:10
+    # 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
    steps:
      # Working directory is owned by 1001:1001 by default.
      # Change it to our user.
--- 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:
@@ -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,328 @@
 # Changelog

+## [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.
+
+### 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
+
+- Remove footer from reactions on the receiver side ([#4780](https://github.com/deltachat/deltachat-core-rust/pull/4780)).
+
+### CI
+
+- Pin `urllib3` version to `<2`. ([#4788](https://github.com/deltachat/deltachat-core-rust/issues/4788))
+
+## [1.124.0] - 2023-10-04
+
+### API-Changes
+
+- [**breaking**] Return `DC_CONTACT_ID_SELF` from `dc_contact_get_verifier_id()` for directly verified contacts.
+- Deprecate `dc_contact_get_verifier_addr`.
+- python: use `dc_contact_get_verifier_id()`. `get_verifier()` returns a Contact rather than an address now.
+- Deprecate `get_next_media()`.
+- Ignore public key argument in `dc_preconfigure_keypair()`. Public key is extracted from the private key.
+
+### Fixes
+
+- Wrap base64-encoded parts to 76 characters.
+- Require valid email addresses in `dc_provider_new_from_email[_with_dns]`.
+- Do not trash messages with attachments and no text when `location.kml` is attached ([#4749](https://github.com/deltachat/deltachat-core-rust/issues/4749)).
+- Initialise `last_msg_id` to the highest known row id. This ensures bots migrated from older version to `dc_get_next_msgs()` API do not process all previous messages from scratch.
+- Do not put the status footer into reaction MIME parts.
+- Ignore special chats in `get_similar_chat_ids()`. This prevents trash chat from showing up in similar chat list ([#4756](https://github.com/deltachat/deltachat-core-rust/issues/4756)).
+- Cap percentage in connectivity layout to 100% ([#4765](https://github.com/deltachat/deltachat-core-rust/pull/4765)).
+- Add Let's Encrypt root certificate to `reqwest`. This should allow scanning `DCACCOUNT` QR-codes on older Android phones when the server has a Let's Encrypt certificate.
+- deltachat-rpc-client: Increase stdio buffer to 64 MiB to avoid Python bots crashing when trying to load large messages via a JSON-RPC call.
+- Add `protected-headers` directive to Content-Type of encrypted messages with attachments ([#2302](https://github.com/deltachat/deltachat-core-rust/issues/2302)). This makes Thunderbird show encrypted Subject for Delta Chat messages.
+- webxdc: Reset `document.update` on forwarding. This fixes the test `test_forward_webxdc_instance()`.
+
+### Features / Changes
+
+- Remove extra members from the local list in sake of group membership consistency ([#3782](https://github.com/deltachat/deltachat-core-rust/issues/3782)).
+- deltachat-rpc-client: Log exceptions when long-running tasks die.
+
+### Build
+
+- Build wheels for Python 3.12 and PyPy 3.10.
+
+## [1.123.0] - 2023-09-22
+
+### API-Changes
+
+- Make it possible to import secret key from a file with `DC_IMEX_IMPORT_SELF_KEYS`.
+- [**breaking**] Make `dc_jsonrpc_blocking_call` accept JSON-RPC request.
+
+### Fixes
+
+- `lookup_chat_by_reply()`: Skip not fully downloaded and undecipherable messages ([#4676](https://github.com/deltachat/deltachat-core-rust/pull/4676)).
+- `lookup_chat_by_reply()`: Skip undecipherable parent messages created by older versions ([#4676](https://github.com/deltachat/deltachat-core-rust/pull/4676)).
+- imex: Use "default" in the filename of the default key.
+
+### Miscellaneous Tasks
+
+- Update OpenSSL from 3.1.2 to 3.1.3.
+
+## [1.122.0] - 2023-09-12
+
+### API-Changes
+
+- jsonrpc: Return only chat IDs for similar chats.
+
+### Fixes
+
+- Reopen all connections on database passpharse change.
+- Do not block new group chats if 1:1 chat is blocked.
+- Improve group membership consistency algorithm ([#3782](https://github.com/deltachat/deltachat-core-rust/pull/3782))([#4624](https://github.com/deltachat/deltachat-core-rust/pull/4624)).
+- Forbid membership changes from possible non-members ([#3782](https://github.com/deltachat/deltachat-core-rust/pull/3782)).
+- `ChatId::parent_query()`: Don't filter out OutPending and OutFailed messages.
+
+### Build system
+
+- Update to OpenSSL 3.0.
+- Bump webpki from 0.22.0 to 0.22.1.
+- python: Add link to Mastodon into projects.urls.
+
+### Features / Changes
+
+- Add RSA-4096 key generation support.
+
+### Refactor
+
+- pgp: Add constants for encryption algorithm and hash.
+
+## [1.121.0] - 2023-09-06
+
+### API-Changes
+
+- Add `dc_context_change_passphrase()`.
+- Add `Message.set_file_from_bytes()` API.
+- Add experimental API to get similar chats.
+
+### Build system
+
+- Build node packages on Ubuntu 18.04 instead of Debian 10.
+  This reduces the requirement for glibc version from 2.28 to 2.27.
+
+### Fixes
+
+- Allow membership changes by a MUA if we're not in the group ([#4624](https://github.com/deltachat/deltachat-core-rust/pull/4624)).
+- Save mime headers for messages not signed with a known key ([#4557](https://github.com/deltachat/deltachat-core-rust/pull/4557)).
+- 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)).
+- Do not allow dots at the end of email addresses.
+- deltachat-rpc-client: Remove `aiodns` optional dependency from required dependencies.
+  `aiodns` depends on `pycares` which [fails to install in Termux](https://github.com/saghul/aiodns/issues/98).
+
+## [1.120.0] - 2023-08-28
+
+### API-Changes
+
+- jsonrpc: Add `resend_messages`.
+
+### Fixes
+
+- Update async-imap to 0.9.1 to fix memory leak.
+- Delete messages from SMTP queue only on user demand ([#4579](https://github.com/deltachat/deltachat-core-rust/pull/4579)).
+- Do not send images without transparency as stickers ([#4611](https://github.com/deltachat/deltachat-core-rust/pull/4611)).
+- `prepare_msg_blob()`: do not use the image if it has Exif metadata but the image cannot be recoded.
+
+### Refactor
+
+- Hide accounts.rs constants from public API.
+- Hide pgp module from public API.
+
+### Build system
+
+- Update to Zig 0.11.0.
+- Update to Rust 1.72.0.
+
+### CI
+
+- Run on push to stable branch.
+
+### Miscellaneous Tasks
+
+- python: Fix lint errors.
+- python: Fix `ruff` 0.0.286 warnings.
+- Fix beta clippy warnings.
+
+## [1.119.1] - 2023-08-06
+
+Bugfix release attempting to fix the [iOS build error](https://github.com/deltachat/deltachat-core-rust/issues/4610).
+
+### Features / Changes
+
+- Guess message viewtype from "application/octet-stream" attachment extension ([#4378](https://github.com/deltachat/deltachat-core-rust/pull/4378)).
+
+### Fixes
+
+- Update `xattr` from 1.0.0 to 1.0.1 to fix UnsupportedPlatformError import.
+
+### Tests
+
+- webxdc: Ensure unknown WebXDC update properties do not result in an error.
+
 ## [1.119.0] - 2023-08-03

 ### Fixes
@@ -769,7 +1092,7 @@

 ### 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
@@ -2355,7 +2678,7 @@

 - 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

@@ -2712,3 +3035,17 @@ https://github.com/deltachat/deltachat-core-rust/pulls?q=is%3Apr+is%3Aclosed
 [1.116.0]: https://github.com/deltachat/deltachat-core-rust/compare/v1.115.0...v1.116.0
 [1.117.0]: https://github.com/deltachat/deltachat-core-rust/compare/v1.116.0...v1.117.0
 [1.118.0]: https://github.com/deltachat/deltachat-core-rust/compare/v1.117.0...v1.118.0
+[1.119.0]: https://github.com/deltachat/deltachat-core-rust/compare/v1.118.0...v1.119.0
+[1.119.1]: https://github.com/deltachat/deltachat-core-rust/compare/v1.119.0...v1.119.1
+[1.120.0]: https://github.com/deltachat/deltachat-core-rust/compare/v1.119.1...v1.120.0
+[1.121.0]: https://github.com/deltachat/deltachat-core-rust/compare/v1.120.0...v1.121.0
+[1.122.0]: https://github.com/deltachat/deltachat-core-rust/compare/v1.121.0...v1.122.0
+[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
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -76,6 +76,29 @@ If you have multiple changes in one PR, create multiple conventional commits, an
 [Conventional Commits]: https://www.conventionalcommits.org/
 [git-cliff]: https://git-cliff.org/

+### Errors
+
+Delta Chat core mostly uses [`anyhow`](https://docs.rs/anyhow/) errors.
+When using [`Context`](https://docs.rs/anyhow/latest/anyhow/trait.Context.html),
+capitalize it but do not add a full stop as the contexts will be separated by `:`.
+For example:
+```
+.with_context(|| format!("Unable to trash message {msg_id}"))
+```
+
+### Logging
+
+For logging, use `info!`, `warn!` and `error!` macros.
+Log messages should be capitalized and have a full stop in the end. For example:
+```
+info!(context, "Ignoring addition of {added_addr:?} to {chat_id}.");
+```
+
+Format anyhow errors with `{:#}` to print all the contexts like this:
+```
+error!(context, "Failed to set selfavatar timestamp: {err:#}.");
+```
+
 ### Reviewing

 Once a PR has an approval and passes CI, it can be merged.
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,9 +1,9 @@
 [package]
 name = "deltachat"
-version = "1.119.0"
+version = "1.127.2"
 edition = "2021"
 license = "MPL-2.0"
-rust-version = "1.65"
+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,25 +32,27 @@ format-flowed = { path = "./format-flowed" }
 ratelimit = { path = "./deltachat-ratelimit" }

 anyhow = "1"
-async-channel = "1.8.0"
-async-imap = { version = "0.9.0", default-features = false, features = ["runtime-tokio"] }
+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"] }
 async_zip = { version = "0.0.12", default-features = false, features = ["deflate", "fs"] }
 backtrace = "0.3"
 base64 = "0.21"
-brotli = { version = "3.3", default-features=false, features = ["std"] }
+brotli = { version = "3.4", default-features=false, features = ["std"] }
 chrono = { version = "0.4", default-features=false, features = ["clock", "std"] }
 email = { git = "https://github.com/deltachat/rust-email", branch = "master" }
 encoded-words = { git = "https://github.com/async-email/encoded-words", branch = "master" }
 escaper = "0.1"
 fast-socks5 = "0.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.6", default-features=false, features = ["gif", "jpeg", "ico", "png", "pnm", "webp", "bmp"] }
-iroh = { version = "0.4.1", default-features = false }
+image = { version = "0.24.7", default-features=false, features = ["gif", "jpeg", "ico", "png", "pnm", "webp", "bmp"] }
+iroh = { git = "https://github.com/deltachat/iroh", branch = "0.4-update-quic", default-features = false }
 kamadak-exif = "0.5"
 lettre_email = { git = "https://github.com/deltachat/lettre", branch = "master" }
 libc = "0.2"
@@ -66,15 +65,16 @@ 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.29"
+quick-xml = "0.31"
 rand = "0.8"
-regex = "1.8"
-reqwest = { version = "0.11.18", features = ["json"] }
+regex = "1.9"
+reqwest = { version = "0.11.20", features = ["json"] }
 rusqlite = { version = "0.29", features = ["sqlcipher"] }
 rust-hsluv = "0.1"
-sanitize-filename = "0.4"
+sanitize-filename = "0.5"
 serde_json = "1.0"
 serde = { version = "1.0", features = ["derive"] }
 sha-1 = "0.10"
@@ -89,16 +89,15 @@ tokio = { version = "1", features = ["fs", "rt-multi-thread", "macros"] }
 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.8"
+tokio-util = "0.7.9"
 toml = "0.7"
-trust-dns-resolver = "0.22"
 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"] }
@@ -118,11 +117,6 @@ members = [
  "format-flowed",
 ]

-[[example]]
-name = "simple"
-path = "examples/simple.rs"
-
-
 [[bench]]
 name = "create_account"
 harness = false
--- a/README.md
+++ b/README.md
@@ -1,8 +1,16 @@
-# Delta Chat Rust
+<p align="center">
+  <img alt="Delta Chat Logo" height="200px" src="https://raw.githubusercontent.com/deltachat/deltachat-pages/master/assets/blog/rust-delta.png">
+</p>

-> Deltachat-core written in Rust 
+<p align="center">
+  <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>

-[![Rust CI](https://github.com/deltachat/deltachat-core-rust/actions/workflows/ci.yml/badge.svg)](https://github.com/deltachat/deltachat-core-rust/actions/workflows/ci.yml)
+<p align="center">
+The core library for Delta Chat, written in Rust
+</p>

 ## Installing Rust and Cargo

--- a/benches/create_account.rs
+++ b/benches/create_account.rs
@@ -8,7 +8,8 @@ async fn create_accounts(n: u32) {
    let dir = tempdir().unwrap();
    let p: PathBuf = dir.path().join("accounts");

-    let mut accounts = Accounts::new(p.clone()).await.unwrap();
+    let writable = true;
+    let mut accounts = Accounts::new(p.clone(), writable).await.unwrap();

    for expected_id in 2..n {
        let id = accounts.add_account().await.unwrap();
--- a/cliff.toml
+++ b/cliff.toml
@@ -54,7 +54,7 @@ header = """
 # Changelog\n
 """
 # template for the changelog body
-# https://tera.netlify.app/docs/#introduction
+# https://keats.github.io/tera/docs/#templates
 body = """
 {% if version %}\
    ## [{{ version | trim_start_matches(pat="v") }}] - {{ timestamp | date(format="%Y-%m-%d") }}
--- a/deltachat-ffi/Cargo.toml
+++ b/deltachat-ffi/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "deltachat_ffi"
-version = "1.119.0"
+version = "1.127.2"
 description = "Deltachat FFI"
 edition = "2018"
 readme = "README.md"
--- a/deltachat-ffi/Doxyfile
+++ b/deltachat-ffi/Doxyfile
@@ -846,7 +846,7 @@ EXCLUDE_PATTERNS       =
 # exclude all test directories use the pattern */test/*

 ######################################################
-EXCLUDE_SYMBOLS        = dc_aheader_t dc_apeerstate_t dc_e2ee_helper_t dc_imap_t dc_job*_t dc_key_t dc_keyring_t dc_loginparam_t dc_mime*_t
+EXCLUDE_SYMBOLS        = dc_aheader_t dc_apeerstate_t dc_e2ee_helper_t dc_imap_t dc_job*_t dc_key_t dc_loginparam_t dc_mime*_t
 EXCLUDE_SYMBOLS       += dc_saxparser_t dc_simplify_t dc_smtp_t dc_sqlite3_t dc_strbuilder_t dc_param_t dc_hash_t dc_hashelem_t
 EXCLUDE_SYMBOLS       += _dc_* jsmn*
 ######################################################
--- a/deltachat-ffi/deltachat.h
+++ b/deltachat-ffi/deltachat.h
@@ -301,6 +301,19 @@ dc_context_t*   dc_context_new_closed        (const char* dbfile);
 int             dc_context_open              (dc_context_t *context, const char* passphrase);


+/**
+ * Changes the passphrase on the open database.
+ * Existing database must already be encrypted and the passphrase cannot be NULL or empty.
+ * It is impossible to encrypt unencrypted database with this method and vice versa.
+ *
+ * @memberof dc_context_t
+ * @param context The context object.
+ * @param passphrase The new passphrase.
+ * @return 1 on success, 0 on error.
+ */
+int             dc_context_change_passphrase (dc_context_t* context, const char* passphrase);
+
+
 /**
 * Returns 1 if database is open.
 *
@@ -371,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)
@@ -430,7 +448,9 @@ char*           dc_get_blobdir               (const dc_context_t* context);
 *                    DC_KEY_GEN_RSA2048 (1)=
 *                    generate RSA 2048 keypair
 *                    DC_KEY_GEN_ED25519 (2)=
- *                    generate Ed25519 keypair
+ *                    generate Curve25519 keypair
+ *                    DC_KEY_GEN_RSA4096 (3)=
+ *                    generate RSA 4096 keypair
 * - `save_mime_headers` = 1=save mime headers
 *                    and make dc_get_mime_headers() work for subsequent calls,
 *                    0=do not save mime headers (default)
@@ -477,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.
@@ -485,6 +508,16 @@ 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,
+ *                    and when the key changes, an info message is posted into the chat.
+ *                    0=Nothing else happens when the key changes.
+ *                    1=After the key changed, `dc_chat_can_send()` returns false and `dc_chat_is_protection_broken()` returns true
+ *                    until `dc_accept_chat()` is called.
 * - `ui.*`         = All keys prefixed by `ui.` can be used by the user-interfaces for system-specific purposes.
 *                    The prefix should be followed by the system and maybe subsystem,
 *                    e.g. `ui.desktop.foo`, `ui.desktop.linux.bar`, `ui.android.foo`, `ui.dc40.bar`, `ui.bot.simplebot.baz`.
@@ -809,7 +842,7 @@ void            dc_maybe_network             (dc_context_t* context);
 * @param context The context as created by dc_context_new().
 * @param addr The e-mail address of the user. This must match the
 *    configured_addr setting of the context as well as the UID of the key.
- * @param public_data ASCII armored public key.
+ * @param public_data Ignored, actual public key is extracted from secret_data.
 * @param secret_data ASCII armored secret key.
 * @return 1 on success, 0 on failure.
 */
@@ -863,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.
@@ -1103,7 +1137,7 @@ dc_reactions_t* dc_get_msg_reactions (dc_context_t *context, int msg_id);
 *
 * In JS land, that would be mapped to something as:
 * ```
- * success = window.webxdc.sendUpdate('{"action":"move","src":"A3","dest":"B4"}', 'move A3 B4');
+ * success = window.webxdc.sendUpdate('{payload: {"action":"move","src":"A3","dest":"B4"}}', 'move A3 B4');
 * ```
 * `context` and `msg_id` are not needed in JS as those are unique within a webxdc instance.
 * See dc_get_webxdc_status_updates() for the receiving counterpart.
@@ -1321,6 +1355,20 @@ int             dc_get_msg_cnt               (dc_context_t* context, uint32_t ch
 int             dc_get_fresh_msg_cnt         (dc_context_t* context, uint32_t chat_id);


+/**
+ * Returns a list of similar chats.
+ *
+ * @warning This is an experimental API which may change or be removed in the future.
+ *
+ * @memberof dc_context_t
+ * @param context The context object as returned from dc_context_new().
+ * @param chat_id The ID of the chat for which to find similar chats.
+ * @return The list of similar chats.
+ *     On errors, NULL is returned.
+ *     Must be freed using dc_chatlist_unref() when no longer used.
+ */
+dc_chatlist_t*     dc_get_similar_chatlist   (dc_context_t* context, uint32_t chat_id);
+

 /**
 * Estimate the number of messages that will be deleted
@@ -1452,6 +1500,7 @@ dc_array_t*     dc_get_chat_media            (dc_context_t* context, uint32_t ch
 * Typically used to implement the "next" and "previous" buttons
 * in a gallery or in a media player.
 *
+ * @deprecated Deprecated 2023-10-03, use dc_get_chat_media() and navigate the returned array instead.
 * @memberof dc_context_t
 * @param context The context object as returned from dc_context_new().
 * @param msg_id The ID of the current message from which the next or previous message should be searched.
@@ -1470,24 +1519,6 @@ dc_array_t*     dc_get_chat_media            (dc_context_t* context, uint32_t ch
 uint32_t        dc_get_next_media            (dc_context_t* context, uint32_t msg_id, int dir, int msg_type, int msg_type2, int msg_type3);


-/**
- * Enable or disable protection against active attacks.
- * To enable protection, it is needed that all members are verified;
- * if this condition is met, end-to-end-encryption is always enabled
- * and only the verified keys are used.
- *
- * Sends out #DC_EVENT_CHAT_MODIFIED on changes
- * and #DC_EVENT_MSGS_CHANGED if a status message was sent.
- *
- * @memberof dc_context_t
- * @param context The context object as returned from dc_context_new().
- * @param chat_id The ID of the chat to change the protection for.
- * @param protect 1=protect chat, 0=unprotect chat
- * @return 1=success, 0=error, e.g. some members may be unverified
- */
-int             dc_set_chat_protection       (dc_context_t* context, uint32_t chat_id, int protect);
-
-
 /**
 * Set chat visibility to pinned, archived or normal.
 *
@@ -1681,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.
@@ -2241,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
@@ -2255,6 +2273,7 @@ dc_contact_t*   dc_get_contact               (dc_context_t* context, uint32_t co
 *
 * - **DC_IMEX_IMPORT_SELF_KEYS** (2) - Import private keys found in the directory given as `param1`.
 *   The last imported key is made the default keys unless its name contains the string `legacy`. Public keys are not imported.
+ *   If `param1` is a filename, import the private key from the file and make it the default.
 *
 * While dc_imex() returns immediately, the started job may take a while,
 * you can stop it using dc_stop_ongoing_process(). During execution of the job,
@@ -2926,12 +2945,15 @@ int dc_receive_backup (dc_context_t* context, const char* qr);
 * @param dir The directory to create the context-databases in.
 *     If the directory does not exist,
 *     dc_accounts_new() will try to create it.
+ * @param writable Whether the returned account manager is writable, i.e. calling these functions on
+ *     it is possible: dc_accounts_add_account(), dc_accounts_add_closed_account(),
+ *     dc_accounts_migrate_account(), dc_accounts_remove_account(), dc_accounts_select_account().
 * @return An account manager object.
 *     The object must be passed to the other account manager functions
 *     and must be freed using dc_accounts_unref() after usage.
 *     On errors, NULL is returned.
 */
-dc_accounts_t* dc_accounts_new                  (const char* os_name, const char* dir);
+dc_accounts_t* dc_accounts_new                  (const char* dir, int writable);


 /**
@@ -3712,7 +3734,6 @@ 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.
- * The status can be changed using dc_set_chat_protection().
 *
 * @memberof dc_chat_t
 * @param chat The chat object.
@@ -3721,6 +3742,26 @@ int             dc_chat_can_send              (const dc_chat_t* chat);
 int             dc_chat_is_protected         (const dc_chat_t* chat);


+/**
+ * Checks if the chat was protected, and then an incoming message broke this protection.
+ *
+ * This function is only useful if the UI enabled the `verified_one_on_one_chats` feature flag,
+ * otherwise it will return false for all chats.
+ *
+ * 1:1 chats are automatically set as protected when a contact is verified.
+ * When a message comes in that is not encrypted / signed correctly,
+ * the chat is automatically set as unprotected again.
+ * dc_chat_is_protection_broken() will return true until dc_accept_chat() is called.
+ *
+ * The UI should let the user confirm that this is OK with a message like
+ * `Bob sent a message from another device. Tap to learn more` and then call dc_accept_chat().
+ * @memberof dc_chat_t
+ * @param chat The chat object.
+ * @return 1=chat protection broken, 0=otherwise.
+ */
+int             dc_chat_is_protection_broken (const dc_chat_t* chat);
+
+
 /**
 * Check if locations are sent to the chat
 * at the time the object was created using dc_get_chat().
@@ -3925,7 +3966,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().
@@ -4315,7 +4356,7 @@ int             dc_msg_is_forwarded           (const dc_msg_t* msg);
 * Check if the message is an informational message, created by the
 * device or by another users. Such messages are not "typed" by the user but
 * created due to other actions,
- * e.g. dc_set_chat_name(), dc_set_chat_profile_image(), dc_set_chat_protection()
+ * e.g. dc_set_chat_name(), dc_set_chat_profile_image(),
 * or dc_add_contact_to_chat().
 *
 * These messages are typically shown in the center of the chat view,
@@ -5009,7 +5050,12 @@ int             dc_contact_is_verified       (dc_contact_t* contact);
 /**
 * Return the address that verified a contact
 *
- * The UI may use this in addition to a checkmark showing the verification status
+ * 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.
 *
 * @memberof dc_contact_t
 * @param contact The contact object.
@@ -5017,6 +5063,7 @@ int             dc_contact_is_verified       (dc_contact_t* contact);
 *    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);

@@ -5029,7 +5076,7 @@ char*           dc_contact_get_verifier_addr       (dc_contact_t* contact);
 * @memberof dc_contact_t
 * @param contact The contact object.
 * @return 
- *    The `ContactId` of the verifiers address. If it is the same address as the contact itself,
+ *    The contact ID of the verifier. If it is DC_CONTACT_ID_SELF,
 *    we verified the contact ourself. If it is 0, we don't have verifier information or 
 *    the contact is not verified.
 */
@@ -5725,12 +5772,11 @@ char* dc_jsonrpc_next_response(dc_jsonrpc_instance_t* jsonrpc_instance);
 *
 * @memberof dc_jsonrpc_instance_t
 * @param jsonrpc_instance jsonrpc instance as returned from dc_jsonrpc_init().
- * @param method JSON-RPC method name, e.g. `check_email_validity`.
- * @param params JSON-RPC method parameters, e.g. `["alice@example.org"]`.
+ * @param input JSON-RPC request.
 * @return JSON-RPC response as string, must be freed using dc_str_unref() after usage.
- *     On error, NULL is returned.
+ *     If there is no response, NULL is returned.
 */
-char* dc_jsonrpc_blocking_call(dc_jsonrpc_instance_t* jsonrpc_instance, const char *method, const char *params);
+char* dc_jsonrpc_blocking_call(dc_jsonrpc_instance_t* jsonrpc_instance, const char *input);

 /**
 * @class dc_event_emitter_t
@@ -6266,6 +6312,7 @@ void dc_event_unref(dc_event_t* event);
 #define DC_KEY_GEN_DEFAULT 0
 #define DC_KEY_GEN_RSA2048 1
 #define DC_KEY_GEN_ED25519 2
+#define DC_KEY_GEN_RSA4096 3


 /**
@@ -6749,15 +6796,6 @@ void dc_event_unref(dc_event_t* event);
 /// Used in error strings.
 #define DC_STR_ERROR_NO_NETWORK           87

-/// "Chat protection enabled."
-///
-
-/// @deprecated Deprecated, replaced by DC_STR_MSG_YOU_ENABLED_PROTECTION and DC_STR_MSG_PROTECTION_ENABLED_BY.
-#define DC_STR_PROTECTION_ENABLED         88
-
-/// @deprecated Deprecated, replaced by DC_STR_MSG_YOU_DISABLED_PROTECTION and DC_STR_MSG_PROTECTION_DISABLED_BY.
-#define DC_STR_PROTECTION_DISABLED        89
-
 /// "Reply"
 ///
 /// Used in summaries.
@@ -7202,26 +7240,6 @@ void dc_event_unref(dc_event_t* event);
 /// `%2$s` will be replaced by name and address of the contact.
 #define DC_STR_EPHEMERAL_TIMER_WEEKS_BY_OTHER 157

-/// "You enabled chat protection."
-///
-/// Used in status messages.
-#define DC_STR_PROTECTION_ENABLED_BY_YOU 158
-
-/// "Chat protection enabled by %1$s."
-///
-/// `%1$s` will be replaced by name and address of the contact.
-///
-/// Used in status messages.
-#define DC_STR_PROTECTION_ENABLED_BY_OTHER 159
-
-/// "You disabled chat protection."
-#define DC_STR_PROTECTION_DISABLED_BY_YOU 160
-
-/// "Chat protection disabled by %1$s."
-///
-/// `%1$s` will be replaced by name and address of the contact.
-#define DC_STR_PROTECTION_DISABLED_BY_OTHER 161
-
 /// "Scan to set up second device for %1$s"
 ///
 /// `%1$s` will be replaced by name and address of the account.
@@ -7232,6 +7250,16 @@ void dc_event_unref(dc_event_t* event);
 /// Used as a device message after a successful backup transfer.
 #define DC_STR_BACKUP_TRANSFER_MSG_BODY 163

+/// "Messages are guaranteed to be end-to-end encrypted from now on."
+///
+/// Used in info messages.
+#define DC_STR_CHAT_PROTECTION_ENABLED 170
+
+/// "%1$s sent a message from another device."
+///
+/// Used in info messages.
+#define DC_STR_CHAT_PROTECTION_DISABLED 171
+
 /**
 * @}
 */
--- a/deltachat-ffi/src/lib.rs
+++ b/deltachat-ffi/src/lib.rs
@@ -29,7 +29,7 @@ use deltachat::contact::{Contact, ContactId, Origin};
 use deltachat::context::Context;
 use deltachat::ephemeral::Timer as EphemeralTimer;
 use deltachat::imex::BackupProvider;
-use deltachat::key::DcKey;
+use deltachat::key::preconfigure_keypair;
 use deltachat::message::MsgId;
 use deltachat::net::read_url_blob;
 use deltachat::qr_code_generator::{generate_backup_qr, get_securejoin_qr_svg};
@@ -167,6 +167,24 @@ pub unsafe extern "C" fn dc_context_open(
        .unwrap_or(0)
 }

+#[no_mangle]
+pub unsafe extern "C" fn dc_context_change_passphrase(
+    context: *mut dc_context_t,
+    passphrase: *const libc::c_char,
+) -> libc::c_int {
+    if context.is_null() {
+        eprintln!("ignoring careless call to dc_context_change_passphrase()");
+        return 0;
+    }
+
+    let ctx = &*context;
+    let passphrase = to_string_lossy(passphrase);
+    block_on(ctx.change_passphrase(passphrase))
+        .context("dc_context_change_passphrase() failed")
+        .log_err(ctx)
+        .is_ok() as libc::c_int
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn dc_context_is_open(context: *mut dc_context_t) -> libc::c_int {
    if context.is_null() {
@@ -787,7 +805,7 @@ pub unsafe extern "C" fn dc_maybe_network(context: *mut dc_context_t) {
 pub unsafe extern "C" fn dc_preconfigure_keypair(
    context: *mut dc_context_t,
    addr: *const libc::c_char,
-    public_data: *const libc::c_char,
+    _public_data: *const libc::c_char,
    secret_data: *const libc::c_char,
 ) -> i32 {
    if context.is_null() {
@@ -795,21 +813,12 @@ pub unsafe extern "C" fn dc_preconfigure_keypair(
        return 0;
    }
    let ctx = &*context;
-    block_on(async move {
-        let addr = tools::EmailAddress::new(&to_string_lossy(addr))?;
-        let public = key::SignedPublicKey::from_asc(&to_string_lossy(public_data))?.0;
-        let secret = key::SignedSecretKey::from_asc(&to_string_lossy(secret_data))?.0;
-        let keypair = key::KeyPair {
-            addr,
-            public,
-            secret,
-        };
-        key::store_self_keypair(ctx, &keypair, key::KeyPairUse::Default).await?;
-        Ok::<_, anyhow::Error>(1)
-    })
-    .context("Failed to save keypair")
-    .log_err(ctx)
-    .unwrap_or(0)
+    let addr = to_string_lossy(addr);
+    let secret_data = to_string_lossy(secret_data);
+    block_on(preconfigure_keypair(ctx, &addr, &secret_data))
+        .context("Failed to save keypair")
+        .log_err(ctx)
+        .is_ok() as libc::c_int
 }

 #[no_mangle]
@@ -1242,6 +1251,30 @@ pub unsafe extern "C" fn dc_get_fresh_msg_cnt(
    })
 }

+#[no_mangle]
+pub unsafe extern "C" fn dc_get_similar_chatlist(
+    context: *mut dc_context_t,
+    chat_id: u32,
+) -> *mut dc_chatlist_t {
+    if context.is_null() {
+        eprintln!("ignoring careless call to dc_get_similar_chatlist()");
+        return ptr::null_mut();
+    }
+    let ctx = &*context;
+
+    let chat_id = ChatId::new(chat_id);
+    match block_on(chat_id.get_similar_chatlist(ctx))
+        .context("failed to get similar chatlist")
+        .log_err(ctx)
+    {
+        Ok(list) => {
+            let ffi_list = ChatlistWrapper { context, list };
+            Box::into_raw(Box::new(ffi_list))
+        }
+        Err(_) => ptr::null_mut(),
+    }
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn dc_estimate_deletion_cnt(
    context: *mut dc_context_t,
@@ -1389,6 +1422,7 @@ pub unsafe extern "C" fn dc_get_chat_media(
 }

 #[no_mangle]
+#[allow(deprecated)]
 pub unsafe extern "C" fn dc_get_next_media(
    context: *mut dc_context_t,
    msg_id: u32,
@@ -1429,32 +1463,6 @@ pub unsafe extern "C" fn dc_get_next_media(
    })
 }

-#[no_mangle]
-pub unsafe extern "C" fn dc_set_chat_protection(
-    context: *mut dc_context_t,
-    chat_id: u32,
-    protect: libc::c_int,
-) -> libc::c_int {
-    if context.is_null() {
-        eprintln!("ignoring careless call to dc_set_chat_protection()");
-        return 0;
-    }
-    let ctx = &*context;
-    let protect = if let Some(s) = ProtectionStatus::from_i32(protect) {
-        s
-    } else {
-        warn!(ctx, "bad protect-value for dc_set_chat_protection()");
-        return 0;
-    };
-
-    block_on(async move {
-        match ChatId::new(chat_id).set_protection(ctx, protect).await {
-            Ok(()) => 1,
-            Err(_) => 0,
-        }
-    })
-}
-
 #[no_mangle]
 pub unsafe extern "C" fn dc_set_chat_visibility(
    context: *mut dc_context_t,
@@ -2525,7 +2533,12 @@ pub unsafe extern "C" fn dc_set_location(
    }
    let ctx = &*context;

-    block_on(location::set(ctx, latitude, longitude, accuracy)) as _
+    block_on(async move {
+        location::set(ctx, latitude, longitude, accuracy)
+            .await
+            .log_err(ctx)
+            .unwrap_or_default()
+    }) as libc::c_int
 }

 #[no_mangle]
@@ -3084,6 +3097,16 @@ pub unsafe extern "C" fn dc_chat_is_protected(chat: *mut dc_chat_t) -> libc::c_i
    ffi_chat.chat.is_protected() as libc::c_int
 }

+#[no_mangle]
+pub unsafe extern "C" fn dc_chat_is_protection_broken(chat: *mut dc_chat_t) -> libc::c_int {
+    if chat.is_null() {
+        eprintln!("ignoring careless call to dc_chat_is_protection_broken()");
+        return 0;
+    }
+    let ffi_chat = &*chat;
+    ffi_chat.chat.is_protection_broken() as libc::c_int
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn dc_chat_is_sending_locations(chat: *mut dc_chat_t) -> libc::c_int {
    if chat.is_null() {
@@ -4489,7 +4512,14 @@ pub unsafe extern "C" fn dc_provider_new_from_email(

    let ctx = &*context;

-    match block_on(provider::get_provider_info(ctx, addr.as_str(), true)) {
+    match block_on(provider::get_provider_info_by_addr(
+        ctx,
+        addr.as_str(),
+        true,
+    ))
+    .log_err(ctx)
+    .unwrap_or_default()
+    {
        Some(provider) => provider,
        None => ptr::null_mut(),
    }
@@ -4516,11 +4546,14 @@ pub unsafe extern "C" fn dc_provider_new_from_email_with_dns(

    match socks5_enabled {
        Ok(socks5_enabled) => {
-            match block_on(provider::get_provider_info(
+            match block_on(provider::get_provider_info_by_addr(
                ctx,
                addr.as_str(),
                socks5_enabled,
-            )) {
+            ))
+            .log_err(ctx)
+            .unwrap_or_default()
+            {
                Some(provider) => provider,
                None => ptr::null_mut(),
            }
@@ -4692,17 +4725,17 @@ pub type dc_accounts_t = AccountsWrapper;

 #[no_mangle]
 pub unsafe extern "C" fn dc_accounts_new(
-    _os_name: *const libc::c_char,
-    dbfile: *const libc::c_char,
+    dir: *const libc::c_char,
+    writable: libc::c_int,
 ) -> *mut dc_accounts_t {
    setup_panic!();

-    if dbfile.is_null() {
+    if dir.is_null() {
        eprintln!("ignoring careless call to dc_accounts_new()");
        return ptr::null_mut();
    }

-    let accs = block_on(Accounts::new(as_path(dbfile).into()));
+    let accs = block_on(Accounts::new(as_path(dir).into(), writable != 0));

    match accs {
        Ok(accs) => Box::into_raw(Box::new(AccountsWrapper::new(accs))),
@@ -4968,7 +5001,7 @@ pub unsafe extern "C" fn dc_accounts_get_event_emitter(
 #[cfg(feature = "jsonrpc")]
 mod jsonrpc {
    use deltachat_jsonrpc::api::CommandApi;
-    use deltachat_jsonrpc::yerpc::{OutReceiver, RpcClient, RpcServer, RpcSession};
+    use deltachat_jsonrpc::yerpc::{OutReceiver, RpcClient, RpcSession};

    use super::*;

@@ -5044,25 +5077,24 @@ mod jsonrpc {
    #[no_mangle]
    pub unsafe extern "C" fn dc_jsonrpc_blocking_call(
        jsonrpc_instance: *mut dc_jsonrpc_instance_t,
-        method: *const libc::c_char,
-        params: *const libc::c_char,
+        input: *const libc::c_char,
    ) -> *mut libc::c_char {
        if jsonrpc_instance.is_null() {
            eprintln!("ignoring careless call to dc_jsonrpc_blocking_call()");
            return ptr::null_mut();
        }
        let api = &*jsonrpc_instance;
-        let method = to_string_lossy(method);
-        let params = to_string_lossy(params);
-        let params: Option<yerpc::Params> = match serde_json::from_str(&params) {
-            Ok(params) => Some(params),
-            Err(_) => None,
-        };
-        let params = params.map(yerpc::Params::into_value).unwrap_or_default();
-        let res = block_on(api.handle.server().handle_request(method, params));
+        let input = to_string_lossy(input);
+        let res = block_on(api.handle.process_incoming(&input));
        match res {
-            Ok(res) => res.to_string().strdup(),
-            Err(_) => ptr::null_mut(),
+            Some(message) => {
+                if let Ok(message) = serde_json::to_string(&message) {
+                    message.strdup()
+                } else {
+                    ptr::null_mut()
+                }
+            }
+            None => ptr::null_mut(),
        }
    }
 }
--- a/deltachat-jsonrpc/Cargo.toml
+++ b/deltachat-jsonrpc/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "deltachat-jsonrpc"
-version = "1.119.0"
+version = "1.127.2"
 description = "DeltaChat JSON-RPC API"
 edition = "2021"
 default-run = "deltachat-jsonrpc-server"
@@ -15,26 +15,26 @@ required-features = ["webserver"]
 anyhow = "1"
 deltachat = { path = ".." }
 num-traits = "0.2"
-schemars = "0.8.11"
+schemars = "0.8.13"
 serde = { version = "1.0", features = ["derive"] }
-tempfile = "3.6.0"
+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.99"
-yerpc = { version = "0.5.1", features = ["anyhow_expose", "openrpc"] }
-typescript-type-def = { version = "0.5.5", features = ["json_value"] }
-tokio = { version = "1.29.1" }
-sanitize-filename = "0.4"
+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.33.0" }
+sanitize-filename = "0.5"
 walkdir = "2.3.3"
 base64 = "0.21"

 # optional dependencies
-axum = { version = "0.6.18", optional = true, features = ["ws"] }
+axum = { version = "0.6.20", optional = true, features = ["ws"] }
 env_logger = { version = "0.10.0", optional = true }

 [dev-dependencies]
-tokio = { version = "1.29.1", 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
@@ -4,30 +4,30 @@ use std::{collections::HashMap, str::FromStr};

 use anyhow::{anyhow, bail, ensure, Context, Result};
 pub use deltachat::accounts::Accounts;
-use deltachat::message::get_msg_read_receipts;
-use deltachat::qr::Qr;
-use deltachat::{
-    chat::{
-        self, add_contact_to_chat, forward_msgs, get_chat_media, get_chat_msgs, get_chat_msgs_ex,
-        marknoticed_chat, remove_contact_from_chat, Chat, ChatId, ChatItem, MessageListOptions,
-        ProtectionStatus,
-    },
-    chatlist::Chatlist,
-    config::Config,
-    constants::DC_MSG_ID_DAYMARKER,
-    contact::{may_be_valid_addr, Contact, ContactId, Origin},
-    context::get_info,
-    ephemeral::Timer,
-    imex, location,
-    message::{self, delete_msgs, markseen_msgs, Message, MessageState, MsgId, Viewtype},
-    provider::get_provider_info,
-    qr,
-    qr_code_generator::{generate_backup_qr, get_securejoin_qr_svg},
-    reaction::{get_msg_reactions, send_reaction},
-    securejoin,
-    stock_str::StockMessage,
-    webxdc::StatusUpdateSerial,
+use deltachat::chat::{
+    self, add_contact_to_chat, forward_msgs, get_chat_media, get_chat_msgs, get_chat_msgs_ex,
+    marknoticed_chat, remove_contact_from_chat, Chat, ChatId, ChatItem, MessageListOptions,
+    ProtectionStatus,
 };
+use deltachat::chatlist::Chatlist;
+use deltachat::config::Config;
+use deltachat::constants::DC_MSG_ID_DAYMARKER;
+use deltachat::contact::{may_be_valid_addr, Contact, ContactId, Origin};
+use deltachat::context::get_info;
+use deltachat::ephemeral::Timer;
+use deltachat::imex;
+use deltachat::location;
+use deltachat::message::get_msg_read_receipts;
+use deltachat::message::{
+    self, delete_msgs, markseen_msgs, Message, MessageState, MsgId, Viewtype,
+};
+use deltachat::provider::get_provider_info;
+use deltachat::qr::{self, Qr};
+use deltachat::qr_code_generator::{generate_backup_qr, get_securejoin_qr_svg};
+use deltachat::reaction::{get_msg_reactions, send_reaction};
+use deltachat::securejoin;
+use deltachat::stock_str::StockMessage;
+use deltachat::webxdc::StatusUpdateSerial;
 use sanitize_filename::is_sanitized;
 use tokio::fs;
 use tokio::sync::{watch, Mutex, RwLock};
@@ -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,
@@ -142,11 +142,7 @@ impl CommandApi {
    }
 }

-#[rpc(
-    all_positional,
-    ts_outdir = "typescript/generated",
-    openrpc_outdir = "openrpc"
-)]
+#[rpc(all_positional, ts_outdir = "typescript/generated")]
 impl CommandApi {
    /// Test function.
    async fn sleep(&self, delay: f64) {
@@ -157,12 +153,12 @@ impl CommandApi {
    //  Misc top level functions
    // ---------------------------------------------

-    /// Check if an email address is valid.
+    /// Checks if an email address is valid.
    async fn check_email_validity(&self, email: String) -> bool {
        may_be_valid_addr(&email)
    }

-    /// Get general system info.
+    /// Returns general system info.
    async fn get_system_info(&self) -> BTreeMap<&'static str, String> {
        get_info()
    }
@@ -223,11 +219,13 @@ impl CommandApi {
        Ok(accounts)
    }

+    /// Starts background tasks for all accounts.
    async fn start_io_for_all_accounts(&self) -> Result<()> {
        self.accounts.read().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;
        Ok(())
@@ -237,14 +235,16 @@ impl CommandApi {
    // Methods that work on individual accounts
    // ---------------------------------------------

-    async fn start_io(&self, id: u32) -> Result<()> {
-        let ctx = self.get_context(id).await?;
+    /// Starts background tasks for a single account.
+    async fn start_io(&self, account_id: u32) -> Result<()> {
+        let ctx = self.get_context(account_id).await?;
        ctx.start_io().await;
        Ok(())
    }

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

+    /// Sets the given configuration key.
    async fn set_config(&self, account_id: u32, key: String, value: Option<String>) -> Result<()> {
        let ctx = self.get_context(account_id).await?;
        set_config(&ctx, &key, value.as_deref()).await
    }

+    /// Updates a batch of configuration values.
    async fn batch_set_config(
        &self,
        account_id: u32,
@@ -347,6 +349,7 @@ impl CommandApi {
        Ok(qr_object)
    }

+    /// Returns configuration value for the given key.
    async fn get_config(&self, account_id: u32, key: String) -> Result<Option<String>> {
        let ctx = self.get_context(account_id).await?;
        get_config(&ctx, &key).await
@@ -566,6 +569,21 @@ impl CommandApi {
        Ok(l)
    }

+    /// Returns chats similar to the given one.
+    ///
+    /// Experimental API, subject to change without notice.
+    async fn get_similar_chat_ids(&self, account_id: u32, chat_id: u32) -> Result<Vec<u32>> {
+        let ctx = self.get_context(account_id).await?;
+        let chat_id = ChatId::new(chat_id);
+        let list = chat_id
+            .get_similar_chat_ids(&ctx)
+            .await?
+            .into_iter()
+            .map(|(chat_id, _metric)| chat_id.to_u32())
+            .collect();
+        Ok(list)
+    }
+
    async fn get_chatlist_items_by_entries(
        &self,
        account_id: u32,
@@ -797,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)
@@ -1120,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,
@@ -1412,6 +1428,10 @@ impl CommandApi {
    ///
    /// one combined call for getting chat::get_next_media for both directions
    /// the manual chat::get_next_media in only one direction is not exposed by the jsonrpc yet
+    ///
+    /// Deprecated 2023-10-03, use `get_chat_media` method
+    /// and navigate the returned array instead.
+    #[allow(deprecated)]
    async fn get_neighboring_chat_media(
        &self,
        account_id: u32,
@@ -1709,6 +1729,20 @@ impl CommandApi {
        forward_msgs(&ctx, &message_ids, ChatId::new(chat_id)).await
    }

+    /// Resend messages and make information available for newly added chat members.
+    /// Resending sends out the original message, however, recipients and webxdc-status may differ.
+    /// Clients that already have the original message can still ignore the resent message as
+    /// they have tracked the state by dedicated updates.
+    ///
+    /// Some messages cannot be resent, eg. info-messages, drafts, already pending messages or messages that are not sent by SELF.
+    ///
+    /// message_ids all message IDs that should be resend. All messages must belong to the same chat.
+    async fn resend_messages(&self, account_id: u32, message_ids: Vec<u32>) -> Result<()> {
+        let ctx = self.get_context(account_id).await?;
+        let message_ids: Vec<MsgId> = message_ids.into_iter().map(MsgId::new).collect();
+        chat::resend_msgs(&ctx, &message_ids).await
+    }
+
    async fn send_sticker(
        &self,
        account_id: u32,
@@ -1720,6 +1754,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())
    }
@@ -1853,7 +1890,7 @@ impl CommandApi {
            .context("path conversion to string failed")
    }

-    /// save a sticker to a collection/folder in the account's sticker folder
+    /// Saves a sticker to a collection/folder in the account's sticker folder.
    async fn misc_save_sticker(
        &self,
        account_id: u32,
@@ -2006,13 +2043,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);
@@ -2032,6 +2075,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/account.rs
+++ b/deltachat-jsonrpc/src/api/types/account.rs
@@ -7,7 +7,7 @@ use typescript_type_def::TypeDef;
 use super::color_int_to_hex_string;

 #[derive(Serialize, TypeDef, schemars::JsonSchema)]
-#[serde(tag = "type")]
+#[serde(tag = "kind")]
 pub enum Account {
    #[serde(rename_all = "camelCase")]
    Configured {
--- a/deltachat-jsonrpc/src/api/types/chat.rs
+++ b/deltachat-jsonrpc/src/api/types/chat.rs
@@ -31,6 +31,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 +101,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(),
@@ -134,6 +136,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 +163,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(),
        })
@@ -167,10 +171,11 @@ impl BasicChat {
 }

 #[derive(Clone, Serialize, Deserialize, TypeDef, schemars::JsonSchema)]
+#[serde(tag = "kind")]
 pub enum MuteDuration {
    NotMuted,
    Forever,
-    Until(i64),
+    Until { duration: i64 },
 }

 impl MuteDuration {
@@ -178,13 +183,13 @@ impl MuteDuration {
        match self {
            MuteDuration::NotMuted => Ok(chat::MuteDuration::NotMuted),
            MuteDuration::Forever => Ok(chat::MuteDuration::Forever),
-            MuteDuration::Until(n) => {
-                if n <= 0 {
+            MuteDuration::Until { duration } => {
+                if duration <= 0 {
                    bail!("failed to read mute duration")
                }

                Ok(SystemTime::now()
-                    .checked_add(Duration::from_secs(n as u64))
+                    .checked_add(Duration::from_secs(duration as u64))
                    .map_or(chat::MuteDuration::Forever, chat::MuteDuration::Until))
            }
        }
--- a/deltachat-jsonrpc/src/api/types/chat_list.rs
+++ b/deltachat-jsonrpc/src/api/types/chat_list.rs
@@ -8,17 +8,14 @@ use deltachat::{
    chatlist::Chatlist,
 };
 use num_traits::cast::ToPrimitive;
-use serde::{Deserialize, Serialize};
+use serde::Serialize;
 use typescript_type_def::TypeDef;

 use super::color_int_to_hex_string;
 use super::message::MessageViewtype;

-#[derive(Deserialize, Serialize, TypeDef, schemars::JsonSchema)]
-pub struct ChatListEntry(pub u32, pub u32);
-
 #[derive(Serialize, TypeDef, schemars::JsonSchema)]
-#[serde(tag = "type")]
+#[serde(tag = "kind")]
 pub enum ChatListItemFetchResult {
    #[serde(rename_all = "camelCase")]
    ChatListItem {
--- a/deltachat-jsonrpc/src/api/types/events.rs
+++ b/deltachat-jsonrpc/src/api/types/events.rs
@@ -22,7 +22,7 @@ impl From<CoreEvent> for Event {
 }

 #[derive(Serialize, TypeDef, schemars::JsonSchema)]
-#[serde(tag = "type")]
+#[serde(tag = "kind")]
 pub enum EventType {
    /// The library-user may write an informational string to the log.
    ///
--- a/deltachat-jsonrpc/src/api/types/message.rs
+++ b/deltachat-jsonrpc/src/api/types/message.rs
@@ -19,7 +19,7 @@ use super::reactions::JSONRPCReactions;
 use super::webxdc::WebxdcMessageInfo;

 #[derive(Serialize, TypeDef, schemars::JsonSchema)]
-#[serde(rename_all = "camelCase", tag = "variant")]
+#[serde(rename_all = "camelCase", tag = "kind")]
 pub enum MessageLoadResult {
    Message(MessageObject),
    LoadingError { error: String },
@@ -318,6 +318,7 @@ pub enum DownloadState {
    Done,
    Available,
    Failure,
+    Undecipherable,
    InProgress,
 }

@@ -327,6 +328,7 @@ impl From<download::DownloadState> for DownloadState {
            download::DownloadState::Done => DownloadState::Done,
            download::DownloadState::Available => DownloadState::Available,
            download::DownloadState::Failure => DownloadState::Failure,
+            download::DownloadState::Undecipherable => DownloadState::Undecipherable,
            download::DownloadState::InProgress => DownloadState::InProgress,
        }
    }
@@ -550,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/api/types/qr.rs
+++ b/deltachat-jsonrpc/src/api/types/qr.rs
@@ -4,7 +4,7 @@ use typescript_type_def::TypeDef;

 #[derive(Serialize, TypeDef, schemars::JsonSchema)]
 #[serde(rename = "Qr", rename_all = "camelCase")]
-#[serde(tag = "type")]
+#[serde(tag = "kind")]
 pub enum QrObject {
    AskVerifyContact {
        contact_id: u32,
--- a/deltachat-jsonrpc/src/lib.rs
+++ b/deltachat-jsonrpc/src/lib.rs
@@ -13,10 +13,11 @@ mod tests {
    #[tokio::test(flavor = "multi_thread")]
    async fn basic_json_rpc_functionality() -> anyhow::Result<()> {
        let tmp_dir = TempDir::new().unwrap().path().into();
-        let accounts = Accounts::new(tmp_dir).await?;
+        let writable = true;
+        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);
@@ -35,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(())
@@ -54,10 +55,11 @@ mod tests {
    #[tokio::test(flavor = "multi_thread")]
    async fn test_batch_set_config() -> anyhow::Result<()> {
        let tmp_dir = TempDir::new().unwrap().path().into();
-        let accounts = Accounts::new(tmp_dir).await?;
+        let writable = true;
+        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);
@@ -76,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
@@ -19,7 +19,8 @@ async fn main() -> Result<(), std::io::Error> {
        .map(|port| port.parse::<u16>().expect("DC_PORT must be a number"))
        .unwrap_or(DEFAULT_PORT);
    log::info!("Starting with accounts directory `{path}`.");
-    let accounts = Accounts::new(PathBuf::from(&path)).await.unwrap();
+    let writable = true;
+    let accounts = Accounts::new(PathBuf::from(&path), writable).await.unwrap();
    let state = CommandApi::new(accounts);

    let app = Router::new()
--- a/deltachat-jsonrpc/typescript/example/example.ts
+++ b/deltachat-jsonrpc/typescript/example/example.ts
@@ -35,7 +35,7 @@ async function run() {
    const accounts = await client.rpc.getAllAccounts();
    console.log("accounts loaded", accounts);
    for (const account of accounts) {
-      if (account.type === "Configured") {
+      if (account.kind === "Configured") {
        write(
          $head,
          `<a href="#" onclick="selectDeltaAccount(${account.id})">
@@ -57,7 +57,7 @@ async function run() {
    clear($main);
    const selectedAccount = SELECTED_ACCOUNT;
    const info = await client.rpc.getAccountInfo(selectedAccount);
-    if (info.type !== "Configured") {
+    if (info.kind !== "Configured") {
      return write($main, "Account is not configured");
    }
    write($main, `<h2>${info.addr!}</h2>`);
@@ -81,8 +81,7 @@ async function run() {
        messageIds
      );
      for (const [_messageId, message] of Object.entries(messages)) {
-        if (message.variant === "message")
-          write($main, `<p>${message.text}</p>`);
+        if (message.kind === "message") write($main, `<p>${message.text}</p>`);
        else write($main, `<p>loading error: ${message.error}</p>`);
      }
    }
@@ -93,9 +92,9 @@ async function run() {
      $side,
      `
        <p class="message">
-          [<strong>${event.type}</strong> on account ${accountId}]<br>
+          [<strong>${event.kind}</strong> on account ${accountId}]<br>
          <em>f1:</em> ${JSON.stringify(
-            Object.assign({}, event, { type: undefined })
+            Object.assign({}, event, { kind: undefined })
          )}
        </p>`
    );
--- a/deltachat-jsonrpc/typescript/package.json
+++ b/deltachat-jsonrpc/typescript/package.json
@@ -55,5 +55,5 @@
  },
  "type": "module",
  "types": "dist/deltachat.d.ts",
-  "version": "1.119.0"
+  "version": "1.127.2"
 }
--- a/deltachat-jsonrpc/typescript/src/client.ts
+++ b/deltachat-jsonrpc/typescript/src/client.ts
@@ -6,22 +6,22 @@ import { WebsocketTransport, BaseTransport, Request } from "yerpc";
 import { TinyEmitter } from "@deltachat/tiny-emitter";

 type Events = { ALL: (accountId: number, event: EventType) => void } & {
-  [Property in EventType["type"]]: (
+  [Property in EventType["kind"]]: (
    accountId: number,
-    event: Extract<EventType, { type: Property }>
+    event: Extract<EventType, { kind: Property }>
  ) => void;
 };

 type ContextEvents = { ALL: (event: EventType) => void } & {
-  [Property in EventType["type"]]: (
-    event: Extract<EventType, { type: Property }>
+  [Property in EventType["kind"]]: (
+    event: Extract<EventType, { kind: Property }>
  ) => void;
 };

 export type DcEvent = EventType;
-export type DcEventType<T extends EventType["type"]> = Extract<
+export type DcEventType<T extends EventType["kind"]> = Extract<
  EventType,
-  { type: T }
+  { kind: T }
 >;

 export class BaseDeltaChat<
@@ -46,12 +46,12 @@ export class BaseDeltaChat<
    while (true) {
      const event = await this.rpc.getNextEvent();
      //@ts-ignore
-      this.emit(event.event.type, event.contextId, event.event);
+      this.emit(event.event.kind, event.contextId, event.event);
      this.emit("ALL", event.contextId, event.event);

      if (this.contextEmitters[event.contextId]) {
        this.contextEmitters[event.contextId].emit(
-          event.event.type,
+          event.event.kind,
          //@ts-ignore
          event.event as any
        );
--- a/deltachat-jsonrpc/typescript/test/online.ts
+++ b/deltachat-jsonrpc/typescript/test/online.ts
@@ -13,27 +13,27 @@ 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();
    }
    serverHandle = await startServer();
    dc = new DeltaChat(serverHandle.stdin, serverHandle.stdout, true);

-    dc.on("ALL", (contextId, { type }) => {
-      if (type !== "Info") console.log(contextId, type);
+    dc.on("ALL", (contextId, { kind }) => {
+      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 +41,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 +148,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 = (
@@ -177,12 +177,12 @@ describe("online tests", function () {
  });
 });

-async function waitForEvent<T extends DcEvent["type"]>(
+async function waitForEvent<T extends DcEvent["kind"]>(
  dc: DeltaChat,
  eventType: T,
  accountId: number,
  timeout: number = EVENT_TIMEOUT
-): Promise<Extract<DcEvent, { type: T }>> {
+): Promise<Extract<DcEvent, { kind: T }>> {
  return new Promise((resolve, reject) => {
    const rejectTimeout = setTimeout(
      () => reject(new Error("Timeout reached before event came in")),
--- a/deltachat-jsonrpc/typescript/test/test_base.ts
+++ b/deltachat-jsonrpc/typescript/test/test_base.ts
@@ -57,15 +57,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-repl/Cargo.toml
+++ b/deltachat-repl/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "deltachat-repl"
-version = "1.119.0"
+version = "1.127.2"
 license = "MPL-2.0"
 edition = "2021"

@@ -9,7 +9,7 @@ ansi_term = "0.12.1"
 anyhow = "1"
 deltachat = { path = "..", features = ["internals"]}
 dirs = "5"
-log = "0.4.19"
+log = "0.4.20"
 pretty_env_logger = "0.5"
 rusqlite = "0.29"
 rustyline = "12"
--- a/deltachat-repl/src/cmdline.rs
+++ b/deltachat-repl/src/cmdline.rs
@@ -18,6 +18,7 @@ use deltachat::imex::*;
 use deltachat::location;
 use deltachat::log::LogExt;
 use deltachat::message::{self, Message, MessageState, MsgId, Viewtype};
+use deltachat::mimeparser::SystemMessage;
 use deltachat::peerstate::*;
 use deltachat::qr::*;
 use deltachat::reaction::send_reaction;
@@ -138,11 +139,7 @@ async fn poke_spec(context: &Context, spec: Option<&str>) -> bool {
        /* import a directory */
        let dir_name = std::path::Path::new(&real_spec);
        let dir = fs::read_dir(dir_name).await;
-        if dir.is_err() {
-            error!(context, "Import: Cannot open directory \"{}\".", &real_spec,);
-            return false;
-        } else {
-            let mut dir = dir.unwrap();
+        if let Ok(mut dir) = dir {
            while let Ok(Some(entry)) = dir.next_entry().await {
                let name_f = entry.file_name();
                let name = name_f.to_string_lossy();
@@ -154,6 +151,9 @@ async fn poke_spec(context: &Context, spec: Option<&str>) -> bool {
                    }
                }
            }
+        } else {
+            error!(context, "Import: Cannot open directory \"{}\".", &real_spec);
+            return false;
        }
    }
    println!("Import: {} items read from \"{}\".", read_cnt, &real_spec);
@@ -187,6 +187,7 @@ async fn log_msg(context: &Context, prefix: impl AsRef<str>, msg: &Message) {
        DownloadState::Available => " [⬇ Download available]",
        DownloadState::InProgress => " [⬇ Download in progress...]️",
        DownloadState::Failure => " [⬇ Download failed]",
+        DownloadState::Undecipherable => " [⬇ Decryption failed]",
    };

    let temp2 = timestamp_to_str(msg.get_timestamp());
@@ -210,7 +211,17 @@ async fn log_msg(context: &Context, prefix: impl AsRef<str>, msg: &Message) {
        } else {
            "[FRESH]"
        },
-        if msg.is_info() { "[INFO]" } else { "" },
+        if msg.is_info() {
+            if msg.get_info_type() == SystemMessage::ChatProtectionEnabled {
+                "[INFO 🛡️]"
+            } else if msg.get_info_type() == SystemMessage::ChatProtectionDisabled {
+                "[INFO 🛡️❌]"
+            } else {
+                "[INFO]"
+            }
+        } else {
+            ""
+        },
        if msg.get_viewtype() == Viewtype::VideochatInvitation {
            format!(
                "[VIDEOCHAT-INVITATION: {}, type={}]",
@@ -395,8 +406,6 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                 unpin <chat-id>\n\
                 mute <chat-id> [<seconds>]\n\
                 unmute <chat-id>\n\
-                 protect <chat-id>\n\
-                 unprotect <chat-id>\n\
                 delchat <chat-id>\n\
                 accept <chat-id>\n\
                 decline <chat-id>\n\
@@ -805,15 +814,30 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
        }
        "chatinfo" => {
            ensure!(sel_chat.is_some(), "No chat selected.");
+            let sel_chat_id = sel_chat.as_ref().unwrap().get_id();

-            let contacts =
-                chat::get_chat_contacts(&context, sel_chat.as_ref().unwrap().get_id()).await?;
+            let contacts = chat::get_chat_contacts(&context, sel_chat_id).await?;
            println!("Memberlist:");

            log_contactlist(&context, &contacts).await?;
+            println!("{} contacts", contacts.len());
+
+            let similar_chats = sel_chat_id.get_similar_chat_ids(&context).await?;
+            if !similar_chats.is_empty() {
+                println!("Similar chats: ");
+                for (similar_chat_id, metric) in similar_chats {
+                    let similar_chat = Chat::load_from_db(&context, similar_chat_id).await?;
+                    println!(
+                        "{} (#{}) {:.1}",
+                        similar_chat.name,
+                        similar_chat_id,
+                        100.0 * metric
+                    );
+                }
+            }
+
            println!(
-                "{} contacts\nLocation streaming: {}",
-                contacts.len(),
+                "Location streaming: {}",
                location::is_sending_locations_to_chat(
                    &context,
                    Some(sel_chat.as_ref().unwrap().get_id())
@@ -878,7 +902,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
            let latitude = arg1.parse()?;
            let longitude = arg2.parse()?;

-            let continue_streaming = location::set(&context, latitude, longitude, 0.).await;
+            let continue_streaming = location::set(&context, latitude, longitude, 0.).await?;
            if continue_streaming {
                println!("Success, streaming should be continued.");
            } else {
@@ -1056,20 +1080,6 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
            };
            chat::set_muted(&context, chat_id, duration).await?;
        }
-        "protect" | "unprotect" => {
-            ensure!(!arg1.is_empty(), "Argument <chat-id> missing.");
-            let chat_id = ChatId::new(arg1.parse()?);
-            chat_id
-                .set_protection(
-                    &context,
-                    match arg0 {
-                        "protect" => ProtectionStatus::Protected,
-                        "unprotect" => ProtectionStatus::Unprotected,
-                        _ => unreachable!("arg0={:?}", arg0),
-                    },
-                )
-                .await?;
-        }
        "delchat" => {
            ensure!(!arg1.is_empty(), "Argument <chat-id> missing.");
            let chat_id = ChatId::new(arg1.parse()?);
--- a/deltachat-rpc-client/README.md
+++ b/deltachat-rpc-client/README.md
@@ -37,19 +37,14 @@ $ tox --devenv env
 $ . env/bin/activate
 ```

-It is recommended to use IPython, because it supports using `await` directly
-from the REPL.
-
 ```
-$ pip install ipython
-$ PATH="../target/debug:$PATH" ipython
-...
-In [1]: from deltachat_rpc_client import *
-In [2]: rpc = Rpc()
-In [3]: await rpc.start()
-In [4]: dc = DeltaChat(rpc)
-In [5]: system_info = await dc.get_system_info()
-In [6]: system_info["level"]
-Out[6]: 'awesome'
-In [7]: await rpc.close()
+$ python
+>>> from deltachat_rpc_client import *
+>>> rpc = Rpc()
+>>> rpc.start()
+>>> dc = DeltaChat(rpc)
+>>> system_info = dc.get_system_info()
+>>> system_info["level"]
+'awesome'
+>>> rpc.close()
 ```
--- a/deltachat-rpc-client/examples/echobot.py
+++ b/deltachat-rpc-client/examples/echobot.py
@@ -4,23 +4,21 @@
 it will echo back any text send to it, it also will print to console all Delta Chat core events.
 Pass --help to the CLI to see available options.
 """
-import asyncio
-
 from deltachat_rpc_client import events, run_bot_cli

 hooks = events.HookCollection()


@hooks.on(events.RawEvent)
-async def log_event(event):
+def log_event(event):
    print(event)


@hooks.on(events.NewMessage)
-async def echo(event):
+def echo(event):
    snapshot = event.message_snapshot
-    await snapshot.chat.send_text(snapshot.text)
+    snapshot.chat.send_text(snapshot.text)


 if __name__ == "__main__":
-    asyncio.run(run_bot_cli(hooks))
+    run_bot_cli(hooks)
--- a/deltachat-rpc-client/examples/echobot_advanced.py
+++ b/deltachat-rpc-client/examples/echobot_advanced.py
@@ -3,9 +3,9 @@

 it will echo back any message that has non-empty text and also supports the /help command.
 """
-import asyncio
 import logging
 import sys
+from threading import Thread

 from deltachat_rpc_client import Bot, DeltaChat, EventType, Rpc, events

@@ -13,62 +13,62 @@ hooks = events.HookCollection()


@hooks.on(events.RawEvent)
-async def log_event(event):
-    if event.type == EventType.INFO:
+def log_event(event):
+    if event.kind == EventType.INFO:
        logging.info(event.msg)
-    elif event.type == EventType.WARNING:
+    elif event.kind == EventType.WARNING:
        logging.warning(event.msg)


@hooks.on(events.RawEvent(EventType.ERROR))
-async def log_error(event):
+def log_error(event):
    logging.error(event.msg)


@hooks.on(events.MemberListChanged)
-async def on_memberlist_changed(event):
+def on_memberlist_changed(event):
    logging.info("member %s was %s", event.member, "added" if event.member_added else "removed")


@hooks.on(events.GroupImageChanged)
-async def on_group_image_changed(event):
+def on_group_image_changed(event):
    logging.info("group image %s", "deleted" if event.image_deleted else "changed")


@hooks.on(events.GroupNameChanged)
-async def on_group_name_changed(event):
+def on_group_name_changed(event):
    logging.info("group name changed, old name: %s", event.old_name)


@hooks.on(events.NewMessage(func=lambda e: not e.command))
-async def echo(event):
+def echo(event):
    snapshot = event.message_snapshot
    if snapshot.text or snapshot.file:
-        await snapshot.chat.send_message(text=snapshot.text, file=snapshot.file)
+        snapshot.chat.send_message(text=snapshot.text, file=snapshot.file)


@hooks.on(events.NewMessage(command="/help"))
-async def help_command(event):
+def help_command(event):
    snapshot = event.message_snapshot
-    await snapshot.chat.send_text("Send me any message and I will echo it back")
+    snapshot.chat.send_text("Send me any message and I will echo it back")


-async def main():
-    async with Rpc() as rpc:
+def main():
+    with Rpc() as rpc:
        deltachat = DeltaChat(rpc)
-        system_info = await deltachat.get_system_info()
+        system_info = deltachat.get_system_info()
        logging.info("Running deltachat core %s", system_info.deltachat_core_version)

-        accounts = await deltachat.get_all_accounts()
-        account = accounts[0] if accounts else await deltachat.add_account()
+        accounts = deltachat.get_all_accounts()
+        account = accounts[0] if accounts else deltachat.add_account()

        bot = Bot(account, hooks)
-        if not await bot.is_configured():
-            # Save a reference to avoid garbage collection of the task.
-            _configure_task = asyncio.create_task(bot.configure(email=sys.argv[1], password=sys.argv[2]))
-        await bot.run_forever()
+        if not bot.is_configured():
+            configure_thread = Thread(run=bot.configure, kwargs={"email": sys.argv[1], "password": sys.argv[2]})
+            configure_thread.start()
+        bot.run_forever()


 if __name__ == "__main__":
    logging.basicConfig(level=logging.INFO)
-    asyncio.run(main())
+    main()
--- a/deltachat-rpc-client/examples/echobot_no_hooks.py
+++ b/deltachat-rpc-client/examples/echobot_no_hooks.py
@@ -2,45 +2,44 @@
 """
 Example echo bot without using hooks
 """
-import asyncio
 import logging
 import sys

 from deltachat_rpc_client import DeltaChat, EventType, Rpc, SpecialContactId


-async def main():
-    async with Rpc() as rpc:
+def main():
+    with Rpc() as rpc:
        deltachat = DeltaChat(rpc)
-        system_info = await deltachat.get_system_info()
+        system_info = deltachat.get_system_info()
        logging.info("Running deltachat core %s", system_info["deltachat_core_version"])

-        accounts = await deltachat.get_all_accounts()
-        account = accounts[0] if accounts else await deltachat.add_account()
+        accounts = deltachat.get_all_accounts()
+        account = accounts[0] if accounts else deltachat.add_account()

-        await account.set_config("bot", "1")
-        if not await account.is_configured():
+        account.set_config("bot", "1")
+        if not account.is_configured():
            logging.info("Account is not configured, configuring")
-            await account.set_config("addr", sys.argv[1])
-            await account.set_config("mail_pw", sys.argv[2])
-            await account.configure()
+            account.set_config("addr", sys.argv[1])
+            account.set_config("mail_pw", sys.argv[2])
+            account.configure()
            logging.info("Configured")
        else:
            logging.info("Account is already configured")
-            await deltachat.start_io()
+            deltachat.start_io()

-        async def process_messages():
-            for message in await account.get_next_messages():
-                snapshot = await message.get_snapshot()
+        def process_messages():
+            for message in account.get_next_messages():
+                snapshot = message.get_snapshot()
                if snapshot.from_id != SpecialContactId.SELF and not snapshot.is_bot and not snapshot.is_info:
-                    await snapshot.chat.send_text(snapshot.text)
-                await snapshot.message.mark_seen()
+                    snapshot.chat.send_text(snapshot.text)
+                snapshot.message.mark_seen()

        # Process old messages.
-        await process_messages()
+        process_messages()

        while True:
-            event = await account.wait_for_event()
+            event = account.wait_for_event()
            if event["type"] == EventType.INFO:
                logging.info("%s", event["msg"])
            elif event["type"] == EventType.WARNING:
@@ -49,9 +48,9 @@ async def main():
                logging.error("%s", event["msg"])
            elif event["type"] == EventType.INCOMING_MSG:
                logging.info("Got an incoming message")
-                await process_messages()
+                process_messages()


 if __name__ == "__main__":
    logging.basicConfig(level=logging.INFO)
-    asyncio.run(main())
+    main()
--- a/deltachat-rpc-client/pyproject.toml
+++ b/deltachat-rpc-client/pyproject.toml
@@ -5,13 +5,8 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "deltachat-rpc-client"
 description = "Python client for Delta Chat core JSON-RPC interface"
-dependencies = [
-    "aiohttp",
-    "aiodns"
-]
 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/init.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/init.py
@@ -1,4 +1,4 @@
-"""Delta Chat asynchronous high-level API"""
+"""Delta Chat JSON-RPC high-level API"""
 from ._utils import AttrDict, run_bot_cli, run_client_cli
 from .account import Account
 from .chat import Chat
--- a/deltachat-rpc-client/src/deltachat_rpc_client/_utils.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/_utils.py
@@ -1,7 +1,7 @@
 import argparse
-import asyncio
 import re
 import sys
+from threading import Thread
 from typing import TYPE_CHECKING, Callable, Iterable, Optional, Tuple, Type, Union

 if TYPE_CHECKING:
@@ -43,7 +43,7 @@ class AttrDict(dict):
        super().__setattr__(attr, val)


-async def run_client_cli(
+def run_client_cli(
    hooks: Optional[Iterable[Tuple[Callable, Union[type, "EventFilter"]]]] = None,
    argv: Optional[list] = None,
    **kwargs,
@@ -54,10 +54,10 @@ async def run_client_cli(
    """
    from .client import Client

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


-async def run_bot_cli(
+def run_bot_cli(
    hooks: Optional[Iterable[Tuple[Callable, Union[type, "EventFilter"]]]] = None,
    argv: Optional[list] = None,
    **kwargs,
@@ -68,10 +68,10 @@ async def run_bot_cli(
    """
    from .client import Bot

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


-async def _run_cli(
+def _run_cli(
    client_type: Type["Client"],
    hooks: Optional[Iterable[Tuple[Callable, Union[type, "EventFilter"]]]] = None,
    argv: Optional[list] = None,
@@ -93,20 +93,20 @@ async def _run_cli(
    parser.add_argument("--password", action="store", help="password")
    args = parser.parse_args(argv[1:])

-    async with Rpc(accounts_dir=args.accounts_dir, **kwargs) as rpc:
+    with Rpc(accounts_dir=args.accounts_dir, **kwargs) as rpc:
        deltachat = DeltaChat(rpc)
-        core_version = (await deltachat.get_system_info()).deltachat_core_version
-        accounts = await deltachat.get_all_accounts()
-        account = accounts[0] if accounts else await deltachat.add_account()
+        core_version = (deltachat.get_system_info()).deltachat_core_version
+        accounts = deltachat.get_all_accounts()
+        account = accounts[0] if accounts else deltachat.add_account()

        client = client_type(account, hooks)
        client.logger.debug("Running deltachat core %s", core_version)
-        if not await client.is_configured():
+        if not client.is_configured():
            assert args.email, "Account is not configured and email must be provided"
            assert args.password, "Account is not configured and password must be provided"
-            # Save a reference to avoid garbage collection of the task.
-            _configure_task = asyncio.create_task(client.configure(email=args.email, password=args.password))
-        await client.run_forever()
+            configure_thread = Thread(run=client.configure, kwargs={"email": args.email, "password": args.password})
+            configure_thread.start()
+        client.run_forever()


 def extract_addr(text: str) -> str:
--- a/deltachat-rpc-client/src/deltachat_rpc_client/account.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/account.py
@@ -24,63 +24,63 @@ class Account:
    def _rpc(self) -> "Rpc":
        return self.manager.rpc

-    async def wait_for_event(self) -> AttrDict:
+    def wait_for_event(self) -> AttrDict:
        """Wait until the next event and return it."""
-        return AttrDict(await self._rpc.wait_for_event(self.id))
+        return AttrDict(self._rpc.wait_for_event(self.id))

-    async def remove(self) -> None:
+    def remove(self) -> None:
        """Remove the account."""
-        await self._rpc.remove_account(self.id)
+        self._rpc.remove_account(self.id)

-    async def start_io(self) -> None:
+    def start_io(self) -> None:
        """Start the account I/O."""
-        await self._rpc.start_io(self.id)
+        self._rpc.start_io(self.id)

-    async def stop_io(self) -> None:
+    def stop_io(self) -> None:
        """Stop the account I/O."""
-        await self._rpc.stop_io(self.id)
+        self._rpc.stop_io(self.id)

-    async def get_info(self) -> AttrDict:
+    def get_info(self) -> AttrDict:
        """Return dictionary of this account configuration parameters."""
-        return AttrDict(await self._rpc.get_info(self.id))
+        return AttrDict(self._rpc.get_info(self.id))

-    async def get_size(self) -> int:
+    def get_size(self) -> int:
        """Get the combined filesize of an account in bytes."""
-        return await self._rpc.get_account_file_size(self.id)
+        return self._rpc.get_account_file_size(self.id)

-    async def is_configured(self) -> bool:
+    def is_configured(self) -> bool:
        """Return True if this account is configured."""
-        return await self._rpc.is_configured(self.id)
+        return self._rpc.is_configured(self.id)

-    async def set_config(self, key: str, value: Optional[str] = None) -> None:
+    def set_config(self, key: str, value: Optional[str] = None) -> None:
        """Set configuration value."""
-        await self._rpc.set_config(self.id, key, value)
+        self._rpc.set_config(self.id, key, value)

-    async def get_config(self, key: str) -> Optional[str]:
+    def get_config(self, key: str) -> Optional[str]:
        """Get configuration value."""
-        return await self._rpc.get_config(self.id, key)
+        return self._rpc.get_config(self.id, key)

-    async def update_config(self, **kwargs) -> None:
+    def update_config(self, **kwargs) -> None:
        """update config values."""
        for key, value in kwargs.items():
-            await self.set_config(key, value)
+            self.set_config(key, value)

-    async def set_avatar(self, img_path: Optional[str] = None) -> None:
+    def set_avatar(self, img_path: Optional[str] = None) -> None:
        """Set self avatar.

        Passing None will discard the currently set avatar.
        """
-        await self.set_config("selfavatar", img_path)
+        self.set_config("selfavatar", img_path)

-    async def get_avatar(self) -> Optional[str]:
+    def get_avatar(self) -> Optional[str]:
        """Get self avatar."""
-        return await self.get_config("selfavatar")
+        return self.get_config("selfavatar")

-    async def configure(self) -> None:
+    def configure(self) -> None:
        """Configure an account."""
-        await self._rpc.configure(self.id)
+        self._rpc.configure(self.id)

-    async def create_contact(self, obj: Union[int, str, Contact], name: Optional[str] = None) -> Contact:
+    def create_contact(self, obj: Union[int, str, Contact], name: Optional[str] = None) -> Contact:
        """Create a new Contact or return an existing one.

        Calling this method will always result in the same
@@ -94,24 +94,24 @@ class Account:
        if isinstance(obj, int):
            obj = Contact(self, obj)
        if isinstance(obj, Contact):
-            obj = (await obj.get_snapshot()).address
-        return Contact(self, await self._rpc.create_contact(self.id, obj, name))
+            obj = obj.get_snapshot().address
+        return Contact(self, self._rpc.create_contact(self.id, obj, name))

    def get_contact_by_id(self, contact_id: int) -> Contact:
        """Return Contact instance for the given contact ID."""
        return Contact(self, contact_id)

-    async def get_contact_by_addr(self, address: str) -> Optional[Contact]:
+    def get_contact_by_addr(self, address: str) -> Optional[Contact]:
        """Check if an e-mail address belongs to a known and unblocked contact."""
-        contact_id = await self._rpc.lookup_contact_id_by_addr(self.id, address)
+        contact_id = self._rpc.lookup_contact_id_by_addr(self.id, address)
        return contact_id and Contact(self, contact_id)

-    async def get_blocked_contacts(self) -> List[AttrDict]:
+    def get_blocked_contacts(self) -> List[AttrDict]:
        """Return a list with snapshots of all blocked contacts."""
-        contacts = await self._rpc.get_blocked_contacts(self.id)
+        contacts = self._rpc.get_blocked_contacts(self.id)
        return [AttrDict(contact=Contact(self, contact["id"]), **contact) for contact in contacts]

-    async def get_contacts(
+    def get_contacts(
        self,
        query: Optional[str] = None,
        with_self: bool = False,
@@ -133,9 +133,9 @@ class Account:
            flags |= ContactFlag.ADD_SELF

        if snapshot:
-            contacts = await self._rpc.get_contacts(self.id, flags, query)
+            contacts = self._rpc.get_contacts(self.id, flags, query)
            return [AttrDict(contact=Contact(self, contact["id"]), **contact) for contact in contacts]
-        contacts = await self._rpc.get_contact_ids(self.id, flags, query)
+        contacts = self._rpc.get_contact_ids(self.id, flags, query)
        return [Contact(self, contact_id) for contact_id in contacts]

    @property
@@ -143,7 +143,7 @@ class Account:
        """This account's identity as a Contact."""
        return Contact(self, SpecialContactId.SELF)

-    async def get_chatlist(
+    def get_chatlist(
        self,
        query: Optional[str] = None,
        contact: Optional[Contact] = None,
@@ -175,29 +175,29 @@ class Account:
        if alldone_hint:
            flags |= ChatlistFlag.ADD_ALLDONE_HINT

-        entries = await self._rpc.get_chatlist_entries(self.id, flags, query, contact and contact.id)
+        entries = self._rpc.get_chatlist_entries(self.id, flags, query, contact and contact.id)
        if not snapshot:
            return [Chat(self, entry) for entry in entries]

-        items = await self._rpc.get_chatlist_items_by_entries(self.id, entries)
+        items = self._rpc.get_chatlist_items_by_entries(self.id, entries)
        chats = []
        for item in items.values():
            item["chat"] = Chat(self, item["id"])
            chats.append(AttrDict(item))
        return chats

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

        After creation, the group has only self-contact as member and is in unpromoted state.
        """
-        return Chat(self, await self._rpc.create_group_chat(self.id, name, protect))
+        return Chat(self, self._rpc.create_group_chat(self.id, name, protect))

    def get_chat_by_id(self, chat_id: int) -> Chat:
        """Return the Chat instance with the given ID."""
        return Chat(self, chat_id)

-    async def secure_join(self, qrdata: str) -> Chat:
+    def secure_join(self, qrdata: str) -> Chat:
        """Continue a Setup-Contact or Verified-Group-Invite protocol started on
        another device.

@@ -208,62 +208,62 @@ class Account:

        :param qrdata: The text of the scanned QR code.
        """
-        return Chat(self, await self._rpc.secure_join(self.id, qrdata))
+        return Chat(self, self._rpc.secure_join(self.id, qrdata))

-    async def get_qr_code(self) -> Tuple[str, str]:
+    def get_qr_code(self) -> Tuple[str, str]:
        """Get Setup-Contact QR Code text and SVG data.

        this data needs to be transferred to another Delta Chat account
        in a second channel, typically used by mobiles with QRcode-show + scan UX.
        """
-        return await self._rpc.get_chat_securejoin_qr_code_svg(self.id, None)
+        return self._rpc.get_chat_securejoin_qr_code_svg(self.id, None)

    def get_message_by_id(self, msg_id: int) -> Message:
        """Return the Message instance with the given ID."""
        return Message(self, msg_id)

-    async def mark_seen_messages(self, messages: List[Message]) -> None:
+    def mark_seen_messages(self, messages: List[Message]) -> None:
        """Mark the given set of messages as seen."""
-        await self._rpc.markseen_msgs(self.id, [msg.id for msg in messages])
+        self._rpc.markseen_msgs(self.id, [msg.id for msg in messages])

-    async def delete_messages(self, messages: List[Message]) -> None:
+    def delete_messages(self, messages: List[Message]) -> None:
        """Delete messages (local and remote)."""
-        await self._rpc.delete_messages(self.id, [msg.id for msg in messages])
+        self._rpc.delete_messages(self.id, [msg.id for msg in messages])

-    async def get_fresh_messages(self) -> List[Message]:
+    def get_fresh_messages(self) -> List[Message]:
        """Return the list of fresh messages, newest messages first.

        This call is intended for displaying notifications.
        If you are writing a bot, use `get_fresh_messages_in_arrival_order()` instead,
        to process oldest messages first.
        """
-        fresh_msg_ids = await self._rpc.get_fresh_msgs(self.id)
+        fresh_msg_ids = self._rpc.get_fresh_msgs(self.id)
        return [Message(self, msg_id) for msg_id in fresh_msg_ids]

-    async def get_next_messages(self) -> List[Message]:
+    def get_next_messages(self) -> List[Message]:
        """Return a list of next messages."""
-        next_msg_ids = await self._rpc.get_next_msgs(self.id)
+        next_msg_ids = self._rpc.get_next_msgs(self.id)
        return [Message(self, msg_id) for msg_id in next_msg_ids]

-    async def wait_next_messages(self) -> List[Message]:
+    def wait_next_messages(self) -> List[Message]:
        """Wait for new messages and return a list of them."""
-        next_msg_ids = await self._rpc.wait_next_msgs(self.id)
+        next_msg_ids = self._rpc.wait_next_msgs(self.id)
        return [Message(self, msg_id) for msg_id in next_msg_ids]

-    async def get_fresh_messages_in_arrival_order(self) -> List[Message]:
+    def get_fresh_messages_in_arrival_order(self) -> List[Message]:
        """Return fresh messages list sorted in the order of their arrival, with ascending IDs."""
        warn(
            "get_fresh_messages_in_arrival_order is deprecated, use get_next_messages instead.",
            DeprecationWarning,
            stacklevel=2,
        )
-        fresh_msg_ids = sorted(await self._rpc.get_fresh_msgs(self.id))
+        fresh_msg_ids = sorted(self._rpc.get_fresh_msgs(self.id))
        return [Message(self, msg_id) for msg_id in fresh_msg_ids]

-    async def export_backup(self, path, passphrase: str = "") -> None:
+    def export_backup(self, path, passphrase: str = "") -> None:
        """Export backup."""
-        await self._rpc.export_backup(self.id, str(path), passphrase)
+        self._rpc.export_backup(self.id, str(path), passphrase)

-    async def import_backup(self, path, passphrase: str = "") -> None:
+    def import_backup(self, path, passphrase: str = "") -> None:
        """Import backup."""
-        await self._rpc.import_backup(self.id, str(path), passphrase)
+        self._rpc.import_backup(self.id, str(path), passphrase)
--- a/deltachat-rpc-client/src/deltachat_rpc_client/chat.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/chat.py
@@ -25,7 +25,7 @@ class Chat:
    def _rpc(self) -> "Rpc":
        return self.account._rpc

-    async def delete(self) -> None:
+    def delete(self) -> None:
        """Delete this chat and all its messages.

        Note:
@@ -33,83 +33,83 @@ class Chat:
        - does not delete messages on server
        - the chat or contact is not blocked, new message will arrive
        """
-        await self._rpc.delete_chat(self.account.id, self.id)
+        self._rpc.delete_chat(self.account.id, self.id)

-    async def block(self) -> None:
+    def block(self) -> None:
        """Block this chat."""
-        await self._rpc.block_chat(self.account.id, self.id)
+        self._rpc.block_chat(self.account.id, self.id)

-    async def accept(self) -> None:
+    def accept(self) -> None:
        """Accept this contact request chat."""
-        await self._rpc.accept_chat(self.account.id, self.id)
+        self._rpc.accept_chat(self.account.id, self.id)

-    async def leave(self) -> None:
+    def leave(self) -> None:
        """Leave this chat."""
-        await self._rpc.leave_group(self.account.id, self.id)
+        self._rpc.leave_group(self.account.id, self.id)

-    async def mute(self, duration: Optional[int] = None) -> None:
+    def mute(self, duration: Optional[int] = None) -> None:
        """Mute this chat, if a duration is not provided the chat is muted forever.

        :param duration: mute duration from now in seconds. Must be greater than zero.
        """
        if duration is not None:
            assert duration > 0, "Invalid duration"
-            dur: Union[str, dict] = {"Until": duration}
+            dur: dict = {"kind": "Until", "duration": duration}
        else:
-            dur = "Forever"
-        await self._rpc.set_chat_mute_duration(self.account.id, self.id, dur)
+            dur = {"kind": "Forever"}
+        self._rpc.set_chat_mute_duration(self.account.id, self.id, dur)

-    async def unmute(self) -> None:
+    def unmute(self) -> None:
        """Unmute this chat."""
-        await self._rpc.set_chat_mute_duration(self.account.id, self.id, "NotMuted")
+        self._rpc.set_chat_mute_duration(self.account.id, self.id, {"kind": "NotMuted"})

-    async def pin(self) -> None:
+    def pin(self) -> None:
        """Pin this chat."""
-        await self._rpc.set_chat_visibility(self.account.id, self.id, ChatVisibility.PINNED)
+        self._rpc.set_chat_visibility(self.account.id, self.id, ChatVisibility.PINNED)

-    async def unpin(self) -> None:
+    def unpin(self) -> None:
        """Unpin this chat."""
-        await self._rpc.set_chat_visibility(self.account.id, self.id, ChatVisibility.NORMAL)
+        self._rpc.set_chat_visibility(self.account.id, self.id, ChatVisibility.NORMAL)

-    async def archive(self) -> None:
+    def archive(self) -> None:
        """Archive this chat."""
-        await self._rpc.set_chat_visibility(self.account.id, self.id, ChatVisibility.ARCHIVED)
+        self._rpc.set_chat_visibility(self.account.id, self.id, ChatVisibility.ARCHIVED)

-    async def unarchive(self) -> None:
+    def unarchive(self) -> None:
        """Unarchive this chat."""
-        await self._rpc.set_chat_visibility(self.account.id, self.id, ChatVisibility.NORMAL)
+        self._rpc.set_chat_visibility(self.account.id, self.id, ChatVisibility.NORMAL)

-    async def set_name(self, name: str) -> None:
+    def set_name(self, name: str) -> None:
        """Set name of this chat."""
-        await self._rpc.set_chat_name(self.account.id, self.id, name)
+        self._rpc.set_chat_name(self.account.id, self.id, name)

-    async def set_ephemeral_timer(self, timer: int) -> None:
+    def set_ephemeral_timer(self, timer: int) -> None:
        """Set ephemeral timer of this chat."""
-        await self._rpc.set_chat_ephemeral_timer(self.account.id, self.id, timer)
+        self._rpc.set_chat_ephemeral_timer(self.account.id, self.id, timer)

-    async def get_encryption_info(self) -> str:
+    def get_encryption_info(self) -> str:
        """Return encryption info for this chat."""
-        return await self._rpc.get_chat_encryption_info(self.account.id, self.id)
+        return self._rpc.get_chat_encryption_info(self.account.id, self.id)

-    async def get_qr_code(self) -> Tuple[str, str]:
+    def get_qr_code(self) -> Tuple[str, str]:
        """Get Join-Group QR code text and SVG data."""
-        return await self._rpc.get_chat_securejoin_qr_code_svg(self.account.id, self.id)
+        return self._rpc.get_chat_securejoin_qr_code_svg(self.account.id, self.id)

-    async def get_basic_snapshot(self) -> AttrDict:
+    def get_basic_snapshot(self) -> AttrDict:
        """Get a chat snapshot with basic info about this chat."""
-        info = await self._rpc.get_basic_chat_info(self.account.id, self.id)
+        info = self._rpc.get_basic_chat_info(self.account.id, self.id)
        return AttrDict(chat=self, **info)

-    async def get_full_snapshot(self) -> AttrDict:
+    def get_full_snapshot(self) -> AttrDict:
        """Get a full snapshot of this chat."""
-        info = await self._rpc.get_full_chat_by_id(self.account.id, self.id)
+        info = self._rpc.get_full_chat_by_id(self.account.id, self.id)
        return AttrDict(chat=self, **info)

-    async def can_send(self) -> bool:
+    def can_send(self) -> bool:
        """Return true if messages can be sent to the chat."""
-        return await self._rpc.can_send(self.account.id, self.id)
+        return self._rpc.can_send(self.account.id, self.id)

-    async def send_message(
+    def send_message(
        self,
        text: Optional[str] = None,
        html: Optional[str] = None,
@@ -132,47 +132,48 @@ class Chat:
            "overrideSenderName": override_sender_name,
            "quotedMessageId": quoted_msg,
        }
-        msg_id = await self._rpc.send_msg(self.account.id, self.id, draft)
+        msg_id = self._rpc.send_msg(self.account.id, self.id, draft)
        return Message(self.account, msg_id)

-    async def send_text(self, text: str) -> Message:
+    def send_text(self, text: str) -> Message:
        """Send a text message and return the resulting Message instance."""
-        msg_id = await self._rpc.misc_send_text_message(self.account.id, self.id, text)
+        msg_id = self._rpc.misc_send_text_message(self.account.id, self.id, text)
        return Message(self.account, msg_id)

-    async def send_videochat_invitation(self) -> Message:
+    def send_videochat_invitation(self) -> Message:
        """Send a videochat invitation and return the resulting Message instance."""
-        msg_id = await self._rpc.send_videochat_invitation(self.account.id, self.id)
+        msg_id = self._rpc.send_videochat_invitation(self.account.id, self.id)
        return Message(self.account, msg_id)

-    async def send_sticker(self, path: str) -> Message:
+    def send_sticker(self, path: str) -> Message:
        """Send an sticker and return the resulting Message instance."""
-        msg_id = await self._rpc.send_sticker(self.account.id, self.id, path)
+        msg_id = self._rpc.send_sticker(self.account.id, self.id, path)
        return Message(self.account, msg_id)

-    async def forward_messages(self, messages: List[Message]) -> None:
+    def forward_messages(self, messages: List[Message]) -> None:
        """Forward a list of messages to this chat."""
        msg_ids = [msg.id for msg in messages]
-        await self._rpc.forward_messages(self.account.id, msg_ids, self.id)
+        self._rpc.forward_messages(self.account.id, msg_ids, self.id)

-    async def set_draft(
+    def set_draft(
        self,
        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
-        await 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)

-    async def remove_draft(self) -> None:
+    def remove_draft(self) -> None:
        """Remove draft message."""
-        await self._rpc.remove_draft(self.account.id, self.id)
+        self._rpc.remove_draft(self.account.id, self.id)

-    async def get_draft(self) -> Optional[AttrDict]:
+    def get_draft(self) -> Optional[AttrDict]:
        """Get draft message."""
-        snapshot = await self._rpc.get_draft(self.account.id, self.id)
+        snapshot = self._rpc.get_draft(self.account.id, self.id)
        if not snapshot:
            return None
        snapshot = AttrDict(snapshot)
@@ -181,61 +182,61 @@ class Chat:
        snapshot["message"] = Message(self.account, snapshot.id)
        return snapshot

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

-    async def get_fresh_message_count(self) -> int:
+    def get_fresh_message_count(self) -> int:
        """Get number of fresh messages in this chat"""
-        return await self._rpc.get_fresh_msg_cnt(self.account.id, self.id)
+        return self._rpc.get_fresh_msg_cnt(self.account.id, self.id)

-    async def mark_noticed(self) -> None:
+    def mark_noticed(self) -> None:
        """Mark all messages in this chat as noticed."""
-        await self._rpc.marknoticed_chat(self.account.id, self.id)
+        self._rpc.marknoticed_chat(self.account.id, self.id)

-    async def add_contact(self, *contact: Union[int, str, Contact]) -> None:
+    def add_contact(self, *contact: Union[int, str, Contact]) -> None:
        """Add contacts to this group."""
        for cnt in contact:
            if isinstance(cnt, str):
-                contact_id = (await self.account.create_contact(cnt)).id
+                contact_id = self.account.create_contact(cnt).id
            elif not isinstance(cnt, int):
                contact_id = cnt.id
            else:
                contact_id = cnt
-            await self._rpc.add_contact_to_chat(self.account.id, self.id, contact_id)
+            self._rpc.add_contact_to_chat(self.account.id, self.id, contact_id)

-    async def remove_contact(self, *contact: Union[int, str, Contact]) -> None:
+    def remove_contact(self, *contact: Union[int, str, Contact]) -> None:
        """Remove members from this group."""
        for cnt in contact:
            if isinstance(cnt, str):
-                contact_id = (await self.account.create_contact(cnt)).id
+                contact_id = self.account.create_contact(cnt).id
            elif not isinstance(cnt, int):
                contact_id = cnt.id
            else:
                contact_id = cnt
-            await self._rpc.remove_contact_from_chat(self.account.id, self.id, contact_id)
+            self._rpc.remove_contact_from_chat(self.account.id, self.id, contact_id)

-    async def get_contacts(self) -> List[Contact]:
+    def get_contacts(self) -> List[Contact]:
        """Get the contacts belonging to this chat.

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

-    async def set_image(self, path: str) -> None:
+    def set_image(self, path: str) -> None:
        """Set profile image of this chat.

        :param path: Full path of the image to use as the group image.
        """
-        await self._rpc.set_chat_profile_image(self.account.id, self.id, path)
+        self._rpc.set_chat_profile_image(self.account.id, self.id, path)

-    async def remove_image(self) -> None:
+    def remove_image(self) -> None:
        """Remove profile image of this chat."""
-        await self._rpc.set_chat_profile_image(self.account.id, self.id, None)
+        self._rpc.set_chat_profile_image(self.account.id, self.id, None)

-    async def get_locations(
+    def get_locations(
        self,
        contact: Optional[Contact] = None,
        timestamp_from: Optional["datetime"] = None,
@@ -246,7 +247,7 @@ class Chat:
        time_to = calendar.timegm(timestamp_to.utctimetuple()) if timestamp_to else 0
        contact_id = contact.id if contact else 0

-        result = await self._rpc.get_locations(self.account.id, self.id, contact_id, time_from, time_to)
+        result = self._rpc.get_locations(self.account.id, self.id, contact_id, time_from, time_to)
        locations = []
        contacts: Dict[int, Contact] = {}
        for loc in result:
--- a/deltachat-rpc-client/src/deltachat_rpc_client/client.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/client.py
@@ -1,10 +1,8 @@
 """Event loop implementations offering high level event handling/hooking."""
-import inspect
 import logging
 from typing import (
    TYPE_CHECKING,
    Callable,
-    Coroutine,
    Dict,
    Iterable,
    Optional,
@@ -78,22 +76,22 @@ class Client:
        )
        self._hooks.get(type(event), set()).remove((hook, event))

-    async def is_configured(self) -> bool:
-        return await self.account.is_configured()
+    def is_configured(self) -> bool:
+        return self.account.is_configured()

-    async def configure(self, email: str, password: str, **kwargs) -> None:
-        await self.account.set_config("addr", email)
-        await self.account.set_config("mail_pw", password)
+    def configure(self, email: str, password: str, **kwargs) -> None:
+        self.account.set_config("addr", email)
+        self.account.set_config("mail_pw", password)
        for key, value in kwargs.items():
-            await self.account.set_config(key, value)
-        await self.account.configure()
+            self.account.set_config(key, value)
+        self.account.configure()
        self.logger.debug("Account configured")

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

-    async 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
@@ -101,39 +99,37 @@ class Client:
        evaluates to True.
        """
        self.logger.debug("Listening to incoming events...")
-        if await self.is_configured():
-            await self.account.start_io()
-        await self._process_messages()  # Process old messages.
+        if self.is_configured():
+            self.account.start_io()
+        self._process_messages()  # Process old messages.
        while True:
-            event = await self.account.wait_for_event()
-            event["type"] = EventType(event.type)
+            event = self.account.wait_for_event()
+            event["kind"] = EventType(event.kind)
            event["account"] = self.account
-            await self._on_event(event)
-            if event.type == EventType.INCOMING_MSG:
-                await self._process_messages()
+            self._on_event(event)
+            if event.kind == EventType.INCOMING_MSG:
+                self._process_messages()

            stop = func(event)
-            if inspect.isawaitable(stop):
-                stop = await stop
            if stop:
                return event

-    async def _on_event(self, event: AttrDict, filter_type: Type[EventFilter] = RawEvent) -> None:
+    def _on_event(self, event: AttrDict, filter_type: Type[EventFilter] = RawEvent) -> None:
        for hook, evfilter in self._hooks.get(filter_type, []):
-            if await evfilter.filter(event):
+            if evfilter.filter(event):
                try:
-                    await hook(event)
+                    hook(event)
                except Exception as ex:
                    self.logger.exception(ex)

-    async def _parse_command(self, event: AttrDict) -> None:
+    def _parse_command(self, event: AttrDict) -> None:
        cmds = [hook[1].command for hook in self._hooks.get(NewMessage, []) if hook[1].command]
        parts = event.message_snapshot.text.split(maxsplit=1)
        payload = parts[1] if len(parts) > 1 else ""
        cmd = parts.pop(0)

        if "@" in cmd:
-            suffix = "@" + (await self.account.self_contact.get_snapshot()).address
+            suffix = "@" + self.account.self_contact.get_snapshot().address
            if cmd.endswith(suffix):
                cmd = cmd[: -len(suffix)]
            else:
@@ -153,32 +149,32 @@ class Client:

        event["command"], event["payload"] = cmd, payload

-    async def _on_new_msg(self, snapshot: AttrDict) -> None:
+    def _on_new_msg(self, snapshot: AttrDict) -> None:
        event = AttrDict(command="", payload="", message_snapshot=snapshot)
        if not snapshot.is_info and snapshot.text.startswith(COMMAND_PREFIX):
-            await self._parse_command(event)
-        await self._on_event(event, NewMessage)
+            self._parse_command(event)
+        self._on_event(event, NewMessage)

-    async def _handle_info_msg(self, snapshot: AttrDict) -> None:
+    def _handle_info_msg(self, snapshot: AttrDict) -> None:
        event = AttrDict(message_snapshot=snapshot)

        img_changed = parse_system_image_changed(snapshot.text)
        if img_changed:
            _, event["image_deleted"] = img_changed
-            await self._on_event(event, GroupImageChanged)
+            self._on_event(event, GroupImageChanged)
            return

        title_changed = parse_system_title_changed(snapshot.text)
        if title_changed:
            _, event["old_name"] = title_changed
-            await self._on_event(event, GroupNameChanged)
+            self._on_event(event, GroupNameChanged)
            return

        members_changed = parse_system_add_remove(snapshot.text)
        if members_changed:
            action, event["member"], _ = members_changed
            event["member_added"] = action == "added"
-            await self._on_event(event, MemberListChanged)
+            self._on_event(event, MemberListChanged)
            return

        self.logger.warning(
@@ -187,20 +183,20 @@ class Client:
            snapshot.text,
        )

-    async def _process_messages(self) -> None:
+    def _process_messages(self) -> None:
        if self._should_process_messages:
-            for message in await self.account.get_next_messages():
-                snapshot = await message.get_snapshot()
+            for message in self.account.get_next_messages():
+                snapshot = message.get_snapshot()
                if snapshot.from_id not in [SpecialContactId.SELF, SpecialContactId.DEVICE]:
-                    await self._on_new_msg(snapshot)
+                    self._on_new_msg(snapshot)
                if snapshot.is_info and snapshot.system_message_type != SystemMessageType.WEBXDC_INFO_MESSAGE:
-                    await self._handle_info_msg(snapshot)
-                await snapshot.message.mark_seen()
+                    self._handle_info_msg(snapshot)
+                snapshot.message.mark_seen()


 class Bot(Client):
    """Simple bot implementation that listent to events of a single account."""

-    async def configure(self, email: str, password: str, **kwargs) -> None:
+    def configure(self, email: str, password: str, **kwargs) -> None:
        kwargs.setdefault("bot", "1")
-        await super().configure(email, password, **kwargs)
+        super().configure(email, password, **kwargs)
--- a/deltachat-rpc-client/src/deltachat_rpc_client/contact.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/contact.py
@@ -24,39 +24,39 @@ class Contact:
    def _rpc(self) -> "Rpc":
        return self.account._rpc

-    async def block(self) -> None:
+    def block(self) -> None:
        """Block contact."""
-        await self._rpc.block_contact(self.account.id, self.id)
+        self._rpc.block_contact(self.account.id, self.id)

-    async def unblock(self) -> None:
+    def unblock(self) -> None:
        """Unblock contact."""
-        await self._rpc.unblock_contact(self.account.id, self.id)
+        self._rpc.unblock_contact(self.account.id, self.id)

-    async def delete(self) -> None:
+    def delete(self) -> None:
        """Delete contact."""
-        await self._rpc.delete_contact(self.account.id, self.id)
+        self._rpc.delete_contact(self.account.id, self.id)

-    async def set_name(self, name: str) -> None:
+    def set_name(self, name: str) -> None:
        """Change the name of this contact."""
-        await self._rpc.change_contact_name(self.account.id, self.id, name)
+        self._rpc.change_contact_name(self.account.id, self.id, name)

-    async def get_encryption_info(self) -> str:
+    def get_encryption_info(self) -> str:
        """Get a multi-line encryption info, containing your fingerprint and
        the fingerprint of the contact.
        """
-        return await self._rpc.get_contact_encryption_info(self.account.id, self.id)
+        return self._rpc.get_contact_encryption_info(self.account.id, self.id)

-    async def get_snapshot(self) -> AttrDict:
+    def get_snapshot(self) -> AttrDict:
        """Return a dictionary with a snapshot of all contact properties."""
-        snapshot = AttrDict(await self._rpc.get_contact(self.account.id, self.id))
+        snapshot = AttrDict(self._rpc.get_contact(self.account.id, self.id))
        snapshot["contact"] = self
        return snapshot

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

        return Chat(
            self.account,
-            await self._rpc.create_chat_by_contact_id(self.account.id, self.id),
+            self._rpc.create_chat_by_contact_id(self.account.id, self.id),
        )
--- a/deltachat-rpc-client/src/deltachat_rpc_client/deltachat.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/deltachat.py
@@ -16,34 +16,34 @@ class DeltaChat:
    def __init__(self, rpc: "Rpc") -> None:
        self.rpc = rpc

-    async def add_account(self) -> Account:
+    def add_account(self) -> Account:
        """Create a new account database."""
-        account_id = await self.rpc.add_account()
+        account_id = self.rpc.add_account()
        return Account(self, account_id)

-    async def get_all_accounts(self) -> List[Account]:
+    def get_all_accounts(self) -> List[Account]:
        """Return a list of all available accounts."""
-        account_ids = await self.rpc.get_all_account_ids()
+        account_ids = self.rpc.get_all_account_ids()
        return [Account(self, account_id) for account_id in account_ids]

-    async def start_io(self) -> None:
+    def start_io(self) -> None:
        """Start the I/O of all accounts."""
-        await self.rpc.start_io_for_all_accounts()
+        self.rpc.start_io_for_all_accounts()

-    async def stop_io(self) -> None:
+    def stop_io(self) -> None:
        """Stop the I/O of all accounts."""
-        await self.rpc.stop_io_for_all_accounts()
+        self.rpc.stop_io_for_all_accounts()

-    async def maybe_network(self) -> None:
+    def maybe_network(self) -> None:
        """Indicate that the network likely has come back or just that the network
        conditions might have changed.
        """
-        await self.rpc.maybe_network()
+        self.rpc.maybe_network()

-    async def get_system_info(self) -> AttrDict:
+    def get_system_info(self) -> AttrDict:
        """Get information about the Delta Chat core in this system."""
-        return AttrDict(await self.rpc.get_system_info())
+        return AttrDict(self.rpc.get_system_info())

-    async def set_translations(self, translations: Dict[str, str]) -> None:
+    def set_translations(self, translations: Dict[str, str]) -> None:
        """Set stock translation strings."""
-        await self.rpc.set_stock_strings(translations)
+        self.rpc.set_stock_strings(translations)
--- a/deltachat-rpc-client/src/deltachat_rpc_client/events.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/events.py
@@ -1,5 +1,4 @@
 """High-level classes for event processing and filtering."""
-import inspect
 import re
 from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING, Callable, Iterable, Iterator, Optional, Set, Tuple, Union
@@ -24,7 +23,7 @@ def _tuple_of(obj, type_: type) -> tuple:
 class EventFilter(ABC):
    """The base event filter.

-    :param func: A Callable (async or not) function that should accept the event as input
+    :param func: A Callable function that should accept the event as input
                 parameter, and return a bool value indicating whether the event
                 should be dispatched or not.
    """
@@ -43,16 +42,13 @@ class EventFilter(ABC):
    def __ne__(self, other):
        return not self == other

-    async def _call_func(self, event) -> bool:
+    def _call_func(self, event) -> bool:
        if not self.func:
            return True
-        res = self.func(event)
-        if inspect.isawaitable(res):
-            return await res
-        return res
+        return self.func(event)

    @abstractmethod
-    async def filter(self, event):
+    def filter(self, event):
        """Return True-like value if the event passed the filter and should be
        used, or False-like value otherwise.
        """
@@ -62,7 +58,7 @@ class RawEvent(EventFilter):
    """Matches raw core events.

    :param types: The types of event to match.
-    :param func: A Callable (async or not) function that should accept the event as input
+    :param func: A Callable function that should accept the event as input
                 parameter, and return a bool value indicating whether the event
                 should be dispatched or not.
    """
@@ -82,10 +78,10 @@ class RawEvent(EventFilter):
            return (self.types, self.func) == (other.types, other.func)
        return False

-    async def filter(self, event: "AttrDict") -> bool:
-        if self.types and event.type not in self.types:
+    def filter(self, event: "AttrDict") -> bool:
+        if self.types and event.kind not in self.types:
            return False
-        return await self._call_func(event)
+        return self._call_func(event)


 class NewMessage(EventFilter):
@@ -104,7 +100,7 @@ class NewMessage(EventFilter):
    :param is_info: If set to True only match info/system messages, if set to False
                    only match messages that are not info/system messages. If omitted
                    info/system messages as well as normal messages will be matched.
-    :param func: A Callable (async or not) function that should accept the event as input
+    :param func: A Callable function that should accept the event as input
                 parameter, and return a bool value indicating whether the event
                 should be dispatched or not.
    """
@@ -159,7 +155,7 @@ class NewMessage(EventFilter):
            )
        return False

-    async def filter(self, event: "AttrDict") -> bool:
+    def filter(self, event: "AttrDict") -> bool:
        if self.is_bot is not None and self.is_bot != event.message_snapshot.is_bot:
            return False
        if self.is_info is not None and self.is_info != event.message_snapshot.is_info:
@@ -168,11 +164,9 @@ class NewMessage(EventFilter):
            return False
        if self.pattern:
            match = self.pattern(event.message_snapshot.text)
-            if inspect.isawaitable(match):
-                match = await match
            if not match:
                return False
-        return await super()._call_func(event)
+        return super()._call_func(event)


 class MemberListChanged(EventFilter):
@@ -184,7 +178,7 @@ class MemberListChanged(EventFilter):
    :param added: If set to True only match if a member was added, if set to False
                  only match if a member was removed. If omitted both, member additions
                  and removals, will be matched.
-    :param func: A Callable (async or not) function that should accept the event as input
+    :param func: A Callable function that should accept the event as input
                 parameter, and return a bool value indicating whether the event
                 should be dispatched or not.
    """
@@ -201,10 +195,10 @@ class MemberListChanged(EventFilter):
            return (self.added, self.func) == (other.added, other.func)
        return False

-    async def filter(self, event: "AttrDict") -> bool:
+    def filter(self, event: "AttrDict") -> bool:
        if self.added is not None and self.added != event.member_added:
            return False
-        return await self._call_func(event)
+        return self._call_func(event)


 class GroupImageChanged(EventFilter):
@@ -216,7 +210,7 @@ class GroupImageChanged(EventFilter):
    :param deleted: If set to True only match if the image was deleted, if set to False
                    only match if a new image was set. If omitted both, image changes and
                    removals, will be matched.
-    :param func: A Callable (async or not) function that should accept the event as input
+    :param func: A Callable function that should accept the event as input
                 parameter, and return a bool value indicating whether the event
                 should be dispatched or not.
    """
@@ -233,10 +227,10 @@ class GroupImageChanged(EventFilter):
            return (self.deleted, self.func) == (other.deleted, other.func)
        return False

-    async def filter(self, event: "AttrDict") -> bool:
+    def filter(self, event: "AttrDict") -> bool:
        if self.deleted is not None and self.deleted != event.image_deleted:
            return False
-        return await self._call_func(event)
+        return self._call_func(event)


 class GroupNameChanged(EventFilter):
@@ -245,7 +239,7 @@ class GroupNameChanged(EventFilter):
    Warning: registering a handler for this event will cause the messages
    to be marked as read. Its usage is mainly intended for bots.

-    :param func: A Callable (async or not) function that should accept the event as input
+    :param func: A Callable function that should accept the event as input
                 parameter, and return a bool value indicating whether the event
                 should be dispatched or not.
    """
@@ -258,8 +252,8 @@ class GroupNameChanged(EventFilter):
            return self.func == other.func
        return False

-    async def filter(self, event: "AttrDict") -> bool:
-        return await self._call_func(event)
+    def filter(self, event: "AttrDict") -> bool:
+        return self._call_func(event)


 class HookCollection:
--- a/deltachat-rpc-client/src/deltachat_rpc_client/message.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/message.py
@@ -21,39 +21,39 @@ class Message:
    def _rpc(self) -> "Rpc":
        return self.account._rpc

-    async def send_reaction(self, *reaction: str):
+    def send_reaction(self, *reaction: str):
        """Send a reaction to this message."""
-        await self._rpc.send_reaction(self.account.id, self.id, reaction)
+        self._rpc.send_reaction(self.account.id, self.id, reaction)

-    async def get_snapshot(self) -> AttrDict:
+    def get_snapshot(self) -> AttrDict:
        """Get a snapshot with the properties of this message."""
        from .chat import Chat

-        snapshot = AttrDict(await self._rpc.get_message(self.account.id, self.id))
+        snapshot = AttrDict(self._rpc.get_message(self.account.id, self.id))
        snapshot["chat"] = Chat(self.account, snapshot.chat_id)
        snapshot["sender"] = Contact(self.account, snapshot.from_id)
        snapshot["message"] = self
        return snapshot

-    async def get_reactions(self) -> Optional[AttrDict]:
+    def get_reactions(self) -> Optional[AttrDict]:
        """Get message reactions."""
-        reactions = await self._rpc.get_message_reactions(self.account.id, self.id)
+        reactions = self._rpc.get_message_reactions(self.account.id, self.id)
        if reactions:
            return AttrDict(reactions)
        return None

-    async def mark_seen(self) -> None:
+    def mark_seen(self) -> None:
        """Mark the message as seen."""
-        await self._rpc.markseen_msgs(self.account.id, [self.id])
+        self._rpc.markseen_msgs(self.account.id, [self.id])

-    async def send_webxdc_status_update(self, update: Union[dict, str], description: str) -> None:
+    def send_webxdc_status_update(self, update: Union[dict, str], description: str) -> None:
        """Send a webxdc status update. This message must be a webxdc."""
        if not isinstance(update, str):
            update = json.dumps(update)
-        await self._rpc.send_webxdc_status_update(self.account.id, self.id, update, description)
+        self._rpc.send_webxdc_status_update(self.account.id, self.id, update, description)

-    async def get_webxdc_status_updates(self, last_known_serial: int = 0) -> list:
-        return json.loads(await self._rpc.get_webxdc_status_updates(self.account.id, self.id, last_known_serial))
+    def get_webxdc_status_updates(self, last_known_serial: int = 0) -> list:
+        return json.loads(self._rpc.get_webxdc_status_updates(self.account.id, self.id, last_known_serial))

-    async def get_webxdc_info(self) -> dict:
-        return await self._rpc.get_webxdc_info(self.account.id, self.id)
+    def get_webxdc_info(self) -> dict:
+        return self._rpc.get_webxdc_info(self.account.id, self.id)
--- a/deltachat-rpc-client/src/deltachat_rpc_client/pytestplugin.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/pytestplugin.py
@@ -1,70 +1,65 @@
-import asyncio
-import json
 import os
+import random
 from typing import AsyncGenerator, List, Optional

-import aiohttp
-import pytest_asyncio
+import pytest

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


-async 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"
-
-    # Replace default 5 minute timeout with a 1 minute timeout.
-    timeout = aiohttp.ClientTimeout(total=60)
-    async with aiohttp.ClientSession() as session, session.post(url, timeout=timeout) as response:
-        return json.loads(await response.text())
+def get_temp_credentials() -> dict:
+    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:
    def __init__(self, deltachat: DeltaChat) -> None:
        self.deltachat = deltachat

-    async def get_unconfigured_account(self) -> Account:
-        return await self.deltachat.add_account()
+    def get_unconfigured_account(self) -> Account:
+        return self.deltachat.add_account()

-    async def get_unconfigured_bot(self) -> Bot:
-        return Bot(await self.get_unconfigured_account())
+    def get_unconfigured_bot(self) -> Bot:
+        return Bot(self.get_unconfigured_account())

-    async def new_preconfigured_account(self) -> Account:
+    def new_preconfigured_account(self) -> Account:
        """Make a new account with configuration options set, but configuration not started."""
-        credentials = await get_temp_credentials()
-        account = await self.get_unconfigured_account()
-        await account.set_config("addr", credentials["email"])
-        await account.set_config("mail_pw", credentials["password"])
-        assert not await account.is_configured()
+        credentials = get_temp_credentials()
+        account = self.get_unconfigured_account()
+        account.set_config("addr", credentials["email"])
+        account.set_config("mail_pw", credentials["password"])
+        assert not account.is_configured()
        return account

-    async def new_configured_account(self) -> Account:
-        account = await self.new_preconfigured_account()
-        await account.configure()
-        assert await account.is_configured()
+    def new_configured_account(self) -> Account:
+        account = self.new_preconfigured_account()
+        account.configure()
+        assert account.is_configured()
        return account

-    async def new_configured_bot(self) -> Bot:
-        credentials = await get_temp_credentials()
-        bot = await self.get_unconfigured_bot()
-        await bot.configure(credentials["email"], credentials["password"])
+    def new_configured_bot(self) -> Bot:
+        credentials = get_temp_credentials()
+        bot = self.get_unconfigured_bot()
+        bot.configure(credentials["email"], credentials["password"])
        return bot

-    async def get_online_account(self) -> Account:
-        account = await self.new_configured_account()
-        await account.start_io()
+    def get_online_account(self) -> Account:
+        account = self.new_configured_account()
+        account.start_io()
        while True:
-            event = await account.wait_for_event()
-            print(event)
-            if event.type == EventType.IMAP_INBOX_IDLE:
+            event = account.wait_for_event()
+            if event.kind == EventType.IMAP_INBOX_IDLE:
                break
        return account

-    async def get_online_accounts(self, num: int) -> List[Account]:
-        return await asyncio.gather(*[self.get_online_account() for _ in range(num)])
+    def get_online_accounts(self, num: int) -> List[Account]:
+        return [self.get_online_account() for _ in range(num)]

-    async def send_message(
+    def send_message(
        self,
        to_account: Account,
        from_account: Optional[Account] = None,
@@ -73,16 +68,16 @@ class ACFactory:
        group: Optional[str] = None,
    ) -> Message:
        if not from_account:
-            from_account = (await self.get_online_accounts(1))[0]
-        to_contact = await from_account.create_contact(await to_account.get_config("addr"))
+            from_account = (self.get_online_accounts(1))[0]
+        to_contact = from_account.create_contact(to_account.get_config("addr"))
        if group:
-            to_chat = await from_account.create_group(group)
-            await to_chat.add_contact(to_contact)
+            to_chat = from_account.create_group(group)
+            to_chat.add_contact(to_contact)
        else:
-            to_chat = await to_contact.create_chat()
-        return await to_chat.send_message(text=text, file=file)
+            to_chat = to_contact.create_chat()
+        return to_chat.send_message(text=text, file=file)

-    async def process_message(
+    def process_message(
        self,
        to_client: Client,
        from_account: Optional[Account] = None,
@@ -90,7 +85,7 @@ class ACFactory:
        file: Optional[str] = None,
        group: Optional[str] = None,
    ) -> AttrDict:
-        await self.send_message(
+        self.send_message(
            to_account=to_client.account,
            from_account=from_account,
            text=text,
@@ -98,16 +93,16 @@ class ACFactory:
            group=group,
        )

-        return await to_client.run_until(lambda e: e.type == EventType.INCOMING_MSG)
+        return to_client.run_until(lambda e: e.kind == EventType.INCOMING_MSG)


-@pytest_asyncio.fixture
-async def rpc(tmp_path) -> AsyncGenerator:
+@pytest.fixture()
+def rpc(tmp_path) -> AsyncGenerator:
    rpc_server = Rpc(accounts_dir=str(tmp_path / "accounts"))
-    async with rpc_server:
+    with rpc_server:
        yield rpc_server


-@pytest_asyncio.fixture
-async def acfactory(rpc) -> AsyncGenerator:
-    yield ACFactory(DeltaChat(rpc))
+@pytest.fixture()
+def acfactory(rpc) -> AsyncGenerator:
+    return ACFactory(DeltaChat(rpc))
--- a/deltachat-rpc-client/src/deltachat_rpc_client/rpc.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/rpc.py
@@ -1,6 +1,10 @@
-import asyncio
 import json
+import logging
 import os
+import subprocess
+import sys
+from queue import Queue
+from threading import Event, Thread
 from typing import Any, Dict, Optional


@@ -10,7 +14,7 @@ class JsonRpcError(Exception):

 class Rpc:
    def __init__(self, accounts_dir: Optional[str] = None, **kwargs):
-        """The given arguments will be passed to asyncio.create_subprocess_exec()"""
+        """The given arguments will be passed to subprocess.Popen()"""
        if accounts_dir:
            kwargs["env"] = {
                **kwargs.get("env", os.environ),
@@ -18,95 +22,142 @@ class Rpc:
            }

        self._kwargs = kwargs
-        self.process: asyncio.subprocess.Process
+        self.process: subprocess.Popen
        self.id: int
-        self.event_queues: Dict[int, asyncio.Queue]
-        # Map from request ID to `asyncio.Future` returning the response.
-        self.request_events: Dict[int, asyncio.Future]
+        self.event_queues: Dict[int, Queue]
+        # Map from request ID to `threading.Event`.
+        self.request_events: Dict[int, Event]
+        # Map from request ID to the result.
+        self.request_results: Dict[int, Any]
+        self.request_queue: Queue[Any]
        self.closing: bool
-        self.reader_task: asyncio.Task
-        self.events_task: asyncio.Task
+        self.reader_thread: Thread
+        self.writer_thread: Thread
+        self.events_thread: Thread

-    async def start(self) -> None:
-        self.process = await asyncio.create_subprocess_exec(
-            "deltachat-rpc-server",
-            stdin=asyncio.subprocess.PIPE,
-            stdout=asyncio.subprocess.PIPE,
-            **self._kwargs,
-        )
+    def start(self) -> None:
+        if sys.version_info >= (3, 11):
+            self.process = subprocess.Popen(
+                "deltachat-rpc-server",
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                # Prevent subprocess from capturing SIGINT.
+                process_group=0,
+                **self._kwargs,
+            )
+        else:
+            self.process = subprocess.Popen(
+                "deltachat-rpc-server",
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                # `process_group` is not supported before Python 3.11.
+                preexec_fn=os.setpgrp,  # noqa: PLW1509
+                **self._kwargs,
+            )
        self.id = 0
        self.event_queues = {}
        self.request_events = {}
+        self.request_results = {}
+        self.request_queue = Queue()
        self.closing = False
-        self.reader_task = asyncio.create_task(self.reader_loop())
-        self.events_task = asyncio.create_task(self.events_loop())
+        self.reader_thread = Thread(target=self.reader_loop)
+        self.reader_thread.start()
+        self.writer_thread = Thread(target=self.writer_loop)
+        self.writer_thread.start()
+        self.events_thread = Thread(target=self.events_loop)
+        self.events_thread.start()

-    async def close(self) -> None:
+    def close(self) -> None:
        """Terminate RPC server process and wait until the reader loop finishes."""
        self.closing = True
-        await self.stop_io_for_all_accounts()
-        await self.events_task
-        self.process.terminate()
-        await self.reader_task
+        self.stop_io_for_all_accounts()
+        self.events_thread.join()
+        self.process.stdin.close()
+        self.reader_thread.join()
+        self.request_queue.put(None)
+        self.writer_thread.join()

-    async def __aenter__(self):
-        await self.start()
+    def __enter__(self):
+        self.start()
        return self

-    async def __aexit__(self, _exc_type, _exc, _tb):
-        await self.close()
+    def __exit__(self, _exc_type, _exc, _tb):
+        self.close()

-    async def reader_loop(self) -> None:
-        while True:
-            line = await self.process.stdout.readline()  # noqa
-            if not line:  # EOF
-                break
-            response = json.loads(line)
-            if "id" in response:
-                fut = self.request_events.pop(response["id"])
-                fut.set_result(response)
-            else:
-                print(response)
+    def reader_loop(self) -> None:
+        try:
+            while True:
+                line = self.process.stdout.readline()
+                if not line:  # EOF
+                    break
+                response = json.loads(line)
+                if "id" in response:
+                    response_id = response["id"]
+                    event = self.request_events.pop(response_id)
+                    self.request_results[response_id] = response
+                    event.set()
+                else:
+                    logging.warning("Got a response without ID: %s", response)
+        except Exception:
+            # Log an exception if the reader loop dies.
+            logging.exception("Exception in the reader loop")

-    async def get_queue(self, account_id: int) -> asyncio.Queue:
+    def writer_loop(self) -> None:
+        """Writer loop ensuring only a single thread writes requests."""
+        try:
+            while True:
+                request = self.request_queue.get()
+                if not request:
+                    break
+                data = (json.dumps(request) + "\n").encode()
+                self.process.stdin.write(data)
+                self.process.stdin.flush()
+
+        except Exception:
+            # Log an exception if the writer loop dies.
+            logging.exception("Exception in the writer loop")
+
+    def get_queue(self, account_id: int) -> Queue:
        if account_id not in self.event_queues:
-            self.event_queues[account_id] = asyncio.Queue()
+            self.event_queues[account_id] = Queue()
        return self.event_queues[account_id]

-    async def events_loop(self) -> None:
+    def events_loop(self) -> None:
        """Requests new events and distributes them between queues."""
-        while True:
-            if self.closing:
-                return
-            event = await self.get_next_event()
-            account_id = event["contextId"]
-            queue = await self.get_queue(account_id)
-            await queue.put(event["event"])
+        try:
+            while True:
+                if self.closing:
+                    return
+                event = self.get_next_event()
+                account_id = event["contextId"]
+                queue = self.get_queue(account_id)
+                queue.put(event["event"])
+        except Exception:
+            # Log an exception if the event loop dies.
+            logging.exception("Exception in the event loop")

-    async def wait_for_event(self, account_id: int) -> Optional[dict]:
+    def wait_for_event(self, account_id: int) -> Optional[dict]:
        """Waits for the next event from the given account and returns it."""
-        queue = await self.get_queue(account_id)
-        return await queue.get()
+        queue = self.get_queue(account_id)
+        return queue.get()

    def __getattr__(self, attr: str):
-        async def method(*args, **kwargs) -> Any:
+        def method(*args) -> Any:
            self.id += 1
            request_id = self.id

-            assert not (args and kwargs), "Mixing positional and keyword arguments"
-
            request = {
                "jsonrpc": "2.0",
                "method": attr,
-                "params": kwargs or args,
+                "params": args,
                "id": self.id,
            }
-            data = (json.dumps(request) + "\n").encode()
-            self.process.stdin.write(data)  # noqa
-            loop = asyncio.get_running_loop()
-            fut = loop.create_future()
-            self.request_events[request_id] = fut
-            response = await fut
+            event = Event()
+            self.request_events[request_id] = event
+            self.request_queue.put(request)
+            event.wait()
+
+            response = self.request_results.pop(request_id)
            if "error" in response:
                raise JsonRpcError(response["error"])
            if "result" in response:
--- a/deltachat-rpc-client/tests/test_something.py
+++ b/deltachat-rpc-client/tests/test_something.py
@@ -1,4 +1,6 @@
-import asyncio
+import concurrent.futures
+import json
+import subprocess
 from unittest.mock import MagicMock

 import pytest
@@ -6,26 +8,26 @@ from deltachat_rpc_client import EventType, events
 from deltachat_rpc_client.rpc import JsonRpcError


-@pytest.mark.asyncio()
-async def test_system_info(rpc) -> None:
-    system_info = await rpc.get_system_info()
+def test_system_info(rpc) -> None:
+    system_info = rpc.get_system_info()
    assert "arch" in system_info
    assert "deltachat_core_version" in system_info


-@pytest.mark.asyncio()
-async def test_sleep(rpc) -> None:
+def test_sleep(rpc) -> None:
    """Test that long-running task does not block short-running task from completion."""
-    sleep_5_task = asyncio.create_task(rpc.sleep(5.0))
-    sleep_3_task = asyncio.create_task(rpc.sleep(3.0))
-    done, pending = await asyncio.wait([sleep_5_task, sleep_3_task], return_when=asyncio.FIRST_COMPLETED)
-    assert sleep_3_task in done
-    assert sleep_5_task in pending
-    sleep_5_task.cancel()
+    with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
+        sleep_5_future = executor.submit(rpc.sleep, 5.0)
+        sleep_3_future = executor.submit(rpc.sleep, 3.0)
+        done, pending = concurrent.futures.wait(
+            [sleep_5_future, sleep_3_future],
+            return_when=concurrent.futures.FIRST_COMPLETED,
+        )
+        assert sleep_3_future in done
+        assert sleep_5_future in pending


-@pytest.mark.asyncio()
-async def test_email_address_validity(rpc) -> None:
+def test_email_address_validity(rpc) -> None:
    valid_addresses = [
        "email@example.com",
        "36aa165ae3406424e0c61af17700f397cad3fe8ab83d682d0bddf3338a5dd52e@yggmail@yggmail",
@@ -33,17 +35,16 @@ async def test_email_address_validity(rpc) -> None:
    invalid_addresses = ["email@", "example.com", "emai221"]

    for addr in valid_addresses:
-        assert await rpc.check_email_validity(addr)
+        assert rpc.check_email_validity(addr)
    for addr in invalid_addresses:
-        assert not await rpc.check_email_validity(addr)
+        assert not rpc.check_email_validity(addr)


-@pytest.mark.asyncio()
-async def test_acfactory(acfactory) -> None:
-    account = await acfactory.new_configured_account()
+def test_acfactory(acfactory) -> None:
+    account = acfactory.new_configured_account()
    while True:
-        event = await account.wait_for_event()
-        if event.type == EventType.CONFIGURE_PROGRESS:
+        event = account.wait_for_event()
+        if event.kind == EventType.CONFIGURE_PROGRESS:
            assert event.progress != 0  # Progress 0 indicates error.
            if event.progress == 1000:  # Success
                break
@@ -52,248 +53,241 @@ async def test_acfactory(acfactory) -> None:
    print("Successful configuration")


-@pytest.mark.asyncio()
-async def test_configure_starttls(acfactory) -> None:
-    account = await acfactory.new_preconfigured_account()
+def test_configure_starttls(acfactory) -> None:
+    account = acfactory.new_preconfigured_account()

    # Use STARTTLS
-    await account.set_config("mail_security", "2")
-    await account.set_config("send_security", "2")
-    await account.configure()
-    assert await account.is_configured()
+    account.set_config("mail_security", "2")
+    account.set_config("send_security", "2")
+    account.configure()
+    assert account.is_configured()


-@pytest.mark.asyncio()
-async def test_account(acfactory) -> None:
-    alice, bob = await acfactory.get_online_accounts(2)
+def test_account(acfactory) -> None:
+    alice, bob = acfactory.get_online_accounts(2)

-    bob_addr = await bob.get_config("addr")
-    alice_contact_bob = await alice.create_contact(bob_addr, "Bob")
-    alice_chat_bob = await alice_contact_bob.create_chat()
-    await alice_chat_bob.send_text("Hello!")
+    bob_addr = bob.get_config("addr")
+    alice_contact_bob = alice.create_contact(bob_addr, "Bob")
+    alice_chat_bob = alice_contact_bob.create_chat()
+    alice_chat_bob.send_text("Hello!")

    while True:
-        event = await bob.wait_for_event()
-        if event.type == EventType.INCOMING_MSG:
+        event = bob.wait_for_event()
+        if event.kind == EventType.INCOMING_MSG:
            chat_id = event.chat_id
            msg_id = event.msg_id
            break

    message = bob.get_message_by_id(msg_id)
-    snapshot = await message.get_snapshot()
+    snapshot = message.get_snapshot()
    assert snapshot.chat_id == chat_id
    assert snapshot.text == "Hello!"
-    await bob.mark_seen_messages([message])
+    bob.mark_seen_messages([message])

    assert alice != bob
    assert repr(alice)
-    assert (await alice.get_info()).level
-    assert await alice.get_size()
-    assert await alice.is_configured()
-    assert not await alice.get_avatar()
-    assert await alice.get_contact_by_addr(bob_addr) == alice_contact_bob
-    assert await alice.get_contacts()
-    assert await alice.get_contacts(snapshot=True)
+    assert alice.get_info().level
+    assert alice.get_size()
+    assert alice.is_configured()
+    assert not alice.get_avatar()
+    assert alice.get_contact_by_addr(bob_addr) == alice_contact_bob
+    assert alice.get_contacts()
+    assert alice.get_contacts(snapshot=True)
    assert alice.self_contact
-    assert await alice.get_chatlist()
-    assert await alice.get_chatlist(snapshot=True)
-    assert await alice.get_qr_code()
-    assert await alice.get_fresh_messages()
-    assert await alice.get_next_messages()
+    assert alice.get_chatlist()
+    assert alice.get_chatlist(snapshot=True)
+    assert alice.get_qr_code()
+    assert alice.get_fresh_messages()
+    assert alice.get_next_messages()

    # Test sending empty message.
-    assert len(await bob.wait_next_messages()) == 0
-    await alice_chat_bob.send_text("")
-    messages = await bob.wait_next_messages()
+    assert len(bob.wait_next_messages()) == 0
+    alice_chat_bob.send_text("")
+    messages = bob.wait_next_messages()
    assert len(messages) == 1
    message = messages[0]
-    snapshot = await message.get_snapshot()
+    snapshot = message.get_snapshot()
    assert snapshot.text == ""
-    await bob.mark_seen_messages([message])
+    bob.mark_seen_messages([message])

-    group = await alice.create_group("test group")
-    await group.add_contact(alice_contact_bob)
-    group_msg = await group.send_message(text="hello")
+    group = alice.create_group("test group")
+    group.add_contact(alice_contact_bob)
+    group_msg = group.send_message(text="hello")
    assert group_msg == alice.get_message_by_id(group_msg.id)
    assert group == alice.get_chat_by_id(group.id)
-    await alice.delete_messages([group_msg])
+    alice.delete_messages([group_msg])

-    await alice.set_config("selfstatus", "test")
-    assert await alice.get_config("selfstatus") == "test"
-    await alice.update_config(selfstatus="test2")
-    assert await alice.get_config("selfstatus") == "test2"
+    alice.set_config("selfstatus", "test")
+    assert alice.get_config("selfstatus") == "test"
+    alice.update_config(selfstatus="test2")
+    assert alice.get_config("selfstatus") == "test2"

-    assert not await alice.get_blocked_contacts()
-    await alice_contact_bob.block()
-    blocked_contacts = await alice.get_blocked_contacts()
+    assert not alice.get_blocked_contacts()
+    alice_contact_bob.block()
+    blocked_contacts = alice.get_blocked_contacts()
    assert blocked_contacts
    assert blocked_contacts[0].contact == alice_contact_bob

-    await bob.remove()
-    await alice.stop_io()
+    bob.remove()
+    alice.stop_io()


-@pytest.mark.asyncio()
-async def test_chat(acfactory) -> None:
-    alice, bob = await acfactory.get_online_accounts(2)
+def test_chat(acfactory) -> None:
+    alice, bob = acfactory.get_online_accounts(2)

-    bob_addr = await bob.get_config("addr")
-    alice_contact_bob = await alice.create_contact(bob_addr, "Bob")
-    alice_chat_bob = await alice_contact_bob.create_chat()
-    await alice_chat_bob.send_text("Hello!")
+    bob_addr = bob.get_config("addr")
+    alice_contact_bob = alice.create_contact(bob_addr, "Bob")
+    alice_chat_bob = alice_contact_bob.create_chat()
+    alice_chat_bob.send_text("Hello!")

    while True:
-        event = await bob.wait_for_event()
-        if event.type == EventType.INCOMING_MSG:
+        event = bob.wait_for_event()
+        if event.kind == EventType.INCOMING_MSG:
            chat_id = event.chat_id
            msg_id = event.msg_id
            break
    message = bob.get_message_by_id(msg_id)
-    snapshot = await message.get_snapshot()
+    snapshot = message.get_snapshot()
    assert snapshot.chat_id == chat_id
    assert snapshot.text == "Hello!"
    bob_chat_alice = bob.get_chat_by_id(chat_id)

    assert alice_chat_bob != bob_chat_alice
    assert repr(alice_chat_bob)
-    await alice_chat_bob.delete()
-    assert not await bob_chat_alice.can_send()
-    await bob_chat_alice.accept()
-    assert await bob_chat_alice.can_send()
-    await bob_chat_alice.block()
-    bob_chat_alice = await snapshot.sender.create_chat()
-    await bob_chat_alice.mute()
-    await bob_chat_alice.unmute()
-    await bob_chat_alice.pin()
-    await bob_chat_alice.unpin()
-    await bob_chat_alice.archive()
-    await bob_chat_alice.unarchive()
+    alice_chat_bob.delete()
+    assert not bob_chat_alice.can_send()
+    bob_chat_alice.accept()
+    assert bob_chat_alice.can_send()
+    bob_chat_alice.block()
+    bob_chat_alice = snapshot.sender.create_chat()
+    bob_chat_alice.mute()
+    bob_chat_alice.unmute()
+    bob_chat_alice.pin()
+    bob_chat_alice.unpin()
+    bob_chat_alice.archive()
+    bob_chat_alice.unarchive()
    with pytest.raises(JsonRpcError):  # can't set name for 1:1 chats
-        await bob_chat_alice.set_name("test")
-    await bob_chat_alice.set_ephemeral_timer(300)
-    await bob_chat_alice.get_encryption_info()
+        bob_chat_alice.set_name("test")
+    bob_chat_alice.set_ephemeral_timer(300)
+    bob_chat_alice.get_encryption_info()

-    group = await alice.create_group("test group")
-    await group.add_contact(alice_contact_bob)
-    await group.get_qr_code()
+    group = alice.create_group("test group")
+    group.add_contact(alice_contact_bob)
+    group.get_qr_code()

-    snapshot = await group.get_basic_snapshot()
+    snapshot = group.get_basic_snapshot()
    assert snapshot.name == "test group"
-    await group.set_name("new name")
-    snapshot = await group.get_full_snapshot()
+    group.set_name("new name")
+    snapshot = group.get_full_snapshot()
    assert snapshot.name == "new name"

-    msg = await group.send_message(text="hi")
-    assert (await msg.get_snapshot()).text == "hi"
-    await group.forward_messages([msg])
+    msg = group.send_message(text="hi")
+    assert (msg.get_snapshot()).text == "hi"
+    group.forward_messages([msg])

-    await group.set_draft(text="test draft")
-    draft = await group.get_draft()
+    group.set_draft(text="test draft")
+    draft = group.get_draft()
    assert draft.text == "test draft"
-    await group.remove_draft()
-    assert not await group.get_draft()
+    group.remove_draft()
+    assert not group.get_draft()

-    assert await group.get_messages()
-    await group.get_fresh_message_count()
-    await group.mark_noticed()
-    assert await group.get_contacts()
-    await group.remove_contact(alice_chat_bob)
-    await group.get_locations()
+    assert group.get_messages()
+    group.get_fresh_message_count()
+    group.mark_noticed()
+    assert group.get_contacts()
+    group.remove_contact(alice_chat_bob)
+    group.get_locations()


-@pytest.mark.asyncio()
-async def test_contact(acfactory) -> None:
-    alice, bob = await acfactory.get_online_accounts(2)
+def test_contact(acfactory) -> None:
+    alice, bob = acfactory.get_online_accounts(2)

-    bob_addr = await bob.get_config("addr")
-    alice_contact_bob = await alice.create_contact(bob_addr, "Bob")
+    bob_addr = bob.get_config("addr")
+    alice_contact_bob = alice.create_contact(bob_addr, "Bob")

    assert alice_contact_bob == alice.get_contact_by_id(alice_contact_bob.id)
    assert repr(alice_contact_bob)
-    await alice_contact_bob.block()
-    await alice_contact_bob.unblock()
-    await alice_contact_bob.set_name("new name")
-    await alice_contact_bob.get_encryption_info()
-    snapshot = await alice_contact_bob.get_snapshot()
+    alice_contact_bob.block()
+    alice_contact_bob.unblock()
+    alice_contact_bob.set_name("new name")
+    alice_contact_bob.get_encryption_info()
+    snapshot = alice_contact_bob.get_snapshot()
    assert snapshot.address == bob_addr
-    await alice_contact_bob.create_chat()
+    alice_contact_bob.create_chat()


-@pytest.mark.asyncio()
-async def test_message(acfactory) -> None:
-    alice, bob = await acfactory.get_online_accounts(2)
+def test_message(acfactory) -> None:
+    alice, bob = acfactory.get_online_accounts(2)

-    bob_addr = await bob.get_config("addr")
-    alice_contact_bob = await alice.create_contact(bob_addr, "Bob")
-    alice_chat_bob = await alice_contact_bob.create_chat()
-    await alice_chat_bob.send_text("Hello!")
+    bob_addr = bob.get_config("addr")
+    alice_contact_bob = alice.create_contact(bob_addr, "Bob")
+    alice_chat_bob = alice_contact_bob.create_chat()
+    alice_chat_bob.send_text("Hello!")

    while True:
-        event = await bob.wait_for_event()
-        if event.type == EventType.INCOMING_MSG:
+        event = bob.wait_for_event()
+        if event.kind == EventType.INCOMING_MSG:
            chat_id = event.chat_id
            msg_id = event.msg_id
            break

    message = bob.get_message_by_id(msg_id)
-    snapshot = await message.get_snapshot()
+    snapshot = message.get_snapshot()
    assert snapshot.chat_id == chat_id
    assert snapshot.text == "Hello!"
    assert not snapshot.is_bot
    assert repr(message)

    with pytest.raises(JsonRpcError):  # chat is not accepted
-        await snapshot.chat.send_text("hi")
-    await snapshot.chat.accept()
-    await snapshot.chat.send_text("hi")
+        snapshot.chat.send_text("hi")
+    snapshot.chat.accept()
+    snapshot.chat.send_text("hi")

-    await message.mark_seen()
-    await message.send_reaction("😎")
-    reactions = await message.get_reactions()
+    message.mark_seen()
+    message.send_reaction("😎")
+    reactions = message.get_reactions()
    assert reactions
-    snapshot = await message.get_snapshot()
+    snapshot = message.get_snapshot()
    assert reactions == snapshot.reactions


-@pytest.mark.asyncio()
-async def test_is_bot(acfactory) -> None:
+def test_is_bot(acfactory) -> None:
    """Test that we can recognize messages submitted by bots."""
-    alice, bob = await acfactory.get_online_accounts(2)
+    alice, bob = acfactory.get_online_accounts(2)

-    bob_addr = await bob.get_config("addr")
-    alice_contact_bob = await alice.create_contact(bob_addr, "Bob")
-    alice_chat_bob = await alice_contact_bob.create_chat()
+    bob_addr = bob.get_config("addr")
+    alice_contact_bob = alice.create_contact(bob_addr, "Bob")
+    alice_chat_bob = alice_contact_bob.create_chat()

    # Alice becomes a bot.
-    await alice.set_config("bot", "1")
-    await alice_chat_bob.send_text("Hello!")
+    alice.set_config("bot", "1")
+    alice_chat_bob.send_text("Hello!")

    while True:
-        event = await bob.wait_for_event()
-        if event.type == EventType.INCOMING_MSG:
+        event = bob.wait_for_event()
+        if event.kind == EventType.INCOMING_MSG:
            msg_id = event.msg_id
            message = bob.get_message_by_id(msg_id)
-            snapshot = await message.get_snapshot()
+            snapshot = message.get_snapshot()
            assert snapshot.chat_id == event.chat_id
            assert snapshot.text == "Hello!"
            assert snapshot.is_bot
            break


-@pytest.mark.asyncio()
-async def test_bot(acfactory) -> None:
+def test_bot(acfactory) -> None:
    mock = MagicMock()
-    user = (await acfactory.get_online_accounts(1))[0]
-    bot = await acfactory.new_configured_bot()
-    bot2 = await acfactory.new_configured_bot()
+    user = (acfactory.get_online_accounts(1))[0]
+    bot = acfactory.new_configured_bot()
+    bot2 = acfactory.new_configured_bot()

-    assert await bot.is_configured()
-    assert await bot.account.get_config("bot") == "1"
+    assert bot.is_configured()
+    assert bot.account.get_config("bot") == "1"

    hook = lambda e: mock.hook(e.msg_id) and None, events.RawEvent(EventType.INCOMING_MSG)
    bot.add_hook(*hook)
-    event = await acfactory.process_message(from_account=user, to_client=bot, text="Hello!")
-    snapshot = await bot.account.get_message_by_id(event.msg_id).get_snapshot()
+    event = acfactory.process_message(from_account=user, to_client=bot, text="Hello!")
+    snapshot = bot.account.get_message_by_id(event.msg_id).get_snapshot()
    assert not snapshot.is_bot
    mock.hook.assert_called_once_with(event.msg_id)
    bot.remove_hook(*hook)
@@ -305,53 +299,93 @@ async def test_bot(acfactory) -> None:
    hook = track, events.NewMessage(r"hello")
    bot.add_hook(*hook)
    bot.add_hook(track, events.NewMessage(command="/help"))
-    event = await acfactory.process_message(from_account=user, to_client=bot, text="hello")
+    event = acfactory.process_message(from_account=user, to_client=bot, text="hello")
    mock.hook.assert_called_with(event.msg_id)
-    event = await acfactory.process_message(from_account=user, to_client=bot, text="hello!")
+    event = acfactory.process_message(from_account=user, to_client=bot, text="hello!")
    mock.hook.assert_called_with(event.msg_id)
-    await acfactory.process_message(from_account=bot2.account, to_client=bot, text="hello")
+    acfactory.process_message(from_account=bot2.account, to_client=bot, text="hello")
    assert len(mock.hook.mock_calls) == 2  # bot messages are ignored between bots
-    await acfactory.process_message(from_account=user, to_client=bot, text="hey!")
+    acfactory.process_message(from_account=user, to_client=bot, text="hey!")
    assert len(mock.hook.mock_calls) == 2
    bot.remove_hook(*hook)

    mock.hook.reset_mock()
-    await acfactory.process_message(from_account=user, to_client=bot, text="hello")
-    event = await acfactory.process_message(from_account=user, to_client=bot, text="/help")
+    acfactory.process_message(from_account=user, to_client=bot, text="hello")
+    event = acfactory.process_message(from_account=user, to_client=bot, text="/help")
    mock.hook.assert_called_once_with(event.msg_id)


-@pytest.mark.asyncio()
-async def test_wait_next_messages(acfactory) -> None:
-    alice = await acfactory.new_configured_account()
+def test_wait_next_messages(acfactory) -> None:
+    alice = acfactory.new_configured_account()

    # Create a bot account so it does not receive device messages in the beginning.
-    bot = await acfactory.new_preconfigured_account()
-    await bot.set_config("bot", "1")
-    await bot.configure()
+    bot = acfactory.new_preconfigured_account()
+    bot.set_config("bot", "1")
+    bot.configure()

    # There are no old messages and the call returns immediately.
-    assert not await bot.wait_next_messages()
+    assert not bot.wait_next_messages()

-    # Bot starts waiting for messages.
-    next_messages_task = asyncio.create_task(bot.wait_next_messages())
+    with concurrent.futures.ThreadPoolExecutor(max_workers=1) as executor:
+        # Bot starts waiting for messages.
+        next_messages_task = executor.submit(bot.wait_next_messages)

-    bot_addr = await bot.get_config("addr")
-    alice_contact_bot = await alice.create_contact(bot_addr, "Bob")
-    alice_chat_bot = await alice_contact_bot.create_chat()
-    await alice_chat_bot.send_text("Hello!")
+        bot_addr = bot.get_config("addr")
+        alice_contact_bot = alice.create_contact(bot_addr, "Bob")
+        alice_chat_bot = alice_contact_bot.create_chat()
+        alice_chat_bot.send_text("Hello!")

-    next_messages = await next_messages_task
-    assert len(next_messages) == 1
-    snapshot = await next_messages[0].get_snapshot()
-    assert snapshot.text == "Hello!"
+        next_messages = next_messages_task.result()
+        assert len(next_messages) == 1
+        snapshot = next_messages[0].get_snapshot()
+        assert snapshot.text == "Hello!"


-@pytest.mark.asyncio()
-async def test_import_export(acfactory, tmp_path) -> None:
-    alice = await acfactory.new_configured_account()
-    await alice.export_backup(tmp_path)
+def test_import_export(acfactory, tmp_path) -> None:
+    alice = acfactory.new_configured_account()
+    alice.export_backup(tmp_path)

    files = list(tmp_path.glob("*.tar"))
-    alice2 = await acfactory.get_unconfigured_account()
-    await alice2.import_backup(files[0])
+    alice2 = acfactory.get_unconfigured_account()
+    alice2.import_backup(files[0])
+
+    assert alice2.manager.get_system_info()
+
+
+def test_openrpc_command_line() -> None:
+    """Test that "deltachat-rpc-server --openrpc" command returns an OpenRPC specification."""
+    out = subprocess.run(["deltachat-rpc-server", "--openrpc"], capture_output=True, check=True).stdout
+    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
+
+
+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:
+            return
--- a/deltachat-rpc-client/tests/test_webxdc.py
+++ b/deltachat-rpc-client/tests/test_webxdc.py
@@ -1,24 +1,22 @@
-import pytest
 from deltachat_rpc_client import EventType


-@pytest.mark.asyncio()
-async def test_webxdc(acfactory) -> None:
-    alice, bob = await acfactory.get_online_accounts(2)
+def test_webxdc(acfactory) -> None:
+    alice, bob = acfactory.get_online_accounts(2)

-    bob_addr = await bob.get_config("addr")
-    alice_contact_bob = await alice.create_contact(bob_addr, "Bob")
-    alice_chat_bob = await alice_contact_bob.create_chat()
-    await alice_chat_bob.send_message(text="Let's play chess!", file="../test-data/webxdc/chess.xdc")
+    bob_addr = bob.get_config("addr")
+    alice_contact_bob = alice.create_contact(bob_addr, "Bob")
+    alice_chat_bob = alice_contact_bob.create_chat()
+    alice_chat_bob.send_message(text="Let's play chess!", file="../test-data/webxdc/chess.xdc")

    while True:
-        event = await bob.wait_for_event()
-        if event.type == EventType.INCOMING_MSG:
+        event = bob.wait_for_event()
+        if event.kind == EventType.INCOMING_MSG:
            bob_chat_alice = bob.get_chat_by_id(event.chat_id)
            message = bob.get_message_by_id(event.msg_id)
            break

-    webxdc_info = await message.get_webxdc_info()
+    webxdc_info = message.get_webxdc_info()
    assert webxdc_info == {
        "document": None,
        "icon": "icon.png",
@@ -28,20 +26,20 @@ async def test_webxdc(acfactory) -> None:
        "summary": None,
    }

-    status_updates = await message.get_webxdc_status_updates()
+    status_updates = message.get_webxdc_status_updates()
    assert status_updates == []

-    await bob_chat_alice.accept()
-    await message.send_webxdc_status_update({"payload": 42}, "")
-    await message.send_webxdc_status_update({"payload": "Second update"}, "description")
+    bob_chat_alice.accept()
+    message.send_webxdc_status_update({"payload": 42}, "")
+    message.send_webxdc_status_update({"payload": "Second update"}, "description")

-    status_updates = await message.get_webxdc_status_updates()
+    status_updates = message.get_webxdc_status_updates()
    assert status_updates == [
        {"payload": 42, "serial": 1, "max_serial": 2},
        {"payload": "Second update", "serial": 2, "max_serial": 2},
    ]

-    status_updates = await message.get_webxdc_status_updates(1)
+    status_updates = message.get_webxdc_status_updates(1)
    assert status_updates == [
        {"payload": "Second update", "serial": 2, "max_serial": 2},
    ]
--- a/deltachat-rpc-client/tox.ini
+++ b/deltachat-rpc-client/tox.ini
@@ -6,18 +6,16 @@ envlist =

 [testenv]
 commands =
-    pytest {posargs}
+    pytest -n6 {posargs}
 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-asyncio
    pytest-timeout
-    aiohttp
-    aiodns
+    pytest-xdist

 [testenv:lint]
 skipsdist = True
@@ -30,4 +28,6 @@ commands =
    ruff src/ examples/ tests/

 [pytest]
-timeout = 60
+timeout = 300
+log_cli = true
+log_level = info
--- a/deltachat-rpc-server/Cargo.toml
+++ b/deltachat-rpc-server/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "deltachat-rpc-server"
-version = "1.119.0"
+version = "1.127.2"
 description = "DeltaChat JSON-RPC server"
 edition = "2021"
 readme = "README.md"
@@ -15,13 +15,13 @@ 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.99"
+serde_json = "1.0.105"
 serde = { version = "1.0", features = ["derive"] }
-tokio = { version = "1.29.1", features = ["io-std"] }
-tokio-util = "0.7.8"
-yerpc = { version = "0.5.1", features = ["anyhow_expose"] }
+tokio = { version = "1.33.0", features = ["io-std"] }
+tokio-util = "0.7.9"
+yerpc = { version = "0.5.2", features = ["anyhow_expose", "openrpc"] }

 [features]
 default = ["vendored"]
--- a/deltachat-rpc-server/README.md
+++ b/deltachat-rpc-server/README.md
@@ -32,3 +32,6 @@ languages other than Rust, for example:

 1. Python: https://github.com/deltachat/deltachat-core-rust/tree/master/deltachat-rpc-client/
 2. Go: https://github.com/deltachat/deltachat-rpc-client-go/
+
+Run `deltachat-rpc-server --version` to check the version of the server.
+Run `deltachat-rpc-server --openrpc` to get [OpenRPC](https://open-rpc.org/) specification of the provided JSON-RPC API.
--- a/deltachat-rpc-server/src/main.rs
+++ b/deltachat-rpc-server/src/main.rs
@@ -10,6 +10,7 @@ use deltachat::constants::DC_VERSION_STR;
 use deltachat_jsonrpc::api::{Accounts, CommandApi};
 use futures_lite::stream::StreamExt;
 use tokio::io::{self, AsyncBufReadExt, BufReader};
+use yerpc::RpcServer as _;

 #[cfg(target_family = "unix")]
 use tokio::signal::unix as signal_unix;
@@ -39,6 +40,12 @@ async fn main_impl() -> Result<()> {
            }
            eprintln!("{}", &*DC_VERSION_STR);
            return Ok(());
+        } else if first_arg.to_str() == Some("--openrpc") {
+            if let Some(arg) = args.next() {
+                return Err(anyhow!("Unrecognized argument {:?}", arg));
+            }
+            println!("{}", CommandApi::openrpc_specification()?);
+            return Ok(());
        } else {
            return Err(anyhow!("Unrecognized option {:?}", first_arg));
        }
@@ -56,7 +63,8 @@ async fn main_impl() -> Result<()> {

    let path = std::env::var("DC_ACCOUNTS_PATH").unwrap_or_else(|_| "accounts".to_string());
    log::info!("Starting with accounts directory `{}`.", path);
-    let accounts = Accounts::new(PathBuf::from(&path)).await?;
+    let writable = true;
+    let accounts = Accounts::new(PathBuf::from(&path), writable).await?;

    log::info!("Creating JSON-RPC API.");
    let accounts = Arc::new(RwLock::new(accounts));
--- a/deny.toml
+++ b/deny.toml
@@ -2,6 +2,7 @@
 unmaintained = "allow"
 ignore = [
    "RUSTSEC-2020-0071",
+    "RUSTSEC-2022-0093",
 ]

 [bans]
@@ -10,7 +11,7 @@ ignore = [
 # when upgrading.
 # Please keep this list alphabetically sorted.
 skip = [
-     { name = "ahash", version = "0.7.6" },
+     { 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,12 +25,10 @@ skip = [
     { name = "digest", version = "<0.10" },
     { name = "ed25519-dalek", version = "1.0.1" },
     { name = "ed25519", version = "1.5.3" },
+     { name = "event-listener", version = "2.5.3" },
     { name = "getrandom", version = "<0.2" },
     { name = "hashbrown", version = "<0.14.0" },
-     { name = "idna", version = "<0.3" },
     { name = "indexmap", version = "<2.0.0" },
-     { name = "linux-raw-sys", version = "0.3.8" },
-     { name = "num-derive", version = "0.3.3" },
     { name = "pem-rfc7468", version = "0.6.0" },
     { name = "pkcs8", version = "0.9.0" },
     { name = "quick-error", version = "<2.0" },
@@ -37,8 +36,9 @@ skip = [
     { name = "rand_core", version = "<0.6" },
     { name = "rand", version = "<0.8" },
     { name = "redox_syscall", version = "0.2.16" },
+     { name = "regex-automata", version = "0.1.10" },
+     { name = "ring", version = "0.16.20" },
     { name = "regex-syntax", version = "0.6.29" },
-     { name = "rustix", version = "0.37.21" },
     { name = "sec1", version = "0.3.0" },
     { name = "sha2", version = "<0.10" },
     { name = "signature", version = "1.6.4" },
@@ -47,18 +47,14 @@ 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_x86_64_gnullvm", version = "<0.48" },
     { name = "windows", version = "0.32.0" },
     { name = "windows_x86_64_gnu", version = "<0.48" },
     { name = "windows_x86_64_msvc", version = "<0.48" },
-     { name = "winreg", version = "0.10.1" },
 ]


@@ -90,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/examples/simple.rs
+++ b/examples/simple.rs
@@ -1,100 +0,0 @@
-use deltachat::chat::{self, ChatId};
-use deltachat::chatlist::*;
-use deltachat::config;
-use deltachat::contact::*;
-use deltachat::context::*;
-use deltachat::message::Message;
-use deltachat::stock_str::StockStrings;
-use deltachat::{EventType, Events};
-use tempfile::tempdir;
-
-fn cb(event: EventType) {
-    match event {
-        EventType::ConfigureProgress { progress, .. } => {
-            log::info!("progress: {}", progress);
-        }
-        EventType::Info(msg) => {
-            log::info!("{}", msg);
-        }
-        EventType::Warning(msg) => {
-            log::warn!("{}", msg);
-        }
-        EventType::Error(msg) => {
-            log::error!("{}", msg);
-        }
-        event => {
-            log::info!("{:?}", event);
-        }
-    }
-}
-
-/// Run with `RUST_LOG=simple=info cargo run --release --example simple -- email pw`.
-#[tokio::main]
-async fn main() {
-    pretty_env_logger::try_init_timed().ok();
-
-    let dir = tempdir().unwrap();
-    let dbfile = dir.path().join("db.sqlite");
-    log::info!("creating database {:?}", dbfile);
-    let ctx = Context::new(&dbfile, 0, Events::new(), StockStrings::new())
-        .await
-        .expect("Failed to create context");
-    let info = ctx.get_info().await;
-    log::info!("info: {:#?}", info);
-
-    let events = ctx.get_event_emitter();
-    let events_spawn = tokio::task::spawn(async move {
-        while let Some(event) = events.recv().await {
-            cb(event.typ);
-        }
-    });
-
-    log::info!("configuring");
-    let args = std::env::args().collect::<Vec<String>>();
-    assert_eq!(args.len(), 3, "requires email password");
-    let email = args[1].clone();
-    let pw = args[2].clone();
-    ctx.set_config(config::Config::Addr, Some(&email))
-        .await
-        .unwrap();
-    ctx.set_config(config::Config::MailPw, Some(&pw))
-        .await
-        .unwrap();
-
-    ctx.configure().await.unwrap();
-
-    log::info!("------ RUN ------");
-    ctx.start_io().await;
-    log::info!("--- SENDING A MESSAGE ---");
-
-    let contact_id = Contact::create(&ctx, "dignifiedquire", "dignifiedquire@gmail.com")
-        .await
-        .unwrap();
-    let chat_id = ChatId::create_for_contact(&ctx, contact_id).await.unwrap();
-
-    for i in 0..1 {
-        log::info!("sending message {}", i);
-        chat::send_text_msg(&ctx, chat_id, format!("Hi, here is my {i}nth message!"))
-            .await
-            .unwrap();
-    }
-
-    // wait for the message to be sent out
-    tokio::time::sleep(std::time::Duration::from_secs(1)).await;
-
-    log::info!("fetching chats..");
-    let chats = Chatlist::try_load(&ctx, 0, None, None).await.unwrap();
-
-    for i in 0..chats.len() {
-        let msg = Message::load_from_db(&ctx, chats.get_msg_id(i).unwrap().unwrap())
-            .await
-            .unwrap();
-        log::info!("[{}] msg: {:?}", i, msg);
-    }
-
-    log::info!("stopping");
-    ctx.stop_io().await;
-    log::info!("closing");
-    drop(ctx);
-    events_spawn.await.unwrap();
-}
--- a/fuzz/Cargo.lock
+++ b/fuzz/Cargo.lock
@@ -177,13 +177,13 @@ dependencies = [

 [[package]]
 name = "async-imap"
-version = "0.9.0"
+version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da93622739d458dd9a6abc1abf0e38e81965a5824a3b37f9500437c82a8bb572"
+checksum = "b538b767cbf9c162a6c5795d4b932bd2c20ba10b5a91a94d2b2b6886c1dce6a8"
 dependencies = [
 "async-channel",
 "base64 0.21.0",
- "byte-pool",
+ "bytes",
 "chrono",
 "futures",
 "imap-proto",
@@ -337,9 +337,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"

 [[package]]
 name = "bitflags"
-version = "2.0.2"
+version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "487f1e0fcbe47deb8b0574e646def1c903389d95241dd1bbcc6ce4a715dfc0c1"
+checksum = "b4682ae6287fcf752ecaabbfcc7b6f9b72aa33933dc23a554d853aea8eea8635"

 [[package]]
 name = "blake3"
@@ -529,16 +529,6 @@ version = "3.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "572f695136211188308f16ad2ca5c851a712c464060ae6974944458eb83880ba"

-[[package]]
-name = "byte-pool"
-version = "0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c2f1b21189f50b5625efa6227cf45e9d4cfdc2e73582df2b879e9689e78a7158"
-dependencies = [
- "crossbeam-queue",
- "stable_deref_trait",
-]
-
 [[package]]
 name = "bytemuck"
 version = "1.12.3"
@@ -741,16 +731,6 @@ dependencies = [
 "cfg-if",
 ]

-[[package]]
-name = "crossbeam-queue"
-version = "0.3.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d1cfb3ea8a53f37c40dea2c7bedcbd88bdfae54f5e2175d6ecaff1c988353add"
-dependencies = [
- "cfg-if",
- "crossbeam-utils",
-]
-
 [[package]]
 name = "crossbeam-utils"
 version = "0.8.14"
@@ -926,7 +906,7 @@ dependencies = [

 [[package]]
 name = "deltachat"
-version = "1.117.0"
+version = "1.123.0"
 dependencies = [
 "anyhow",
 "async-channel",
@@ -943,6 +923,7 @@ dependencies = [
 "encoded-words",
 "escaper",
 "fast-socks5",
+ "fd-lock",
 "format-flowed",
 "futures",
 "futures-lite",
@@ -955,7 +936,7 @@ dependencies = [
 "libc",
 "mailparse 0.14.0",
 "mime",
- "num-derive",
+ "num-derive 0.4.0",
 "num-traits",
 "num_cpus",
 "once_cell",
@@ -1429,14 +1410,14 @@ checksum = "b5320ae4c3782150d900b79807611a59a99fc9a1d61d686faafc24b93fc8d7ca"

 [[package]]
 name = "enum-as-inner"
-version = "0.5.1"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c9720bba047d567ffc8a3cba48bf19126600e249ab7f128e9233e6376976a116"
+checksum = "5ffccbb6966c05b32ef8fbac435df276c4ae4d3dc55a8cd0eb9745e6c12f546a"
 dependencies = [
 "heck",
 "proc-macro2",
 "quote",
- "syn 1.0.107",
+ "syn 2.0.15",
 ]

 [[package]]
@@ -1464,6 +1445,17 @@ dependencies = [
 "winapi",
 ]

+[[package]]
+name = "errno"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "136526188508e25c6fef639d7927dfb3e0e3084488bf202267829cf7fc23dbdd"
+dependencies = [
+ "errno-dragonfly",
+ "libc",
+ "windows-sys 0.48.0",
+]
+
 [[package]]
 name = "errno-dragonfly"
 version = "0.1.2"
@@ -1532,6 +1524,17 @@ dependencies = [
 "instant",
 ]

+[[package]]
+name = "fd-lock"
+version = "3.0.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef033ed5e9bad94e55838ca0ca906db0e043f517adda0c8b79c7a8c66c93c1b5"
+dependencies = [
+ "cfg-if",
+ "rustix 0.38.14",
+ "windows-sys 0.48.0",
+]
+
 [[package]]
 name = "ff"
 version = "0.12.1"
@@ -1616,9 +1619,9 @@ checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"

 [[package]]
 name = "form_urlencoded"
-version = "1.1.0"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a9c384f161156f5260c24a097c56119f9be8c798586aecc13afbcbe7b7e26bf8"
+checksum = "a62bc1cf6f830c2ec14a513a9fb124d0a213a629668a4186f329db21fe045652"
 dependencies = [
 "percent-encoding",
 ]
@@ -1843,18 +1846,15 @@ dependencies = [

 [[package]]
 name = "heck"
-version = "0.4.0"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2540771e65fc8cb83cd6e8a237f70c319bd5c29f78ed1084ba5d50eeac86f7f9"
+checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"

 [[package]]
 name = "hermit-abi"
-version = "0.2.6"
+version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee512640fe35acbfb4bb779db6f0d80704c2cacfa2e39b601ef3e3f47d1ae4c7"
-dependencies = [
- "libc",
-]
+checksum = "d77f7ec81a6d05a3abb01ab6eb7590f6083d08449fe5a1c8b1e620283546ccb7"

 [[package]]
 name = "hex"
@@ -1951,7 +1951,7 @@ dependencies = [
 "httpdate",
 "itoa",
 "pin-project-lite",
- "socket2",
+ "socket2 0.4.7",
 "tokio",
 "tower-service",
 "tracing",
@@ -2012,20 +2012,9 @@ checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"

 [[package]]
 name = "idna"
-version = "0.2.3"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "418a0a6fab821475f634efe3ccc45c013f742efe03d853e8d3355d5cb850ecf8"
-dependencies = [
- "matches",
- "unicode-bidi",
- "unicode-normalization",
-]
-
-[[package]]
-name = "idna"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e14ddfc70884202db2244c223200c204c2bda1bc6e0998d11b5e024d657209e6"
+checksum = "7d20d6b07bfbc108882d88ed8e37d39636dcc260e15e30c45e6ba089610b917c"
 dependencies = [
 "unicode-bidi",
 "unicode-normalization",
@@ -2033,9 +2022,9 @@ dependencies = [

 [[package]]
 name = "image"
-version = "0.24.6"
+version = "0.24.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "527909aa81e20ac3a44803521443a765550f09b5130c2c2fa1ea59c2f8f50a3a"
+checksum = "6f3dfdbdd72063086ff443e297b61695500514b1e41095b6fb9a5ab48a70a711"
 dependencies = [
 "bytemuck",
 "byteorder",
@@ -2100,10 +2089,10 @@ version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bd302af1b90f2463a98fa5ad469fc212c8e3175a41c3068601bfa2727591c5be"
 dependencies = [
- "socket2",
+ "socket2 0.4.7",
 "widestring",
 "winapi",
- "winreg",
+ "winreg 0.10.1",
 ]

 [[package]]
@@ -2230,9 +2219,9 @@ dependencies = [

 [[package]]
 name = "libc"
-version = "0.2.139"
+version = "0.2.148"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "201de327520df007757c1f0adce6e827fe8562fbc28bfd9c15571c66ca1f5f79"
+checksum = "9cdc71e17332e86d2e1d38c1f99edcb6288ee11b815fb1a4b049eaa2114d369b"

 [[package]]
 name = "libm"
@@ -2279,6 +2268,12 @@ version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f051f77a7c8e6957c0696eac88f26b0117e54f52d3fc682ab19397a8812846a4"

+[[package]]
+name = "linux-raw-sys"
+version = "0.4.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a9bad9f94746442c783ca431b22403b519cd7fbeed0533fdd6328b2f2212128"
+
 [[package]]
 name = "lock_api"
 version = "0.4.9"
@@ -2341,15 +2336,9 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8263075bb86c5a1b1427b5ae862e8889656f126e9f77c484496e8b47cf5c5558"
 dependencies = [
- "regex-automata",
+ "regex-automata 0.1.10",
 ]

-[[package]]
-name = "matches"
-version = "0.1.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a3e378b66a060d48947b590737b30a1be76706c8dd7b8ba0f2fe3989c68a853f"
-
 [[package]]
 name = "md-5"
 version = "0.10.5"
@@ -2367,9 +2356,9 @@ checksum = "df39d232f5c40b0891c10216992c2f250c054105cb1e56f0fc9032db6203ecc1"

 [[package]]
 name = "memchr"
-version = "2.5.0"
+version = "2.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
+checksum = "8f232d6ef707e1956a43342693d2a31e72989554d58299d7a88738cc95b0d35c"

 [[package]]
 name = "mime"
@@ -2394,14 +2383,13 @@ dependencies = [

 [[package]]
 name = "mio"
-version = "0.8.5"
+version = "0.8.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5d732bc30207a6423068df043e3d02e0735b155ad7ce1a6f76fe2baa5b158de"
+checksum = "927a765cd3fc26206e66b296465fa9d3e5ab003e651c1b3c060e7956d96b19d2"
 dependencies = [
 "libc",
- "log",
 "wasi 0.11.0+wasi-snapshot-preview1",
- "windows-sys 0.42.0",
+ "windows-sys 0.48.0",
 ]

 [[package]]
@@ -2555,6 +2543,17 @@ dependencies = [
 "syn 1.0.107",
 ]

+[[package]]
+name = "num-derive"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e6a0fd4f737c707bd9086cc16c925f294943eb62eb71499e9fd4cf71f8b9f4e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.15",
+]
+
 [[package]]
 name = "num-integer"
 version = "0.1.45"
@@ -2599,9 +2598,9 @@ dependencies = [

 [[package]]
 name = "num_cpus"
-version = "1.15.0"
+version = "1.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fac9e2da13b5eb447a6ce3d392f23a29d8694bff781bf03a16cd9ac8697593b"
+checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43"
 dependencies = [
 "hermit-abi",
 "libc",
@@ -2854,7 +2853,7 @@ dependencies = [
 "md-5",
 "nom",
 "num-bigint-dig",
- "num-derive",
+ "num-derive 0.3.3",
 "num-traits",
 "p256 0.13.1",
 "p384 0.13.0",
@@ -2894,9 +2893,9 @@ dependencies = [

 [[package]]
 name = "pin-project-lite"
-version = "0.2.9"
+version = "0.2.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0a7ae3ac2f1173085d398531c705756c94a4c56843785df85a60c1a0afac116"
+checksum = "8afb450f006bf6385ca15ef45d71d2288452bc3683ce2e2cacc0d18e4be60b58"

 [[package]]
 name = "pin-utils"
@@ -3087,9 +3086,9 @@ checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0"

 [[package]]
 name = "quick-xml"
-version = "0.28.2"
+version = "0.30.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ce5e73202a820a31f8a0ee32ada5e21029c81fd9e3ebf668a40832e4219d9d1"
+checksum = "eff6510e86862b57b210fd8cbe8ed3f0d7d600b9c2863cd4549a2e033c66e956"
 dependencies = [
 "memchr",
 ]
@@ -3114,9 +3113,9 @@ dependencies = [

 [[package]]
 name = "quinn-proto"
-version = "0.9.2"
+version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72ef4ced82a24bb281af338b9e8f94429b6eca01b4e66d899f40031f074e74c9"
+checksum = "c956be1b23f4261676aed05a0046e204e8a6836e50203902683a718af0797989"
 dependencies = [
 "bytes",
 "rand 0.8.5",
@@ -3139,7 +3138,7 @@ checksum = "641538578b21f5e5c8ea733b736895576d0fe329bb883b937db6f4d163dbaaf4"
 dependencies = [
 "libc",
 "quinn-proto",
- "socket2",
+ "socket2 0.4.7",
 "tracing",
 "windows-sys 0.42.0",
 ]
@@ -3268,13 +3267,14 @@ dependencies = [

 [[package]]
 name = "regex"
-version = "1.8.4"
+version = "1.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d0ab3ca65655bb1e41f2a8c8cd662eb4fb035e67c3f78da1d61dffe89d07300f"
+checksum = "697061221ea1b4a94a624f67d0ae2bfe4e22b8a17b6a192afb11046542cc8c47"
 dependencies = [
 "aho-corasick",
 "memchr",
- "regex-syntax 0.7.2",
+ "regex-automata 0.3.8",
+ "regex-syntax 0.7.5",
 ]

 [[package]]
@@ -3286,6 +3286,17 @@ dependencies = [
 "regex-syntax 0.6.28",
 ]

+[[package]]
+name = "regex-automata"
+version = "0.3.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2f401f4955220693b56f8ec66ee9c78abffd8d1c4f23dc41a23839eb88f0795"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax 0.7.5",
+]
+
 [[package]]
 name = "regex-syntax"
 version = "0.6.28"
@@ -3294,15 +3305,15 @@ checksum = "456c603be3e8d448b072f410900c09faf164fbce2d480456f50eea6e25f9c848"

 [[package]]
 name = "regex-syntax"
-version = "0.7.2"
+version = "0.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "436b050e76ed2903236f032a59761c1eb99e1b0aead2c257922771dab1fc8c78"
+checksum = "dbb5fb1acd8a1a18b3dd5be62d25485eb770e05afb408a9627d14d451bae12da"

 [[package]]
 name = "reqwest"
-version = "0.11.18"
+version = "0.11.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cde824a14b7c14f85caff81225f411faacc04a2013f41670f41443742b1c1c55"
+checksum = "3e9ad3fe7488d7e34558a2033d45a0c90b72d97b4f80705666fea71472e2e6a1"
 dependencies = [
 "base64 0.21.0",
 "bytes",
@@ -3332,7 +3343,7 @@ dependencies = [
 "wasm-bindgen",
 "wasm-bindgen-futures",
 "web-sys",
- "winreg",
+ "winreg 0.50.0",
 ]

 [[package]]
@@ -3438,7 +3449,7 @@ version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "549b9d036d571d42e6e85d1c1425e2ac83491075078ca9a15be021c56b1641f2"
 dependencies = [
- "bitflags 2.0.2",
+ "bitflags 2.4.0",
 "fallible-iterator",
 "fallible-streaming-iterator",
 "hashlink",
@@ -3489,13 +3500,26 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d4fdebc4b395b7fbb9ab11e462e20ed9051e7b16e42d24042c776eca0ac81b03"
 dependencies = [
 "bitflags 1.3.2",
- "errno",
+ "errno 0.2.8",
 "io-lifetimes",
 "libc",
- "linux-raw-sys",
+ "linux-raw-sys 0.1.4",
 "windows-sys 0.42.0",
 ]

+[[package]]
+name = "rustix"
+version = "0.38.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "747c788e9ce8e92b12cd485c49ddf90723550b654b32508f979b71a7b1ecda4f"
+dependencies = [
+ "bitflags 2.4.0",
+ "errno 0.3.3",
+ "libc",
+ "linux-raw-sys 0.4.7",
+ "windows-sys 0.48.0",
+]
+
 [[package]]
 name = "rustls"
 version = "0.20.8"
@@ -3557,9 +3581,9 @@ dependencies = [

 [[package]]
 name = "sanitize-filename"
-version = "0.4.0"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08c502bdb638f1396509467cb0580ef3b29aa2a45c5d43e5d84928241280296c"
+checksum = "2ed72fbaf78e6f2d41744923916966c4fbe3d7c74e3037a8ee482f1115572603"
 dependencies = [
 "lazy_static",
 "regex",
@@ -3855,6 +3879,16 @@ dependencies = [
 "winapi",
 ]

+[[package]]
+name = "socket2"
+version = "0.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4031e820eb552adee9295814c0ced9e5cf38ddf1e8b7d566d6de8e2538ea989e"
+dependencies = [
+ "libc",
+ "windows-sys 0.48.0",
+]
+
 [[package]]
 name = "spin"
 version = "0.5.2"
@@ -3919,12 +3953,6 @@ dependencies = [
 "zeroize",
 ]

-[[package]]
-name = "stable_deref_trait"
-version = "1.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
-
 [[package]]
 name = "stop-token"
 version = "0.7.0"
@@ -3945,21 +3973,21 @@ checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"

 [[package]]
 name = "strum"
-version = "0.24.1"
+version = "0.25.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "063e6045c0e62079840579a7e47a355ae92f60eb74daaf156fb1e84ba164e63f"
+checksum = "290d54ea6f91c969195bdbcd7442c8c2a2ba87da8bf60a7ee86a235d4bc1e125"

 [[package]]
 name = "strum_macros"
-version = "0.24.3"
+version = "0.25.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e385be0d24f186b4ce2f9982191e7101bb737312ad61c1f2f984f34bcf85d59"
+checksum = "ad8d03b598d3d0fff69bf533ee3ef19b8eeb342729596df84bcc7e1f96ec4059"
 dependencies = [
 "heck",
 "proc-macro2",
 "quote",
 "rustversion",
- "syn 1.0.107",
+ "syn 2.0.15",
 ]

 [[package]]
@@ -4038,7 +4066,7 @@ dependencies = [
 "cfg-if",
 "fastrand",
 "redox_syscall",
- "rustix",
+ "rustix 0.36.7",
 "windows-sys 0.42.0",
 ]

@@ -4147,22 +4175,21 @@ checksum = "cda74da7e1a664f795bb1f8a87ec406fb89a02522cf6e50620d016add6dbbf5c"

 [[package]]
 name = "tokio"
-version = "1.25.0"
+version = "1.32.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c8e00990ebabbe4c14c08aca901caed183ecd5c09562a12c824bb53d3c3fd3af"
+checksum = "17ed6077ed6cd6c74735e21f37eb16dc3935f96878b1fe961074089cc80893f9"
 dependencies = [
- "autocfg",
+ "backtrace",
 "bytes",
 "libc",
- "memchr",
 "mio",
 "num_cpus",
 "parking_lot",
 "pin-project-lite",
 "signal-hook-registry",
- "socket2",
+ "socket2 0.5.4",
 "tokio-macros",
- "windows-sys 0.42.0",
+ "windows-sys 0.48.0",
 ]

 [[package]]
@@ -4177,13 +4204,13 @@ dependencies = [

 [[package]]
 name = "tokio-macros"
-version = "1.8.2"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d266c00fde287f55d3f1c3e96c500c362a2b8c695076ec180f27918820bc6df8"
+checksum = "630bdcf245f78637c13ec01ffae6187cca34625e8c63150d424b59e55af2675e"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 1.0.107",
+ "syn 2.0.15",
 ]

 [[package]]
@@ -4239,9 +4266,9 @@ dependencies = [

 [[package]]
 name = "tokio-util"
-version = "0.7.8"
+version = "0.7.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "806fe8c2c87eccc8b3267cbae29ed3ab2d0bd37fca70ab622e46aaa9375ddb7d"
+checksum = "1d68074620f57a0b21594d9735eb2e98ab38b17f80d3fcb189fca266771ca60d"
 dependencies = [
 "bytes",
 "futures-core",
@@ -4365,9 +4392,9 @@ dependencies = [

 [[package]]
 name = "trust-dns-proto"
-version = "0.22.0"
+version = "0.23.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4f7f83d1e4a0e4358ac54c5c3681e5d7da5efc5a7a632c90bb6d6669ddd9bc26"
+checksum = "0dc775440033cb114085f6f2437682b194fa7546466024b1037e82a48a052a69"
 dependencies = [
 "async-trait",
 "cfg-if",
@@ -4376,9 +4403,9 @@ dependencies = [
 "futures-channel",
 "futures-io",
 "futures-util",
- "idna 0.2.3",
+ "idna",
 "ipnet",
- "lazy_static",
+ "once_cell",
 "rand 0.8.5",
 "smallvec",
 "thiserror",
@@ -4390,16 +4417,17 @@ dependencies = [

 [[package]]
 name = "trust-dns-resolver"
-version = "0.22.0"
+version = "0.23.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aff21aa4dcefb0a1afbfac26deb0adc93888c7d295fb63ab273ef276ba2b7cfe"
+checksum = "2dff7aed33ef3e8bf2c9966fccdfed93f93d46f432282ea875cd66faabc6ef2f"
 dependencies = [
 "cfg-if",
 "futures-util",
 "ipconfig",
- "lazy_static",
 "lru-cache",
+ "once_cell",
 "parking_lot",
+ "rand 0.8.5",
 "resolv-conf",
 "smallvec",
 "thiserror",
@@ -4431,9 +4459,9 @@ checksum = "497961ef93d974e23eb6f433eb5fe1b7930b659f06d12dec6fc44a8f554c0bba"

 [[package]]
 name = "unicode-bidi"
-version = "0.3.8"
+version = "0.3.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "099b7128301d285f79ddd55b9a83d5e6b9e97c92e0ea0daebee7263e932de992"
+checksum = "92888ba5573ff080736b3648696b70cafad7d250551175acbaa4e0385b3e1460"

 [[package]]
 name = "unicode-ident"
@@ -4480,12 +4508,12 @@ checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a"

 [[package]]
 name = "url"
-version = "2.3.1"
+version = "2.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d68c799ae75762b8c3fe375feb6600ef5602c883c5d21eb51c09f22b83c4643"
+checksum = "143b538f18257fac9cad154828a57c6bf5157e1aa604d4816b5995bf6de87ae5"
 dependencies = [
 "form_urlencoded",
- "idna 0.3.0",
+ "idna",
 "percent-encoding",
 ]

@@ -4648,9 +4676,9 @@ dependencies = [

 [[package]]
 name = "webpki"
-version = "0.22.0"
+version = "0.22.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f095d78192e208183081cc07bc5515ef55216397af48b873e5edcd72637fa1bd"
+checksum = "07ecc0cd7cac091bf682ec5efa18b1cff79d617b84181f38b3951dbe135f607f"
 dependencies = [
 "ring",
 "untrusted",
@@ -4731,21 +4759,51 @@ version = "0.42.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5a3e1820f08b8513f676f7ab6c1f99ff312fb97b553d30ff4dd86f9f15728aa7"
 dependencies = [
- "windows_aarch64_gnullvm",
+ "windows_aarch64_gnullvm 0.42.0",
 "windows_aarch64_msvc 0.42.0",
 "windows_i686_gnu 0.42.0",
 "windows_i686_msvc 0.42.0",
 "windows_x86_64_gnu 0.42.0",
- "windows_x86_64_gnullvm",
+ "windows_x86_64_gnullvm 0.42.0",
 "windows_x86_64_msvc 0.42.0",
 ]

+[[package]]
+name = "windows-sys"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
+dependencies = [
+ "windows-targets",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
+dependencies = [
+ "windows_aarch64_gnullvm 0.48.5",
+ "windows_aarch64_msvc 0.48.5",
+ "windows_i686_gnu 0.48.5",
+ "windows_i686_msvc 0.48.5",
+ "windows_x86_64_gnu 0.48.5",
+ "windows_x86_64_gnullvm 0.48.5",
+ "windows_x86_64_msvc 0.48.5",
+]
+
 [[package]]
 name = "windows_aarch64_gnullvm"
 version = "0.42.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "41d2aa71f6f0cbe00ae5167d90ef3cfe66527d6f613ca78ac8024c3ccab9a19e"

+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
+
 [[package]]
 name = "windows_aarch64_msvc"
 version = "0.32.0"
@@ -4764,6 +4822,12 @@ version = "0.42.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dd0f252f5a35cac83d6311b2e795981f5ee6e67eb1f9a7f64eb4500fbc4dcdb4"

+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
+
 [[package]]
 name = "windows_i686_gnu"
 version = "0.32.0"
@@ -4782,6 +4846,12 @@ version = "0.42.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fbeae19f6716841636c28d695375df17562ca208b2b7d0dc47635a50ae6c5de7"

+[[package]]
+name = "windows_i686_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
+
 [[package]]
 name = "windows_i686_msvc"
 version = "0.32.0"
@@ -4800,6 +4870,12 @@ version = "0.42.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "84c12f65daa39dd2babe6e442988fc329d6243fdce47d7d2d155b8d874862246"

+[[package]]
+name = "windows_i686_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
+
 [[package]]
 name = "windows_x86_64_gnu"
 version = "0.32.0"
@@ -4818,12 +4894,24 @@ version = "0.42.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bf7b1b21b5362cbc318f686150e5bcea75ecedc74dd157d874d754a2ca44b0ed"

+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
+
 [[package]]
 name = "windows_x86_64_gnullvm"
 version = "0.42.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "09d525d2ba30eeb3297665bd434a54297e4170c7f1a44cad4ef58095b4cd2028"

+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
+
 [[package]]
 name = "windows_x86_64_msvc"
 version = "0.32.0"
@@ -4842,6 +4930,12 @@ version = "0.42.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f40009d85759725a34da6d89a94e63d7bdc50a862acf0dbc7c8e488f1edcb6f5"

+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
+
 [[package]]
 name = "winreg"
 version = "0.10.1"
@@ -4851,6 +4945,16 @@ dependencies = [
 "winapi",
 ]

+[[package]]
+name = "winreg"
+version = "0.50.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "524e57b2c537c0f9b1e69f1965311ec12182b4122e45035b1508cd24d2adadb1"
+dependencies = [
+ "cfg-if",
+ "windows-sys 0.48.0",
+]
+
 [[package]]
 name = "x25519-dalek"
 version = "2.0.0-pre.1"
--- a/node/README.md
+++ b/node/README.md
@@ -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
@@ -90,6 +90,7 @@ module.exports = {
  DC_KEY_GEN_DEFAULT: 0,
  DC_KEY_GEN_ED25519: 2,
  DC_KEY_GEN_RSA2048: 1,
+  DC_KEY_GEN_RSA4096: 3,
  DC_LP_AUTH_NORMAL: 4,
  DC_LP_AUTH_OAUTH2: 2,
  DC_MEDIA_QUALITY_BALANCED: 0,
@@ -158,6 +159,8 @@ module.exports = {
  DC_STR_BROADCAST_LIST: 115,
  DC_STR_CANNOT_LOGIN: 60,
  DC_STR_CANTDECRYPT_MSG_BODY: 29,
+  DC_STR_CHAT_PROTECTION_DISABLED: 171,
+  DC_STR_CHAT_PROTECTION_ENABLED: 170,
  DC_STR_CONFIGURATION_FAILED: 84,
  DC_STR_CONNECTED: 107,
  DC_STR_CONNTECTING: 108,
@@ -243,12 +246,6 @@ module.exports = {
  DC_STR_OUTGOING_MESSAGES: 104,
  DC_STR_PARTIAL_DOWNLOAD_MSG_BODY: 99,
  DC_STR_PART_OF_TOTAL_USED: 116,
-  DC_STR_PROTECTION_DISABLED: 89,
-  DC_STR_PROTECTION_DISABLED_BY_OTHER: 161,
-  DC_STR_PROTECTION_DISABLED_BY_YOU: 160,
-  DC_STR_PROTECTION_ENABLED: 88,
-  DC_STR_PROTECTION_ENABLED_BY_OTHER: 159,
-  DC_STR_PROTECTION_ENABLED_BY_YOU: 158,
  DC_STR_QUOTA_EXCEEDING_MSG_BODY: 98,
  DC_STR_READRCPT: 31,
  DC_STR_READRCPT_MAILBODY: 32,
--- a/node/lib/constants.ts
+++ b/node/lib/constants.ts
@@ -90,6 +90,7 @@ export enum C {
  DC_KEY_GEN_DEFAULT = 0,
  DC_KEY_GEN_ED25519 = 2,
  DC_KEY_GEN_RSA2048 = 1,
+  DC_KEY_GEN_RSA4096 = 3,
  DC_LP_AUTH_NORMAL = 4,
  DC_LP_AUTH_OAUTH2 = 2,
  DC_MEDIA_QUALITY_BALANCED = 0,
@@ -158,6 +159,8 @@ export enum C {
  DC_STR_BROADCAST_LIST = 115,
  DC_STR_CANNOT_LOGIN = 60,
  DC_STR_CANTDECRYPT_MSG_BODY = 29,
+  DC_STR_CHAT_PROTECTION_DISABLED = 171,
+  DC_STR_CHAT_PROTECTION_ENABLED = 170,
  DC_STR_CONFIGURATION_FAILED = 84,
  DC_STR_CONNECTED = 107,
  DC_STR_CONNTECTING = 108,
@@ -243,12 +246,6 @@ export enum C {
  DC_STR_OUTGOING_MESSAGES = 104,
  DC_STR_PARTIAL_DOWNLOAD_MSG_BODY = 99,
  DC_STR_PART_OF_TOTAL_USED = 116,
-  DC_STR_PROTECTION_DISABLED = 89,
-  DC_STR_PROTECTION_DISABLED_BY_OTHER = 161,
-  DC_STR_PROTECTION_DISABLED_BY_YOU = 160,
-  DC_STR_PROTECTION_ENABLED = 88,
-  DC_STR_PROTECTION_ENABLED_BY_OTHER = 159,
-  DC_STR_PROTECTION_ENABLED_BY_YOU = 158,
  DC_STR_QUOTA_EXCEEDING_MSG_BODY = 98,
  DC_STR_READRCPT = 31,
  DC_STR_READRCPT_MAILBODY = 32,
--- 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')
@@ -699,23 +699,6 @@ export class Context extends EventEmitter {
    )
  }

-  /**
-   *
-   * @param chatId
-   * @param protect
-   * @returns success boolean
-   */
-  setChatProtection(chatId: number, protect: boolean) {
-    debug(`setChatProtection ${chatId} ${protect}`)
-    return Boolean(
-      binding.dcn_set_chat_protection(
-        this.dcn_context,
-        Number(chatId),
-        protect ? 1 : 0
-      )
-    )
-  }
-
  getChatEphemeralTimer(chatId: number): number {
    debug(`getChatEphemeralTimer ${chatId}`)
    return binding.dcn_get_chat_ephemeral_timer(
--- a/node/lib/deltachat.ts
+++ b/node/lib/deltachat.ts
@@ -21,12 +21,15 @@ export class AccountManager extends EventEmitter {
  accountDir: string
  jsonRpcStarted = false

-  constructor(cwd: string, os = 'deltachat-node') {
+  constructor(cwd: string, writable = true) {
    super()
    debug('DeltaChat constructor')

    this.accountDir = cwd
-    this.dcn_accounts = binding.dcn_accounts_new(os, this.accountDir)
+    this.dcn_accounts = binding.dcn_accounts_new(
+      this.accountDir,
+      writable ? 1 : 0
+    )
  }

  getAllAccountIds() {
--- a/node/src/module.c
+++ b/node/src/module.c
@@ -1399,18 +1399,6 @@ NAPI_METHOD(dcn_set_chat_name) {
  NAPI_RETURN_INT32(result);
 }

-NAPI_METHOD(dcn_set_chat_protection) {
-  NAPI_ARGV(3);
-  NAPI_DCN_CONTEXT();
-  NAPI_ARGV_UINT32(chat_id, 1);
-  NAPI_ARGV_INT32(protect, 1);
-
-  int result = dc_set_chat_protection(dcn_context->dc_context,
-                                      chat_id,
-                                      protect);
-  NAPI_RETURN_INT32(result);
-}
-
 NAPI_METHOD(dcn_get_chat_ephemeral_timer) {
  NAPI_ARGV(2);
  NAPI_DCN_CONTEXT();
@@ -2915,8 +2903,8 @@ NAPI_METHOD(dcn_msg_get_webxdc_blob){

 NAPI_METHOD(dcn_accounts_new) {
  NAPI_ARGV(2);
-  NAPI_ARGV_UTF8_MALLOC(os_name, 0);
-  NAPI_ARGV_UTF8_MALLOC(dir, 1);
+  NAPI_ARGV_UTF8_MALLOC(dir, 0);
+  NAPI_ARGV_INT32(writable, 1);
  TRACE("calling..");

  dcn_accounts_t* dcn_accounts = calloc(1, sizeof(dcn_accounts_t));
@@ -2925,7 +2913,7 @@ NAPI_METHOD(dcn_accounts_new) {
  }


-  dcn_accounts->dc_accounts = dc_accounts_new(os_name, dir);
+  dcn_accounts->dc_accounts = dc_accounts_new(dir, writable);

  napi_value result;
  NAPI_STATUS_THROWS(napi_create_external(env, dcn_accounts,
@@ -3491,7 +3479,6 @@ NAPI_INIT() {
  NAPI_EXPORT_FUNCTION(dcn_send_msg);
  NAPI_EXPORT_FUNCTION(dcn_send_videochat_invitation);
  NAPI_EXPORT_FUNCTION(dcn_set_chat_name);
-  NAPI_EXPORT_FUNCTION(dcn_set_chat_protection);
  NAPI_EXPORT_FUNCTION(dcn_get_chat_ephemeral_timer);
  NAPI_EXPORT_FUNCTION(dcn_set_chat_ephemeral_timer);
  NAPI_EXPORT_FUNCTION(dcn_set_chat_profile_image);
--- a/node/test/test.js
+++ b/node/test/test.js
@@ -12,22 +12,14 @@ 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 +262,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',
@@ -768,14 +760,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/package.json
+++ b/package.json
@@ -60,5 +60,5 @@
    "test:mocha": "mocha -r esm node/test/test.js --growl --reporter=spec --bail --exit"
  },
  "types": "node/dist/index.d.ts",
-  "version": "1.119.0"
+  "version": "1.127.2"
 }
--- 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/mypy.ini
+++ b/python/mypy.ini
@@ -24,3 +24,5 @@ ignore_missing_imports = True
 [mypy-imap_tools.*]
 ignore_missing_imports = True

+[mypy-distutils.*]
+ignore_missing_imports = True
--- a/python/pyproject.toml
+++ b/python/pyproject.toml
@@ -34,6 +34,7 @@ dynamic = [
 "Home" = "https://github.com/deltachat/deltachat-core-rust/"
 "Bug Tracker" = "https://github.com/deltachat/deltachat-core-rust/issues"
 "Documentation" = "https://py.delta.chat/"
+"Mastodon" = "https://chaos.social/@delta"

 [project.entry-points.pytest11]
 "deltachat.testplugin" = "deltachat.testplugin"
--- a/python/src/deltachat/account.py
+++ b/python/src/deltachat/account.py
@@ -195,7 +195,7 @@ class Account:
        assert res != ffi.NULL, f"config value not found for: {name!r}"
        return from_dc_charpointer(res)

-    def _preconfigure_keypair(self, addr: str, public: str, secret: str) -> None:
+    def _preconfigure_keypair(self, addr: str, secret: str) -> None:
        """See dc_preconfigure_keypair() in deltachat.h.

        In other words, you don't need this.
@@ -203,7 +203,7 @@ class Account:
        res = lib.dc_preconfigure_keypair(
            self._dc_context,
            as_dc_charpointer(addr),
-            as_dc_charpointer(public),
+            ffi.NULL,
            as_dc_charpointer(secret),
        )
        if res == 0:
@@ -427,7 +427,7 @@ class Account:

        assert dc_chatlist != ffi.NULL
        chatlist = []
-        for i in range(0, lib.dc_chatlist_get_cnt(dc_chatlist)):
+        for i in range(lib.dc_chatlist_get_cnt(dc_chatlist)):
            chat_id = lib.dc_chatlist_get_chat_id(dc_chatlist, i)
            chatlist.append(Chat(self, chat_id))
        return chatlist
@@ -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/contact.py
+++ b/python/src/deltachat/contact.py
@@ -75,9 +75,12 @@ class Contact:
        """Return True if the contact is verified."""
        return lib.dc_contact_is_verified(self._dc_contact) == 2

-    def get_verifier(self, contact):
+    def get_verifier(self, contact) -> Optional["Contact"]:
        """Return the address of the contact that verified the contact."""
-        return from_dc_charpointer(lib.dc_contact_get_verifier_addr(contact._dc_contact))
+        verifier_id = lib.dc_contact_get_verifier_id(contact._dc_contact)
+        if verifier_id == 0:
+            return None
+        return Contact(self.account, verifier_id)

    def get_profile_image(self) -> Optional[str]:
        """Get contact profile image.
--- a/python/src/deltachat/cutil.py
+++ b/python/src/deltachat/cutil.py
@@ -15,7 +15,7 @@ def as_dc_charpointer(obj):


 def iter_array(dc_array_t, constructor: Callable[[int], T]) -> Generator[T, None, None]:
-    for i in range(0, lib.dc_array_get_cnt(dc_array_t)):
+    for i in range(lib.dc_array_get_cnt(dc_array_t)):
        yield constructor(lib.dc_array_get_id(dc_array_t, i))


--- a/python/src/deltachat/message.py
+++ b/python/src/deltachat/message.py
@@ -510,8 +510,7 @@ def get_viewtype_code_from_name(view_type_name):
    if code is not None:
        return code
    raise ValueError(
-        "message typecode not found for {!r}, "
-        "available {!r}".format(view_type_name, list(_view_type_mapping.keys())),
+        f"message typecode not found for {view_type_name!r}, available {list(_view_type_mapping.keys())!r}",
    )


--- 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
@@ -29,6 +29,12 @@ def pytest_addoption(parser):
        default=None,
        help="a file with >=2 lines where each line contains NAME=VALUE config settings for one account",
    )
+    group.addoption(
+        "--chatmail",
+        action="store",
+        default=None,
+        help="chatmail server domain name",
+    )
    group.addoption(
        "--ignored",
        action="store_true",
@@ -53,10 +59,12 @@ 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
@@ -157,13 +165,29 @@ class TestProcess:
        """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.
+        a file with a line specifying each accounts config
+        or a --chatmail domain.
        """
        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"):
+        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:
+                    username = "ci-" + "".join(random.choice("2345789acdefghjkmnpqrstuvwxyz") for i in range(6))
+                    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.")
+        elif liveconfig_opt:
+            # Read a list of accounts from file.
            for line in open(liveconfig_opt):
                if line.strip() and not line.strip().startswith("#"):
                    d = {}
@@ -174,20 +198,9 @@ class TestProcess:

            yield from iter(self._configlist)
        else:
-            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"]}
-                    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.")
+            pytest.skip(
+                "specify --liveconfig, 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)
@@ -478,10 +491,9 @@ class ACFactory:
        except IndexError:
            pass
        else:
-            fname_pub = self.data.read_path(f"key/{keyname}-public.asc")
            fname_sec = self.data.read_path(f"key/{keyname}-secret.asc")
-            if fname_pub and fname_sec:
-                account._preconfigure_keypair(addr, fname_pub, fname_sec)
+            if fname_sec:
+                account._preconfigure_keypair(addr, fname_sec)
                return True
            print(f"WARN: could not use preconfigured keys for {addr!r}")

--- a/python/tests/bench_test_setup.py
+++ b/python/tests/bench_test_setup.py
@@ -15,6 +15,6 @@ class TestEmpty:
    def test_prepare_setup_measurings(self, acfactory):
        acfactory.get_online_accounts(BENCH_NUM)

-    @pytest.mark.parametrize("num", range(0, BENCH_NUM + 1))
+    @pytest.mark.parametrize("num", range(BENCH_NUM + 1))
    def test_setup_online_accounts(self, acfactory, num):
        acfactory.get_online_accounts(num)
--- a/python/tests/test_0_complex_or_slow.py
+++ b/python/tests/test_0_complex_or_slow.py
@@ -1,6 +1,7 @@
 import sys

 import pytest
+import deltachat as dc


 class TestGroupStressTests:
@@ -136,6 +137,7 @@ def test_qr_verified_group_and_chatting(acfactory, lp):
    lp.sec("ac2: read member added message")
    msg = ac2._evtracker.wait_next_incoming_message()
    assert msg.is_encrypted()
+    assert msg.is_system_message()
    assert "added" in msg.text.lower()

    lp.sec("ac1: send message")
@@ -149,9 +151,8 @@ def test_qr_verified_group_and_chatting(acfactory, lp):
    assert msg.is_encrypted()

    lp.sec("ac2: Check that ac2 verified ac1")
-    # If we verified the contact ourselves then verifier addr == contact addr
    ac2_ac1_contact = ac2.get_contacts()[0]
-    assert ac2.get_self_contact().get_verifier(ac2_ac1_contact) == ac1_addr
+    assert ac2.get_self_contact().get_verifier(ac2_ac1_contact).id == dc.const.DC_CONTACT_ID_SELF

    lp.sec("ac2: send message and let ac1 read it")
    chat2.send_text("world")
@@ -176,14 +177,15 @@ def test_qr_verified_group_and_chatting(acfactory, lp):

    lp.sec("ac2: Check that ac1 verified ac3 for ac2")
    ac2_ac1_contact = ac2.get_contacts()[0]
-    assert ac2.get_self_contact().get_verifier(ac2_ac1_contact) == ac1_addr
+    assert ac2.get_self_contact().get_verifier(ac2_ac1_contact).id == dc.const.DC_CONTACT_ID_SELF
    ac2_ac3_contact = ac2.get_contacts()[1]
-    assert ac2.get_self_contact().get_verifier(ac2_ac3_contact) == ac1_addr
+    assert ac2.get_self_contact().get_verifier(ac2_ac3_contact).addr == ac1_addr

    lp.sec("ac2: send message and let ac3 read it")
    chat2.send_text("hi")
-    # Skip system message about added member
-    ac3._evtracker.wait_next_incoming_message()
+    # System message about the added member.
+    msg = ac3._evtracker.wait_next_incoming_message()
+    assert msg.is_system_message()
    msg = ac3._evtracker.wait_next_incoming_message()
    assert msg.text == "hi"
    assert msg.is_encrypted()
@@ -524,7 +526,8 @@ def test_see_new_verified_member_after_going_online(acfactory, tmp_path, lp):
    lp.sec("ac2: sending message")
    # Message can be sent only after a receipt of "vg-member-added" message. Just wait for
    # "Member Me (<addr>) added by <addr>." message.
-    ac2._evtracker.wait_next_incoming_message()
+    msg_in = ac2._evtracker.wait_next_incoming_message()
+    assert msg_in.is_system_message()
    msg_out = chat2.send_text("hello")

    lp.sec("ac1: receiving message")
@@ -539,8 +542,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:
@@ -589,4 +590,67 @@ 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 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
@@ -9,7 +9,7 @@ import pytest
 from imap_tools import AND, U

 import deltachat as dc
-from deltachat import account_hookimpl, Message
+from deltachat import account_hookimpl, Message, Chat
 from deltachat.tracker import ImexTracker


@@ -1467,13 +1467,18 @@ def test_reaction_to_partially_fetched_msg(acfactory, lp, tmp_path):
    path = tmp_path / "large"
    path.write_bytes(os.urandom(download_limit + 1))
    msgs.append(chat.send_file(str(path)))
-
-    lp.sec("sending a reaction to the large message from ac1 to ac2")
-    react_str = "\N{THUMBS UP SIGN}"
-    msgs.append(msgs[-1].send_reaction(react_str))
-
    for m in msgs:
        ac1._evtracker.wait_msg_delivered(m)
+
+    lp.sec("sending a reaction to the large message from ac1 to ac2")
+    # TODO: Find the reason of an occasional message reordering on the server (so that the reaction
+    # has a lower UID than the previous message). W/a is to sleep for some time to let the reaction
+    # have a later INTERNALDATE.
+    time.sleep(1.1)
+    react_str = "\N{THUMBS UP SIGN}"
+    msgs.append(msgs[-1].send_reaction(react_str))
+    ac1._evtracker.wait_msg_delivered(msgs[-1])
+
    ac2.start_io()

    lp.sec("wait for ac2 to receive a reaction")
@@ -1505,7 +1510,7 @@ def test_reactions_for_a_reordering_move(acfactory, lp):
    ac1._evtracker.wait_msg_delivered(msg1)
    # It's is sad, but messages must differ in their INTERNALDATEs to be processed in the correct
    # order by DC, and most (if not all) mail servers provide only seconds precision.
-    time.sleep(2)
+    time.sleep(1.1)
    react_str = "\N{THUMBS UP SIGN}"
    ac1._evtracker.wait_msg_delivered(msg1.send_reaction(react_str))

@@ -1664,8 +1669,12 @@ def test_qr_setup_contact(acfactory, lp):
    ac1._evtracker.wait_securejoin_inviter_progress(1000)


-def test_qr_join_chat(acfactory, lp):
+@pytest.mark.parametrize("verified_one_on_one_chats", [0, 1])
+def test_qr_join_chat(acfactory, lp, verified_one_on_one_chats):
    ac1, ac2 = acfactory.get_online_accounts(2)
+    ac1.set_config("verified_one_on_one_chats", verified_one_on_one_chats)
+    ac2.set_config("verified_one_on_one_chats", verified_one_on_one_chats)
+
    lp.sec("ac1: create QR code and let ac2 scan it, starting the securejoin")
    chat = ac1.create_group_chat("hello")
    qr = chat.get_join_qr()
@@ -1678,6 +1687,45 @@ def test_qr_join_chat(acfactory, lp):
    ac2._evtracker.get_matching("DC_EVENT_IMAP_MESSAGE_DELETED")
    ac1._evtracker.wait_securejoin_inviter_progress(1000)

+    msg = ac2._evtracker.wait_next_incoming_message()
+    assert msg.text == "Member Me ({}) added by {}.".format(ac2.get_config("addr"), ac1.get_config("addr"))
+
+    # ac1 reloads the chat.
+    chat = Chat(chat.account, chat.id)
+    assert not chat.is_protected()
+
+    # ac2 reloads the chat.
+    ch = Chat(ch.account, ch.id)
+    assert not ch.is_protected()
+
+
+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.
+    This results in creation of a blocked 1:1 chat with ac1 on ac2,
+    but ac1 contact is not blocked on ac2.
+    Then ac1 creates a group, adds ac2 there and promotes it by sending a message.
+    ac2 should receive a message and create a contact request for the group.
+    Due to a bug previously ac2 created a blocked group.
+    """
+
+    ac1, ac2 = acfactory.get_online_accounts(2)
+    ac1_chat = ac1.create_group_chat("Group for joining", verified=True)
+    qr = ac1_chat.get_join_qr()
+    ac2.qr_join_chat(qr)
+
+    ac1._evtracker.wait_securejoin_inviter_progress(1000)
+
+    ac1_new_chat = ac1.create_group_chat("Another group")
+    ac1_new_chat.add_contact(ac2)
+    # Receive "Member added" message.
+    ac2._evtracker.wait_next_incoming_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()
+

 def test_qr_email_capitalization(acfactory, lp):
    """Regression test for a bug
@@ -1896,13 +1944,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
@@ -2158,7 +2208,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")
@@ -2189,13 +2249,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"
@@ -2498,7 +2560,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)
@@ -2507,7 +2569,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_3_offline.py
+++ b/python/tests/test_3_offline.py
@@ -67,10 +67,9 @@ class TestOfflineAccountBasic:

    def test_preconfigure_keypair(self, acfactory, data):
        ac = acfactory.get_unconfigured_account()
-        alice_public = data.read_path("key/alice-public.asc")
        alice_secret = data.read_path("key/alice-secret.asc")
-        assert alice_public and alice_secret
-        ac._preconfigure_keypair("alice@example.org", alice_public, alice_secret)
+        assert alice_secret
+        ac._preconfigure_keypair("alice@example.org", alice_secret)

    def test_getinfo(self, acfactory):
        ac1 = acfactory.get_unconfigured_account()
--- a/python/tests/test_4_lowlevel.py
+++ b/python/tests/test_4_lowlevel.py
@@ -1,3 +1,4 @@
+import json
 from queue import Queue

 import deltachat as dc
@@ -221,15 +222,32 @@ def test_logged_ac_process_ffi_failure(acfactory):

 def test_jsonrpc_blocking_call(tmp_path):
    accounts_fname = tmp_path / "accounts"
+    writable = True
    accounts = ffi.gc(
-        lib.dc_accounts_new(ffi.NULL, str(accounts_fname).encode("ascii")),
+        lib.dc_accounts_new(str(accounts_fname).encode("ascii"), writable),
        lib.dc_accounts_unref,
    )
    jsonrpc = ffi.gc(lib.dc_jsonrpc_init(accounts), lib.dc_jsonrpc_unref)
-    res = from_optional_dc_charpointer(
-        lib.dc_jsonrpc_blocking_call(jsonrpc, b"check_email_validity", b'["alice@example.org"]'),
+    res = json.loads(
+        from_optional_dc_charpointer(
+            lib.dc_jsonrpc_blocking_call(
+                jsonrpc,
+                json.dumps(
+                    {"jsonrpc": "2.0", "method": "check_email_validity", "params": ["alice@example.org"], "id": "123"},
+                ).encode("utf-8"),
+            ),
+        ),
    )
-    assert res == "true"
+    assert res == {"jsonrpc": "2.0", "id": "123", "result": True}

-    res = from_optional_dc_charpointer(lib.dc_jsonrpc_blocking_call(jsonrpc, b"check_email_validity", b'["alice"]'))
-    assert res == "false"
+    res = json.loads(
+        from_optional_dc_charpointer(
+            lib.dc_jsonrpc_blocking_call(
+                jsonrpc,
+                json.dumps(
+                    {"jsonrpc": "2.0", "method": "check_email_validity", "params": ["alice"], "id": "456"},
+                ).encode("utf-8"),
+            ),
+        ),
+    )
+    assert res == {"jsonrpc": "2.0", "id": "456", "result": False}
--- 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 = 
@@ -25,6 +25,9 @@ deps =
    pytest-xdist
    pdbpp
    requests
+# urllib3 2.0 does not work in manylinux2014 containers.
+# https://github.com/deltachat/deltachat-core-rust/issues/4788
+    urllib3<2

 [testenv:.pkg]
 passenv =
@@ -59,7 +62,8 @@ commands =
 [testenv:doc]
 changedir=doc
 deps =
-    sphinx
+# Pinned due to incompatibility of breathe with sphinx 7.2: <https://github.com/breathe-doc/breathe/issues/943>
+    sphinx<=7.1.2
    breathe
 commands =
    sphinx-build -Q -w toxdoc-warnings.log -b html . _build/html
@@ -81,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-08-03
+2023-10-29
--- a/scripts/README.md
+++ b/scripts/README.md
@@ -10,18 +10,27 @@ and an own build machine.

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

+- `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/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/coredeps/Dockerfile
+++ b/scripts/coredeps/Dockerfile
@@ -6,3 +6,4 @@ FROM $BASEIMAGE
 RUN pipx install tox
 COPY install-rust.sh /scripts/
 RUN /scripts/install-rust.sh
+RUN if command -v yum; then yum install -y perl-IPC-Cmd; fi
--- a/scripts/coredeps/install-rust.sh
+++ b/scripts/coredeps/install-rust.sh
@@ -7,7 +7,7 @@ set -euo pipefail
 #
 # Avoid using rustup here as it depends on reading /proc/self/exe and
 # has problems running under QEMU.
-RUST_VERSION=1.68.0
+RUST_VERSION=1.72.0

 ARCH="$(uname -m)"
 test -f "/lib/libc.musl-$ARCH.so.1" && LIBC=musl || LIBC=gnu
--- a/scripts/create-provider-data-rs.py
+++ b/scripts/create-provider-data-rs.py
@@ -44,7 +44,7 @@ def file2url(f):

 def process_opt(data):
    if not "opt" in data:
-        return "Default::default()"
+        return "ProviderOptions::new()"
    opt = "ProviderOptions {\n"
    opt_data = data.get("opt", "")
    for key in opt_data:
@@ -54,7 +54,7 @@ def process_opt(data):
        if value in {"True", "False"}:
            value = value.lower()
        opt += "        " + key + ": " + value + ",\n"
-    opt += "        ..Default::default()\n"
+    opt += "        ..ProviderOptions::new()\n"
    opt += "    }"
    return opt

@@ -62,7 +62,7 @@ def process_opt(data):
 def process_config_defaults(data):
    if not "config_defaults" in data:
        return "None"
-    defaults = "Some(vec![\n"
+    defaults = "Some(&[\n"
    config_defaults = data.get("config_defaults", "")
    for key in config_defaults:
        value = str(config_defaults[key])
@@ -96,11 +96,11 @@ def process_data(data, file):
            raise TypeError("domain used twice: " + domain)
        domains_set.add(domain)

-        domains += '    ("' + domain + '", &*' + file2varname(file) + "),\n"
+        domains += '    ("' + domain + '", &' + file2varname(file) + "),\n"
        comment += domain + ", "

    ids = ""
-    ids += '    ("' + file2id(file) + '", &*' + file2varname(file) + "),\n"
+    ids += '    ("' + file2id(file) + '", &' + file2varname(file) + "),\n"

    server = ""
    has_imap = False
@@ -155,18 +155,18 @@ def process_data(data, file):
        provider += (
            "static "
            + file2varname(file)
-            + ": Lazy<Provider> = Lazy::new(|| Provider {\n"
+            + ": Provider = Provider {\n"
        )
        provider += '    id: "' + file2id(file) + '",\n'
        provider += "    status: Status::" + status.capitalize() + ",\n"
        provider += '    before_login_hint: "' + before_login_hint + '",\n'
        provider += '    after_login_hint: "' + after_login_hint + '",\n'
        provider += '    overview_page: "' + file2url(file) + '",\n'
-        provider += "    server: vec![\n" + server + "    ],\n"
+        provider += "    server: &[\n" + server + "    ],\n"
        provider += "    opt: " + opt + ",\n"
        provider += "    config_defaults: " + config_defaults + ",\n"
        provider += "    oauth2_authorizer: " + oauth2 + ",\n"
-        provider += "});\n\n"
+        provider += "};\n\n"
    else:
        raise TypeError("SMTP and IMAP must be specified together or left out both")

--- 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,11 +27,11 @@ 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
-tox --workdir "$TOXWORKDIR" -e py37,py38,py39,py310,py311,pypy37,pypy38,pypy39 --skip-missing-interpreters true
+tox --workdir "$TOXWORKDIR" -e py37,py38,py39,py310,py311,py312,pypy37,pypy38,pypy39,pypy310 --skip-missing-interpreters true

 auditwheel repair "$TOXWORKDIR"/wheelhouse/deltachat* -w "$TOXWORKDIR/wheelhouse"

--- 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/Show More
+++ b/Show More
@@ -1 +1 @@
 -08-03
 -10-29