Serialize mime_compressed

Serialize uid
Do not serialize is_default
2026-04-02 13:32:11 +03:00 · 2024-04-06 16:37:51 +00:00 · 2024-04-06 15:54:12 +00:00 · 2024-04-06 15:27:11 +00:00 · 2024-04-06 02:48:27 +00:00 · 2024-04-06 01:45:14 +00:00
106 changed files with 3640 additions and 3632 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -105,20 +105,10 @@ jobs:
      - name: Cache rust cargo artifacts
        uses: swatinem/rust-cache@v2

-      - name: Install nextest
-        uses: taiki-e/install-action@v2
-        with:
-          tool: nextest
-
      - name: Tests
        env:
          RUST_BACKTRACE: 1
-        run: cargo nextest run --workspace
-
-      - name: Doc-Tests
-        env:
-          RUST_BACKTRACE: 1
-        run: cargo test --workspace --doc
+        run: cargo test --workspace

      - name: Test cargo vendor
        run: cargo vendor
--- a/.github/workflows/node-tests.yml
+++ b/.github/workflows/node-tests.yml
@@ -21,17 +21,14 @@ jobs:
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
-        os: [ubuntu-latest, macos-14, windows-latest]
-        node: ["18", "20"]
+        os: [ubuntu-latest, macos-latest, windows-latest]
    steps:
      - uses: actions/checkout@v4
        with:
          show-progress: false
      - uses: actions/setup-node@v4
        with:
-          node-version: ${{ matrix.node }}
-      - if: matrix.os == 'macos-14'
-        run: sudo xcode-select --switch /Applications/Xcode_15.3.app/Contents/Developer
+          node-version: "18"
      - name: System info
        run: |
          rustc -vV
--- a/.github/workflows/upload-docs.yml
+++ b/.github/workflows/upload-docs.yml
@@ -1,4 +1,4 @@
-name: Build & deploy documentation on rs.delta.chat, c.delta.chat, and py.delta.chat
+name: Build & Deploy Documentation on rs.delta.chat, c.delta.chat, py.delta.chat

 on:
  push:
@@ -56,7 +56,7 @@ jobs:
      - uses: DeterminateSystems/magic-nix-cache-action@main
      - name: Build C documentation
        run: nix build .#docs
-      - name: Upload to c.delta.chat
+      - name: Upload to py.delta.chat
        run: |
          mkdir -p "$HOME/.ssh"
          echo "${{ secrets.CODESPEAK_KEY }}" > "$HOME/.ssh/key"
--- a/.github/workflows/upload-ffi-docs.yml
+++ b/.github/workflows/upload-ffi-docs.yml
@@ -1,5 +1,5 @@
 # GitHub Actions workflow
-# to build `deltachat_ffi` crate documentation
+# to build `deltachat_fii` crate documentation
 # and upload it to <https://cffi.delta.chat/>

 name: Build & Deploy Documentation on cffi.delta.chat
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,71 +1,5 @@
 # Changelog

-## [1.137.3] - 2024-04-16
-
-### API-Changes
-
- [**breaking**] Remove reactions ffi; all implementations use jsonrpc.
- Don't load trashed messages with `Message::load_from_db`.
- Add `ChatListChanged` and `ChatListItemChanged` events ([#4476](https://github.com/deltachat/deltachat-core-rust/pull/4476)).
- deltachat-rpc-client: Add `check_qr` and `set_config_from_qr` APIs.
- deltachat-rpc-client: Add `Account.create_chat()`.
- deltachat-rpc-client: Add `Message.wait_until_delivered()`.
- deltachat-rpc-client: Add `Chat.send_file()`.
- deltachat-rpc-client: Add `Account.wait_for_reactions_changed()`.
- deltachat-rpc-client: Return Message from `Message.send_reaction()`.
- deltachat-rpc-client: Add `Account.bring_online()`.
- deltachat-rpc-client: Add `ACFactory.get_accepted_chat()`.
-
-### Features / Changes
-
- Port `direct_imap.py` into deltachat-rpc-client.
-
-### Fixes
-
- Do not emit `MSGS_CHANGED` event for outgoing hidden messages.
- `Message::get_summary()` must not return reaction summary.
- Fix emitting `ContactsChanged` events on "recently seen" status change ([#5377](https://github.com/deltachat/deltachat-core-rust/pull/5377)).
- deltachat-jsonrpc: block in `inner_get_backup_qr`.
- Add tolerance to `MemberListTimestamp` ([#5366](https://github.com/deltachat/deltachat-core-rust/pull/5366)).
- Keep webxdc instance for `delete_device_after` period after a status update ([#5365](https://github.com/deltachat/deltachat-core-rust/pull/5365)).
- Don't try to do `fetch_move_delete()` if Trash is needed but not yet configured.
- Assign messages to chats based on not fully downloaded references.
- Do not create ad-hoc groups from partial downloads.
- deltachat-rpc-client: construct Thread with `target` keyword argument.
- Format error context in `Message::load_from_db`.
-
-### Build system
-
- cmake: adapt target install path if env var `CARGO_BUILD_TARGET` is set.
- nix: Use stable Rust in flake.nix devshell.
-
-### CI
-
- Use cargo-nextest instead of cargo-test.
- Run doc tests with cargo test --workspace --doc ([#5459](https://github.com/deltachat/deltachat-core-rust/pull/5459)).
- Typos in CI files ([#5453](https://github.com/deltachat/deltachat-core-rust/pull/5453)).
-
-### Documentation
-
- Add <https://deps.rs> badge.
- Add 'Ubuntu Touch' to the list of 'frontend projects'
-
-### Refactor
-
- Do not ignore `Contact::get_by_id` errors in `get_encrinfo`.
- deltachat-rpc-client: Use `list`, `set` and `tuple` instead of `typing`.
- Use `clone_from()` ([#5451](https://github.com/deltachat/deltachat-core-rust/pull/5451)).
- Do not check for `is_trash()` in `get_last_reaction_if_newer_than()`.
- Split off functional contact tools into its own crate ([#5444](https://github.com/deltachat/deltachat-core-rust/pull/5444))
- Fix nightly clippy warnings.
-
-### Tests
-
- Test withdrawing group join QR codes.
- `display_chat()`: Don't add day markers.
- Move reaction tests to JSON-RPC.
- node: Increase 'static tests' timeout to 5 minutes.
-
 ## [1.137.2] - 2024-04-05

 ### API-Changes
@@ -3938,4 +3872,3 @@ https://github.com/deltachat/deltachat-core-rust/pulls?q=is%3Apr+is%3Aclosed
 [1.137.0]: https://github.com/deltachat/deltachat-core-rust/compare/v1.136.6...v1.137.0
 [1.137.1]: https://github.com/deltachat/deltachat-core-rust/compare/v1.137.0...v1.137.1
 [1.137.2]: https://github.com/deltachat/deltachat-core-rust/compare/v1.137.1...v1.137.2
-[1.137.3]: https://github.com/deltachat/deltachat-core-rust/compare/v1.137.2...v1.137.3
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -12,12 +12,6 @@ else()
       set(DYNAMIC_EXT "dll")
 endif()

-if(DEFINED ENV{CARGO_BUILD_TARGET})
-    set(ARCH_DIR "$ENV{CARGO_BUILD_TARGET}")
-else()
-    set(ARCH_DIR "./")
-endif()
-
 add_custom_command(
 	OUTPUT
 	"${CMAKE_BINARY_DIR}/target/release/libdeltachat.a"
@@ -41,6 +35,6 @@ add_custom_target(
 )

 install(FILES "deltachat-ffi/deltachat.h" DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
-install(FILES "${CMAKE_BINARY_DIR}/target/${ARCH_DIR}/release/libdeltachat.a" DESTINATION ${CMAKE_INSTALL_LIBDIR})
-install(FILES "${CMAKE_BINARY_DIR}/target/${ARCH_DIR}/release/libdeltachat.${DYNAMIC_EXT}" DESTINATION ${CMAKE_INSTALL_LIBDIR})
-install(FILES "${CMAKE_BINARY_DIR}/target/${ARCH_DIR}/release/pkgconfig/deltachat.pc" DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
+install(FILES "${CMAKE_BINARY_DIR}/target/release/libdeltachat.a" DESTINATION ${CMAKE_INSTALL_LIBDIR})
+install(FILES "${CMAKE_BINARY_DIR}/target/release/libdeltachat.${DYNAMIC_EXT}" DESTINATION ${CMAKE_INSTALL_LIBDIR})
+install(FILES "${CMAKE_BINARY_DIR}/target/release/pkgconfig/deltachat.pc" DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -113,54 +113,12 @@ dependencies = [
 "winapi",
 ]

-[[package]]
-name = "anstream"
-version = "0.6.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d96bd03f33fe50a863e394ee9718a706f988b9079b20c3784fb726e7678b62fb"
-dependencies = [
- "anstyle",
- "anstyle-parse",
- "anstyle-query",
- "anstyle-wincon",
- "colorchoice",
- "utf8parse",
-]
-
 [[package]]
 name = "anstyle"
 version = "1.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8901269c6307e8d93993578286ac0edf7f195079ffff5ebdeea6a59ffb7e36bc"

-[[package]]
-name = "anstyle-parse"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c75ac65da39e5fe5ab759307499ddad880d724eed2f6ce5b5e8a26f4f387928c"
-dependencies = [
- "utf8parse",
-]
-
-[[package]]
-name = "anstyle-query"
-version = "1.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e28923312444cdd728e4738b3f9c9cac739500909bb3d3c94b43551b16517648"
-dependencies = [
- "windows-sys 0.52.0",
-]
-
-[[package]]
-name = "anstyle-wincon"
-version = "3.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1cd54b81ec8d6180e24654d0b371ad22fc3dd083b6ff8ba325b72e00c87660a7"
-dependencies = [
- "anstyle",
- "windows-sys 0.52.0",
-]
-
 [[package]]
 name = "anyhow"
 version = "1.0.81"
@@ -227,18 +185,6 @@ dependencies = [
 "syn 1.0.109",
 ]

-[[package]]
-name = "async-broadcast"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "258b52a1aa741b9f09783b2d86cf0aeeb617bbf847f6933340a39644227acbdb"
-dependencies = [
- "event-listener 5.2.0",
- "event-listener-strategy",
- "futures-core",
- "pin-project-lite",
-]
-
 [[package]]
 name = "async-channel"
 version = "1.9.0"
@@ -476,12 +422,6 @@ version = "0.21.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567"

-[[package]]
-name = "base64"
-version = "0.22.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9475866fec1451be56a3c2400fd081ff546538961565ccb5b7142cbd22bc7a51"
-
 [[package]]
 name = "base64ct"
 version = "1.6.0"
@@ -567,9 +507,9 @@ dependencies = [

 [[package]]
 name = "brotli"
-version = "5.0.0"
+version = "4.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "19483b140a7ac7174d34b5a581b406c64f84da5409d3e09cf4fff604f9270e67"
+checksum = "125740193d7fee5cc63ab9e16c2fdc4e07c74ba755cc53b327d6ea029e9fc569"
 dependencies = [
 "alloc-no-stdlib",
 "alloc-stdlib",
@@ -578,9 +518,9 @@ dependencies = [

 [[package]]
 name = "brotli-decompressor"
-version = "4.0.0"
+version = "3.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6221fe77a248b9117d431ad93761222e1cf8ff282d9d1d5d9f53d6299a1cf76"
+checksum = "65622a320492e09b5e0ac436b14c54ff68199bac392d0e89a6832c4518eea525"
 dependencies = [
 "alloc-no-stdlib",
 "alloc-stdlib",
@@ -819,12 +759,6 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b"

-[[package]]
-name = "colorchoice"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "acbf1af155f9b9ef647e42cdc158db4b64a1b61f743629225fde6f3e0be2a7c7"
-
 [[package]]
 name = "concurrent-queue"
 version = "2.4.0"
@@ -1157,22 +1091,22 @@ dependencies = [

 [[package]]
 name = "deltachat"
-version = "1.137.3"
+version = "1.137.2"
 dependencies = [
 "ansi_term",
 "anyhow",
- "async-broadcast",
 "async-channel 2.2.0",
 "async-imap",
 "async-native-tls",
 "async-smtp",
 "async_zip",
 "backtrace",
- "base64 0.22.0",
+ "base64 0.21.7",
+ "bitflags 1.3.2",
 "brotli",
+ "bstr",
 "chrono",
 "criterion",
- "deltachat-contact-tools",
 "deltachat-time",
 "deltachat_derive",
 "email",
@@ -1202,6 +1136,7 @@ dependencies = [
 "parking_lot",
 "percent-encoding",
 "pgp",
+ "pin-project",
 "pretty_assertions",
 "pretty_env_logger",
 "proptest",
@@ -1237,26 +1172,16 @@ dependencies = [
 "uuid",
 ]

-[[package]]
-name = "deltachat-contact-tools"
-version = "0.1.0"
-dependencies = [
- "anyhow",
- "once_cell",
- "regex",
- "rusqlite",
-]
-
 [[package]]
 name = "deltachat-jsonrpc"
-version = "1.137.3"
+version = "1.137.2"
 dependencies = [
 "anyhow",
 "async-channel 2.2.0",
 "axum",
- "base64 0.22.0",
+ "base64 0.21.7",
 "deltachat",
- "env_logger 0.11.3",
+ "env_logger",
 "futures",
 "log",
 "num-traits",
@@ -1273,7 +1198,7 @@ dependencies = [

 [[package]]
 name = "deltachat-repl"
-version = "1.137.3"
+version = "1.137.2"
 dependencies = [
 "ansi_term",
 "anyhow",
@@ -1288,12 +1213,12 @@ dependencies = [

 [[package]]
 name = "deltachat-rpc-server"
-version = "1.137.3"
+version = "1.137.2"
 dependencies = [
 "anyhow",
 "deltachat",
 "deltachat-jsonrpc",
- "env_logger 0.11.3",
+ "env_logger",
 "futures-lite",
 "log",
 "serde",
@@ -1317,7 +1242,7 @@ dependencies = [

 [[package]]
 name = "deltachat_ffi"
-version = "1.137.3"
+version = "1.137.2"
 dependencies = [
 "anyhow",
 "deltachat",
@@ -1846,16 +1771,6 @@ dependencies = [
 "syn 2.0.57",
 ]

-[[package]]
-name = "env_filter"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a009aa4810eb158359dda09d0c87378e4bbb89b5a801f016885a4707ba24f7ea"
-dependencies = [
- "log",
- "regex",
-]
-
 [[package]]
 name = "env_logger"
 version = "0.10.2"
@@ -1869,19 +1784,6 @@ dependencies = [
 "termcolor",
 ]

-[[package]]
-name = "env_logger"
-version = "0.11.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38b35839ba51819680ba087cd351788c9a3c476841207e0b8cee0b04722343b9"
-dependencies = [
- "anstream",
- "anstyle",
- "env_filter",
- "humantime",
- "log",
-]
-
 [[package]]
 name = "equivalent"
 version = "1.0.1"
@@ -3699,7 +3601,7 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "865724d4dbe39d9f3dd3b52b88d859d66bcb2d6a0acfd5ea68a65fb66d4bdc1c"
 dependencies = [
- "env_logger 0.10.2",
+ "env_logger",
 "log",
 ]

@@ -4290,9 +4192,9 @@ dependencies = [

 [[package]]
 name = "rustls"
-version = "0.21.11"
+version = "0.21.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fecbfb7b1444f477b345853b1fce097a2c6fb637b2bfb87e6bc5db0f043fae4"
+checksum = "f9d5a6813c0759e4609cd494e8e725babae6a2ca7b62a5536a13daaec6fcb7ba"
 dependencies = [
 "ring 0.17.8",
 "rustls-webpki",
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "deltachat"
-version = "1.137.3"
+version = "1.137.2"
 edition = "2021"
 license = "MPL-2.0"
 rust-version = "1.77"
@@ -34,21 +34,21 @@ strip = true
 [dependencies]
 deltachat_derive = { path = "./deltachat_derive" }
 deltachat-time = { path = "./deltachat-time" }
-deltachat-contact-tools = { path = "./deltachat-contact-tools" }
 format-flowed = { path = "./format-flowed" }
 ratelimit = { path = "./deltachat-ratelimit" }

-anyhow = { workspace = true }
-async-broadcast = "0.7.0"
+anyhow = "1"
 async-channel = "2.0.0"
 async-imap = { version = "0.9.7", default-features = false, features = ["runtime-tokio"] }
 async-native-tls = { version = "0.5", default-features = false, features = ["runtime-tokio"] }
 async-smtp = { version = "0.9", default-features = false, features = ["runtime-tokio"] }
 async_zip = { version = "0.0.12", default-features = false, features = ["deflate", "fs"] }
 backtrace = "0.3"
-base64 = "0.22"
-brotli = { version = "5", default-features=false, features = ["std"] }
-chrono = { version = "0.4.37", default-features=false, features = ["clock", "std"] }
+base64 = "0.21"
+brotli = { version = "4", default-features=false, features = ["std"] }
+bitflags = "1.3"
+bstr = { version = "1.4.0", default-features=false, features = ["std", "alloc"] }
+chrono = { version = "0.4", default-features=false, features = ["clock", "std"] }
 email = { git = "https://github.com/deltachat/rust-email", branch = "master" }
 encoded-words = { git = "https://github.com/async-email/encoded-words", branch = "master" }
 escaper = "0.1"
@@ -61,7 +61,7 @@ hickory-resolver = "0.24"
 humansize = "2"
 image = { version = "0.25.1", default-features=false, features = ["gif", "jpeg", "ico", "png", "pnm", "webp", "bmp"] }
 iroh = { version = "0.4.2", default-features = false }
-kamadak-exif = "0.5.3"
+kamadak-exif = "0.5"
 lettre_email = { git = "https://github.com/deltachat/lettre", branch = "master" }
 libc = "0.2"
 mailparse = "0.14"
@@ -69,31 +69,32 @@ mime = "0.3.17"
 num_cpus = "1.16"
 num-derive = "0.4"
 num-traits = "0.2"
-once_cell = { workspace = true }
+once_cell = "1.18.0"
 percent-encoding = "2.3"
 parking_lot = "0.12"
 pgp = { version = "0.11", default-features = false }
+pin-project = "1"
 pretty_env_logger = { version = "0.5", optional = true }
 qrcodegen = "1.7.0"
 quick-xml = "0.31"
 quoted_printable = "0.5"
 rand = "0.8"
-regex = { workspace = true }
+regex = "1.10"
 reqwest = { version = "0.12.2", features = ["json"] }
-rusqlite = { workspace = true, features = ["sqlcipher"] }
+rusqlite = { version = "0.31", features = ["sqlcipher"] }
 rust-hsluv = "0.1"
 sanitize-filename = "0.5"
 serde_json = "1"
 serde = { version = "1.0", features = ["derive"] }
 sha-1 = "0.10"
 sha2 = "0.10"
-smallvec = "1.13.2"
+smallvec = "1"
 strum = "0.26"
 strum_macros = "0.26"
 tagger = "4.3.4"
 textwrap = "0.16.1"
 thiserror = "1"
-tokio = { version = "1.37.0", features = ["fs", "rt-multi-thread", "macros"] }
+tokio = { version = "1", features = ["fs", "rt-multi-thread", "macros"] }
 tokio-io-timeout = "1.2.0"
 tokio-stream = { version = "0.1.15", features = ["fs"] }
 tokio-tar = { version = "0.3" } # TODO: integrate tokio into async-tar
@@ -120,7 +121,7 @@ pretty_env_logger = "0.5"
 proptest = { version = "1", default-features = false, features = ["std"] }
 tempfile = "3"
 testdir = "0.9.0"
-tokio = { version = "1.37.0", features = ["parking_lot", "rt-multi-thread", "macros"] }
+tokio = { version = "1", features = ["parking_lot", "rt-multi-thread", "macros"] }
 pretty_assertions = "1.3.0"

 [workspace]
@@ -133,7 +134,6 @@ members = [
  "deltachat-repl",
  "deltachat-time",
  "format-flowed",
-  "deltachat-contact-tools",
 ]

 [[bench]]
@@ -164,12 +164,6 @@ harness = false
 name = "send_events"
 harness = false

-[workspace.dependencies]
-anyhow = "1"
-once_cell = "1.18.0"
-regex = "1.10"
-rusqlite = { version = "0.31" }
-
 [features]
 default = ["vendored"]
 internals = []
--- a/README.md
+++ b/README.md
@@ -6,9 +6,6 @@
  <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>
-  <a href="https://deps.rs/repo/github/deltachat/deltachat-core-rust">
-    <img alt="dependency status" src="https://deps.rs/repo/github/deltachat/deltachat-core-rust/status.svg">
-  </a>
 </p>

 <p align="center">
@@ -195,7 +192,6 @@ or its language bindings:
 - [Desktop](https://github.com/deltachat/deltachat-desktop)
 - [Pidgin](https://code.ur.gs/lupine/purple-plugin-delta/)
 - [Telepathy](https://code.ur.gs/lupine/telepathy-padfoot/)
- [Ubuntu Touch](https://codeberg.org/lk108/deltatouch)
 - several **Bots**

 [^1]: Out of date / unmaintained, if you like those languages feel free to start maintaining them. If you have questions we'll help you, please ask in the issues.
--- a/deltachat-contact-tools/Cargo.toml
+++ b/deltachat-contact-tools/Cargo.toml
@@ -1,18 +0,0 @@
-[package]
-name = "deltachat-contact-tools"
-version = "0.1.0"
-edition = "2021"
-description = "Contact-related tools, like parsing vcards and sanitizing name and address"
-license = "MPL-2.0"
-# TODO maybe it should be called "deltachat-text-utils" or similar?
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-anyhow = { workspace = true }
-once_cell = { workspace = true }
-regex = { workspace = true }
-rusqlite = { workspace = true } # Needed in order to `impl rusqlite::types::ToSql for EmailAddress`. Could easily be put behind a feature.
-
-[dev-dependencies]
-anyhow = { workspace = true, features = ["backtrace"] } # Enable `backtrace` feature in tests.
--- a/deltachat-contact-tools/src/lib.rs
+++ b/deltachat-contact-tools/src/lib.rs
@@ -1,280 +0,0 @@
-//! Contact-related tools, like parsing vcards and sanitizing name and address
-
-#![forbid(unsafe_code)]
-#![warn(
-    unused,
-    clippy::correctness,
-    missing_debug_implementations,
-    missing_docs,
-    clippy::all,
-    clippy::wildcard_imports,
-    clippy::needless_borrow,
-    clippy::cast_lossless,
-    clippy::unused_async,
-    clippy::explicit_iter_loop,
-    clippy::explicit_into_iter_loop,
-    clippy::cloned_instead_of_copied
-)]
-#![cfg_attr(not(test), warn(clippy::indexing_slicing))]
-#![allow(
-    clippy::match_bool,
-    clippy::mixed_read_write_in_expression,
-    clippy::bool_assert_comparison,
-    clippy::manual_split_once,
-    clippy::format_push_string,
-    clippy::bool_to_int_with_if
-)]
-
-use std::fmt;
-use std::ops::Deref;
-
-use anyhow::bail;
-use anyhow::Result;
-use once_cell::sync::Lazy;
-use regex::Regex;
-
-/// Valid contact address.
-#[derive(Debug, Clone)]
-pub struct ContactAddress(String);
-
-impl Deref for ContactAddress {
-    type Target = str;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl AsRef<str> for ContactAddress {
-    fn as_ref(&self) -> &str {
-        &self.0
-    }
-}
-
-impl fmt::Display for ContactAddress {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", self.0)
-    }
-}
-
-impl ContactAddress {
-    /// Constructs a new contact address from string,
-    /// normalizing and validating it.
-    pub fn new(s: &str) -> Result<Self> {
-        let addr = addr_normalize(s);
-        if !may_be_valid_addr(&addr) {
-            bail!("invalid address {:?}", s);
-        }
-        Ok(Self(addr.to_string()))
-    }
-}
-
-/// Allow converting [`ContactAddress`] to an SQLite type.
-impl rusqlite::types::ToSql for ContactAddress {
-    fn to_sql(&self) -> rusqlite::Result<rusqlite::types::ToSqlOutput> {
-        let val = rusqlite::types::Value::Text(self.0.to_string());
-        let out = rusqlite::types::ToSqlOutput::Owned(val);
-        Ok(out)
-    }
-}
-
-/// Make the name and address
-pub fn sanitize_name_and_addr(name: &str, addr: &str) -> (String, String) {
-    static ADDR_WITH_NAME_REGEX: Lazy<Regex> = Lazy::new(|| Regex::new("(.*)<(.*)>").unwrap());
-    if let Some(captures) = ADDR_WITH_NAME_REGEX.captures(addr.as_ref()) {
-        (
-            if name.is_empty() {
-                strip_rtlo_characters(
-                    &captures
-                        .get(1)
-                        .map_or("".to_string(), |m| normalize_name(m.as_str())),
-                )
-            } else {
-                strip_rtlo_characters(name)
-            },
-            captures
-                .get(2)
-                .map_or("".to_string(), |m| m.as_str().to_string()),
-        )
-    } else {
-        (strip_rtlo_characters(name), addr.to_string())
-    }
-}
-
-/// Normalize a name.
-///
-/// - Remove quotes (come from some bad MUA implementations)
-/// - Trims the resulting string
-///
-/// Typically, this function is not needed as it is called implicitly by `Contact::add_address_book`.
-pub fn normalize_name(full_name: &str) -> String {
-    let full_name = full_name.trim();
-    if full_name.is_empty() {
-        return full_name.into();
-    }
-
-    match full_name.as_bytes() {
-        [b'\'', .., b'\''] | [b'\"', .., b'\"'] | [b'<', .., b'>'] => full_name
-            .get(1..full_name.len() - 1)
-            .map_or("".to_string(), |s| s.trim().to_string()),
-        _ => full_name.to_string(),
-    }
-}
-
-const RTLO_CHARACTERS: [char; 5] = ['\u{202A}', '\u{202B}', '\u{202C}', '\u{202D}', '\u{202E}'];
-/// This method strips all occurrences of the RTLO Unicode character.
-/// [Why is this needed](https://github.com/deltachat/deltachat-core-rust/issues/3479)?
-pub fn strip_rtlo_characters(input_str: &str) -> String {
-    input_str.replace(|char| RTLO_CHARACTERS.contains(&char), "")
-}
-
-/// Returns false if addr is an invalid address, otherwise true.
-pub fn may_be_valid_addr(addr: &str) -> bool {
-    let res = EmailAddress::new(addr);
-    res.is_ok()
-}
-
-/// Returns address lowercased,
-/// with whitespace trimmed and `mailto:` prefix removed.
-pub fn addr_normalize(addr: &str) -> String {
-    let norm = addr.trim().to_lowercase();
-
-    if norm.starts_with("mailto:") {
-        norm.get(7..).unwrap_or(&norm).to_string()
-    } else {
-        norm
-    }
-}
-
-/// Compares two email addresses, normalizing them beforehand.
-pub fn addr_cmp(addr1: &str, addr2: &str) -> bool {
-    let norm1 = addr_normalize(addr1);
-    let norm2 = addr_normalize(addr2);
-
-    norm1 == norm2
-}
-
-///
-/// Represents an email address, right now just the `name@domain` portion.
-///
-/// # Example
-///
-/// ```
-/// use deltachat_contact_tools::EmailAddress;
-/// let email = match EmailAddress::new("someone@example.com") {
-///     Ok(addr) => addr,
-///     Err(e) => panic!("Error parsing address, error was {}", e),
-/// };
-/// assert_eq!(&email.local, "someone");
-/// assert_eq!(&email.domain, "example.com");
-/// assert_eq!(email.to_string(), "someone@example.com");
-/// ```
-#[derive(Debug, PartialEq, Eq, Clone)]
-pub struct EmailAddress {
-    /// Local part of the email address.
-    pub local: String,
-
-    /// Email address domain.
-    pub domain: String,
-}
-
-impl fmt::Display for EmailAddress {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}@{}", self.local, self.domain)
-    }
-}
-
-impl EmailAddress {
-    /// Performs a dead-simple parse of an email address.
-    pub fn new(input: &str) -> Result<EmailAddress> {
-        if input.is_empty() {
-            bail!("empty string is not valid");
-        }
-        let parts: Vec<&str> = input.rsplitn(2, '@').collect();
-
-        if input
-            .chars()
-            .any(|c| c.is_whitespace() || c == '<' || c == '>')
-        {
-            bail!("Email {:?} must not contain whitespaces, '>' or '<'", input);
-        }
-
-        match &parts[..] {
-            [domain, local] => {
-                if local.is_empty() {
-                    bail!("empty string is not valid for local part in {:?}", input);
-                }
-                if domain.is_empty() {
-                    bail!("missing domain after '@' in {:?}", input);
-                }
-                if domain.ends_with('.') {
-                    bail!("Domain {domain:?} should not contain the dot in the end");
-                }
-                Ok(EmailAddress {
-                    local: (*local).to_string(),
-                    domain: (*domain).to_string(),
-                })
-            }
-            _ => bail!("Email {:?} must contain '@' character", input),
-        }
-    }
-}
-
-impl rusqlite::types::ToSql for EmailAddress {
-    fn to_sql(&self) -> rusqlite::Result<rusqlite::types::ToSqlOutput> {
-        let val = rusqlite::types::Value::Text(self.to_string());
-        let out = rusqlite::types::ToSqlOutput::Owned(val);
-        Ok(out)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_contact_address() -> Result<()> {
-        let alice_addr = "alice@example.org";
-        let contact_address = ContactAddress::new(alice_addr)?;
-        assert_eq!(contact_address.as_ref(), alice_addr);
-
-        let invalid_addr = "<> foobar";
-        assert!(ContactAddress::new(invalid_addr).is_err());
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_emailaddress_parse() {
-        assert_eq!(EmailAddress::new("").is_ok(), false);
-        assert_eq!(
-            EmailAddress::new("user@domain.tld").unwrap(),
-            EmailAddress {
-                local: "user".into(),
-                domain: "domain.tld".into(),
-            }
-        );
-        assert_eq!(
-            EmailAddress::new("user@localhost").unwrap(),
-            EmailAddress {
-                local: "user".into(),
-                domain: "localhost".into()
-            }
-        );
-        assert_eq!(EmailAddress::new("uuu").is_ok(), false);
-        assert_eq!(EmailAddress::new("dd.tt").is_ok(), false);
-        assert!(EmailAddress::new("tt.dd@uu").is_ok());
-        assert!(EmailAddress::new("u@d").is_ok());
-        assert!(EmailAddress::new("u@d.").is_err());
-        assert!(EmailAddress::new("u@d.t").is_ok());
-        assert_eq!(
-            EmailAddress::new("u@d.tt").unwrap(),
-            EmailAddress {
-                local: "u".into(),
-                domain: "d.tt".into(),
-            }
-        );
-        assert!(EmailAddress::new("u@tt").is_ok());
-        assert_eq!(EmailAddress::new("@d.tt").is_ok(), false);
-    }
-}
--- a/deltachat-ffi/Cargo.toml
+++ b/deltachat-ffi/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "deltachat_ffi"
-version = "1.137.3"
+version = "1.137.2"
 description = "Deltachat FFI"
 edition = "2018"
 readme = "README.md"
@@ -20,7 +20,7 @@ libc = "0.2"
 human-panic = { version = "1", default-features = false }
 num-traits = "0.2"
 serde_json = "1.0"
-tokio = { version = "1.37.0", features = ["rt-multi-thread"] }
+tokio = { version = "1", features = ["rt-multi-thread"] }
 anyhow = "1"
 thiserror = "1"
 rand = "0.8"
--- a/deltachat-ffi/deltachat.h
+++ b/deltachat-ffi/deltachat.h
@@ -17,6 +17,7 @@ typedef struct _dc_array     dc_array_t;
 typedef struct _dc_chatlist  dc_chatlist_t;
 typedef struct _dc_chat      dc_chat_t;
 typedef struct _dc_msg       dc_msg_t;
+typedef struct _dc_reactions dc_reactions_t;
 typedef struct _dc_contact   dc_contact_t;
 typedef struct _dc_lot       dc_lot_t;
 typedef struct _dc_provider  dc_provider_t;
@@ -362,12 +363,8 @@ uint32_t        dc_get_id                    (dc_context_t* context);
 *     Must be freed using dc_event_emitter_unref() after usage.
 *
 * Note: Use only one event emitter per context.
- * The result of having multiple event emitters is unspecified.
- * Currently events are broadcasted to all existing event emitters,
- * but previous versions delivered events to only one event emitter
- * and this behavior may change again in the future.
- * Events emitted before creation of event emitter
- * may or may not be available to event emitter.
+ * Having more than one event emitter running at the same time on the same context
+ * will result in events being randomly delivered to one of the emitters.
 */
 dc_event_emitter_t* dc_get_event_emitter(dc_context_t* context);

@@ -1120,6 +1117,36 @@ uint32_t        dc_send_text_msg             (dc_context_t* context, uint32_t ch
 uint32_t dc_send_videochat_invitation (dc_context_t* context, uint32_t chat_id);


+/**
+ * Send a reaction to message.
+ *
+ * Reaction is a string of emojis separated by spaces. Reaction to a
+ * single message can be sent multiple times. The last reaction
+ * received overrides all previously received reactions. It is
+ * possible to remove all reactions by sending an empty string.
+ *
+ * @deprecated 2023-11-27, use jsonrpc method `send_reaction` instead
+ * @memberof dc_context_t
+ * @param context The context object.
+ * @param msg_id ID of the message you react to.
+ * @param reaction A string consisting of emojis separated by spaces.
+ * @return The ID of the message sent out or 0 for errors.
+ */
+uint32_t dc_send_reaction (dc_context_t* context, uint32_t msg_id, char *reaction);
+
+
+/**
+ * Get a structure with reactions to the message.
+ *
+ * @deprecated 2023-11-27, use jsonrpc method `get_message_reactions` instead
+ * @memberof dc_context_t
+ * @param context The context object.
+ * @param msg_id The message ID to get reactions for.
+ * @return A structure with all reactions to the message.
+ */
+dc_reactions_t* dc_get_msg_reactions (dc_context_t *context, int msg_id);
+
+
 /**
 * A webxdc instance sends a status update to its other members.
 *
@@ -1182,65 +1209,6 @@ int dc_send_webxdc_status_update (dc_context_t* context, uint32_t msg_id, const
 */
 char* dc_get_webxdc_status_updates (dc_context_t* context, uint32_t msg_id, uint32_t serial);

-
-/**
- * Set Webxdc file as integration.
- * see dc_init_webxdc_integration() for more details about Webxdc integrations.
- *
- * @warning This is an experimental API which may change in the future
- *
- * @memberof dc_context_t
- * @param context The context object.
- * @param file The .xdc file to use as Webxdc integration.
- */
-void             dc_set_webxdc_integration (dc_context_t* context, const char* file);
-
-
-/**
- * Init a Webxdc integration.
- *
- * A Webxdc integration is
- * a Webxdc showing a map, getting locations via setUpdateListener(), setting POIs via sendUpdate();
- * core takes eg. care of feeding locations to the Webxdc or sending the data out.
- *
- * @warning This is an experimental API, esp. support of integration types (eg. image editor, tools) is left out for simplicity
- *
- * Currently, Webxdc integrations are .xdc files shipped together with the main app.
- * Before dc_init_webxdc_integration() can be called,
- * UI has to call dc_set_webxdc_integration() to define a .xdc file to be used as integration.
- *
- * dc_init_webxdc_integration() returns a Webxdc message ID that
- * UI can open and use mostly as usual.
- *
- * Concrete behaviour and status updates depend on the integration, driven by UI needs.
- *
- * There is no need to de-initialize the integration,
- * however, unless documented otherwise,
- * the integration is valid only as long as not re-initialized
- * In other words, UI must not have a Webxdc with the same integration open twice.
- *
- * Example:
- *
- * ~~~
- * // Define a .xdc file to be used as maps integration
- * dc_set_webxdc_integration(context, path_to_maps_xdc);
- *
- * // Integrate the map to a chat, the map will show locations for this chat then:
- * uint32_t webxdc_instance = dc_init_webxdc_integration(context, any_chat_id);
- *
- * // Or use the Webxdc as a global map, showing locations of all chats:
- * uint32_t webxdc_instance = dc_init_webxdc_integration(context, 0);
- * ~~~
- *
- * @memberof dc_context_t
- * @param context The context object.
- * @param chat_id The chat to get the integration for.
- * @return ID of the message that refers to the Webxdc instance.
- *     UI can open a Webxdc as usual with this instance.
- */
-uint32_t        dc_init_webxdc_integration    (dc_context_t* context, uint32_t chat_id);
-
-
 /**
 * Save a draft for a chat in the database.
 *
@@ -2608,7 +2576,7 @@ dc_lot_t*       dc_check_qr                  (dc_context_t* context, const char*
 *     the Verified-Group-Invite protocol is offered in the QR code;
 *     works for protected groups as well as for normal groups.
 *     If set to 0, the Setup-Contact protocol is offered in the QR code.
- *     See https://securejoin.delta.chat/
+ *     See https://securejoin.readthedocs.io/en/latest/new.html
 *     for details about both protocols.
 * @return The text that should go to the QR code,
 *     On errors, an empty QR code is returned, NULL is never returned.
@@ -2644,7 +2612,8 @@ char*           dc_get_securejoin_qr_svg         (dc_context_t* context, uint32_
 *
 * Subsequent calls of dc_join_securejoin() will abort previous, unfinished handshakes.
 *
- * See https://securejoin.delta.chat/ for details about both protocols.
+ * See https://securejoin.readthedocs.io/en/latest/new.html
+ * for details about both protocols.
 *
 * @memberof dc_context_t
 * @param context The context object.
@@ -4169,6 +4138,7 @@ char*             dc_msg_get_webxdc_blob      (const dc_msg_t* msg, const char*
 *   true if the Webxdc should get full internet access, including Webrtc.
 *   currently, this is only true for encrypted Webxdc's in the self chat
 *   that have requested internet access in the manifest.
+ *   this is useful for development and maybe for internal integrations at some point.
 *
 * @memberof dc_msg_t
 * @param msg The webxdc instance.
@@ -5350,6 +5320,52 @@ uint32_t        dc_lot_get_id            (const dc_lot_t* lot);
 int64_t         dc_lot_get_timestamp     (const dc_lot_t* lot);


+/**
+ * @class dc_reactions_t
+ * @deprecated 2023-11-27, use jsonrpc method `get_message_reactions` instead
+ *
+ * An object representing all reactions for a single message.
+ */
+
+/**
+ * Returns array of contacts which reacted to the given message.
+ *
+ * @deprecated 2023-11-27, use jsonrpc method `get_message_reactions` instead
+ * @memberof dc_reactions_t
+ * @param reactions The object containing message reactions.
+ * @return array of contact IDs. Use dc_array_get_cnt() to get array length and
+ *         dc_array_get_id() to get the IDs. Should be freed using `dc_array_unref()` after usage.
+ */
+dc_array_t*     dc_reactions_get_contacts(dc_reactions_t* reactions);
+
+
+/**
+ * Returns a string containing space-separated reactions of a single contact.
+ *
+ * @deprecated 2023-11-27, use jsonrpc method `get_message_reactions` instead
+ * @memberof dc_reactions_t
+ * @param reactions The object containing message reactions.
+ * @param contact_id ID of the contact.
+ * @return Space-separated list of emoji sequences, which could be empty.
+ *         Returned string should not be modified and should be freed
+ *         with dc_str_unref() after usage.
+ */
+char*           dc_reactions_get_by_contact_id(dc_reactions_t* reactions, uint32_t contact_id);
+
+
+/**
+ * Frees an object containing message reactions.
+ *
+ * Reactions objects are created by dc_get_msg_reactions().
+ *
+ * @deprecated 2023-11-27
+ * @memberof dc_reactions_t
+ * @param reactions The object to free.
+ *     If NULL is given, nothing is done.
+ */
+void            dc_reactions_unref       (dc_reactions_t* reactions);
+
+
 /**
 * @defgroup DC_MSG DC_MSG
 *
@@ -6274,24 +6290,7 @@ void dc_event_unref(dc_event_t* event);
 * This event is only emitted by the account manager
 */

-#define DC_EVENT_ACCOUNTS_BACKGROUND_FETCH_DONE   2200
-
-/**
- * Inform that set of chats or the order of the chats in the chatlist has changed.
- *
- * Sometimes this is emitted together with `DC_EVENT_CHATLIST_ITEM_CHANGED`.
- */
-
-#define DC_EVENT_CHATLIST_CHANGED              2300
-
-/**
- * Inform that all or a single chat list item changed and needs to be rerendered
- * If `chat_id` is set to 0, then all currently visible chats need to be rerendered, and all not-visible items need to be cleared from cache if the UI has a cache.
- * 
- * @param data1 (int) chat_id chat id of chatlist item to be rerendered, if chat_id = 0 all (cached & visible) items need to be rerendered
- */
-
-#define DC_EVENT_CHATLIST_ITEM_CHANGED         2301
+#define DC_EVENT_ACCOUNTS_BACKGROUND_FETCH_DONE  2200

 /**
 * @}
--- a/deltachat-ffi/src/lib.rs
+++ b/deltachat-ffi/src/lib.rs
@@ -3,6 +3,8 @@
    non_camel_case_types,
    non_snake_case,
    non_upper_case_globals,
+    non_upper_case_globals,
+    non_camel_case_types,
    clippy::missing_safety_doc,
    clippy::expect_fun_call
 )]
@@ -30,6 +32,7 @@ use deltachat::imex::BackupProvider;
 use deltachat::key::preconfigure_keypair;
 use deltachat::message::MsgId;
 use deltachat::qr_code_generator::{generate_backup_qr, get_securejoin_qr_svg};
+use deltachat::reaction::{get_msg_reactions, send_reaction, Reactions};
 use deltachat::stock_str::StockMessage;
 use deltachat::webxdc::StatusUpdateSerial;
 use deltachat::*;
@@ -65,6 +68,8 @@ const DC_GCM_INFO_ONLY: u32 = 0x02;
 /// Struct representing the deltachat context.
 pub type dc_context_t = Context;

+pub type dc_reactions_t = Reactions;
+
 static RT: Lazy<Runtime> = Lazy::new(|| Runtime::new().expect("unable to create tokio runtime"));

 fn block_on<T>(fut: T) -> T::Output
@@ -562,8 +567,6 @@ pub unsafe extern "C" fn dc_event_get_id(event: *mut dc_event_t) -> libc::c_int
        EventType::WebxdcStatusUpdate { .. } => 2120,
        EventType::WebxdcInstanceDeleted { .. } => 2121,
        EventType::AccountsBackgroundFetchDone => 2200,
-        EventType::ChatlistChanged => 2300,
-        EventType::ChatlistItemChanged { .. } => 2301,
    }
 }

@@ -593,7 +596,6 @@ pub unsafe extern "C" fn dc_event_get_data1_int(event: *mut dc_event_t) -> libc:
        | EventType::IncomingMsgBunch { .. }
        | EventType::ErrorSelfNotInGroup(_)
        | EventType::AccountsBackgroundFetchDone => 0,
-        EventType::ChatlistChanged => 0,
        EventType::MsgsChanged { chat_id, .. }
        | EventType::ReactionsChanged { chat_id, .. }
        | EventType::IncomingMsg { chat_id, .. }
@@ -618,9 +620,6 @@ pub unsafe extern "C" fn dc_event_get_data1_int(event: *mut dc_event_t) -> libc:
        }
        EventType::WebxdcStatusUpdate { msg_id, .. } => msg_id.to_u32() as libc::c_int,
        EventType::WebxdcInstanceDeleted { msg_id, .. } => msg_id.to_u32() as libc::c_int,
-        EventType::ChatlistItemChanged { chat_id } => {
-            chat_id.unwrap_or_default().to_u32() as libc::c_int
-        }
    }
 }

@@ -657,8 +656,6 @@ pub unsafe extern "C" fn dc_event_get_data2_int(event: *mut dc_event_t) -> libc:
        | EventType::IncomingMsgBunch { .. }
        | EventType::SelfavatarChanged
        | EventType::AccountsBackgroundFetchDone
-        | EventType::ChatlistChanged
-        | EventType::ChatlistItemChanged { .. }
        | EventType::ConfigSynced { .. } => 0,
        EventType::ChatModified(_) => 0,
        EventType::MsgsChanged { msg_id, .. }
@@ -723,9 +720,7 @@ pub unsafe extern "C" fn dc_event_get_data2_str(event: *mut dc_event_t) -> *mut
        | EventType::WebxdcInstanceDeleted { .. }
        | EventType::AccountsBackgroundFetchDone
        | EventType::ChatEphemeralTimerModified { .. }
-        | EventType::IncomingMsgBunch { .. }
-        | EventType::ChatlistItemChanged { .. }
-        | EventType::ChatlistChanged => ptr::null_mut(),
+        | EventType::IncomingMsgBunch { .. } => ptr::null_mut(),
        EventType::ConfigureProgress { comment, .. } => {
            if let Some(comment) = comment {
                comment.to_c_string().unwrap_or_default().into_raw()
@@ -1020,6 +1015,49 @@ pub unsafe extern "C" fn dc_send_videochat_invitation(
    })
 }

+#[no_mangle]
+pub unsafe extern "C" fn dc_send_reaction(
+    context: *mut dc_context_t,
+    msg_id: u32,
+    reaction: *const libc::c_char,
+) -> u32 {
+    if context.is_null() {
+        eprintln!("ignoring careless call to dc_send_reaction()");
+        return 0;
+    }
+    let ctx = &*context;
+
+    block_on(async move {
+        send_reaction(ctx, MsgId::new(msg_id), &to_string_lossy(reaction))
+            .await
+            .map(|msg_id| msg_id.to_u32())
+            .unwrap_or_log_default(ctx, "Failed to send reaction")
+    })
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn dc_get_msg_reactions(
+    context: *mut dc_context_t,
+    msg_id: u32,
+) -> *mut dc_reactions_t {
+    if context.is_null() {
+        eprintln!("ignoring careless call to dc_get_msg_reactions()");
+        return ptr::null_mut();
+    }
+    let ctx = &*context;
+
+    let reactions = if let Ok(reactions) = block_on(get_msg_reactions(ctx, MsgId::new(msg_id)))
+        .context("failed dc_get_msg_reactions() call")
+        .log_err(ctx)
+    {
+        reactions
+    } else {
+        return ptr::null_mut();
+    };
+
+    Box::into_raw(Box::new(reactions))
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn dc_send_webxdc_status_update(
    context: *mut dc_context_t,
@@ -1063,43 +1101,6 @@ pub unsafe extern "C" fn dc_get_webxdc_status_updates(
    .strdup()
 }

-#[no_mangle]
-pub unsafe extern "C" fn dc_set_webxdc_integration(
-    context: *mut dc_context_t,
-    file: *const libc::c_char,
-) {
-    if context.is_null() || file.is_null() {
-        eprintln!("ignoring careless call to dc_set_webxdc_integration()");
-        return;
-    }
-    let ctx = &*context;
-    block_on(ctx.set_webxdc_integration(&to_string_lossy(file)))
-        .log_err(ctx)
-        .unwrap_or_default();
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn dc_init_webxdc_integration(
-    context: *mut dc_context_t,
-    chat_id: u32,
-) -> u32 {
-    if context.is_null() {
-        eprintln!("ignoring careless call to dc_init_webxdc_integration()");
-        return 0;
-    }
-    let ctx = &*context;
-    let chat_id = if chat_id == 0 {
-        None
-    } else {
-        Some(ChatId::new(chat_id))
-    };
-
-    block_on(ctx.init_webxdc_integration(chat_id))
-        .log_err(ctx)
-        .map(|msg_id| msg_id.map(|id| id.to_u32()).unwrap_or_default())
-        .unwrap_or(0)
-}
-
 #[no_mangle]
 pub unsafe extern "C" fn dc_set_draft(
    context: *mut dc_context_t,
@@ -2045,7 +2046,7 @@ pub unsafe extern "C" fn dc_get_msg(context: *mut dc_context_t, msg_id: u32) ->
                    );
                    message::Message::default()
                } else {
-                    warn!(ctx, "dc_get_msg could not retrieve msg_id {msg_id}: {e:#}");
+                    error!(ctx, "dc_get_msg could not retrieve msg_id {msg_id}: {e:#}");
                    return ptr::null_mut();
                }
            }
@@ -4243,6 +4244,45 @@ pub unsafe extern "C" fn dc_lot_get_timestamp(lot: *mut dc_lot_t) -> i64 {
    lot.get_timestamp()
 }

+#[no_mangle]
+pub unsafe extern "C" fn dc_reactions_get_contacts(
+    reactions: *mut dc_reactions_t,
+) -> *mut dc_array::dc_array_t {
+    if reactions.is_null() {
+        eprintln!("ignoring careless call to dc_reactions_get_contacts()");
+        return ptr::null_mut();
+    }
+
+    let reactions = &*reactions;
+    let array: dc_array_t = reactions.contacts().into();
+
+    Box::into_raw(Box::new(array))
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn dc_reactions_get_by_contact_id(
+    reactions: *mut dc_reactions_t,
+    contact_id: u32,
+) -> *mut libc::c_char {
+    if reactions.is_null() {
+        eprintln!("ignoring careless call to dc_reactions_get_by_contact_id()");
+        return ptr::null_mut();
+    }
+
+    let reactions = &*reactions;
+    reactions.get(ContactId::new(contact_id)).as_str().strdup()
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn dc_reactions_unref(reactions: *mut dc_reactions_t) {
+    if reactions.is_null() {
+        eprintln!("ignoring careless call to dc_reactions_unref()");
+        return;
+    }
+
+    drop(Box::from_raw(reactions));
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn dc_str_unref(s: *mut libc::c_char) {
    libc::free(s as *mut _)
@@ -4443,6 +4483,19 @@ where
    }
 }

+trait ResultNullableExt<T> {
+    fn into_raw(self) -> *mut T;
+}
+
+impl<T, E> ResultNullableExt<T> for Result<T, E> {
+    fn into_raw(self) -> *mut T {
+        match self {
+            Ok(t) => Box::into_raw(Box::new(t)),
+            Err(_) => ptr::null_mut(),
+        }
+    }
+}
+
 fn convert_and_prune_message_ids(msg_ids: *const u32, msg_cnt: libc::c_int) -> Vec<MsgId> {
    let ids = unsafe { std::slice::from_raw_parts(msg_ids, msg_cnt as usize) };
    let msg_ids: Vec<MsgId> = ids
@@ -4922,9 +4975,7 @@ mod jsonrpc {
        }

        let account_manager = &*account_manager;
-        let cmd_api = block_on(deltachat_jsonrpc::api::CommandApi::from_arc(
-            account_manager.inner.clone(),
-        ));
+        let cmd_api = deltachat_jsonrpc::api::CommandApi::from_arc(account_manager.inner.clone());

        let (request_handle, receiver) = RpcClient::new();
        let handle = RpcSession::new(request_handle, cmd_api);
--- a/deltachat-jsonrpc/Cargo.toml
+++ b/deltachat-jsonrpc/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "deltachat-jsonrpc"
-version = "1.137.3"
+version = "1.137.2"
 description = "DeltaChat JSON-RPC API"
 edition = "2021"
 default-run = "deltachat-jsonrpc-server"
@@ -28,11 +28,11 @@ typescript-type-def = { version = "0.5.8", features = ["json_value"] }
 tokio = { version = "1.37.0" }
 sanitize-filename = "0.5"
 walkdir = "2.5.0"
-base64 = "0.22"
+base64 = "0.21"

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

 [dev-dependencies]
 tokio = { version = "1.37.0", features = ["full", "rt-multi-thread"] }
--- a/deltachat-jsonrpc/src/api.rs
+++ b/deltachat-jsonrpc/src/api.rs
@@ -1,6 +1,5 @@
 use std::collections::BTreeMap;
 use std::sync::Arc;
-use std::time::Duration;
 use std::{collections::HashMap, str::FromStr};

 use anyhow::{anyhow, bail, ensure, Context, Result};
@@ -29,7 +28,6 @@ use deltachat::reaction::{get_msg_reactions, send_reaction};
 use deltachat::securejoin;
 use deltachat::stock_str::StockMessage;
 use deltachat::webxdc::StatusUpdateSerial;
-use deltachat::EventEmitter;
 use sanitize_filename::is_sanitized;
 use tokio::fs;
 use tokio::sync::{watch, Mutex, RwLock};
@@ -64,14 +62,14 @@ use crate::api::types::qr::QrObject;
 struct AccountState {
    /// The Qr code for current [`CommandApi::provide_backup`] call.
    ///
-    /// If there is currently is a call to [`CommandApi::provide_backup`] this will be
-    /// `Some`, otherwise `None`.
-    backup_provider_qr: watch::Sender<Option<Qr>>,
+    /// If there currently is a call to [`CommandApi::provide_backup`] this will be
+    /// `Pending` or `Ready`, otherwise `NoProvider`.
+    backup_provider_qr: watch::Sender<ProviderQr>,
 }

 impl Default for AccountState {
    fn default() -> Self {
-        let tx = watch::Sender::new(None);
+        let (tx, _rx) = watch::channel(ProviderQr::NoProvider);
        Self {
            backup_provider_qr: tx,
        }
@@ -82,30 +80,21 @@ impl Default for AccountState {
 pub struct CommandApi {
    pub(crate) accounts: Arc<RwLock<Accounts>>,

-    /// Receiver side of the event channel.
-    ///
-    /// Events from it can be received by calling `get_next_event` method.
-    event_emitter: Arc<EventEmitter>,
-
    states: Arc<Mutex<BTreeMap<u32, AccountState>>>,
 }

 impl CommandApi {
    pub fn new(accounts: Accounts) -> Self {
-        let event_emitter = Arc::new(accounts.get_event_emitter());
        CommandApi {
            accounts: Arc::new(RwLock::new(accounts)),
-            event_emitter,
            states: Arc::new(Mutex::new(BTreeMap::new())),
        }
    }

    #[allow(dead_code)]
-    pub async fn from_arc(accounts: Arc<RwLock<Accounts>>) -> Self {
-        let event_emitter = Arc::new(accounts.read().await.get_event_emitter());
+    pub fn from_arc(accounts: Arc<RwLock<Accounts>>) -> Self {
        CommandApi {
            accounts,
-            event_emitter,
            states: Arc::new(Mutex::new(BTreeMap::new())),
        }
    }
@@ -134,13 +123,21 @@ impl CommandApi {
            .with_state(account_id, |state| state.backup_provider_qr.subscribe())
            .await;

-        loop {
-            if let Some(qr) = receiver.borrow_and_update().clone() {
-                return Ok(qr);
-            }
-            if receiver.changed().await.is_err() {
-                bail!("No backup being provided (account state dropped)");
-            }
+        let val: ProviderQr = receiver.borrow_and_update().clone();
+        match val {
+            ProviderQr::NoProvider => bail!("No backup being provided"),
+            ProviderQr::Pending => loop {
+                if receiver.changed().await.is_err() {
+                    bail!("No backup being provided (account state dropped)");
+                }
+                let val: ProviderQr = receiver.borrow().clone();
+                match val {
+                    ProviderQr::NoProvider => bail!("No backup being provided"),
+                    ProviderQr::Pending => continue,
+                    ProviderQr::Ready(qr) => break Ok(qr),
+                };
+            },
+            ProviderQr::Ready(qr) => Ok(qr),
        }
    }
 }
@@ -168,7 +165,8 @@ impl CommandApi {

    /// Get the next event.
    async fn get_next_event(&self) -> Result<Event> {
-        self.event_emitter
+        let event_emitter = self.accounts.read().await.get_event_emitter();
+        event_emitter
            .recv()
            .await
            .map(|event| event.into())
@@ -699,7 +697,8 @@ impl CommandApi {
    ///     the Verified-Group-Invite protocol is offered in the QR code;
    ///     works for protected groups as well as for normal groups.
    ///     If not set, the Setup-Contact protocol is offered in the QR code.
-    ///     See https://securejoin.delta.chat/ for details about both protocols.
+    ///     See https://securejoin.readthedocs.io/en/latest/new.html
+    ///     for details about both protocols.
    ///
    /// return format: `[code, svg]`
    async fn get_chat_securejoin_qr_code_svg(
@@ -727,7 +726,8 @@ impl CommandApi {
    ///
    /// Subsequent calls of `secure_join()` will abort previous, unfinished handshakes.
    ///
-    /// See https://securejoin.delta.chat/ for details about both protocols.
+    /// See https://securejoin.readthedocs.io/en/latest/new.html
+    /// for details about both protocols.
    ///
    /// **qr**: The text of the scanned QR code. Typically, the same string as given
    ///     to `check_qr()`.
@@ -1569,21 +1569,20 @@ impl CommandApi {
    /// Returns once a remote device has retrieved the backup, or is cancelled.
    async fn provide_backup(&self, account_id: u32) -> Result<()> {
        let ctx = self.get_context(account_id).await?;
+        self.with_state(account_id, |state| {
+            state.backup_provider_qr.send_replace(ProviderQr::Pending);
+        })
+        .await;

        let provider = imex::BackupProvider::prepare(&ctx).await?;
        self.with_state(account_id, |state| {
-            state.backup_provider_qr.send_replace(Some(provider.qr()));
+            state
+                .backup_provider_qr
+                .send_replace(ProviderQr::Ready(provider.qr()));
        })
        .await;

-        let res = provider.await;
-
-        self.with_state(account_id, |state| {
-            state.backup_provider_qr.send_replace(None);
-        })
-        .await;
-
-        res
+        provider.await
    }

    /// Returns the text of the QR code for the running [`CommandApi::provide_backup`].
@@ -1591,17 +1590,11 @@ impl CommandApi {
    /// This QR code text can be used in [`CommandApi::get_backup`] on a second device to
    /// retrieve the backup and setup this second device.
    ///
-    /// This call will block until the QR code is ready,
-    /// even if there is no concurrent call to [`CommandApi::provide_backup`],
-    /// but will fail after 10 seconds to avoid deadlocks.
+    /// This call will fail if there is currently no concurrent call to
+    /// [`CommandApi::provide_backup`].  This call may block if the QR code is not yet
+    /// ready.
    async fn get_backup_qr(&self, account_id: u32) -> Result<String> {
-        let qr = tokio::time::timeout(
-            Duration::from_secs(10),
-            self.inner_get_backup_qr(account_id),
-        )
-        .await
-        .context("Backup provider did not start in time")?
-        .context("Failed to get backup QR code")?;
+        let qr = self.inner_get_backup_qr(account_id).await?;
        qr::format_backup(&qr)
    }

@@ -1610,20 +1603,14 @@ impl CommandApi {
    /// This QR code can be used in [`CommandApi::get_backup`] on a second device to
    /// retrieve the backup and setup this second device.
    ///
-    /// This call will block until the QR code is ready,
-    /// even if there is no concurrent call to [`CommandApi::provide_backup`],
-    /// but will fail after 10 seconds to avoid deadlocks.
+    /// This call will fail if there is currently no concurrent call to
+    /// [`CommandApi::provide_backup`].  This call may block if the QR code is not yet
+    /// ready.
    ///
    /// Returns the QR code rendered as an SVG image.
    async fn get_backup_qr_svg(&self, account_id: u32) -> Result<String> {
        let ctx = self.get_context(account_id).await?;
-        let qr = tokio::time::timeout(
-            Duration::from_secs(10),
-            self.inner_get_backup_qr(account_id),
-        )
-        .await
-        .context("Backup provider did not start in time")?
-        .context("Failed to get backup QR code")?;
+        let qr = self.inner_get_backup_qr(account_id).await?;
        generate_backup_qr(&ctx, &qr).await
    }

@@ -1633,9 +1620,6 @@ impl CommandApi {
    /// the current device.
    ///
    /// Can be cancelled by stopping the ongoing process.
-    ///
-    /// Do not forget to call start_io on the account after a successful import,
-    /// otherwise it will not connect to the email server.
    async fn get_backup(&self, account_id: u32, qr_text: String) -> Result<()> {
        let ctx = self.get_context(account_id).await?;
        let qr = qr::check_qr(&ctx, &qr_text).await?;
@@ -2157,3 +2141,15 @@ async fn get_config(
            .await
    }
 }
+
+/// Whether a QR code for a BackupProvider is currently available.
+#[allow(clippy::large_enum_variant)]
+#[derive(Clone, Debug)]
+enum ProviderQr {
+    /// There is no provider, asking for a QR is an error.
+    NoProvider,
+    /// There is a provider, the QR code is pending.
+    Pending,
+    /// There is a provider and QR code.
+    Ready(Qr),
+}
--- a/deltachat-jsonrpc/src/api/types/events.rs
+++ b/deltachat-jsonrpc/src/api/types/events.rs
@@ -250,15 +250,6 @@ pub enum EventType {
    ///
    /// This event is only emitted by the account manager
    AccountsBackgroundFetchDone,
-    /// Inform that set of chats or the order of the chats in the chatlist has changed.
-    ///
-    /// Sometimes this is emitted together with `UIChatlistItemChanged`.
-    ChatlistChanged,
-
-    /// Inform that a single chat list item changed and needs to be rerendered.
-    /// If `chat_id` is set to None, then all currently visible chats need to be rerendered, and all not-visible items need to be cleared from cache if the UI has a cache.
-    #[serde(rename_all = "camelCase")]
-    ChatlistItemChanged { chat_id: Option<u32> },
 }

 impl From<CoreEventType> for EventType {
@@ -366,10 +357,6 @@ impl From<CoreEventType> for EventType {
                msg_id: msg_id.to_u32(),
            },
            CoreEventType::AccountsBackgroundFetchDone => AccountsBackgroundFetchDone,
-            CoreEventType::ChatlistItemChanged { chat_id } => ChatlistItemChanged {
-                chat_id: chat_id.map(|id| id.to_u32()),
-            },
-            CoreEventType::ChatlistChanged => ChatlistChanged,
        }
    }
 }
--- a/deltachat-jsonrpc/typescript/package.json
+++ b/deltachat-jsonrpc/typescript/package.json
@@ -53,5 +53,5 @@
  },
  "type": "module",
  "types": "dist/deltachat.d.ts",
-  "version": "1.137.3"
+  "version": "1.137.2"
 }
--- a/deltachat-repl/Cargo.toml
+++ b/deltachat-repl/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "deltachat-repl"
-version = "1.137.3"
+version = "1.137.2"
 license = "MPL-2.0"
 edition = "2021"
 repository = "https://github.com/deltachat/deltachat-core-rust"
@@ -14,7 +14,7 @@ log = "0.4.21"
 pretty_env_logger = "0.5"
 rusqlite = "0.31"
 rustyline = "14"
-tokio = { version = "1.37.0", features = ["fs", "rt-multi-thread", "macros"] }
+tokio = { version = "1", features = ["fs", "rt-multi-thread", "macros"] }

 [features]
 default = ["vendored"]
--- a/deltachat-repl/src/cmdline.rs
+++ b/deltachat-repl/src/cmdline.rs
@@ -339,6 +339,8 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                 export-keys\n\
                 import-keys\n\
                 export-setup\n\
+                 dump <filename>\n\n
+                 read <filename>\n\n
                 poke [<eml-file>|<folder>|<addr> <key-file>]\n\
                 reset <flags>\n\
                 stop\n\
@@ -514,6 +516,14 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                &setup_code,
            );
        }
+        "dump" => {
+            ensure!(!arg1.is_empty(), "Argument <filename> missing.");
+            serialize_database(&context, arg1).await?;
+        }
+        "read" => {
+            ensure!(!arg1.is_empty(), "Argument <filename> missing.");
+            deserialize_database(&context, arg1).await?;
+        }
        "poke" => {
            ensure!(poke_spec(&context, Some(arg1)).await, "Poke failed");
        }
--- a/deltachat-rpc-client/pyproject.toml
+++ b/deltachat-rpc-client/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"

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

 [tool.setuptools.package-data]
 deltachat_rpc_client = [
--- a/deltachat-rpc-client/src/deltachat_rpc_client/_utils.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/_utils.py
@@ -104,11 +104,7 @@ def _run_cli(
        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"
-            configure_thread = Thread(
-                target=client.configure,
-                daemon=True,
-                kwargs={"email": args.email, "password": args.password},
-            )
+            configure_thread = Thread(run=client.configure, kwargs={"email": args.email, "password": args.password})
            configure_thread.start()
        client.run_forever()

--- a/deltachat-rpc-client/src/deltachat_rpc_client/account.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/account.py
@@ -1,7 +1,5 @@
-from __future__ import annotations
-
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Optional, Union
+from typing import TYPE_CHECKING, List, Optional, Tuple, Union
 from warnings import warn

 from ._utils import AttrDict, futuremethod
@@ -30,10 +28,6 @@ class Account:
        """Wait until the next event and return it."""
        return AttrDict(self._rpc.wait_for_event(self.id))

-    def clear_all_events(self):
-        """Removes all queued-up events for a given account. Useful for tests."""
-        self._rpc.clear_all_events(self.id)
-
    def remove(self) -> None:
        """Remove the account."""
        self._rpc.remove_account(self.id)
@@ -93,14 +87,6 @@ class Account:
        """Configure an account."""
        yield self._rpc.configure.future(self.id)

-    def bring_online(self):
-        """Start I/O and wait until IMAP becomes IDLE."""
-        self.start_io()
-        while True:
-            event = self.wait_for_event()
-            if event.kind == EventType.IMAP_INBOX_IDLE:
-                break
-
    def create_contact(self, obj: Union[int, str, Contact], name: Optional[str] = None) -> Contact:
        """Create a new Contact or return an existing one.

@@ -118,11 +104,6 @@ class Account:
            obj = obj.get_snapshot().address
        return Contact(self, self._rpc.create_contact(self.id, obj, name))

-    def create_chat(self, account: "Account") -> Chat:
-        addr = account.get_config("addr")
-        contact = self.create_contact(addr)
-        return contact.create_chat()
-
    def get_contact_by_id(self, contact_id: int) -> Contact:
        """Return Contact instance for the given contact ID."""
        return Contact(self, contact_id)
@@ -132,7 +113,7 @@ class Account:
        contact_id = self._rpc.lookup_contact_id_by_addr(self.id, address)
        return contact_id and Contact(self, contact_id)

-    def get_blocked_contacts(self) -> list[AttrDict]:
+    def get_blocked_contacts(self) -> List[AttrDict]:
        """Return a list with snapshots of all blocked contacts."""
        contacts = self._rpc.get_blocked_contacts(self.id)
        return [AttrDict(contact=Contact(self, contact["id"]), **contact) for contact in contacts]
@@ -157,7 +138,7 @@ class Account:
        with_self: bool = False,
        verified_only: bool = False,
        snapshot: bool = False,
-    ) -> Union[list[Contact], list[AttrDict]]:
+    ) -> Union[List[Contact], List[AttrDict]]:
        """Get a filtered list of contacts.

        :param query: if a string is specified, only return contacts
@@ -192,7 +173,7 @@ class Account:
        no_specials: bool = False,
        alldone_hint: bool = False,
        snapshot: bool = False,
-    ) -> Union[list[Chat], list[AttrDict]]:
+    ) -> Union[List[Chat], List[AttrDict]]:
        """Return list of chats.

        :param query: if a string is specified only chats matching this query are returned.
@@ -244,13 +225,13 @@ class Account:
        The function returns immediately and the handshake runs in background, sending
        and receiving several messages.
        Subsequent calls of `secure_join()` will abort previous, unfinished handshakes.
-        See https://securejoin.delta.chat/ for protocol details.
+        See https://securejoin.readthedocs.io/en/latest/new.html for protocol details.

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

-    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
@@ -262,15 +243,15 @@ class Account:
        """Return the Message instance with the given ID."""
        return Message(self, msg_id)

-    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."""
        self._rpc.markseen_msgs(self.id, [msg.id for msg in messages])

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

-    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.
@@ -280,12 +261,12 @@ class Account:
        fresh_msg_ids = self._rpc.get_fresh_msgs(self.id)
        return [Message(self, msg_id) for msg_id in fresh_msg_ids]

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

-    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 = self._rpc.wait_next_msgs(self.id)
        return [Message(self, msg_id) for msg_id in next_msg_ids]
@@ -309,13 +290,7 @@ class Account:
            if event["kind"] == "SecurejoinJoinerProgress" and event["progress"] == 1000:
                break

-    def wait_for_reactions_changed(self):
-        while True:
-            event = self.wait_for_event()
-            if event.kind == EventType.REACTIONS_CHANGED:
-                return event
-
-    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.",
--- a/deltachat-rpc-client/src/deltachat_rpc_client/chat.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/chat.py
@@ -1,8 +1,6 @@
-from __future__ import annotations
-
 import calendar
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Optional, Union
+from typing import TYPE_CHECKING, Dict, List, Optional, Tuple, Union

 from ._utils import AttrDict
 from .const import ChatVisibility, ViewType
@@ -95,7 +93,7 @@ class Chat:
        """Return encryption info for this chat."""
        return self._rpc.get_chat_encryption_info(self.account.id, self.id)

-    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 self._rpc.get_chat_securejoin_qr_code_svg(self.account.id, self.id)

@@ -119,7 +117,7 @@ class Chat:
        html: Optional[str] = None,
        viewtype: Optional[ViewType] = None,
        file: Optional[str] = None,
-        location: Optional[tuple[float, float]] = None,
+        location: Optional[Tuple[float, float]] = None,
        override_sender_name: Optional[str] = None,
        quoted_msg: Optional[Union[int, Message]] = None,
    ) -> Message:
@@ -144,10 +142,6 @@ class Chat:
        msg_id = self._rpc.misc_send_text_message(self.account.id, self.id, text)
        return Message(self.account, msg_id)

-    def send_file(self, path):
-        """Send a file and return the resulting Message instance."""
-        return self.send_message(file=path)
-
    def send_videochat_invitation(self) -> Message:
        """Send a videochat invitation and return the resulting Message instance."""
        msg_id = self._rpc.send_videochat_invitation(self.account.id, self.id)
@@ -158,7 +152,7 @@ class Chat:
        msg_id = self._rpc.send_sticker(self.account.id, self.id, path)
        return Message(self.account, msg_id)

-    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]
        self._rpc.forward_messages(self.account.id, msg_ids, self.id)
@@ -190,7 +184,7 @@ class Chat:
        snapshot["message"] = Message(self.account, snapshot.id)
        return snapshot

-    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 = 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]
@@ -225,7 +219,7 @@ class Chat:
                contact_id = cnt
            self._rpc.remove_contact_from_chat(self.account.id, self.id, contact_id)

-    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.
@@ -249,7 +243,7 @@ class Chat:
        contact: Optional[Contact] = None,
        timestamp_from: Optional["datetime"] = None,
        timestamp_to: Optional["datetime"] = None,
-    ) -> list[AttrDict]:
+    ) -> List[AttrDict]:
        """Get list of location snapshots for the given contact in the given timespan."""
        time_from = calendar.timegm(timestamp_from.utctimetuple()) if timestamp_from else 0
        time_to = calendar.timegm(timestamp_to.utctimetuple()) if timestamp_to else 0
@@ -257,7 +251,7 @@ class Chat:

        result = self._rpc.get_locations(self.account.id, self.id, contact_id, time_from, time_to)
        locations = []
-        contacts: dict[int, Contact] = {}
+        contacts: Dict[int, Contact] = {}
        for loc in result:
            location = AttrDict(loc)
            location["chat"] = self
--- a/deltachat-rpc-client/src/deltachat_rpc_client/client.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/client.py
@@ -1,13 +1,14 @@
 """Event loop implementations offering high level event handling/hooking."""

-from __future__ import annotations
-
 import logging
 from typing import (
    TYPE_CHECKING,
    Callable,
+    Dict,
    Iterable,
    Optional,
+    Set,
+    Tuple,
    Type,
    Union,
 )
@@ -38,16 +39,16 @@ class Client:
    def __init__(
        self,
        account: "Account",
-        hooks: Optional[Iterable[tuple[Callable, Union[type, EventFilter]]]] = None,
+        hooks: Optional[Iterable[Tuple[Callable, Union[type, EventFilter]]]] = None,
        logger: Optional[logging.Logger] = None,
    ) -> None:
        self.account = account
        self.logger = logger or logging
-        self._hooks: dict[type, set[tuple]] = {}
+        self._hooks: Dict[type, Set[tuple]] = {}
        self._should_process_messages = 0
        self.add_hooks(hooks or [])

-    def add_hooks(self, hooks: Iterable[tuple[Callable, Union[type, EventFilter]]]) -> None:
+    def add_hooks(self, hooks: Iterable[Tuple[Callable, Union[type, EventFilter]]]) -> None:
        for hook, event in hooks:
            self.add_hook(hook, event)

--- a/deltachat-rpc-client/src/deltachat_rpc_client/const.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/const.py
@@ -59,8 +59,6 @@ class EventType(str, Enum):
    SELFAVATAR_CHANGED = "SelfavatarChanged"
    WEBXDC_STATUS_UPDATE = "WebxdcStatusUpdate"
    WEBXDC_INSTANCE_DELETED = "WebxdcInstanceDeleted"
-    CHATLIST_CHANGED = "ChatlistChanged"
-    CHATLIST_ITEM_CHANGED = "ChatlistItemChanged"


 class ChatId(IntEnum):
--- a/deltachat-rpc-client/src/deltachat_rpc_client/deltachat.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/deltachat.py
@@ -1,6 +1,4 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Dict, List

 from ._utils import AttrDict
 from .account import Account
@@ -23,7 +21,7 @@ class DeltaChat:
        account_id = self.rpc.add_account()
        return Account(self, account_id)

-    def get_all_accounts(self) -> list[Account]:
+    def get_all_accounts(self) -> List[Account]:
        """Return a list of all available accounts."""
        account_ids = self.rpc.get_all_account_ids()
        return [Account(self, account_id) for account_id in account_ids]
@@ -46,6 +44,6 @@ class DeltaChat:
        """Get information about the Delta Chat core in this system."""
        return AttrDict(self.rpc.get_system_info())

-    def set_translations(self, translations: dict[str, str]) -> None:
+    def set_translations(self, translations: Dict[str, str]) -> None:
        """Set stock translation strings."""
        self.rpc.set_stock_strings(translations)
--- a/deltachat-rpc-client/src/deltachat_rpc_client/direct_imap.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/direct_imap.py
@@ -1,226 +0,0 @@
-"""
-Internal Python-level IMAP handling used by the tests.
-"""
-
-from __future__ import annotations
-
-import imaplib
-import io
-import pathlib
-import ssl
-from contextlib import contextmanager
-
-from imap_tools import (
-    AND,
-    Header,
-    MailBox,
-    MailBoxTls,
-    MailMessage,
-    MailMessageFlags,
-    errors,
-)
-
-from . import Account, const
-
-FLAGS = b"FLAGS"
-FETCH = b"FETCH"
-ALL = "1:*"
-
-
-class DirectImap:
-    def __init__(self, account: Account) -> None:
-        self.account = account
-        self.logid = account.get_config("displayname") or id(account)
-        self._idling = False
-        self.connect()
-
-    def connect(self):
-        host = self.account.get_config("configured_mail_server")
-        port = int(self.account.get_config("configured_mail_port"))
-        security = int(self.account.get_config("configured_mail_security"))
-
-        user = self.account.get_config("addr")
-        pw = self.account.get_config("mail_pw")
-
-        if security == const.SocketSecurity.PLAIN:
-            ssl_context = None
-        else:
-            ssl_context = ssl.create_default_context()
-
-            # don't check if certificate hostname doesn't match target hostname
-            ssl_context.check_hostname = False
-
-            # don't check if the certificate is trusted by a certificate authority
-            ssl_context.verify_mode = ssl.CERT_NONE
-
-        if security == const.SocketSecurity.STARTTLS:
-            self.conn = MailBoxTls(host, port, ssl_context=ssl_context)
-        elif security == const.SocketSecurity.PLAIN or security == const.SocketSecurity.SSL:
-            self.conn = MailBox(host, port, ssl_context=ssl_context)
-        self.conn.login(user, pw)
-
-        self.select_folder("INBOX")
-
-    def shutdown(self):
-        try:
-            self.conn.logout()
-        except (OSError, imaplib.IMAP4.abort):
-            print("Could not logout direct_imap conn")
-
-    def create_folder(self, foldername):
-        try:
-            self.conn.folder.create(foldername)
-        except errors.MailboxFolderCreateError as e:
-            print("Can't create", foldername, "probably it already exists:", str(e))
-
-    def select_folder(self, foldername: str) -> tuple:
-        assert not self._idling
-        return self.conn.folder.set(foldername)
-
-    def select_config_folder(self, config_name: str):
-        """Return info about selected folder if it is
-        configured, otherwise None.
-        """
-        if "_" not in config_name:
-            config_name = f"configured_{config_name}_folder"
-        foldername = self.account.get_config(config_name)
-        if foldername:
-            return self.select_folder(foldername)
-        return None
-
-    def list_folders(self) -> list[str]:
-        """return list of all existing folder names."""
-        assert not self._idling
-        return [folder.name for folder in self.conn.folder.list()]
-
-    def delete(self, uid_list: str, expunge=True):
-        """delete a range of messages (imap-syntax).
-        If expunge is true, perform the expunge-operation
-        to make sure the messages are really gone and not
-        just flagged as deleted.
-        """
-        self.conn.client.uid("STORE", uid_list, "+FLAGS", r"(\Deleted)")
-        if expunge:
-            self.conn.expunge()
-
-    def get_all_messages(self) -> list[MailMessage]:
-        assert not self._idling
-        return list(self.conn.fetch())
-
-    def get_unread_messages(self) -> list[str]:
-        assert not self._idling
-        return [msg.uid for msg in self.conn.fetch(AND(seen=False))]
-
-    def mark_all_read(self):
-        messages = self.get_unread_messages()
-        if messages:
-            res = self.conn.flag(messages, MailMessageFlags.SEEN, True)
-            print("marked seen:", messages, res)
-
-    def get_unread_cnt(self) -> int:
-        return len(self.get_unread_messages())
-
-    def dump_imap_structures(self, dir, logfile):
-        assert not self._idling
-        stream = io.StringIO()
-
-        def log(*args, **kwargs):
-            kwargs["file"] = stream
-            print(*args, **kwargs)
-
-        empty_folders = []
-        for imapfolder in self.list_folders():
-            self.select_folder(imapfolder)
-            messages = list(self.get_all_messages())
-            if not messages:
-                empty_folders.append(imapfolder)
-                continue
-
-            log("---------", imapfolder, len(messages), "messages ---------")
-            # get message content without auto-marking it as seen
-            # fetching 'RFC822' would mark it as seen.
-            for msg in self.conn.fetch(mark_seen=False):
-                body = getattr(msg.obj, "text", None)
-                if not body:
-                    body = getattr(msg.obj, "html", None)
-                if not body:
-                    log("Message", msg.uid, "has empty body")
-                    continue
-
-                path = pathlib.Path(str(dir)).joinpath("IMAP", self.logid, imapfolder)
-                path.mkdir(parents=True, exist_ok=True)
-                fn = path.joinpath(str(msg.uid))
-                fn.write_bytes(body)
-                log("Message", msg.uid, fn)
-                log(
-                    "Message",
-                    msg.uid,
-                    msg.flags,
-                    "Message-Id:",
-                    msg.obj.get("Message-Id"),
-                )
-
-        if empty_folders:
-            log("--------- EMPTY FOLDERS:", empty_folders)
-
-        print(stream.getvalue(), file=logfile)
-
-    @contextmanager
-    def idle(self):
-        """return Idle ContextManager."""
-        idle_manager = IdleManager(self)
-        try:
-            yield idle_manager
-        finally:
-            idle_manager.done()
-
-    def append(self, folder: str, msg: str):
-        """Upload a message to *folder*.
-        Trailing whitespace or a linebreak at the beginning will be removed automatically.
-        """
-        if msg.startswith("\n"):
-            msg = msg[1:]
-        msg = "\n".join([s.lstrip() for s in msg.splitlines()])
-        self.conn.append(bytes(msg, encoding="ascii"), folder)
-
-    def get_uid_by_message_id(self, message_id) -> str:
-        msgs = [msg.uid for msg in self.conn.fetch(AND(header=Header("MESSAGE-ID", message_id)))]
-        if len(msgs) == 0:
-            raise Exception("Did not find message " + message_id + ", maybe you forgot to select the correct folder?")
-        return msgs[0]
-
-
-class IdleManager:
-    def __init__(self, direct_imap) -> None:
-        self.direct_imap = direct_imap
-        self.log = direct_imap.account.log
-        # fetch latest messages before starting idle so that it only
-        # returns messages that arrive anew
-        self.direct_imap.conn.fetch("1:*")
-        self.direct_imap.conn.idle.start()
-
-    def check(self, timeout=None) -> list[bytes]:
-        """(blocking) wait for next idle message from server."""
-        self.log("imap-direct: calling idle_check")
-        res = self.direct_imap.conn.idle.poll(timeout=timeout)
-        self.log(f"imap-direct: idle_check returned {res!r}")
-        return res
-
-    def wait_for_new_message(self, timeout=None) -> bytes:
-        while True:
-            for item in self.check(timeout=timeout):
-                if b"EXISTS" in item or b"RECENT" in item:
-                    return item
-
-    def wait_for_seen(self, timeout=None) -> int:
-        """Return first message with SEEN flag from a running idle-stream."""
-        while True:
-            for item in self.check(timeout=timeout):
-                if FETCH in item:
-                    self.log(str(item))
-                    if FLAGS in item and rb"\Seen" in item:
-                        return int(item.split(b" ")[1])
-
-    def done(self):
-        """send idle-done to server if we are currently in idle mode."""
-        return self.direct_imap.conn.idle.stop()
--- a/deltachat-rpc-client/src/deltachat_rpc_client/events.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/events.py
@@ -1,10 +1,8 @@
 """High-level classes for event processing and filtering."""

-from __future__ import annotations
-
 import re
 from abc import ABC, abstractmethod
-from typing import TYPE_CHECKING, Callable, Iterable, Iterator, Optional, Union
+from typing import TYPE_CHECKING, Callable, Iterable, Iterator, Optional, Set, Tuple, Union

 from .const import EventType

@@ -265,9 +263,9 @@ class HookCollection:
    """

    def __init__(self) -> None:
-        self._hooks: set[tuple[Callable, Union[type, EventFilter]]] = set()
+        self._hooks: Set[Tuple[Callable, Union[type, EventFilter]]] = set()

-    def __iter__(self) -> Iterator[tuple[Callable, Union[type, EventFilter]]]:
+    def __iter__(self) -> Iterator[Tuple[Callable, Union[type, EventFilter]]]:
        return iter(self._hooks)

    def on(self, event: Union[type, EventFilter]) -> Callable:  # noqa
--- a/deltachat-rpc-client/src/deltachat_rpc_client/message.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/message.py
@@ -3,7 +3,6 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING, Optional, Union

 from ._utils import AttrDict
-from .const import EventType
 from .contact import Contact

 if TYPE_CHECKING:
@@ -22,10 +21,9 @@ class Message:
    def _rpc(self) -> "Rpc":
        return self.account._rpc

-    def send_reaction(self, *reaction: str) -> "Message":
+    def send_reaction(self, *reaction: str):
        """Send a reaction to this message."""
-        msg_id = self._rpc.send_reaction(self.account.id, self.id, reaction)
-        return Message(self.account, msg_id)
+        self._rpc.send_reaction(self.account.id, self.id, reaction)

    def get_snapshot(self) -> AttrDict:
        """Get a snapshot with the properties of this message."""
@@ -63,10 +61,3 @@ class Message:

    def get_webxdc_info(self) -> dict:
        return self._rpc.get_webxdc_info(self.account.id, self.id)
-
-    def wait_until_delivered(self) -> None:
-        """Consume events until the message is delivered."""
-        while True:
-            event = self.account.wait_for_event()
-            if event.kind == EventType.MSG_DELIVERED and event.msg_id == self.id:
-                break
--- a/deltachat-rpc-client/src/deltachat_rpc_client/pytestplugin.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/pytestplugin.py
@@ -1,12 +1,10 @@
-from __future__ import annotations
-
 import os
 import random
-from typing import AsyncGenerator, Optional
+from typing import AsyncGenerator, List, Optional

 import pytest

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

@@ -56,10 +54,14 @@ class ACFactory:
    @futuremethod
    def get_online_account(self):
        account = yield self.new_configured_account.future()
-        account.bring_online()
+        account.start_io()
+        while True:
+            event = account.wait_for_event()
+            if event.kind == EventType.IMAP_INBOX_IDLE:
+                break
        return account

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

@@ -73,10 +75,6 @@ class ACFactory:
        ac_clone.configure()
        return ac_clone

-    def get_accepted_chat(self, ac1: Account, ac2: Account) -> Chat:
-        ac2.create_chat(ac1)
-        return ac1.create_chat(ac2)
-
    def send_message(
        self,
        to_account: Account,
--- a/deltachat-rpc-client/src/deltachat_rpc_client/rpc.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/rpc.py
@@ -1,14 +1,12 @@
-from __future__ import annotations
-
 import itertools
 import json
 import logging
 import os
 import subprocess
 import sys
-from queue import Empty, Queue
+from queue import Queue
 from threading import Event, Thread
-from typing import Any, Iterator, Optional
+from typing import Any, Dict, Iterator, Optional


 class JsonRpcError(Exception):
@@ -69,11 +67,11 @@ class Rpc:
        self._kwargs = kwargs
        self.process: subprocess.Popen
        self.id_iterator: Iterator[int]
-        self.event_queues: dict[int, Queue]
+        self.event_queues: Dict[int, Queue]
        # Map from request ID to `threading.Event`.
-        self.request_events: dict[int, Event]
+        self.request_events: Dict[int, Event]
        # Map from request ID to the result.
-        self.request_results: dict[int, Any]
+        self.request_results: Dict[int, Any]
        self.request_queue: Queue[Any]
        self.closing: bool
        self.reader_thread: Thread
@@ -188,14 +186,5 @@ class Rpc:
        queue = self.get_queue(account_id)
        return queue.get()

-    def clear_all_events(self, account_id: int):
-        """Removes all queued-up events for a given account. Useful for tests."""
-        queue = self.get_queue(account_id)
-        try:
-            while True:
-                queue.get_nowait()
-        except Empty:
-            pass
-
    def __getattr__(self, attr: str):
        return RpcMethod(self, attr)
--- a/deltachat-rpc-client/tests/test_chatlist_events.py
+++ b/deltachat-rpc-client/tests/test_chatlist_events.py
@@ -1,218 +0,0 @@
-from __future__ import annotations
-
-import base64
-import os
-from typing import TYPE_CHECKING
-
-from deltachat_rpc_client import Account, EventType, const
-
-if TYPE_CHECKING:
-    from deltachat_rpc_client.pytestplugin import ACFactory
-
-
-def wait_for_chatlist_and_specific_item(account, chat_id):
-    first_event = ""
-    while True:
-        event = account.wait_for_event()
-        if event.kind == EventType.CHATLIST_CHANGED:
-            first_event = "change"
-            break
-        if event.kind == EventType.CHATLIST_ITEM_CHANGED and event.chat_id == chat_id:
-            first_event = "item_change"
-            break
-    while True:
-        event = account.wait_for_event()
-        if event.kind == EventType.CHATLIST_CHANGED and first_event == "item_change":
-            break
-        if event.kind == EventType.CHATLIST_ITEM_CHANGED and event.chat_id == chat_id and first_event == "change":
-            break
-
-
-def wait_for_chatlist_specific_item(account, chat_id):
-    while True:
-        event = account.wait_for_event()
-        if event.kind == EventType.CHATLIST_ITEM_CHANGED and event.chat_id == chat_id:
-            break
-
-
-def wait_for_chatlist(account):
-    while True:
-        event = account.wait_for_event()
-        if event.kind == EventType.CHATLIST_CHANGED:
-            break
-
-
-def test_delivery_status(acfactory: ACFactory) -> None:
-    """
-    Test change status on chatlistitem when status changes (delivered, read)
-    """
-    alice, bob = acfactory.get_online_accounts(2)
-
-    bob_addr = bob.get_config("addr")
-    alice_contact_bob = alice.create_contact(bob_addr, "Bob")
-    alice_chat_bob = alice_contact_bob.create_chat()
-
-    alice.clear_all_events()
-    bob.stop_io()
-    alice.stop_io()
-    alice_chat_bob.send_text("hi")
-    wait_for_chatlist_and_specific_item(alice, chat_id=alice_chat_bob.id)
-
-    alice.clear_all_events()
-    alice.start_io()
-    wait_for_chatlist_specific_item(alice, chat_id=alice_chat_bob.id)
-
-    bob.clear_all_events()
-    bob.start_io()
-
-    event = bob.wait_for_incoming_msg_event()
-    msg = bob.get_message_by_id(event.msg_id)
-    msg.get_snapshot().chat.accept()
-    msg.mark_seen()
-
-    chat_item = alice._rpc.get_chatlist_items_by_entries(alice.id, [alice_chat_bob.id])[str(alice_chat_bob.id)]
-    assert chat_item["summaryStatus"] == const.MessageState.OUT_DELIVERED
-
-    alice.clear_all_events()
-
-    while True:
-        event = alice.wait_for_event()
-        if event.kind == EventType.MSG_READ:
-            break
-
-    wait_for_chatlist_specific_item(alice, chat_id=alice_chat_bob.id)
-    chat_item = alice._rpc.get_chatlist_items_by_entries(alice.id, [alice_chat_bob.id])[str(alice_chat_bob.id)]
-    assert chat_item["summaryStatus"] == const.MessageState.OUT_MDN_RCVD
-
-
-def test_delivery_status_failed(acfactory: ACFactory) -> None:
-    """
-    Test change status on chatlistitem when status changes failed
-    """
-    (alice,) = acfactory.get_online_accounts(1)
-
-    invalid_contact = alice.create_contact("example@example.com", "invalid address")
-    invalid_chat = alice.get_chat_by_id(alice._rpc.create_chat_by_contact_id(alice.id, invalid_contact.id))
-
-    alice.clear_all_events()
-
-    failing_message = invalid_chat.send_text("test")
-
-    wait_for_chatlist_and_specific_item(alice, invalid_chat.id)
-
-    assert failing_message.get_snapshot().state == const.MessageState.OUT_PENDING
-
-    while True:
-        event = alice.wait_for_event()
-        if event.kind == EventType.MSG_FAILED:
-            break
-
-    wait_for_chatlist_specific_item(alice, invalid_chat.id)
-
-    assert failing_message.get_snapshot().state == const.MessageState.OUT_FAILED
-
-
-def test_download_on_demand(acfactory: ACFactory) -> None:
-    """
-    Test if download on demand emits chatlist update events.
-    This is only needed for last message in chat, but finding that out is too expensive, so it's always emitted
-    """
-    alice, bob = acfactory.get_online_accounts(2)
-
-    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("hi")
-
-    alice.set_config("download_limit", "1")
-
-    event = bob.wait_for_incoming_msg_event()
-    msg = bob.get_message_by_id(event.msg_id)
-    chat_id = msg.get_snapshot().chat_id
-    msg.get_snapshot().chat.accept()
-    bob.get_chat_by_id(chat_id).send_message(
-        "Hello World, this message is bigger than 5 bytes",
-        html=base64.b64encode(os.urandom(300000)).decode("utf-8"),
-    )
-
-    msg_id = alice.wait_for_incoming_msg_event().msg_id
-
-    assert alice.get_message_by_id(msg_id).get_snapshot().download_state == const.DownloadState.AVAILABLE
-
-    alice.clear_all_events()
-    chat_id = alice.get_message_by_id(msg_id).get_snapshot().chat_id
-    alice._rpc.download_full_message(alice.id, msg_id)
-
-    wait_for_chatlist_specific_item(alice, chat_id)
-
-
-def get_multi_account_test_setup(acfactory: ACFactory) -> [Account, Account, Account]:
-    alice, bob = acfactory.get_online_accounts(2)
-
-    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("hi")
-
-    bob.wait_for_incoming_msg_event()
-
-    alice_second_device: Account = acfactory.get_unconfigured_account()
-
-    alice._rpc.provide_backup.future(alice.id)
-    backup_code = alice._rpc.get_backup_qr(alice.id)
-    alice_second_device._rpc.get_backup(alice_second_device.id, backup_code)
-    alice_second_device.start_io()
-    alice.clear_all_events()
-    alice_second_device.clear_all_events()
-    bob.clear_all_events()
-    return [alice, alice_second_device, bob, alice_chat_bob]
-
-
-def test_imap_sync_seen_msgs(acfactory: ACFactory) -> None:
-    """
-    Test that chatlist changed events are emitted for the second device
-    when the message is marked as read on the first device
-    """
-    alice, alice_second_device, bob, alice_chat_bob = get_multi_account_test_setup(acfactory)
-
-    alice_chat_bob.send_text("hello")
-
-    event = bob.wait_for_incoming_msg_event()
-    msg = bob.get_message_by_id(event.msg_id)
-    bob_chat_id = msg.get_snapshot().chat_id
-    msg.get_snapshot().chat.accept()
-
-    alice.clear_all_events()
-    alice_second_device.clear_all_events()
-    bob.get_chat_by_id(bob_chat_id).send_text("hello")
-
-    # make sure alice_second_device already received the message
-    alice_second_device.wait_for_incoming_msg_event()
-
-    event = alice.wait_for_incoming_msg_event()
-    msg = alice.get_message_by_id(event.msg_id)
-    alice_second_device.clear_all_events()
-    msg.mark_seen()
-
-    wait_for_chatlist_specific_item(bob, bob_chat_id)
-    wait_for_chatlist_specific_item(alice, alice_chat_bob.id)
-
-
-def test_multidevice_sync_chat(acfactory: ACFactory) -> None:
-    """
-    Test multidevice sync: syncing chat visibility and muting across multiple devices
-    """
-    alice, alice_second_device, bob, alice_chat_bob = get_multi_account_test_setup(acfactory)
-
-    alice_chat_bob.archive()
-    wait_for_chatlist_specific_item(alice_second_device, alice_chat_bob.id)
-    assert alice_second_device.get_chat_by_id(alice_chat_bob.id).get_basic_snapshot().archived
-
-    alice_second_device.clear_all_events()
-    alice_chat_bob.pin()
-    wait_for_chatlist_specific_item(alice_second_device, alice_chat_bob.id)
-
-    alice_second_device.clear_all_events()
-    alice_chat_bob.mute()
-    wait_for_chatlist_specific_item(alice_second_device, alice_chat_bob.id)
-    assert alice_second_device.get_chat_by_id(alice_chat_bob.id).get_basic_snapshot().is_muted
--- a/deltachat-rpc-client/tests/test_something.py
+++ b/deltachat-rpc-client/tests/test_something.py
@@ -1,15 +1,10 @@
 import concurrent.futures
 import json
-import logging
-import os
 import subprocess
-import time
 from unittest.mock import MagicMock

 import pytest
-from deltachat_rpc_client import Contact, EventType, Message, events
-from deltachat_rpc_client.const import DownloadState, MessageState
-from deltachat_rpc_client.direct_imap import DirectImap
+from deltachat_rpc_client import EventType, events
 from deltachat_rpc_client.rpc import JsonRpcError


@@ -444,172 +439,3 @@ def test_mdn_doesnt_break_autocrypt(acfactory) -> None:
    message = alice.get_message_by_id(msg_id)
    snapshot = message.get_snapshot()
    assert snapshot.show_padlock
-
-
-def test_reaction_to_partially_fetched_msg(acfactory, tmp_path):
-    """See https://github.com/deltachat/deltachat-core-rust/issues/3688 "Partially downloaded
-    messages are received out of order".
-
-    If the Inbox contains X small messages followed by Y large messages followed by Z small
-    messages, Delta Chat first downloaded a batch of X+Z messages, and then a batch of Y messages.
-
-    This bug was discovered by @Simon-Laux while testing reactions PR #3644 and can be reproduced
-    with online test as follows:
-    - Bob enables download limit and goes offline.
-    - Alice sends a large message to Bob and reacts to this message with a thumbs-up.
-    - Bob goes online
-    - Bob first processes a reaction message and throws it away because there is no corresponding
-      message, then processes a partially downloaded message.
-    - As a result, Bob does not see a reaction
-    """
-    download_limit = 300000
-    ac1, ac2 = acfactory.get_online_accounts(2)
-    ac1_addr = ac1.get_config("addr")
-    chat = ac1.create_chat(ac2)
-    ac2.set_config("download_limit", str(download_limit))
-    ac2.stop_io()
-
-    logging.info("sending small+large messages from ac1 to ac2")
-    msgs = []
-    msgs.append(chat.send_text("hi"))
-    path = tmp_path / "large"
-    path.write_bytes(os.urandom(download_limit + 1))
-    msgs.append(chat.send_file(str(path)))
-    for m in msgs:
-        m.wait_until_delivered()
-
-    logging.info("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))
-    msgs[-1].wait_until_delivered()
-
-    ac2.start_io()
-
-    logging.info("wait for ac2 to receive a reaction")
-    msg2 = Message(ac2, ac2.wait_for_reactions_changed().msg_id)
-    assert msg2.get_sender_contact().get_snapshot().address == ac1_addr
-    assert msg2.get_snapshot().download_state == DownloadState.AVAILABLE
-    reactions = msg2.get_reactions()
-    contacts = [Contact(ac2, int(i)) for i in reactions.reactions_by_contact]
-    assert len(contacts) == 1
-    assert contacts[0].get_snapshot().address == ac1_addr
-    assert list(reactions.reactions_by_contact.values())[0] == [react_str]
-
-
-def test_reactions_for_a_reordering_move(acfactory):
-    """When a batch of messages is moved from Inbox to DeltaChat folder with a single MOVE command,
-    their UIDs may be reordered (e.g. Gmail is known for that) which led to that messages were
-    processed by receive_imf in the wrong order, and, particularly, reactions were processed before
-    messages they refer to and thus dropped.
-    """
-    (ac1,) = acfactory.get_online_accounts(1)
-    ac2 = acfactory.new_preconfigured_account()
-    ac2.set_config("mvbox_move", "1")
-    ac2.configure()
-    ac2.bring_online()
-    chat1 = acfactory.get_accepted_chat(ac1, ac2)
-    ac2.stop_io()
-
-    logging.info("sending message + reaction from ac1 to ac2")
-    msg1 = chat1.send_text("hi")
-    msg1.wait_until_delivered()
-    # 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(1.1)
-    react_str = "\N{THUMBS UP SIGN}"
-    msg1.send_reaction(react_str).wait_until_delivered()
-
-    logging.info("moving messages to ac2's DeltaChat folder in the reverse order")
-    ac2_direct_imap = DirectImap(ac2)
-    ac2_direct_imap.connect()
-    for uid in sorted([m.uid for m in ac2_direct_imap.get_all_messages()], reverse=True):
-        ac2_direct_imap.conn.move(uid, "DeltaChat")
-
-    logging.info("receiving messages by ac2")
-    ac2.start_io()
-    msg2 = Message(ac2, ac2.wait_for_reactions_changed().msg_id)
-    assert msg2.get_snapshot().text == msg1.get_snapshot().text
-    reactions = msg2.get_reactions()
-    contacts = [Contact(ac2, int(i)) for i in reactions.reactions_by_contact]
-    assert len(contacts) == 1
-    assert contacts[0].get_snapshot().address == ac1.get_config("addr")
-    assert list(reactions.reactions_by_contact.values())[0] == [react_str]
-
-
-@pytest.mark.parametrize("n_accounts", [3, 2])
-def test_download_limit_chat_assignment(acfactory, tmp_path, n_accounts):
-    download_limit = 300000
-
-    alice, *others = acfactory.get_online_accounts(n_accounts)
-    bob = others[0]
-
-    alice_group = alice.create_group("test group")
-    for account in others:
-        chat = account.create_chat(alice)
-        chat.send_text("Hello Alice!")
-        assert alice.get_message_by_id(alice.wait_for_incoming_msg_event().msg_id).get_snapshot().text == "Hello Alice!"
-
-        contact_addr = account.get_config("addr")
-        contact = alice.create_contact(contact_addr, "")
-
-        alice_group.add_contact(contact)
-
-    if n_accounts == 2:
-        bob_chat_alice = bob.create_chat(alice)
-    bob.set_config("download_limit", str(download_limit))
-
-    alice_group.send_text("hi")
-    snapshot = bob.get_message_by_id(bob.wait_for_incoming_msg_event().msg_id).get_snapshot()
-    assert snapshot.text == "hi"
-    bob_group = snapshot.chat
-
-    path = tmp_path / "large"
-    path.write_bytes(os.urandom(download_limit + 1))
-
-    for i in range(10):
-        logging.info("Sending message %s", i)
-        alice_group.send_file(str(path))
-        snapshot = bob.get_message_by_id(bob.wait_for_incoming_msg_event().msg_id).get_snapshot()
-        assert snapshot.download_state == DownloadState.AVAILABLE
-        if n_accounts > 2:
-            assert snapshot.chat == bob_group
-        else:
-            # Group contains only Alice and Bob,
-            # so partially downloaded messages are
-            # hard to distinguish from private replies to group messages.
-            #
-            # Message may be a private reply, so we assign it to 1:1 chat with Alice.
-            assert snapshot.chat == bob_chat_alice
-
-
-def test_markseen_contact_request(acfactory, tmp_path):
-    """
-    Test that seen status is synchronized for contact request messages
-    even though read receipt is not sent.
-    """
-    alice, bob = acfactory.get_online_accounts(2)
-
-    # Bob sets up a second device.
-    bob.export_backup(tmp_path)
-    files = list(tmp_path.glob("*.tar"))
-    bob2 = acfactory.get_unconfigured_account()
-    bob2.import_backup(files[0])
-    bob2.start_io()
-
-    alice_chat_bob = alice.create_chat(bob)
-    alice_chat_bob.send_text("Hello Bob!")
-
-    message = bob.get_message_by_id(bob.wait_for_incoming_msg_event().msg_id)
-    message2 = bob2.get_message_by_id(bob2.wait_for_incoming_msg_event().msg_id)
-    assert message2.get_snapshot().state == MessageState.IN_FRESH
-
-    message.mark_seen()
-    while True:
-        event = bob2.wait_for_event()
-        if event.kind == EventType.MSGS_NOTICED:
-            break
-    assert message2.get_snapshot().state == MessageState.IN_SEEN
--- a/deltachat-rpc-client/tox.ini
+++ b/deltachat-rpc-client/tox.ini
@@ -25,7 +25,7 @@ deps =
    black
 commands =
    black --quiet --check --diff src/ examples/ tests/
-    ruff check src/ examples/ tests/
+    ruff src/ examples/ tests/

 [pytest]
 timeout = 300
--- a/deltachat-rpc-server/Cargo.toml
+++ b/deltachat-rpc-server/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "deltachat-rpc-server"
-version = "1.137.3"
+version = "1.137.2"
 description = "DeltaChat JSON-RPC server"
 edition = "2021"
 readme = "README.md"
@@ -14,7 +14,7 @@ deltachat-jsonrpc = { path = "../deltachat-jsonrpc", default-features = false }
 deltachat = { path = "..", default-features = false }

 anyhow = "1"
-env_logger = { version = "0.11.3" }
+env_logger = { version = "0.10.0" }
 futures-lite = "2.3.0"
 log = "0.4"
 serde_json = "1"
--- a/deltachat-rpc-server/src/main.rs
+++ b/deltachat-rpc-server/src/main.rs
@@ -68,7 +68,7 @@ async fn main_impl() -> Result<()> {

    log::info!("Creating JSON-RPC API.");
    let accounts = Arc::new(RwLock::new(accounts));
-    let state = CommandApi::from_arc(accounts.clone()).await;
+    let state = CommandApi::from_arc(accounts.clone());

    let (client, mut out_receiver) = RpcClient::new();
    let session = RpcSession::new(client.clone(), state.clone());
--- a/deny.toml
+++ b/deny.toml
@@ -26,7 +26,6 @@ skip = [
     { name = "async-channel", version = "1.9.0" },
     { name = "base16ct", version = "0.1.1" },
     { name = "base64", version = "<0.21" },
-     { name = "base64", version = "0.21.7" },
     { name = "bitflags", version = "1.3.2" },
     { name = "block-buffer", version = "<0.10" },
     { name = "convert_case", version = "0.4.0" },
@@ -38,7 +37,6 @@ skip = [
     { name = "digest", version = "<0.10" },
     { name = "ed25519-dalek", version = "1.0.1" },
     { name = "ed25519", version = "1.5.3" },
-     { name = "env_logger", version = "0.10.2" },
     { name = "event-listener", version = "2.5.3" },
     { name = "getrandom", version = "<0.2" },
     { name = "idna", version = "0.4.0" },
--- a/flake.lock
+++ b/flake.lock
@@ -7,11 +7,11 @@
        "nixpkgs": "nixpkgs"
      },
      "locked": {
-        "lastModified": 1712088936,
-        "narHash": "sha256-mVjeSWQiR/t4UZ9fUawY9OEPAhY1R3meYG+0oh8DUBs=",
+        "lastModified": 1710633978,
+        "narHash": "sha256-yemnwSvW7cdWtXGpivFA5jDO35rGPs6fqxlQ4l6ODXs=",
        "owner": "tadfisher",
        "repo": "android-nixpkgs",
-        "rev": "2d8181caef279f19c4a33dc694723f89ffc195d4",
+        "rev": "e91fb3d8517538e5ad9b422c9a4f604b56008a9e",
        "type": "github"
      },
      "original": {
@@ -29,11 +29,11 @@
        ]
      },
      "locked": {
-        "lastModified": 1711099426,
-        "narHash": "sha256-HzpgM/wc3aqpnHJJ2oDqPBkNsqWbW0WfWUO8lKu8nGk=",
+        "lastModified": 1708939976,
+        "narHash": "sha256-O5+nFozxz2Vubpdl1YZtPrilcIXPcRAjqNdNE8oCRoA=",
        "owner": "numtide",
        "repo": "devshell",
-        "rev": "2d45b54ca4a183f2fdcf4b19c895b64fbf620ee8",
+        "rev": "5ddecd67edbd568ebe0a55905273e56cc82aabe3",
        "type": "github"
      },
      "original": {
@@ -48,11 +48,11 @@
        "rust-analyzer-src": "rust-analyzer-src"
      },
      "locked": {
-        "lastModified": 1713421495,
-        "narHash": "sha256-5vVF9W1tJT+WdfpWAEG76KywktKDAW/71mVmNHEHjac=",
+        "lastModified": 1710742993,
+        "narHash": "sha256-W0PQCe0bW3hKF5lHawXrKynBcdSP18Qa4sb8DcUfOqI=",
        "owner": "nix-community",
        "repo": "fenix",
-        "rev": "fd47b1f9404fae02a4f38bd9f4b12bad7833c96b",
+        "rev": "6f2fec850f569d61562d3a47dc263f19e9c7d825",
        "type": "github"
      },
      "original": {
@@ -84,11 +84,11 @@
        "systems": "systems_2"
      },
      "locked": {
-        "lastModified": 1710146030,
-        "narHash": "sha256-SZ5L6eA7HJ/nmkzGG7/ISclqe6oZdOZTNoesiInkXPQ=",
+        "lastModified": 1709126324,
+        "narHash": "sha256-q6EQdSeUZOG26WelxqkmR7kArjgWCdw5sfJVHPH/7j8=",
        "owner": "numtide",
        "repo": "flake-utils",
-        "rev": "b1d9ab70662946ef0850d488da1c9019f3a9752a",
+        "rev": "d465f4819400de7c8d874d50b982301f28a84605",
        "type": "github"
      },
      "original": {
@@ -120,11 +120,11 @@
        "nixpkgs": "nixpkgs_3"
      },
      "locked": {
-        "lastModified": 1713520724,
-        "narHash": "sha256-CO8MmVDmqZX2FovL75pu5BvwhW+Vugc7Q6ze7Hj8heI=",
+        "lastModified": 1698420672,
+        "narHash": "sha256-/TdeHMPRjjdJub7p7+w55vyABrsJlt5QkznPYy55vKA=",
        "owner": "nix-community",
        "repo": "naersk",
-        "rev": "c5037590290c6c7dae2e42e7da1e247e54ed2d49",
+        "rev": "aeb58d5e8faead8980a807c840232697982d47b9",
        "type": "github"
      },
      "original": {
@@ -150,11 +150,11 @@
    },
    "nixpkgs": {
      "locked": {
-        "lastModified": 1711703276,
-        "narHash": "sha256-iMUFArF0WCatKK6RzfUJknjem0H9m4KgorO/p3Dopkk=",
+        "lastModified": 1709237383,
+        "narHash": "sha256-cy6ArO4k5qTx+l5o+0mL9f5fa86tYUX3ozE1S+Txlds=",
        "owner": "NixOS",
        "repo": "nixpkgs",
-        "rev": "d8fe5e6c92d0d190646fb9f1056741a229980089",
+        "rev": "1536926ef5621b09bba54035ae2bb6d806d72ac8",
        "type": "github"
      },
      "original": {
@@ -166,11 +166,11 @@
    },
    "nixpkgs_2": {
      "locked": {
-        "lastModified": 1713248628,
-        "narHash": "sha256-NLznXB5AOnniUtZsyy/aPWOk8ussTuePp2acb9U+ISA=",
+        "lastModified": 1710631334,
+        "narHash": "sha256-rL5LSYd85kplL5othxK5lmAtjyMOBg390sGBTb3LRMM=",
        "owner": "nixos",
        "repo": "nixpkgs",
-        "rev": "5672bc9dbf9d88246ddab5ac454e82318d094bb8",
+        "rev": "c75037bbf9093a2acb617804ee46320d6d1fea5a",
        "type": "github"
      },
      "original": {
@@ -182,11 +182,11 @@
    },
    "nixpkgs_3": {
      "locked": {
-        "lastModified": 1713562564,
-        "narHash": "sha256-NQpYhgoy0M89g9whRixSwsHb8RFIbwlxeYiVSDwSXJg=",
+        "lastModified": 1710765496,
+        "narHash": "sha256-p7ryWEeQfMwTB6E0wIUd5V2cFTgq+DRRBz2hYGnJZyA=",
        "owner": "NixOS",
        "repo": "nixpkgs",
-        "rev": "92d295f588631b0db2da509f381b4fb1e74173c5",
+        "rev": "e367f7a1fb93137af22a3908f00b9a35e2d286a7",
        "type": "github"
      },
      "original": {
@@ -196,11 +196,11 @@
    },
    "nixpkgs_4": {
      "locked": {
-        "lastModified": 1713537308,
-        "narHash": "sha256-XtTSSIB2DA6tOv+l0FhvfDMiyCmhoRbNB+0SeInZkbk=",
+        "lastModified": 1710631334,
+        "narHash": "sha256-rL5LSYd85kplL5othxK5lmAtjyMOBg390sGBTb3LRMM=",
        "owner": "nixos",
        "repo": "nixpkgs",
-        "rev": "5c24cf2f0a12ad855f444c30b2421d044120c66f",
+        "rev": "c75037bbf9093a2acb617804ee46320d6d1fea5a",
        "type": "github"
      },
      "original": {
@@ -223,11 +223,11 @@
    "rust-analyzer-src": {
      "flake": false,
      "locked": {
-        "lastModified": 1713373173,
-        "narHash": "sha256-octd9BFY9G/Gbr4KfwK4itZp4Lx+qvJeRRcYnN+dEH8=",
+        "lastModified": 1710708100,
+        "narHash": "sha256-Jd6pmXlwKk5uYcjyO/8BfbUVmx8g31Qfk7auI2IG66A=",
        "owner": "rust-lang",
        "repo": "rust-analyzer",
-        "rev": "46702ffc1a02a2ac153f1d1ce619ec917af8f3a6",
+        "rev": "b6d1887bc4f9543b6c6bf098179a62446f34a6c3",
        "type": "github"
      },
      "original": {
--- a/flake.nix
+++ b/flake.nix
@@ -35,7 +35,6 @@
            ./CMakeLists.txt
            ./CONTRIBUTING.md
            ./deltachat_derive
-            ./deltachat-contact-tools
            ./deltachat-ffi
            ./deltachat-jsonrpc
            ./deltachat-ratelimit
@@ -483,7 +482,6 @@
                format = "pyproject";
                propagatedBuildInputs = [
                  pkgs.python3Packages.setuptools
-                  pkgs.python3Packages.imap-tools
                ];
              };

@@ -527,12 +525,15 @@

        devShells.default = pkgs.mkShell {
          buildInputs = with pkgs; [
-            cargo
-            clippy
-            rustc
-            rustfmt
-            rust-analyzer
+            (fenixPkgs.complete.withComponents [
+              "cargo"
+              "clippy"
+              "rust-src"
+              "rustc"
+              "rustfmt"
+            ])
            cargo-deny
+            fenixPkgs.rust-analyzer
            perl # needed to build vendored OpenSSL
          ];
        };
--- a/fuzz/Cargo.lock
+++ b/fuzz/Cargo.lock
@@ -94,12 +94,6 @@ version = "0.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0942ffc6dcaadf03badf6e6a2d0228460359d5e34b57ccdc720b7382dfbd5ec5"

-[[package]]
-name = "android-tzdata"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e999941b234f3131b00bc13c22d06e8c5ff726d1b6318ac7eb276997bbb4fef0"
-
 [[package]]
 name = "android_system_properties"
 version = "0.1.5"
@@ -527,9 +521,9 @@ dependencies = [

 [[package]]
 name = "brotli"
-version = "5.0.0"
+version = "4.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "19483b140a7ac7174d34b5a581b406c64f84da5409d3e09cf4fff604f9270e67"
+checksum = "125740193d7fee5cc63ab9e16c2fdc4e07c74ba755cc53b327d6ea029e9fc569"
 dependencies = [
 "alloc-no-stdlib",
 "alloc-stdlib",
@@ -538,9 +532,9 @@ dependencies = [

 [[package]]
 name = "brotli-decompressor"
-version = "4.0.0"
+version = "3.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6221fe77a248b9117d431ad93761222e1cf8ff282d9d1d5d9f53d6299a1cf76"
+checksum = "65622a320492e09b5e0ac436b14c54ff68199bac392d0e89a6832c4518eea525"
 dependencies = [
 "alloc-no-stdlib",
 "alloc-stdlib",
@@ -645,16 +639,17 @@ dependencies = [

 [[package]]
 name = "chrono"
-version = "0.4.38"
+version = "0.4.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a21f936df1771bf62b77f047b726c4625ff2e8aa607c01ec06e5a05bd8463401"
+checksum = "16b0a3d9ed01224b22057780a37bb8c5dbfe1be8ba48678e7bf57ec4b385411f"
 dependencies = [
- "android-tzdata",
 "iana-time-zone",
 "js-sys",
+ "num-integer",
 "num-traits",
+ "time 0.1.45",
 "wasm-bindgen",
- "windows-targets 0.52.0",
+ "winapi",
 ]

 [[package]]
@@ -964,7 +959,7 @@ dependencies = [

 [[package]]
 name = "deltachat"
-version = "1.137.3"
+version = "1.137.2"
 dependencies = [
 "anyhow",
 "async-channel 2.1.1",
@@ -973,10 +968,9 @@ dependencies = [
 "async-smtp",
 "async_zip",
 "backtrace",
- "base64 0.22.0",
+ "base64 0.21.0",
 "brotli",
 "chrono",
- "deltachat-contact-tools",
 "deltachat-time",
 "deltachat_derive",
 "email",
@@ -1036,16 +1030,6 @@ dependencies = [
 "uuid 1.2.2",
 ]

-[[package]]
-name = "deltachat-contact-tools"
-version = "0.1.0"
-dependencies = [
- "anyhow",
- "once_cell",
- "regex",
- "rusqlite",
-]
-
 [[package]]
 name = "deltachat-fuzz"
 version = "0.0.0"
@@ -2170,7 +2154,7 @@ dependencies = [
 "http-body",
 "hyper",
 "pin-project-lite",
- "socket2 0.5.6",
+ "socket2 0.5.4",
 "tokio",
 "tower",
 "tower-service",
@@ -3355,7 +3339,7 @@ checksum = "055b4e778e8feb9f93c4e439f71dc2156ef13360b432b799e179a8c4cdf0b1d7"
 dependencies = [
 "bytes",
 "libc",
- "socket2 0.5.6",
+ "socket2 0.5.4",
 "tracing",
 "windows-sys 0.48.0",
 ]
@@ -3764,9 +3748,9 @@ dependencies = [

 [[package]]
 name = "rustls"
-version = "0.21.11"
+version = "0.21.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fecbfb7b1444f477b345853b1fce097a2c6fb637b2bfb87e6bc5db0f043fae4"
+checksum = "629648aced5775d558af50b2b4c7b02983a04b312126d45eeead26e7caa498b9"
 dependencies = [
 "ring 0.17.6",
 "rustls-webpki",
@@ -4149,12 +4133,12 @@ dependencies = [

 [[package]]
 name = "socket2"
-version = "0.5.6"
+version = "0.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05ffd9c0a93b7543e062e759284fcf5f5e3b098501104bfbdde4d404db792871"
+checksum = "4031e820eb552adee9295814c0ced9e5cf38ddf1e8b7d566d6de8e2538ea989e"
 dependencies = [
 "libc",
- "windows-sys 0.52.0",
+ "windows-sys 0.48.0",
 ]

 [[package]]
@@ -4449,9 +4433,9 @@ checksum = "cda74da7e1a664f795bb1f8a87ec406fb89a02522cf6e50620d016add6dbbf5c"

 [[package]]
 name = "tokio"
-version = "1.37.0"
+version = "1.32.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1adbebffeca75fcfd058afa480fb6c0b81e165a0323f9c9d39c9697e37c46787"
+checksum = "17ed6077ed6cd6c74735e21f37eb16dc3935f96878b1fe961074089cc80893f9"
 dependencies = [
 "backtrace",
 "bytes",
@@ -4461,7 +4445,7 @@ dependencies = [
 "parking_lot",
 "pin-project-lite",
 "signal-hook-registry",
- "socket2 0.5.6",
+ "socket2 0.5.4",
 "tokio-macros",
 "windows-sys 0.48.0",
 ]
@@ -4478,9 +4462,9 @@ dependencies = [

 [[package]]
 name = "tokio-macros"
-version = "2.2.0"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b8a1e28f2deaa14e508979454cb3a223b10b938b45af148bc0986de36f1923b"
+checksum = "630bdcf245f78637c13ec01ffae6187cca34625e8c63150d424b59e55af2675e"
 dependencies = [
 "proc-macro2",
 "quote",
--- a/node/constants.js
+++ b/node/constants.js
@@ -30,8 +30,6 @@ module.exports = {
  DC_DOWNLOAD_IN_PROGRESS: 1000,
  DC_DOWNLOAD_UNDECIPHERABLE: 30,
  DC_EVENT_ACCOUNTS_BACKGROUND_FETCH_DONE: 2200,
-  DC_EVENT_CHATLIST_CHANGED: 2300,
-  DC_EVENT_CHATLIST_ITEM_CHANGED: 2301,
  DC_EVENT_CHAT_EPHEMERAL_TIMER_MODIFIED: 2021,
  DC_EVENT_CHAT_MODIFIED: 2020,
  DC_EVENT_CONFIGURE_PROGRESS: 2041,
--- a/node/events.js
+++ b/node/events.js
@@ -37,7 +37,5 @@ module.exports = {
  2111: 'DC_EVENT_CONFIG_SYNCED',
  2120: 'DC_EVENT_WEBXDC_STATUS_UPDATE',
  2121: 'DC_EVENT_WEBXDC_INSTANCE_DELETED',
-  2200: 'DC_EVENT_ACCOUNTS_BACKGROUND_FETCH_DONE',
-  2300: 'DC_EVENT_CHATLIST_CHANGED',
-  2301: 'DC_EVENT_CHATLIST_ITEM_CHANGED'
+  2200: 'DC_EVENT_ACCOUNTS_BACKGROUND_FETCH_DONE'
 }
--- a/node/lib/constants.ts
+++ b/node/lib/constants.ts
@@ -30,8 +30,6 @@ export enum C {
  DC_DOWNLOAD_IN_PROGRESS = 1000,
  DC_DOWNLOAD_UNDECIPHERABLE = 30,
  DC_EVENT_ACCOUNTS_BACKGROUND_FETCH_DONE = 2200,
-  DC_EVENT_CHATLIST_CHANGED = 2300,
-  DC_EVENT_CHATLIST_ITEM_CHANGED = 2301,
  DC_EVENT_CHAT_EPHEMERAL_TIMER_MODIFIED = 2021,
  DC_EVENT_CHAT_MODIFIED = 2020,
  DC_EVENT_CONFIGURE_PROGRESS = 2041,
@@ -335,6 +333,4 @@ export const EventId2EventName: { [key: number]: string } = {
  2120: 'DC_EVENT_WEBXDC_STATUS_UPDATE',
  2121: 'DC_EVENT_WEBXDC_INSTANCE_DELETED',
  2200: 'DC_EVENT_ACCOUNTS_BACKGROUND_FETCH_DONE',
-  2300: 'DC_EVENT_CHATLIST_CHANGED',
-  2301: 'DC_EVENT_CHATLIST_ITEM_CHANGED',
 }
--- a/node/src/module.c
+++ b/node/src/module.c
@@ -1,4 +1,5 @@
 #define NAPI_VERSION 4
+#define NAPI_EXPERIMENTAL

 #include <stdlib.h>
 #include <stdio.h>
--- a/node/test/test.mjs
+++ b/node/test/test.mjs
@@ -26,8 +26,6 @@ function createTempUser(chatmailDomain) {
 }

 describe('static tests', function () {
-  this.timeout(60 * 5 * 1000) // increase timeout to 5 min
-
  it('reverse lookup of events', function () {
    const eventKeys = Object.keys(EventId2EventName).map((k) => Number(k))
    const eventValues = Object.values(EventId2EventName)
@@ -703,7 +701,7 @@ describe('Offline Tests with unconfigured account', function () {
 })

 describe('Integration tests', function () {
-  this.timeout(60 * 5 * 1000) // increase timeout to 5 min
+  this.timeout(60 * 3000) // increase timeout to 1min

  let [dc, context, accountId, directory, account] = [
    null,
--- a/package.json
+++ b/package.json
@@ -55,5 +55,5 @@
    "test:mocha": "mocha node/test/test.mjs --growl --reporter=spec --bail --exit"
  },
  "types": "node/dist/index.d.ts",
-  "version": "1.137.3"
+  "version": "1.137.2"
 }
--- a/python/pyproject.toml
+++ b/python/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"

 [project]
 name = "deltachat"
-version = "1.137.3"
+version = "1.137.2"
 description = "Python bindings for the Delta Chat Core library using CFFI against the Rust-implemented libdeltachat"
 readme = "README.rst"
 requires-python = ">=3.7"
--- a/python/src/deltachat/events.py
+++ b/python/src/deltachat/events.py
@@ -328,12 +328,10 @@ class EventThread(threading.Thread):
        elif name == "DC_EVENT_REACTIONS_CHANGED":
            assert ffi_event.data1 > 0
            msg = account.get_message_by_id(ffi_event.data2)
-            if msg is not None:
-                yield "ac_reactions_changed", {"message": msg}
+            yield "ac_reactions_changed", {"message": msg}
        elif name == "DC_EVENT_MSG_DELIVERED":
            msg = account.get_message_by_id(ffi_event.data2)
-            if msg is not None:
-                yield "ac_message_delivered", {"message": msg}
+            yield "ac_message_delivered", {"message": msg}
        elif name == "DC_EVENT_CHAT_MODIFIED":
            chat = account.get_chat_by_id(ffi_event.data1)
            yield "ac_chat_modified", {"chat": chat}
--- a/python/src/deltachat/message.py
+++ b/python/src/deltachat/message.py
@@ -364,9 +364,6 @@ class Message:
        else:
            # load message from db to get a fresh/current state
            dc_msg = ffi.gc(lib.dc_get_msg(self.account._dc_context, self.id), lib.dc_msg_unref)
-            # Message could be trashed, use the cached object if so.
-            if dc_msg == ffi.NULL:
-                dc_msg = self._dc_msg
        return lib.dc_msg_get_state(dc_msg)

    def is_in_fresh(self):
@@ -395,7 +392,7 @@ class Message:

    def is_outgoing(self):
        """Return True if Message is outgoing."""
-        return lib.dc_msg_get_state(self._dc_msg) in (
+        return self._msgstate in (
            const.DC_STATE_OUT_PREPARING,
            const.DC_STATE_OUT_PENDING,
            const.DC_STATE_OUT_FAILED,
@@ -487,9 +484,6 @@ class Message:

        # load message from db to get a fresh/current state
        dc_msg = ffi.gc(lib.dc_get_msg(self.account._dc_context, self.id), lib.dc_msg_unref)
-        # Message could be trashed, use the cached object if so.
-        if dc_msg == ffi.NULL:
-            dc_msg = self._dc_msg
        return lib.dc_msg_get_download_state(dc_msg)

    def download_full(self) -> None:
--- a/python/tests/test_1_online.py
+++ b/python/tests/test_1_online.py
@@ -1,6 +1,7 @@
 import os
 import queue
 import sys
+import time
 import base64
 from datetime import datetime, timezone

@@ -1492,6 +1493,107 @@ def test_send_and_receive_image(acfactory, lp, data):
    assert m == msg_in


+def test_reaction_to_partially_fetched_msg(acfactory, lp, tmp_path):
+    """See https://github.com/deltachat/deltachat-core-rust/issues/3688 "Partially downloaded
+    messages are received out of order".
+
+    If the Inbox contains X small messages followed by Y large messages followed by Z small
+    messages, Delta Chat first downloaded a batch of X+Z messages, and then a batch of Y messages.
+
+    This bug was discovered by @Simon-Laux while testing reactions PR #3644 and can be reproduced
+    with online test as follows:
+    - Bob enables download limit and goes offline.
+    - Alice sends a large message to Bob and reacts to this message with a thumbs-up.
+    - Bob goes online
+    - Bob first processes a reaction message and throws it away because there is no corresponding
+      message, then processes a partially downloaded message.
+    - As a result, Bob does not see a reaction
+    """
+    download_limit = 300000
+    ac1, ac2 = acfactory.get_online_accounts(2)
+    ac1_addr = ac1.get_config("addr")
+    chat = ac1.create_chat(ac2)
+    ac2.set_config("download_limit", str(download_limit))
+    ac2.stop_io()
+
+    reactions_queue = queue.Queue()
+
+    class InPlugin:
+        @account_hookimpl
+        def ac_reactions_changed(self, message):
+            reactions_queue.put(message)
+
+    ac2.add_account_plugin(InPlugin())
+
+    lp.sec("sending small+large messages from ac1 to ac2")
+    msgs = []
+    msgs.append(chat.send_text("hi"))
+    path = tmp_path / "large"
+    path.write_bytes(os.urandom(download_limit + 1))
+    msgs.append(chat.send_file(str(path)))
+    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")
+    msg2 = ac2._evtracker.wait_next_reactions_changed()
+    assert msg2.get_sender_contact().addr == ac1_addr
+    assert msg2.download_state == dc.const.DC_DOWNLOAD_AVAILABLE
+    assert reactions_queue.get() == msg2
+    reactions = msg2.get_reactions()
+    contacts = reactions.get_contacts()
+    assert len(contacts) == 1
+    assert contacts[0].addr == ac1_addr
+    assert reactions.get_by_contact(contacts[0]) == react_str
+
+
+def test_reactions_for_a_reordering_move(acfactory, lp):
+    """When a batch of messages is moved from Inbox to DeltaChat folder with a single MOVE command,
+    their UIDs may be reordered (e.g. Gmail is known for that) which led to that messages were
+    processed by receive_imf in the wrong order, and, particularly, reactions were processed before
+    messages they refer to and thus dropped.
+    """
+    (ac1,) = acfactory.get_online_accounts(1)
+    ac2 = acfactory.new_online_configuring_account(mvbox_move=True)
+    acfactory.bring_accounts_online()
+    chat1 = acfactory.get_accepted_chat(ac1, ac2)
+    ac2.stop_io()
+
+    lp.sec("sending message + reaction from ac1 to ac2")
+    msg1 = chat1.send_text("hi")
+    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(1.1)
+    react_str = "\N{THUMBS UP SIGN}"
+    ac1._evtracker.wait_msg_delivered(msg1.send_reaction(react_str))
+
+    lp.sec("moving messages to ac2's DeltaChat folder in the reverse order")
+    ac2.direct_imap.connect()
+    for uid in sorted([m.uid for m in ac2.direct_imap.get_all_messages()], reverse=True):
+        ac2.direct_imap.conn.move(uid, "DeltaChat")
+
+    lp.sec("receiving messages by ac2")
+    ac2.start_io()
+    msg2 = ac2._evtracker.wait_next_reactions_changed()
+    assert msg2.text == msg1.text
+    reactions = msg2.get_reactions()
+    contacts = reactions.get_contacts()
+    assert len(contacts) == 1
+    assert contacts[0].addr == ac1.get_config("addr")
+    assert reactions.get_by_contact(contacts[0]) == react_str
+
+
 def test_import_export_online_all(acfactory, tmp_path, data, lp):
    (ac1, some1) = acfactory.get_online_accounts(2)

@@ -2128,21 +2230,17 @@ def test_delete_multiple_messages(acfactory, lp):

 def test_trash_multiple_messages(acfactory, lp):
    ac1, ac2 = acfactory.get_online_accounts(2)
-    ac2.stop_io()

-    # Create the Trash folder on IMAP server and configure deletion to it. There was a bug that if
-    # Trash wasn't configured initially, it can't be configured later, let's check this.
+    # 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")
-    ac2.set_config("delete_to_trash", "1")
-
-    lp.sec("Check that Trash can be configured initially as well")
-    ac3 = acfactory.new_online_configuring_account(cloned_from=ac2)
+    lp.sec("Creating new accounts")
+    ac2 = acfactory.new_online_configuring_account(cloned_from=ac2)
    acfactory.bring_accounts_online()
-    assert ac3.get_config("configured_trash_folder")
-    ac3.stop_io()

-    ac2.start_io()
+    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")
@@ -2157,9 +2255,6 @@ def test_trash_multiple_messages(acfactory, lp):
        assert msg.text in texts
        if text != "second":
            to_delete.append(msg)
-    # ac2 has received some messages, this is impossible w/o the trash folder configured, let's
-    # check the configuration.
-    assert ac2.get_config("configured_trash_folder") == "Trash"

    lp.sec("ac2: deleting all messages except second")
    assert len(to_delete) == len(texts) - 1
--- a/python/tox.ini
+++ b/python/tox.ini
@@ -47,7 +47,7 @@ deps =
    restructuredtext_lint 
 commands =
    black --quiet --check --diff setup.py src/deltachat examples/ tests/
-    ruff check src/deltachat tests/ examples/
+    ruff src/deltachat tests/ examples/
    rst-lint --encoding 'utf-8' README.rst

 [testenv:mypy]
@@ -62,8 +62,7 @@ commands =
 [testenv:doc]
 changedir=doc
 deps =
-# Pinned version, workaround for <https://github.com/breathe-doc/breathe/issues/981>
-    sphinx<7.3
+    sphinx
    breathe
    sphinx_rtd_theme
 commands =
--- a/release-date.in
+++ b/release-date.in
@@ -1 +1 @@
-2024-04-16
+2024-04-05
--- a/src/authres.rs
+++ b/src/authres.rs
@@ -6,7 +6,6 @@ use std::collections::BTreeSet;
 use std::fmt;

 use anyhow::Result;
-use deltachat_contact_tools::EmailAddress;
 use mailparse::MailHeaderMap;
 use mailparse::ParsedMail;
 use once_cell::sync::Lazy;
@@ -15,6 +14,7 @@ use crate::config::Config;
 use crate::context::Context;
 use crate::headerdef::HeaderDef;
 use crate::tools::time;
+use crate::tools::EmailAddress;

 /// `authres` is short for the Authentication-Results header, defined in
 /// <https://datatracker.ietf.org/doc/html/rfc8601>, which contains info
--- a/src/blob.rs
+++ b/src/blob.rs
@@ -740,6 +740,7 @@ fn add_white_bg(img: &mut DynamicImage) {
 #[cfg(test)]
 mod tests {
    use fs::File;
+    use image::Pixel;

    use super::*;
    use crate::chat::{self, create_group_chat, ProtectionStatus};
--- a/src/chat.rs
+++ b/src/chat.rs
@@ -8,7 +8,6 @@ use std::str::FromStr;
 use std::time::Duration;

 use anyhow::{anyhow, bail, ensure, Context as _, Result};
-use deltachat_contact_tools::{strip_rtlo_characters, ContactAddress};
 use deltachat_derive::{FromSql, ToSql};
 use serde::{Deserialize, Serialize};
 use strum_macros::EnumIter;
@@ -16,14 +15,13 @@ use strum_macros::EnumIter;
 use crate::aheader::EncryptPreference;
 use crate::blob::BlobObject;
 use crate::chatlist::Chatlist;
-use crate::chatlist_events;
 use crate::color::str_to_color;
 use crate::config::Config;
 use crate::constants::{
    self, Blocked, Chattype, DC_CHAT_ID_ALLDONE_HINT, DC_CHAT_ID_ARCHIVED_LINK,
    DC_CHAT_ID_LAST_SPECIAL, DC_CHAT_ID_TRASH, DC_RESEND_USER_AVATAR_DAYS,
 };
-use crate::contact::{self, Contact, ContactId, Origin};
+use crate::contact::{self, Contact, ContactAddress, ContactId, Origin};
 use crate::context::Context;
 use crate::debug_logging::maybe_set_logging_xdc;
 use crate::download::DownloadState;
@@ -45,7 +43,7 @@ use crate::sync::{self, Sync::*, SyncData};
 use crate::tools::{
    buf_compress, create_id, create_outgoing_rfc724_mid, create_smeared_timestamp,
    create_smeared_timestamps, get_abs_path, gm2local_offset, improve_single_line_input,
-    smeared_time, time, IsNoneOrEmpty, SystemTime,
+    smeared_time, strip_rtlo_characters, time, IsNoneOrEmpty, SystemTime,
 };
 use crate::webxdc::WEBXDC_SUFFIX;

@@ -211,11 +209,24 @@ impl ChatId {
    }

    /// Returns [`ChatId`] of a chat that `msg` belongs to.
+    ///
+    /// Checks that `msg` is assigned to the right chat.
    pub(crate) fn lookup_by_message(msg: &Message) -> Option<Self> {
        if msg.chat_id == DC_CHAT_ID_TRASH {
            return None;
        }
-        if msg.download_state == DownloadState::Undecipherable {
+        if msg.download_state != DownloadState::Done
+            // TODO (2023-09-12): Added for backward compatibility with versions that did not have
+            // `DownloadState::Undecipherable`. Remove eventually with the comment in
+            // `MimeMessage::from_bytes()`.
+            || msg
+                .error
+                .as_ref()
+                .filter(|e| e.starts_with("Decrypting failed:"))
+                .is_some()
+        {
+            // If `msg` is not fully downloaded or undecipherable, it may have been assigned to the
+            // wrong chat (they often get assigned to the 1:1 chat with the sender).
            return None;
        }
        Some(msg.chat_id)
@@ -297,8 +308,6 @@ impl ChatId {
            }
        };
        context.emit_msgs_changed_without_ids();
-        chatlist_events::emit_chatlist_changed(context);
-        chatlist_events::emit_chatlist_item_changed(context, chat_id);
        Ok(chat_id)
    }

@@ -415,7 +424,6 @@ impl ChatId {
                }
            }
        }
-        chatlist_events::emit_chatlist_changed(context);

        if sync.into() {
            // NB: For a 1:1 chat this currently triggers `Contact::block()` on other devices.
@@ -438,8 +446,6 @@ impl ChatId {
    pub(crate) async fn unblock_ex(self, context: &Context, sync: sync::Sync) -> Result<()> {
        self.set_blocked(context, Blocked::Not).await?;

-        chatlist_events::emit_chatlist_changed(context);
-
        if sync.into() {
            let chat = Chat::load_from_db(context, self).await?;
            // TODO: For a 1:1 chat this currently triggers `Contact::unblock()` on other devices.
@@ -450,7 +456,6 @@ impl ChatId {
                .log_err(context)
                .ok();
        }
-
        Ok(())
    }

@@ -494,7 +499,6 @@ impl ChatId {

        if self.set_blocked(context, Blocked::Not).await? {
            context.emit_event(EventType::ChatModified(self));
-            chatlist_events::emit_chatlist_item_changed(context, self);
        }

        if sync.into() {
@@ -537,7 +541,6 @@ impl ChatId {
            .await?;

        context.emit_event(EventType::ChatModified(self));
-        chatlist_events::emit_chatlist_item_changed(context, self);

        // make sure, the receivers will get all keys
        self.reset_gossiped_timestamp(context).await?;
@@ -586,7 +589,6 @@ impl ChatId {
                if protection_status_modified {
                    self.add_protection_msg(context, protect, contact_id, timestamp_sort)
                        .await?;
-                    chatlist_events::emit_chatlist_item_changed(context, self);
                }
                Ok(())
            }
@@ -673,8 +675,6 @@ impl ChatId {
            .await?;

        context.emit_msgs_changed_without_ids();
-        chatlist_events::emit_chatlist_changed(context);
-        chatlist_events::emit_chatlist_item_changed(context, self);

        if sync.into() {
            let chat = Chat::load_from_db(context, self).await?;
@@ -781,7 +781,6 @@ impl ChatId {
            .await?;

        context.emit_msgs_changed_without_ids();
-        chatlist_events::emit_chatlist_changed(context);

        context
            .set_config_internal(Config::LastHousekeeping, None)
@@ -793,7 +792,6 @@ impl ChatId {
            msg.text = stock_str::self_deleted_msg_body(context).await;
            add_device_msg(context, None, Some(&mut msg)).await?;
        }
-        chatlist_events::emit_chatlist_changed(context);

        Ok(())
    }
@@ -1174,15 +1172,6 @@ impl ChatId {
        Ok(self.get_param(context).await?.exists(Param::Devicetalk))
    }

-    /// Returns chat member list timestamp.
-    pub(crate) async fn get_member_list_timestamp(self, context: &Context) -> Result<i64> {
-        Ok(self
-            .get_param(context)
-            .await?
-            .get_i64(Param::MemberListTimestamp)
-            .unwrap_or_default())
-    }
-
    async fn parent_query<T, F>(
        self,
        context: &Context,
@@ -1441,7 +1430,7 @@ impl rusqlite::types::ToSql for ChatId {
 impl rusqlite::types::FromSql for ChatId {
    fn column_result(value: rusqlite::types::ValueRef) -> rusqlite::types::FromSqlResult<Self> {
        i64::column_result(value).and_then(|val| {
-            if 0 <= val && val <= i64::from(u32::MAX) {
+            if 0 <= val && val <= i64::from(std::u32::MAX) {
                Ok(ChatId::new(val as u32))
            } else {
                Err(rusqlite::types::FromSqlError::OutOfRange(val))
@@ -1529,7 +1518,7 @@ impl Chat {
                    Ok(contacts) => {
                        if let Some(contact_id) = contacts.first() {
                            if let Ok(contact) = Contact::get_by_id(context, *contact_id).await {
-                                contact.get_display_name().clone_into(&mut chat_name);
+                                chat_name = contact.get_display_name().to_owned();
                            }
                        }
                    }
@@ -2049,7 +2038,6 @@ impl Chat {
            msg.id = MsgId::new(u32::try_from(raw_id)?);

            maybe_set_logging_xdc(context, msg, self.id).await?;
-            context.update_webxdc_integration_database(msg).await?;
        }
        context.scheduler.interrupt_ephemeral_task().await;
        Ok(msg.id)
@@ -2715,7 +2703,7 @@ async fn send_msg_inner(context: &Context, chat_id: ChatId, msg: &mut Message) -
        }

        if msg.param.exists(Param::SetLatitude) {
-            context.emit_location_changed(Some(ContactId::SELF)).await?;
+            context.emit_event(EventType::LocationChanged(Some(ContactId::SELF)));
        }

        context.scheduler.interrupt_smtp().await;
@@ -2782,11 +2770,6 @@ pub(crate) async fn create_send_msg_jobs(context: &Context, msg: &mut Message) -
        recipients.push(from);
    }

-    // Webxdc integrations are messages, however, shipped with main app and must not be sent out
-    if msg.param.get_int(Param::WebxdcIntegration).is_some() {
-        recipients.clear();
-    }
-
    if recipients.is_empty() {
        // may happen eg. for groups with only SELF and bcc_self disabled
        info!(
@@ -2821,21 +2804,15 @@ pub(crate) async fn create_send_msg_jobs(context: &Context, msg: &mut Message) -
        );
    }

-    let now = smeared_time(context);
+    let now = time();

    if rendered_msg.is_gossiped {
        msg.chat_id.set_gossiped_timestamp(context, now).await?;
    }

-    if msg.param.get_cmd() == SystemMessage::MemberRemovedFromGroup {
-        // Reject member list synchronisation from older messages. See also
-        // `receive_imf::apply_group_changes()`.
+    if rendered_msg.is_group {
        msg.chat_id
-            .update_timestamp(
-                context,
-                Param::MemberListTimestamp,
-                now.saturating_add(constants::TIMESTAMP_SENT_TOLERANCE),
-            )
+            .update_timestamp(context, Param::MemberListTimestamp, now)
            .await?;
    }

@@ -2869,7 +2846,7 @@ pub(crate) async fn create_send_msg_jobs(context: &Context, msg: &mut Message) -
        msg.update_param(context).await?;
    }

-    msg.subject.clone_from(&rendered_msg.subject);
+    msg.subject = rendered_msg.subject.clone();
    msg.update_subject(context).await?;
    let chunk_size = context
        .get_configured_provider()
@@ -3124,9 +3101,7 @@ pub async fn marknoticed_chat(context: &Context, chat_id: ChatId) -> Result<()>
            .await?;
        for chat_id_in_archive in chat_ids_in_archive {
            context.emit_event(EventType::MsgsNoticed(chat_id_in_archive));
-            chatlist_events::emit_chatlist_item_changed(context, chat_id_in_archive);
        }
-        chatlist_events::emit_chatlist_item_changed(context, DC_CHAT_ID_ARCHIVED_LINK);
    } else {
        let exists = context
            .sql
@@ -3153,7 +3128,6 @@ pub async fn marknoticed_chat(context: &Context, chat_id: ChatId) -> Result<()>
    }

    context.emit_event(EventType::MsgsNoticed(chat_id));
-    chatlist_events::emit_chatlist_item_changed(context, chat_id);

    Ok(())
 }
@@ -3221,7 +3195,6 @@ pub(crate) async fn mark_old_messages_as_noticed(

    for c in changed_chats {
        context.emit_event(EventType::MsgsNoticed(c));
-        chatlist_events::emit_chatlist_item_changed(context, c);
    }

    Ok(())
@@ -3384,8 +3357,6 @@ pub async fn create_group_chat(
    }

    context.emit_msgs_changed_without_ids();
-    chatlist_events::emit_chatlist_changed(context);
-    chatlist_events::emit_chatlist_item_changed(context, chat_id);

    if protect == ProtectionStatus::Protected {
        chat_id
@@ -3473,14 +3444,11 @@ pub(crate) async fn create_broadcast_list_ex(
    let chat_id = ChatId::new(u32::try_from(row_id)?);

    context.emit_msgs_changed_without_ids();
-    chatlist_events::emit_chatlist_changed(context);
-
    if sync.into() {
        let id = SyncId::Grpid(grpid);
        let action = SyncAction::CreateBroadcast(chat_name);
        self::sync(context, id, action).await.log_err(context).ok();
    }
-
    Ok(chat_id)
 }

@@ -3751,7 +3719,6 @@ pub(crate) async fn set_muted_ex(
        .await
        .context(format!("Failed to set mute duration for {chat_id}"))?;
    context.emit_event(EventType::ChatModified(chat_id));
-    chatlist_events::emit_chatlist_item_changed(context, chat_id);
    if sync.into() {
        let chat = Chat::load_from_db(context, chat_id).await?;
        chat.sync(context, SyncAction::SetMuted(duration))
@@ -3912,7 +3879,6 @@ async fn rename_ex(
                sync = Nosync;
            }
            context.emit_event(EventType::ChatModified(chat_id));
-            chatlist_events::emit_chatlist_item_changed(context, chat_id);
            success = true;
        }
    }
@@ -3973,7 +3939,6 @@ pub async fn set_chat_profile_image(
        context.emit_msgs_changed(chat_id, msg.id);
    }
    context.emit_event(EventType::ChatModified(chat_id));
-    chatlist_events::emit_chatlist_item_changed(context, chat_id);
    Ok(())
 }

@@ -4120,8 +4085,6 @@ pub async fn resend_msgs(context: &Context, msg_ids: &[MsgId]) -> Result<()> {
            msg_id: msg.id,
        });
        msg.timestamp_sort = create_smeared_timestamp(context);
-        // note(treefit): only matters if it is the last message in chat (but probably to expensive to check, debounce also solves it)
-        chatlist_events::emit_chatlist_item_changed(context, msg.chat_id);
        if !create_send_msg_jobs(context, &mut msg).await?.is_empty() {
            context.scheduler.interrupt_smtp().await;
        }
@@ -4814,9 +4777,9 @@ mod tests {
        Ok(())
    }

-    /// Test parallel removal of user from the chat and leaving the group.
+    /// Test simultaneous removal of user from the chat and leaving the group.
    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_parallel_member_remove() -> Result<()> {
+    async fn test_simultaneous_member_remove() -> Result<()> {
        let mut tcm = TestContextManager::new();

        let alice = tcm.alice().await;
@@ -4847,25 +4810,20 @@ mod tests {
        add_contact_to_chat(&alice, alice_chat_id, alice_claire_contact_id).await?;
        let alice_sent_add_msg = alice.pop_sent_msg().await;

+        // Alice removes Bob from the chat.
+        remove_contact_from_chat(&alice, alice_chat_id, alice_bob_contact_id).await?;
+        let alice_sent_remove_msg = alice.pop_sent_msg().await;
+
        // Bob leaves the chat.
        remove_contact_from_chat(&bob, bob_chat_id, ContactId::SELF).await?;

        // Bob receives a msg about Alice adding Claire to the group.
        bob.recv_msg(&alice_sent_add_msg).await;

-        SystemTime::shift(Duration::from_secs(3600));
-        // This adds Bob because they left quite long ago.
-        let alice_sent_msg = alice.send_text(alice_chat_id, "What a silence!").await;
-        bob.recv_msg(&alice_sent_msg).await;
-
        // Test that add message is rewritten.
-        bob.golden_test_chat(bob_chat_id, "chat_test_parallel_member_remove")
+        bob.golden_test_chat(bob_chat_id, "chat_test_simultaneous_member_remove")
            .await;

-        // Alice removes Bob from the chat.
-        remove_contact_from_chat(&alice, alice_chat_id, alice_bob_contact_id).await?;
-        let alice_sent_remove_msg = alice.pop_sent_msg().await;
-
        // Bob receives a msg about Alice removing him from the group.
        let bob_received_remove_msg = bob.recv_msg(&alice_sent_remove_msg).await;

@@ -4902,13 +4860,8 @@ mod tests {
        bob.recv_msg(&sent_msg).await;
        remove_contact_from_chat(&bob, bob_chat_id, bob_fiona_contact_id).await?;

-        // This doesn't add Fiona back because Bob just removed them.
        let sent_msg = alice.send_text(alice_chat_id, "Welcome, Fiona!").await;
        bob.recv_msg(&sent_msg).await;
-
-        SystemTime::shift(Duration::from_secs(3600));
-        let sent_msg = alice.send_text(alice_chat_id, "Welcome back, Fiona!").await;
-        bob.recv_msg(&sent_msg).await;
        bob.golden_test_chat(bob_chat_id, "chat_test_msg_with_implicit_member_add")
            .await;
        Ok(())
--- a/src/chatlist.rs
+++ b/src/chatlist.rs
@@ -416,7 +416,7 @@ impl Chatlist {
        if chat.id.is_archived_link() {
            Ok(Default::default())
        } else if let Some(lastmsg) = lastmsg.filter(|msg| msg.from_id != ContactId::UNDEFINED) {
-            Summary::new_with_reaction_details(context, &lastmsg, chat, lastcontact.as_ref()).await
+            Summary::new(context, &lastmsg, chat, lastcontact.as_ref()).await
        } else {
            Ok(Summary {
                text: stock_str::no_messages(context).await,
--- a/src/config.rs
+++ b/src/config.rs
@@ -6,7 +6,6 @@ use std::str::FromStr;

 use anyhow::{ensure, Context as _, Result};
 use base64::Engine as _;
-use deltachat_contact_tools::addr_cmp;
 use serde::{Deserialize, Serialize};
 use strum::{EnumProperty, IntoEnumIterator};
 use strum_macros::{AsRefStr, Display, EnumIter, EnumProperty, EnumString};
@@ -14,6 +13,7 @@ use tokio::fs;

 use crate::blob::BlobObject;
 use crate::constants::{self, DC_VERSION_STR};
+use crate::contact::addr_cmp;
 use crate::context::Context;
 use crate::events::EventType;
 use crate::log::LogExt;
@@ -356,9 +356,6 @@ pub enum Config {
    /// This key is sent to the self_reporting bot so that the bot can recognize the user
    /// without storing the email address
    SelfReportingId,
-
-    /// MsgId of webxdc map integration.
-    WebxdcIntegration,
 }

 impl Config {
@@ -671,7 +668,7 @@ impl Context {
        {
            return Ok(());
        }
-        Box::pin(self.send_sync_msg()).await.log_err(self).ok();
+        self.send_sync_msg().await.log_err(self).ok();
        Ok(())
    }

--- a/src/configure.rs
+++ b/src/configure.rs
@@ -16,7 +16,6 @@ mod server_params;
 use anyhow::{bail, ensure, Context as _, Result};
 use auto_mozilla::moz_autoconfigure;
 use auto_outlook::outlk_autodiscover;
-use deltachat_contact_tools::EmailAddress;
 use futures::FutureExt;
 use futures_lite::FutureExt as _;
 use percent_encoding::{utf8_percent_encode, NON_ALPHANUMERIC};
@@ -24,6 +23,7 @@ use server_params::{expand_param_vector, ServerParams};
 use tokio::task;

 use crate::config::{self, Config};
+use crate::contact::addr_cmp;
 use crate::context::Context;
 use crate::imap::{session::Session as ImapSession, Imap};
 use crate::log::LogExt;
@@ -35,9 +35,8 @@ use crate::smtp::Smtp;
 use crate::socks::Socks5Config;
 use crate::stock_str;
 use crate::sync::Sync::*;
-use crate::tools::time;
+use crate::tools::{time, EmailAddress};
 use crate::{chat, e2ee, provider};
-use deltachat_contact_tools::addr_cmp;

 macro_rules! progress {
    ($context:tt, $progress:expr, $comment:expr) => {
@@ -357,8 +356,8 @@ async fn configure(ctx: &Context, param: &mut LoginParam) -> Result<()> {
        let mut smtp_configured = false;
        let mut errors = Vec::new();
        for smtp_server in smtp_servers {
-            smtp_param.user.clone_from(&smtp_server.username);
-            smtp_param.server.clone_from(&smtp_server.hostname);
+            smtp_param.user = smtp_server.username.clone();
+            smtp_param.server = smtp_server.hostname.clone();
            smtp_param.port = smtp_server.port;
            smtp_param.security = smtp_server.socket;
            smtp_param.certificate_checks = match smtp_server.strict_tls {
@@ -404,8 +403,8 @@ async fn configure(ctx: &Context, param: &mut LoginParam) -> Result<()> {
    let imap_servers_count = imap_servers.len();
    let mut errors = Vec::new();
    for (imap_server_index, imap_server) in imap_servers.into_iter().enumerate() {
-        param.imap.user.clone_from(&imap_server.username);
-        param.imap.server.clone_from(&imap_server.hostname);
+        param.imap.user = imap_server.username.clone();
+        param.imap.server = imap_server.hostname.clone();
        param.imap.port = imap_server.port;
        param.imap.security = imap_server.socket;
        param.imap.certificate_checks = match imap_server.strict_tls {
--- a/src/constants.rs
+++ b/src/constants.rs
@@ -219,10 +219,6 @@ pub(crate) const DEFAULT_MAX_SMTP_RCPT_TO: usize = 50;
 /// How far the last quota check needs to be in the past to be checked by the background function (in seconds).
 pub(crate) const DC_BACKGROUND_FETCH_QUOTA_CHECK_RATELIMIT: u64 = 12 * 60 * 60; // 12 hours

-/// How far in the future the sender timestamp of a message is allowed to be, in seconds. Also used
-/// in the group membership consistency algo to reject outdated membership changes.
-pub(crate) const TIMESTAMP_SENT_TOLERANCE: i64 = 60;
-
 #[cfg(test)]
 mod tests {
    use num_traits::FromPrimitive;
--- a/src/contact.rs
+++ b/src/contact.rs
@@ -3,17 +3,15 @@
 use std::cmp::Reverse;
 use std::collections::BinaryHeap;
 use std::fmt;
+use std::ops::Deref;
 use std::path::{Path, PathBuf};
 use std::time::UNIX_EPOCH;

 use anyhow::{bail, ensure, Context as _, Result};
 use async_channel::{self as channel, Receiver, Sender};
-pub use deltachat_contact_tools::may_be_valid_addr;
-use deltachat_contact_tools::{
-    addr_cmp, addr_normalize, normalize_name, sanitize_name_and_addr, strip_rtlo_characters,
-    ContactAddress,
-};
 use deltachat_derive::{FromSql, ToSql};
+use once_cell::sync::Lazy;
+use regex::Regex;
 use rusqlite::OptionalExtension;
 use serde::{Deserialize, Serialize};
 use tokio::task;
@@ -35,12 +33,60 @@ use crate::param::{Param, Params};
 use crate::peerstate::Peerstate;
 use crate::sql::{self, params_iter};
 use crate::sync::{self, Sync::*};
-use crate::tools::{duration_to_str, get_abs_path, improve_single_line_input, time, SystemTime};
-use crate::{chat, chatlist_events, stock_str};
+use crate::tools::{
+    duration_to_str, get_abs_path, improve_single_line_input, strip_rtlo_characters, time,
+    EmailAddress, SystemTime,
+};
+use crate::{chat, stock_str};

 /// Time during which a contact is considered as seen recently.
 const SEEN_RECENTLY_SECONDS: i64 = 600;

+/// Valid contact address.
+#[derive(Debug, Clone)]
+pub(crate) struct ContactAddress(String);
+
+impl Deref for ContactAddress {
+    type Target = str;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl AsRef<str> for ContactAddress {
+    fn as_ref(&self) -> &str {
+        &self.0
+    }
+}
+
+impl fmt::Display for ContactAddress {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+impl ContactAddress {
+    /// Constructs a new contact address from string,
+    /// normalizing and validating it.
+    pub fn new(s: &str) -> Result<Self> {
+        let addr = addr_normalize(s);
+        if !may_be_valid_addr(&addr) {
+            bail!("invalid address {:?}", s);
+        }
+        Ok(Self(addr.to_string()))
+    }
+}
+
+/// Allow converting [`ContactAddress`] to an SQLite type.
+impl rusqlite::types::ToSql for ContactAddress {
+    fn to_sql(&self) -> rusqlite::Result<rusqlite::types::ToSqlOutput> {
+        let val = rusqlite::types::Value::Text(self.0.to_string());
+        let out = rusqlite::types::ToSqlOutput::Owned(val);
+        Ok(out)
+    }
+}
+
 /// Contact ID, including reserved IDs.
 ///
 /// Some contact IDs are reserved to identify special contacts.  This
@@ -714,7 +760,6 @@ impl Contact {
                            if count > 0 {
                                // Chat name updated
                                context.emit_event(EventType::ChatModified(chat_id));
-                                chatlist_events::emit_chatlist_items_changed_for_contact(context, contact_id);
                            }
                        }
                    }
@@ -751,9 +796,7 @@ impl Contact {
            Ok(row_id)
        }).await?;

-        let contact_id = ContactId::new(row_id);
-
-        Ok((contact_id, sth_modified))
+        Ok((ContactId::new(row_id), sth_modified))
    }

    /// Add a number of contacts.
@@ -1008,52 +1051,55 @@ impl Contact {
            "Can not provide encryption info for special contact"
        );

-        let contact = Contact::get_by_id(context, contact_id).await?;
-        let loginparam = LoginParam::load_configured_params(context).await?;
-        let peerstate = Peerstate::from_addr(context, &contact.addr).await?;
+        let mut ret = String::new();
+        if let Ok(contact) = Contact::get_by_id(context, contact_id).await {
+            let loginparam = LoginParam::load_configured_params(context).await?;
+            let peerstate = Peerstate::from_addr(context, &contact.addr).await?;

-        let Some(peerstate) = peerstate.filter(|peerstate| peerstate.peek_key(false).is_some())
-        else {
-            return Ok(stock_str::encr_none(context).await);
-        };
+            if let Some(peerstate) =
+                peerstate.filter(|peerstate| peerstate.peek_key(false).is_some())
+            {
+                let stock_message = match peerstate.prefer_encrypt {
+                    EncryptPreference::Mutual => stock_str::e2e_preferred(context).await,
+                    EncryptPreference::NoPreference => stock_str::e2e_available(context).await,
+                    EncryptPreference::Reset => stock_str::encr_none(context).await,
+                };

-        let stock_message = match peerstate.prefer_encrypt {
-            EncryptPreference::Mutual => stock_str::e2e_preferred(context).await,
-            EncryptPreference::NoPreference => stock_str::e2e_available(context).await,
-            EncryptPreference::Reset => stock_str::encr_none(context).await,
-        };
+                let finger_prints = stock_str::finger_prints(context).await;
+                ret += &format!("{stock_message}.\n{finger_prints}:");

-        let finger_prints = stock_str::finger_prints(context).await;
-        let mut ret = format!("{stock_message}.\n{finger_prints}:");
-
-        let fingerprint_self = load_self_public_key(context)
-            .await?
-            .fingerprint()
-            .to_string();
-        let fingerprint_other_verified = peerstate
-            .peek_key(true)
-            .map(|k| k.fingerprint().to_string())
-            .unwrap_or_default();
-        let fingerprint_other_unverified = peerstate
-            .peek_key(false)
-            .map(|k| k.fingerprint().to_string())
-            .unwrap_or_default();
-        if loginparam.addr < peerstate.addr {
-            cat_fingerprint(&mut ret, &loginparam.addr, &fingerprint_self, "");
-            cat_fingerprint(
-                &mut ret,
-                &peerstate.addr,
-                &fingerprint_other_verified,
-                &fingerprint_other_unverified,
-            );
-        } else {
-            cat_fingerprint(
-                &mut ret,
-                &peerstate.addr,
-                &fingerprint_other_verified,
-                &fingerprint_other_unverified,
-            );
-            cat_fingerprint(&mut ret, &loginparam.addr, &fingerprint_self, "");
+                let fingerprint_self = load_self_public_key(context)
+                    .await?
+                    .fingerprint()
+                    .to_string();
+                let fingerprint_other_verified = peerstate
+                    .peek_key(true)
+                    .map(|k| k.fingerprint().to_string())
+                    .unwrap_or_default();
+                let fingerprint_other_unverified = peerstate
+                    .peek_key(false)
+                    .map(|k| k.fingerprint().to_string())
+                    .unwrap_or_default();
+                if loginparam.addr < peerstate.addr {
+                    cat_fingerprint(&mut ret, &loginparam.addr, &fingerprint_self, "");
+                    cat_fingerprint(
+                        &mut ret,
+                        &peerstate.addr,
+                        &fingerprint_other_verified,
+                        &fingerprint_other_unverified,
+                    );
+                } else {
+                    cat_fingerprint(
+                        &mut ret,
+                        &peerstate.addr,
+                        &fingerprint_other_verified,
+                        &fingerprint_other_unverified,
+                    );
+                    cat_fingerprint(&mut ret, &loginparam.addr, &fingerprint_self, "");
+                }
+            } else {
+                ret += &stock_str::encr_none(context).await;
+            }
        }

        Ok(ret)
@@ -1369,6 +1415,46 @@ impl Contact {
    }
 }

+/// Returns false if addr is an invalid address, otherwise true.
+pub fn may_be_valid_addr(addr: &str) -> bool {
+    let res = EmailAddress::new(addr);
+    res.is_ok()
+}
+
+/// Returns address lowercased,
+/// with whitespace trimmed and `mailto:` prefix removed.
+pub fn addr_normalize(addr: &str) -> String {
+    let norm = addr.trim().to_lowercase();
+
+    if norm.starts_with("mailto:") {
+        norm.get(7..).unwrap_or(&norm).to_string()
+    } else {
+        norm
+    }
+}
+
+fn sanitize_name_and_addr(name: &str, addr: &str) -> (String, String) {
+    static ADDR_WITH_NAME_REGEX: Lazy<Regex> = Lazy::new(|| Regex::new("(.*)<(.*)>").unwrap());
+    if let Some(captures) = ADDR_WITH_NAME_REGEX.captures(addr.as_ref()) {
+        (
+            if name.is_empty() {
+                strip_rtlo_characters(
+                    &captures
+                        .get(1)
+                        .map_or("".to_string(), |m| normalize_name(m.as_str())),
+                )
+            } else {
+                strip_rtlo_characters(name)
+            },
+            captures
+                .get(2)
+                .map_or("".to_string(), |m| m.as_str().to_string()),
+        )
+    } else {
+        (strip_rtlo_characters(name), addr.to_string())
+    }
+}
+
 pub(crate) async fn set_blocked(
    context: &Context,
    sync: sync::Sync,
@@ -1441,7 +1527,6 @@ WHERE type=? AND id IN (
        }
    }

-    chatlist_events::emit_chatlist_changed(context);
    Ok(())
 }

@@ -1492,7 +1577,6 @@ pub(crate) async fn set_profile_image(
    if changed {
        contact.update_param(context).await?;
        context.emit_event(EventType::ContactsChanged(Some(contact_id)));
-        chatlist_events::emit_chatlist_item_changed_for_contact_chat(context, contact_id).await;
    }
    Ok(())
 }
@@ -1548,7 +1632,6 @@ pub(crate) async fn update_last_seen(
        > 0
        && timestamp > time() - SEEN_RECENTLY_SECONDS
    {
-        context.emit_event(EventType::ContactsChanged(Some(contact_id)));
        context
            .scheduler
            .interrupt_recently_seen(contact_id, timestamp)
@@ -1557,6 +1640,26 @@ pub(crate) async fn update_last_seen(
    Ok(())
 }

+/// Normalize a name.
+///
+/// - Remove quotes (come from some bad MUA implementations)
+/// - Trims the resulting string
+///
+/// Typically, this function is not needed as it is called implicitly by `Contact::add_address_book`.
+pub fn normalize_name(full_name: &str) -> String {
+    let full_name = full_name.trim();
+    if full_name.is_empty() {
+        return full_name.into();
+    }
+
+    match full_name.as_bytes() {
+        [b'\'', .., b'\''] | [b'\"', .., b'\"'] | [b'<', .., b'>'] => full_name
+            .get(1..full_name.len() - 1)
+            .map_or("".to_string(), |s| s.trim().to_string()),
+        _ => full_name.to_string(),
+    }
+}
+
 fn cat_fingerprint(
    ret: &mut String,
    addr: &str,
@@ -1580,6 +1683,14 @@ fn cat_fingerprint(
    }
 }

+/// Compares two email addresses, normalizing them beforehand.
+pub fn addr_cmp(addr1: &str, addr2: &str) -> bool {
+    let norm1 = addr_normalize(addr1);
+    let norm2 = addr_normalize(addr2);
+
+    norm1 == norm2
+}
+
 fn split_address_book(book: &str) -> Vec<(&str, &str)> {
    book.lines()
        .collect::<Vec<&str>>()
@@ -1651,7 +1762,6 @@ impl RecentlySeenLoop {
            .unwrap_or_default();

        loop {
-            let now = SystemTime::now();
            let (until, contact_id) =
                if let Some((Reverse(timestamp), contact_id)) = unseen_queue.peek() {
                    (
@@ -1677,11 +1787,6 @@ impl RecentlySeenLoop {
                        // Timeout, notify about contact.
                        if let Some(contact_id) = contact_id {
                            context.emit_event(EventType::ContactsChanged(Some(*contact_id)));
-                            chatlist_events::emit_chatlist_item_changed_for_contact_chat(
-                                &context,
-                                *contact_id,
-                            )
-                            .await;
                            unseen_queue.pop();
                        }
                    }
@@ -1699,10 +1804,7 @@ impl RecentlySeenLoop {
                        timestamp,
                    })) => {
                        // Received an interrupt.
-                        if contact_id != ContactId::UNDEFINED {
-                            unseen_queue
-                                .push((Reverse(timestamp + SEEN_RECENTLY_SECONDS), contact_id));
-                        }
+                        unseen_queue.push((Reverse(timestamp + SEEN_RECENTLY_SECONDS), contact_id));
                    }
                }
            } else {
@@ -1714,18 +1816,13 @@ impl RecentlySeenLoop {
                // Event is already in the past.
                if let Some(contact_id) = contact_id {
                    context.emit_event(EventType::ContactsChanged(Some(*contact_id)));
-                    chatlist_events::emit_chatlist_item_changed_for_contact_chat(
-                        &context,
-                        *contact_id,
-                    )
-                    .await;
                }
                unseen_queue.pop();
            }
        }
    }

-    pub(crate) fn try_interrupt(&self, contact_id: ContactId, timestamp: i64) {
+    pub(crate) fn interrupt(&self, contact_id: ContactId, timestamp: i64) {
        self.interrupt_send
            .try_send(RecentlySeenInterrupt {
                contact_id,
@@ -1734,17 +1831,6 @@ impl RecentlySeenLoop {
            .ok();
    }

-    #[cfg(test)]
-    pub(crate) async fn interrupt(&self, contact_id: ContactId, timestamp: i64) {
-        self.interrupt_send
-            .send(RecentlySeenInterrupt {
-                contact_id,
-                timestamp,
-            })
-            .await
-            .unwrap();
-    }
-
    pub(crate) fn abort(self) {
        self.handle.abort();
    }
@@ -1752,8 +1838,6 @@ impl RecentlySeenLoop {

 #[cfg(test)]
 mod tests {
-    use deltachat_contact_tools::may_be_valid_addr;
-
    use super::*;
    use crate::chat::{get_chat_contacts, send_text_msg, Chat};
    use crate::chatlist::Chatlist;
@@ -1893,6 +1977,18 @@ mod tests {
        Ok(())
    }

+    #[test]
+    fn test_contact_address() -> Result<()> {
+        let alice_addr = "alice@example.org";
+        let contact_address = ContactAddress::new(alice_addr)?;
+        assert_eq!(contact_address.as_ref(), alice_addr);
+
+        let invalid_addr = "<> foobar";
+        assert!(ContactAddress::new(invalid_addr).is_err());
+
+        Ok(())
+    }
+
    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
    async fn test_add_or_lookup() {
        // add some contacts, this also tests add_address_book()
@@ -2716,44 +2812,6 @@ Hi."#;
        Ok(())
    }

-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_was_seen_recently_event() -> Result<()> {
-        let mut tcm = TestContextManager::new();
-        let alice = tcm.alice().await;
-        let bob = tcm.bob().await;
-        let recently_seen_loop = RecentlySeenLoop::new(bob.ctx.clone());
-        let chat = bob.create_chat(&alice).await;
-        let contacts = chat::get_chat_contacts(&bob, chat.id).await?;
-
-        for _ in 0..2 {
-            let chat = alice.create_chat(&bob).await;
-            let sent_msg = alice.send_text(chat.id, "moin").await;
-            let contact = Contact::get_by_id(&bob, *contacts.first().unwrap()).await?;
-            assert!(!contact.was_seen_recently());
-            bob.evtracker.clear_events();
-            bob.recv_msg(&sent_msg).await;
-            let contact = Contact::get_by_id(&bob, *contacts.first().unwrap()).await?;
-            assert!(contact.was_seen_recently());
-            bob.evtracker
-                .get_matching(|evt| matches!(evt, EventType::ContactsChanged { .. }))
-                .await;
-            recently_seen_loop
-                .interrupt(contact.id, contact.last_seen)
-                .await;
-
-            // Wait for `was_seen_recently()` to turn off.
-            bob.evtracker.clear_events();
-            SystemTime::shift(Duration::from_secs(SEEN_RECENTLY_SECONDS as u64 * 2));
-            recently_seen_loop.interrupt(ContactId::UNDEFINED, 0).await;
-            let contact = Contact::get_by_id(&bob, *contacts.first().unwrap()).await?;
-            assert!(!contact.was_seen_recently());
-            bob.evtracker
-                .get_matching(|evt| matches!(evt, EventType::ContactsChanged { .. }))
-                .await;
-        }
-        Ok(())
-    }
-
    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
    async fn test_verified_by_none() -> Result<()> {
        let mut tcm = TestContextManager::new();
--- a/src/context.rs
+++ b/src/context.rs
@@ -16,7 +16,6 @@ use tokio::sync::{Mutex, Notify, RwLock};

 use crate::aheader::EncryptPreference;
 use crate::chat::{get_chat_cnt, ChatId, ProtectionStatus};
-use crate::chatlist_events;
 use crate::config::Config;
 use crate::constants::{
    self, DC_BACKGROUND_FETCH_QUOTA_CHECK_RATELIMIT, DC_CHAT_ID_TRASH, DC_VERSION_STR,
@@ -594,32 +593,11 @@ impl Context {
    /// Emits a MsgsChanged event with specified chat and message ids
    pub fn emit_msgs_changed(&self, chat_id: ChatId, msg_id: MsgId) {
        self.emit_event(EventType::MsgsChanged { chat_id, msg_id });
-        chatlist_events::emit_chatlist_changed(self);
-        chatlist_events::emit_chatlist_item_changed(self, chat_id);
    }

    /// Emits an IncomingMsg event with specified chat and message ids
    pub fn emit_incoming_msg(&self, chat_id: ChatId, msg_id: MsgId) {
        self.emit_event(EventType::IncomingMsg { chat_id, msg_id });
-        chatlist_events::emit_chatlist_changed(self);
-        chatlist_events::emit_chatlist_item_changed(self, chat_id);
-    }
-
-    /// Emits an LocationChanged event and a WebxdcStatusUpdate in case there is a maps integration
-    pub async fn emit_location_changed(&self, contact_id: Option<ContactId>) -> Result<()> {
-        self.emit_event(EventType::LocationChanged(contact_id));
-
-        if let Some(msg_id) = self
-            .get_config_parsed::<u32>(Config::WebxdcIntegration)
-            .await?
-        {
-            self.emit_event(EventType::WebxdcStatusUpdate {
-                msg_id: MsgId::new(msg_id),
-                status_update_serial: Default::default(),
-            })
-        }
-
-        Ok(())
    }

    /// Returns a receiver for emitted events.
@@ -1648,7 +1626,6 @@ mod tests {
            "socks5_user",
            "socks5_password",
            "key_id",
-            "webxdc_integration",
        ];
        let t = TestContext::new().await;
        let info = t.get_info().await.unwrap();
--- a/src/debug_logging.rs
+++ b/src/debug_logging.rs
@@ -64,7 +64,6 @@ pub async fn debug_logging_loop(context: &Context, events: Receiver<DebugEventLo
                    document: None,
                    uid: None,
                },
-                time,
            )
            .await
        {
--- a/src/decrypt.rs
+++ b/src/decrypt.rs
@@ -4,12 +4,12 @@ use std::collections::HashSet;
 use std::str::FromStr;

 use anyhow::Result;
-use deltachat_contact_tools::addr_cmp;
 use mailparse::ParsedMail;

 use crate::aheader::Aheader;
 use crate::authres::handle_authres;
 use crate::authres::{self, DkimResults};
+use crate::contact::addr_cmp;
 use crate::context::Context;
 use crate::headerdef::{HeaderDef, HeaderDefMap};
 use crate::key::{DcKey, Fingerprint, SignedPublicKey, SignedSecretKey};
--- a/src/download.rs
+++ b/src/download.rs
@@ -13,7 +13,7 @@ use crate::imap::session::Session;
 use crate::message::{Message, MsgId, Viewtype};
 use crate::mimeparser::{MimeMessage, Part};
 use crate::tools::time;
-use crate::{chatlist_events, stock_str, EventType};
+use crate::{stock_str, EventType};

 /// Download limits should not be used below `MIN_DOWNLOAD_LIMIT`.
 ///
@@ -115,7 +115,6 @@ impl MsgId {
            chat_id: msg.chat_id,
            msg_id: self,
        });
-        chatlist_events::emit_chatlist_item_changed(context, msg.chat_id);
        Ok(())
    }
 }
@@ -449,9 +448,10 @@ mod tests {
        )
        .await?;
        assert_eq!(get_chat_msgs(&bob, chat_id).await?.len(), 0);
-        assert!(Message::load_from_db_optional(&bob, msg.id)
+        assert!(Message::load_from_db(&bob, msg.id)
            .await?
-            .is_none());
+            .chat_id
+            .is_trash());

        Ok(())
    }
@@ -507,9 +507,10 @@ mod tests {
        // (usually mdn are too small for not being downloaded directly)
        receive_imf_from_inbox(&bob, "bar@example.org", raw, false, None, false).await?;
        assert_eq!(get_chat_msgs(&bob, chat_id).await?.len(), 0);
-        assert!(Message::load_from_db_optional(&bob, msg.id)
+        assert!(Message::load_from_db(&bob, msg.id)
            .await?
-            .is_none());
+            .chat_id
+            .is_trash());

        Ok(())
    }
--- a/src/ephemeral.rs
+++ b/src/ephemeral.rs
@@ -392,8 +392,7 @@ WHERE
 SELECT id, chat_id, type
 FROM msgs
 WHERE
-  timestamp < ?1
-  AND timestamp_rcvd < ?1
+  timestamp < ?
  AND chat_id > ?
  AND chat_id != ?
  AND chat_id != ?
@@ -491,7 +490,7 @@ async fn next_delete_device_after_timestamp(context: &Context) -> Result<Option<
            .sql
            .query_get_value(
                r#"
-                SELECT min(max(timestamp, timestamp_rcvd))
+                SELECT min(timestamp)
                FROM msgs
                WHERE chat_id > ?
                  AND chat_id != ?
@@ -1098,8 +1097,8 @@ mod tests {
            })
            .await;

-        let loaded = Message::load_from_db_optional(t, msg_id).await?;
-        assert!(loaded.is_none());
+        let loaded = Message::load_from_db(t, msg_id).await?;
+        assert_eq!(loaded.chat_id, DC_CHAT_ID_TRASH);

        // Check that the msg was deleted locally.
        check_msg_is_deleted(t, chat, msg_id).await;
--- a/src/events.rs
+++ b/src/events.rs
@@ -1,9 +1,8 @@
 //! # Events specification.

-use anyhow::Result;
-use tokio::sync::Mutex;
+use async_channel::{self as channel, Receiver, Sender, TrySendError};
+use pin_project::pin_project;

-pub(crate) mod chatlist_events;
 mod payload;

 pub use self::payload::EventType;
@@ -11,11 +10,8 @@ pub use self::payload::EventType;
 /// Event channel.
 #[derive(Debug, Clone)]
 pub struct Events {
-    /// Unused receiver to prevent the channel from closing.
-    _receiver: async_broadcast::InactiveReceiver<Event>,
-
-    /// Sender side of the event channel.
-    sender: async_broadcast::Sender<Event>,
+    receiver: Receiver<Event>,
+    sender: Sender<Event>,
 }

 impl Default for Events {
@@ -27,30 +23,33 @@ impl Default for Events {
 impl Events {
    /// Creates a new event channel.
    pub fn new() -> Self {
-        let (mut sender, _receiver) = async_broadcast::broadcast(1_000);
+        let (sender, receiver) = channel::bounded(1_000);

-        // We only keep this receiver around
-        // to prevent the channel from closing.
-        // Deactivating it to prevent it from consuming memory
-        // holding events that are not going to be received.
-        let _receiver = _receiver.deactivate();
-
-        // Remove oldest event on overflow.
-        sender.set_overflow(true);
-
-        Self { _receiver, sender }
+        Self { receiver, sender }
    }

    /// Emits an event into event channel.
    ///
    /// If the channel is full, deletes the oldest event first.
    pub fn emit(&self, event: Event) {
-        self.sender.try_broadcast(event).ok();
+        match self.sender.try_send(event) {
+            Ok(()) => {}
+            Err(TrySendError::Full(event)) => {
+                // when we are full, we pop remove the oldest event and push on the new one
+                let _ = self.receiver.try_recv();
+
+                // try again
+                self.emit(event);
+            }
+            Err(TrySendError::Closed(_)) => {
+                unreachable!("unable to emit event, channel disconnected");
+            }
+        }
    }

    /// Creates an event emitter.
    pub fn get_emitter(&self) -> EventEmitter {
-        EventEmitter(Mutex::new(self.sender.new_receiver()))
+        EventEmitter(self.receiver.clone())
    }
 }

@@ -60,34 +59,30 @@ impl Events {
 /// created events emitted by the [`Context`] will only be delivered to one of the
 /// `EventEmitter`s.
 ///
+/// The `EventEmitter` is also a [`Stream`], so a typical usage is in a `while let` loop.
+///
 /// [`Context`]: crate::context::Context
 /// [`Context::get_event_emitter`]: crate::context::Context::get_event_emitter
-#[derive(Debug)]
-pub struct EventEmitter(Mutex<async_broadcast::Receiver<Event>>);
+/// [`Stream`]: futures::stream::Stream
+#[derive(Debug, Clone)]
+#[pin_project]
+pub struct EventEmitter(#[pin] Receiver<Event>);

 impl EventEmitter {
    /// Async recv of an event. Return `None` if the `Sender` has been dropped.
-    ///
-    /// [`try_recv`]: Self::try_recv
    pub async fn recv(&self) -> Option<Event> {
-        let mut lock = self.0.lock().await;
-        lock.recv().await.ok()
+        self.0.recv().await.ok()
    }
+}

-    /// Tries to receive an event without blocking.
-    ///
-    /// Returns error if no events are available for reception
-    /// or if receiver mutex is locked by a concurrent call to [`recv`]
-    /// or `try_recv`.
-    ///
-    /// [`recv`]: Self::recv
-    pub fn try_recv(&self) -> Result<Event> {
-        // Using `try_lock` instead of `lock`
-        // to avoid blocking
-        // in case there is a concurrent call to `recv`.
-        let mut lock = self.0.try_lock()?;
-        let event = lock.try_recv()?;
-        Ok(event)
+impl futures::stream::Stream for EventEmitter {
+    type Item = Event;
+
+    fn poll_next(
+        self: std::pin::Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+    ) -> std::task::Poll<Option<Self::Item>> {
+        self.project().0.poll_next(cx)
    }
 }

--- a/src/events/chatlist_events.rs
+++ b/src/events/chatlist_events.rs
@@ -1,643 +0,0 @@
-use crate::{chat::ChatId, contact::ContactId, context::Context, EventType};
-
-/// order or content of chatlist changes (chat ids, not the actual chatlist item)
-pub(crate) fn emit_chatlist_changed(context: &Context) {
-    context.emit_event(EventType::ChatlistChanged);
-}
-
-/// Chatlist item of a specific chat changed
-pub(crate) fn emit_chatlist_item_changed(context: &Context, chat_id: ChatId) {
-    context.emit_event(EventType::ChatlistItemChanged {
-        chat_id: Some(chat_id),
-    });
-}
-
-/// Used when you don't know which chatlist items changed, this reloads all cached chatlist items in the UI
-///
-/// Avoid calling this when you can find out the affected chat ids easialy (without extra expensive db queries).
-///
-/// This method is not public, so you have to define and document your new case here in this file.
-fn emit_unknown_chatlist_items_changed(context: &Context) {
-    context.emit_event(EventType::ChatlistItemChanged { chat_id: None });
-}
-
-/// update event for the 1:1 chat with the contact
-/// used when recently seen changes and when profile image changes
-pub(crate) async fn emit_chatlist_item_changed_for_contact_chat(
-    context: &Context,
-    contact_id: ContactId,
-) {
-    match ChatId::lookup_by_contact(context, contact_id).await {
-        Ok(Some(chat_id)) => self::emit_chatlist_item_changed(context, chat_id),
-        Ok(None) => {}
-        Err(error) => context.emit_event(EventType::Error(format!(
-            "failed to find chat id for contact for chatlist event: {error:?}"
-        ))),
-    }
-}
-
-/// update items for chats that have the contact
-/// used when contact changes their name or did AEAP for example
-///
-/// The most common case is that the contact changed their name
-/// and their name should be updated in the chatlistitems for the chats
-/// where they sent the last message as there their name is shown in the summary on those
-pub(crate) fn emit_chatlist_items_changed_for_contact(context: &Context, _contact_id: ContactId) {
-    // note:(treefit): it is too expensive to find the right chats
-    // so we'll just tell ui to reload every loaded item
-    emit_unknown_chatlist_items_changed(context)
-    // note:(treefit): in the future we could instead emit an extra event for this and also store contact id in the chatlistitems
-    // (contact id for dm chats and contact id of contact that wrote the message in the summary)
-    // the ui could then look for this info in the cache and only reload the needed chats.
-}
-
-/// Tests for chatlist events
-///
-/// Only checks if the events are emitted,
-/// does not check for excess/too-many events
-#[cfg(test)]
-mod test_chatlist_events {
-
-    use std::{
-        sync::atomic::{AtomicBool, Ordering},
-        time::Duration,
-    };
-
-    use crate::{
-        chat::{
-            self, create_broadcast_list, create_group_chat, set_muted, ChatId, ChatVisibility,
-            MuteDuration, ProtectionStatus,
-        },
-        config::Config,
-        constants::*,
-        contact::Contact,
-        message::{self, Message, MessageState},
-        reaction,
-        receive_imf::receive_imf,
-        securejoin::{get_securejoin_qr, join_securejoin},
-        test_utils::{TestContext, TestContextManager},
-        EventType,
-    };
-
-    use crate::tools::SystemTime;
-    use anyhow::Result;
-
-    async fn wait_for_chatlist_and_specific_item(context: &TestContext, chat_id: ChatId) {
-        let first_event_is_item = AtomicBool::new(false);
-        context
-            .evtracker
-            .get_matching(|evt| match evt {
-                EventType::ChatlistItemChanged {
-                    chat_id: Some(ev_chat_id),
-                } => {
-                    if ev_chat_id == &chat_id {
-                        first_event_is_item.store(true, Ordering::Relaxed);
-                        true
-                    } else {
-                        false
-                    }
-                }
-                EventType::ChatlistChanged => true,
-                _ => false,
-            })
-            .await;
-        if first_event_is_item.load(Ordering::Relaxed) {
-            wait_for_chatlist(context).await;
-        } else {
-            wait_for_chatlist_specific_item(context, chat_id).await;
-        }
-    }
-
-    async fn wait_for_chatlist_specific_item(context: &TestContext, chat_id: ChatId) {
-        context
-            .evtracker
-            .get_matching(|evt| match evt {
-                EventType::ChatlistItemChanged {
-                    chat_id: Some(ev_chat_id),
-                } => ev_chat_id == &chat_id,
-                _ => false,
-            })
-            .await;
-    }
-
-    async fn wait_for_chatlist_all_items(context: &TestContext) {
-        context
-            .evtracker
-            .get_matching(|evt| matches!(evt, EventType::ChatlistItemChanged { chat_id: None }))
-            .await;
-    }
-
-    async fn wait_for_chatlist(context: &TestContext) {
-        context
-            .evtracker
-            .get_matching(|evt| matches!(evt, EventType::ChatlistChanged))
-            .await;
-    }
-
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_change_chat_visibility() -> Result<()> {
-        let mut tcm = TestContextManager::new();
-        let alice = tcm.alice().await;
-        let chat_id = create_group_chat(
-            &alice,
-            crate::chat::ProtectionStatus::Unprotected,
-            "my_group",
-        )
-        .await?;
-
-        chat_id
-            .set_visibility(&alice, ChatVisibility::Pinned)
-            .await?;
-        wait_for_chatlist_and_specific_item(&alice, chat_id).await;
-
-        chat_id
-            .set_visibility(&alice, ChatVisibility::Archived)
-            .await?;
-        wait_for_chatlist_and_specific_item(&alice, chat_id).await;
-
-        chat_id
-            .set_visibility(&alice, ChatVisibility::Normal)
-            .await?;
-        wait_for_chatlist_and_specific_item(&alice, chat_id).await;
-
-        Ok(())
-    }
-
-    /// mute a chat, archive it, then use another account to send a message to it, the counter on the archived chatlist item should change
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_archived_counter_increases_for_muted_chats() -> Result<()> {
-        let mut tcm = TestContextManager::new();
-        let alice = tcm.alice().await;
-        let bob = tcm.bob().await;
-
-        let chat = alice.create_chat(&bob).await;
-        let sent_msg = alice.send_text(chat.id, "moin").await;
-        bob.recv_msg(&sent_msg).await;
-
-        let bob_chat = bob.create_chat(&alice).await;
-        bob_chat
-            .id
-            .set_visibility(&bob, ChatVisibility::Archived)
-            .await?;
-        set_muted(&bob, bob_chat.id, MuteDuration::Forever).await?;
-
-        bob.evtracker.clear_events();
-
-        let sent_msg = alice.send_text(chat.id, "moin2").await;
-        bob.recv_msg(&sent_msg).await;
-
-        bob.evtracker
-            .get_matching(|evt| match evt {
-                EventType::ChatlistItemChanged {
-                    chat_id: Some(chat_id),
-                } => chat_id.is_archived_link(),
-                _ => false,
-            })
-            .await;
-
-        Ok(())
-    }
-
-    /// Mark noticed on archive-link chatlistitem should update the unread counter on it
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_archived_counter_update_on_mark_noticed() -> Result<()> {
-        let mut tcm = TestContextManager::new();
-        let alice = tcm.alice().await;
-        let bob = tcm.bob().await;
-        let chat = alice.create_chat(&bob).await;
-        let sent_msg = alice.send_text(chat.id, "moin").await;
-        bob.recv_msg(&sent_msg).await;
-        let bob_chat = bob.create_chat(&alice).await;
-        bob_chat
-            .id
-            .set_visibility(&bob, ChatVisibility::Archived)
-            .await?;
-        set_muted(&bob, bob_chat.id, MuteDuration::Forever).await?;
-        let sent_msg = alice.send_text(chat.id, "moin2").await;
-        bob.recv_msg(&sent_msg).await;
-
-        bob.evtracker.clear_events();
-        chat::marknoticed_chat(&bob, DC_CHAT_ID_ARCHIVED_LINK).await?;
-        wait_for_chatlist_specific_item(&bob, DC_CHAT_ID_ARCHIVED_LINK).await;
-
-        Ok(())
-    }
-
-    /// Contact name update - expect all chats to update
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_contact_name_update() -> Result<()> {
-        let mut tcm = TestContextManager::new();
-        let alice = tcm.alice().await;
-        let bob = tcm.bob().await;
-        let alice_to_bob_chat = alice.create_chat(&bob).await;
-        let sent_msg = alice.send_text(alice_to_bob_chat.id, "hello").await;
-        bob.recv_msg(&sent_msg).await;
-
-        bob.evtracker.clear_events();
-        // set alice name then receive messagefrom her with bob
-        alice.set_config(Config::Displayname, Some("Alice")).await?;
-        let sent_msg = alice
-            .send_text(alice_to_bob_chat.id, "hello, I set a displayname")
-            .await;
-        bob.recv_msg(&sent_msg).await;
-        let alice_on_bob = bob.add_or_lookup_contact(&alice).await;
-        assert!(alice_on_bob.get_display_name() == "Alice");
-
-        wait_for_chatlist_all_items(&bob).await;
-
-        bob.evtracker.clear_events();
-        // set name
-        let addr = alice_on_bob.get_addr();
-        Contact::create(&bob, "Alice2", addr).await?;
-        assert!(bob.add_or_lookup_contact(&alice).await.get_display_name() == "Alice2");
-
-        wait_for_chatlist_all_items(&bob).await;
-
-        Ok(())
-    }
-
-    /// Contact changed avatar
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_contact_changed_avatar() -> Result<()> {
-        let mut tcm = TestContextManager::new();
-        let alice = tcm.alice().await;
-        let bob = tcm.bob().await;
-        let alice_to_bob_chat = alice.create_chat(&bob).await;
-        let sent_msg = alice.send_text(alice_to_bob_chat.id, "hello").await;
-        bob.recv_msg(&sent_msg).await;
-
-        bob.evtracker.clear_events();
-        // set alice avatar then receive messagefrom her with bob
-        let file = alice.dir.path().join("avatar.png");
-        let bytes = include_bytes!("../../test-data/image/avatar64x64.png");
-        tokio::fs::write(&file, bytes).await?;
-        alice
-            .set_config(Config::Selfavatar, Some(file.to_str().unwrap()))
-            .await?;
-        let sent_msg = alice
-            .send_text(alice_to_bob_chat.id, "hello, I have a new avatar")
-            .await;
-        bob.recv_msg(&sent_msg).await;
-        let alice_on_bob = bob.add_or_lookup_contact(&alice).await;
-        assert!(alice_on_bob.get_profile_image(&bob).await?.is_some());
-
-        wait_for_chatlist_specific_item(&bob, bob.create_chat(&alice).await.id).await;
-        Ok(())
-    }
-
-    /// Delete chat
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_delete_chat() -> Result<()> {
-        let mut tcm = TestContextManager::new();
-        let alice = tcm.alice().await;
-        let chat = create_group_chat(&alice, ProtectionStatus::Protected, "My Group").await?;
-
-        alice.evtracker.clear_events();
-        chat.delete(&alice).await?;
-        wait_for_chatlist(&alice).await;
-        Ok(())
-    }
-
-    /// Create group chat
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_create_group_chat() -> Result<()> {
-        let mut tcm = TestContextManager::new();
-        let alice = tcm.alice().await;
-        alice.evtracker.clear_events();
-        let chat = create_group_chat(&alice, ProtectionStatus::Protected, "My Group").await?;
-        wait_for_chatlist_and_specific_item(&alice, chat).await;
-        Ok(())
-    }
-
-    /// Create broadcastlist
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_create_broadcastlist() -> Result<()> {
-        let mut tcm = TestContextManager::new();
-        let alice = tcm.alice().await;
-        alice.evtracker.clear_events();
-        create_broadcast_list(&alice).await?;
-        wait_for_chatlist(&alice).await;
-        Ok(())
-    }
-
-    /// Mute chat
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_mute_chat() -> Result<()> {
-        let mut tcm = TestContextManager::new();
-        let alice = tcm.alice().await;
-        let chat = create_group_chat(&alice, ProtectionStatus::Protected, "My Group").await?;
-
-        alice.evtracker.clear_events();
-        chat::set_muted(&alice, chat, MuteDuration::Forever).await?;
-        wait_for_chatlist_specific_item(&alice, chat).await;
-
-        alice.evtracker.clear_events();
-        chat::set_muted(&alice, chat, MuteDuration::NotMuted).await?;
-        wait_for_chatlist_specific_item(&alice, chat).await;
-
-        Ok(())
-    }
-
-    /// Expiry of mute should also trigger an event
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    #[ignore = "does not work yet"]
-    async fn test_mute_chat_expired() -> Result<()> {
-        let mut tcm = TestContextManager::new();
-        let alice = tcm.alice().await;
-        let chat = create_group_chat(&alice, ProtectionStatus::Protected, "My Group").await?;
-
-        let mute_duration = MuteDuration::Until(
-            std::time::SystemTime::now()
-                .checked_add(Duration::from_secs(2))
-                .unwrap(),
-        );
-        chat::set_muted(&alice, chat, mute_duration).await?;
-        alice.evtracker.clear_events();
-        SystemTime::shift(Duration::from_secs(3));
-        wait_for_chatlist_specific_item(&alice, chat).await;
-
-        Ok(())
-    }
-
-    /// Change chat name
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_change_chat_name() -> Result<()> {
-        let mut tcm = TestContextManager::new();
-        let alice = tcm.alice().await;
-        let chat = create_group_chat(&alice, ProtectionStatus::Protected, "My Group").await?;
-
-        alice.evtracker.clear_events();
-        chat::set_chat_name(&alice, chat, "New Name").await?;
-        wait_for_chatlist_specific_item(&alice, chat).await;
-
-        Ok(())
-    }
-
-    /// Change chat profile image
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_change_chat_profile_image() -> Result<()> {
-        let mut tcm = TestContextManager::new();
-        let alice = tcm.alice().await;
-        let chat = create_group_chat(&alice, ProtectionStatus::Protected, "My Group").await?;
-
-        alice.evtracker.clear_events();
-        let file = alice.dir.path().join("avatar.png");
-        let bytes = include_bytes!("../../test-data/image/avatar64x64.png");
-        tokio::fs::write(&file, bytes).await?;
-        chat::set_chat_profile_image(&alice, chat, file.to_str().unwrap()).await?;
-        wait_for_chatlist_specific_item(&alice, chat).await;
-
-        Ok(())
-    }
-
-    /// Receive group and receive name change
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_receiving_group_and_group_changes() -> Result<()> {
-        let mut tcm = TestContextManager::new();
-        let alice = tcm.alice().await;
-        let bob = tcm.bob().await;
-        let chat = alice
-            .create_group_with_members(ProtectionStatus::Unprotected, "My Group", &[&bob])
-            .await;
-
-        let sent_msg = alice.send_text(chat, "Hello").await;
-        let chat_id_for_bob = bob.recv_msg(&sent_msg).await.chat_id;
-        wait_for_chatlist_specific_item(&bob, chat_id_for_bob).await;
-        chat_id_for_bob.accept(&bob).await?;
-
-        bob.evtracker.clear_events();
-        chat::set_chat_name(&alice, chat, "New Name").await?;
-        let sent_msg = alice.send_text(chat, "Hello").await;
-        bob.recv_msg(&sent_msg).await;
-        wait_for_chatlist_specific_item(&bob, chat_id_for_bob).await;
-
-        Ok(())
-    }
-
-    /// Accept contact request
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_accept_contact_request() -> Result<()> {
-        let mut tcm = TestContextManager::new();
-        let alice = tcm.alice().await;
-        let bob = tcm.bob().await;
-        let chat = alice
-            .create_group_with_members(ProtectionStatus::Unprotected, "My Group", &[&bob])
-            .await;
-        let sent_msg = alice.send_text(chat, "Hello").await;
-        let chat_id_for_bob = bob.recv_msg(&sent_msg).await.chat_id;
-
-        bob.evtracker.clear_events();
-        chat_id_for_bob.accept(&bob).await?;
-        wait_for_chatlist_specific_item(&bob, chat_id_for_bob).await;
-
-        Ok(())
-    }
-
-    /// Block contact request
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_block_contact_request() -> Result<()> {
-        let mut tcm = TestContextManager::new();
-        let alice = tcm.alice().await;
-        let bob = tcm.bob().await;
-        let chat = alice
-            .create_group_with_members(ProtectionStatus::Unprotected, "My Group", &[&bob])
-            .await;
-        let sent_msg = alice.send_text(chat, "Hello").await;
-        let chat_id_for_bob = bob.recv_msg(&sent_msg).await.chat_id;
-
-        bob.evtracker.clear_events();
-        chat_id_for_bob.block(&bob).await?;
-        wait_for_chatlist(&bob).await;
-
-        Ok(())
-    }
-
-    /// Delete message
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_delete_message() -> Result<()> {
-        let mut tcm = TestContextManager::new();
-        let alice = tcm.alice().await;
-        let chat = create_group_chat(&alice, ProtectionStatus::Protected, "My Group").await?;
-        let message = chat::send_text_msg(&alice, chat, "Hello World".to_owned()).await?;
-
-        alice.evtracker.clear_events();
-        message::delete_msgs(&alice, &[message]).await?;
-        wait_for_chatlist_specific_item(&alice, chat).await;
-
-        Ok(())
-    }
-
-    /// Click on chat should remove the unread count (on msgs noticed)
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_msgs_noticed_on_chat() -> Result<()> {
-        let mut tcm = TestContextManager::new();
-        let alice = tcm.alice().await;
-        let bob = tcm.bob().await;
-
-        let chat = alice
-            .create_group_with_members(ProtectionStatus::Unprotected, "My Group", &[&bob])
-            .await;
-        let sent_msg = alice.send_text(chat, "Hello").await;
-        let chat_id_for_bob = bob.recv_msg(&sent_msg).await.chat_id;
-        chat_id_for_bob.accept(&bob).await?;
-
-        let sent_msg = alice.send_text(chat, "New Message").await;
-        let chat_id_for_bob = bob.recv_msg(&sent_msg).await.chat_id;
-        assert!(chat_id_for_bob.get_fresh_msg_cnt(&bob).await? >= 1);
-
-        bob.evtracker.clear_events();
-        chat::marknoticed_chat(&bob, chat_id_for_bob).await?;
-        wait_for_chatlist_specific_item(&bob, chat_id_for_bob).await;
-
-        Ok(())
-    }
-
-    // Block and Unblock contact
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_unblock_contact() -> Result<()> {
-        let mut tcm = TestContextManager::new();
-        let alice = tcm.alice().await;
-        let contact_id = Contact::create(&alice, "example", "example@example.com").await?;
-        let _ = ChatId::create_for_contact(&alice, contact_id).await;
-
-        alice.evtracker.clear_events();
-        Contact::block(&alice, contact_id).await?;
-        wait_for_chatlist(&alice).await;
-
-        alice.evtracker.clear_events();
-        Contact::unblock(&alice, contact_id).await?;
-        wait_for_chatlist(&alice).await;
-
-        Ok(())
-    }
-
-    /// Tests that expired disappearing message
-    /// produces events about chatlist being modified.
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_update_after_ephemeral_messages() -> Result<()> {
-        let mut tcm = TestContextManager::new();
-        let alice = tcm.alice().await;
-        let chat = create_group_chat(&alice, ProtectionStatus::Protected, "My Group").await?;
-        chat.set_ephemeral_timer(&alice, crate::ephemeral::Timer::Enabled { duration: 60 })
-            .await?;
-        alice
-            .evtracker
-            .get_matching(|evt| matches!(evt, EventType::ChatEphemeralTimerModified { .. }))
-            .await;
-
-        let _ = chat::send_text_msg(&alice, chat, "Hello".to_owned()).await?;
-        wait_for_chatlist_and_specific_item(&alice, chat).await;
-
-        SystemTime::shift(Duration::from_secs(70));
-        crate::ephemeral::delete_expired_messages(&alice, crate::tools::time()).await?;
-        wait_for_chatlist_and_specific_item(&alice, chat).await;
-
-        Ok(())
-    }
-
-    /// AdHoc (Groups without a group ID.) group receiving
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_adhoc_group() -> Result<()> {
-        let alice = TestContext::new_alice().await;
-        let mime = br#"Subject: First thread
-Message-ID: first@example.org
-To: Alice <alice@example.org>, Bob <bob@example.net>
-From: Claire <claire@example.org>
-Content-Type: text/plain; charset=utf-8; format=flowed; delsp=no
-
-First thread."#;
-
-        alice.evtracker.clear_events();
-        receive_imf(&alice, mime, false).await?;
-        wait_for_chatlist(&alice).await;
-
-        Ok(())
-    }
-
-    /// Test both direction of securejoin
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_secure_join_group() -> Result<()> {
-        let mut tcm = TestContextManager::new();
-        let alice = tcm.alice().await;
-        let bob = tcm.bob().await;
-
-        let alice_chatid =
-            chat::create_group_chat(&alice.ctx, ProtectionStatus::Protected, "the chat").await?;
-
-        // Step 1: Generate QR-code, secure-join implied by chatid
-        let qr = get_securejoin_qr(&alice.ctx, Some(alice_chatid)).await?;
-
-        // Step 2: Bob scans QR-code, sends vg-request
-        bob.evtracker.clear_events();
-        let bob_chatid = join_securejoin(&bob.ctx, &qr).await?;
-        wait_for_chatlist(&bob).await;
-
-        let sent = bob.pop_sent_msg().await;
-
-        // Step 3: Alice receives vg-request, sends vg-auth-required
-        alice.evtracker.clear_events();
-        alice.recv_msg_trash(&sent).await;
-
-        let sent = alice.pop_sent_msg().await;
-
-        // Step 4: Bob receives vg-auth-required, sends vg-request-with-auth
-        bob.evtracker.clear_events();
-        bob.recv_msg_trash(&sent).await;
-        wait_for_chatlist_and_specific_item(&bob, bob_chatid).await;
-
-        let sent = bob.pop_sent_msg().await;
-
-        // Step 5+6: Alice receives vg-request-with-auth, sends vg-member-added
-        alice.evtracker.clear_events();
-        alice.recv_msg_trash(&sent).await;
-        wait_for_chatlist_and_specific_item(&alice, alice_chatid).await;
-
-        let sent = alice.pop_sent_msg().await;
-
-        // Step 7: Bob receives vg-member-added
-        bob.evtracker.clear_events();
-        bob.recv_msg(&sent).await;
-        wait_for_chatlist_and_specific_item(&bob, bob_chatid).await;
-
-        Ok(())
-    }
-
-    /// Call Resend on message
-    ///
-    /// (the event is technically only needed if it is the last message in the chat, but checking that would be too expensive so the event is always emitted)
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_resend_message() -> Result<()> {
-        let mut tcm = TestContextManager::new();
-        let alice = tcm.alice().await;
-        let chat = create_group_chat(&alice, ProtectionStatus::Protected, "My Group").await?;
-
-        let msg_id = chat::send_text_msg(&alice, chat, "Hello".to_owned()).await?;
-        let _ = alice.pop_sent_msg().await;
-
-        let message = Message::load_from_db(&alice, msg_id).await?;
-        assert_eq!(message.get_state(), MessageState::OutDelivered);
-
-        alice.evtracker.clear_events();
-        chat::resend_msgs(&alice, &[msg_id]).await?;
-        wait_for_chatlist_specific_item(&alice, chat).await;
-
-        Ok(())
-    }
-
-    /// test that setting a reaction emits chatlistitem update event
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_reaction() -> Result<()> {
-        let mut tcm = TestContextManager::new();
-        let alice = tcm.alice().await;
-        let chat = create_group_chat(&alice, ProtectionStatus::Protected, "My Group").await?;
-        let msg_id = chat::send_text_msg(&alice, chat, "Hello".to_owned()).await?;
-        let _ = alice.pop_sent_msg().await;
-
-        alice.evtracker.clear_events();
-        reaction::send_reaction(&alice, msg_id, "👍").await?;
-        let _ = alice.pop_sent_msg().await;
-        wait_for_chatlist_specific_item(&alice, chat).await;
-
-        Ok(())
-    }
-}
--- a/src/events/payload.rs
+++ b/src/events/payload.rs
@@ -182,7 +182,7 @@ pub enum EventType {
        timer: EphemeralTimer,
    },

-    /// Contact(s) created, renamed, blocked, deleted or changed their "recently seen" status.
+    /// Contact(s) created, renamed, blocked or deleted.
    ///
    /// @param data1 (int) If set, this is the contact_id of an added contact that should be selected.
    ContactsChanged(Option<ContactId>),
@@ -291,15 +291,4 @@ pub enum EventType {
    ///
    /// This event is only emitted by the account manager
    AccountsBackgroundFetchDone,
-    /// Inform that set of chats or the order of the chats in the chatlist has changed.
-    ///
-    /// Sometimes this is emitted together with `UIChatlistItemChanged`.
-    ChatlistChanged,
-
-    /// Inform that a single chat list item changed and needs to be rerendered.
-    /// If `chat_id` is set to None, then all currently visible chats need to be rerendered, and all not-visible items need to be cleared from cache if the UI has a cache.
-    ChatlistItemChanged {
-        /// ID of the changed chat
-        chat_id: Option<ChatId>,
-    },
 }
--- a/src/imap.rs
+++ b/src/imap.rs
@@ -15,7 +15,6 @@ use std::{
 use anyhow::{bail, format_err, Context as _, Result};
 use async_channel::Receiver;
 use async_imap::types::{Fetch, Flag, Name, NameAttribute, UnsolicitedResponse};
-use deltachat_contact_tools::{normalize_name, ContactAddress};
 use futures::{FutureExt as _, StreamExt, TryStreamExt};
 use futures_lite::FutureExt;
 use num_traits::FromPrimitive;
@@ -23,10 +22,9 @@ use ratelimit::Ratelimit;
 use tokio::sync::RwLock;

 use crate::chat::{self, ChatId, ChatIdBlocked};
-use crate::chatlist_events;
 use crate::config::Config;
 use crate::constants::{self, Blocked, Chattype, ShowEmails};
-use crate::contact::{Contact, ContactId, Modifier, Origin};
+use crate::contact::{normalize_name, Contact, ContactAddress, ContactId, Modifier, Origin};
 use crate::context::Context;
 use crate::events::EventType;
 use crate::headerdef::{HeaderDef, HeaderDefMap};
@@ -390,7 +388,7 @@ impl Imap {
            Ok(session) => {
                // Store server ID in the context to display in account info.
                let mut lock = context.server_id.write().await;
-                lock.clone_from(&session.capabilities.server_id);
+                *lock = session.capabilities.server_id.clone();

                self.login_failed_once = false;
                context.emit_event(EventType::ImapConnected(format!(
@@ -422,7 +420,7 @@ impl Imap {
                    drop(lock);

                    let mut msg = Message::new(Viewtype::Text);
-                    msg.text.clone_from(&message);
+                    msg.text = message.clone();
                    if let Err(e) =
                        chat::add_device_msg_with_importance(context, None, Some(&mut msg), true)
                            .await
@@ -1172,7 +1170,6 @@ impl Session {
            .with_context(|| format!("failed to set MODSEQ for folder {folder}"))?;
        for updated_chat_id in updated_chat_ids {
            context.emit_event(EventType::MsgsNoticed(updated_chat_id));
-            chatlist_events::emit_chatlist_item_changed(context, updated_chat_id);
        }

        Ok(())
--- a/src/imap/scan_folders.rs
+++ b/src/imap/scan_folders.rs
@@ -89,16 +89,9 @@ impl Imap {
            Config::ConfiguredSentboxFolder,
            Config::ConfiguredTrashFolder,
        ] {
-            let val = folder_configs.get(&conf).map(|s| s.as_str());
-            let interrupt = conf == Config::ConfiguredTrashFolder
-                && val.is_some()
-                && context.get_config(conf).await?.is_none();
-            context.set_config_internal(conf, val).await?;
-            if interrupt {
-                // `Imap::fetch_move_delete()` is possible now for other folders (NB: we are in the
-                // Inbox loop).
-                context.scheduler.interrupt_oboxes().await;
-            }
+            context
+                .set_config_internal(conf, folder_configs.get(&conf).map(|s| s.as_str()))
+                .await?;
        }

        last_scan.replace(tools::Time::now());
--- a/src/imex.rs
+++ b/src/imex.rs
@@ -6,11 +6,11 @@ use std::path::{Path, PathBuf};

 use ::pgp::types::KeyTrait;
 use anyhow::{bail, ensure, format_err, Context as _, Result};
-use deltachat_contact_tools::EmailAddress;
 use futures::StreamExt;
 use futures_lite::FutureExt;
 use rand::{thread_rng, Rng};
 use tokio::fs::{self, File};
+use tokio::io::BufWriter;
 use tokio_tar::Archive;

 use crate::blob::{BlobDirContents, BlobObject};
@@ -32,6 +32,7 @@ use crate::sql;
 use crate::stock_str;
 use crate::tools::{
    create_folder, delete_file, get_filesuffix_lc, open_file_std, read_file, time, write_file,
+    EmailAddress,
 };

 mod transfer;
@@ -816,6 +817,20 @@ async fn export_database(
        .await
 }

+/// Serializes the database to a file.
+pub async fn serialize_database(context: &Context, filename: &str) -> Result<()> {
+    let file = File::create(filename).await?;
+    context.sql.serialize(BufWriter::new(file)).await?;
+    Ok(())
+}
+
+/// Deserializes the database from a file.
+pub async fn deserialize_database(context: &Context, filename: &str) -> Result<()> {
+    let file = File::open(filename).await?;
+    context.sql.deserialize(file).await?;
+    Ok(())
+}
+
 #[cfg(test)]
 mod tests {
    use std::time::Duration;
@@ -1158,8 +1173,7 @@ mod tests {
        // Send a message that cannot be decrypted because the keys are
        // not synchronized yet.
        let sent = alice2.send_text(msg.chat_id, "Test").await;
-        let trashed_message = alice.recv_msg_opt(&sent).await;
-        assert!(trashed_message.is_none());
+        alice.recv_msg(&sent).await;
        assert_ne!(alice.get_last_msg().await.get_text(), "Test");

        // Transfer the key.
--- a/src/key.rs
+++ b/src/key.rs
@@ -6,7 +6,6 @@ use std::io::Cursor;

 use anyhow::{ensure, Context as _, Result};
 use base64::Engine as _;
-use deltachat_contact_tools::EmailAddress;
 use num_traits::FromPrimitive;
 use pgp::composed::Deserializable;
 pub use pgp::composed::{SignedPublicKey, SignedSecretKey};
@@ -19,7 +18,7 @@ use crate::constants::KeyGenType;
 use crate::context::Context;
 use crate::log::LogExt;
 use crate::pgp::KeyPair;
-use crate::tools::{self, time_elapsed};
+use crate::tools::{self, time_elapsed, EmailAddress};

 /// Convenience trait for working with keys.
 ///
--- a/src/location.rs
+++ b/src/location.rs
@@ -13,8 +13,8 @@ use crate::context::Context;
 use crate::events::EventType;
 use crate::message::{Message, MsgId, Viewtype};
 use crate::mimeparser::SystemMessage;
+use crate::stock_str;
 use crate::tools::{duration_to_str, time};
-use crate::{chatlist_events, stock_str};

 /// Location record.
 #[derive(Debug, Clone, Default)]
@@ -290,7 +290,6 @@ pub async fn send_locations_to_chat(
        chat::add_info_msg(context, chat_id, &stock_str, now).await?;
    }
    context.emit_event(EventType::ChatModified(chat_id));
-    chatlist_events::emit_chatlist_item_changed(context, chat_id);
    if 0 != seconds {
        context.scheduler.interrupt_location().await;
    }
@@ -367,7 +366,7 @@ pub async fn set(context: &Context, latitude: f64, longitude: f64, accuracy: f64
        continue_streaming = true;
    }
    if continue_streaming {
-        context.emit_location_changed(Some(ContactId::SELF)).await?;
+        context.emit_event(EventType::LocationChanged(Some(ContactId::SELF)));
    };

    Ok(continue_streaming)
@@ -457,7 +456,7 @@ fn is_marker(txt: &str) -> bool {
 /// Deletes all locations from the database.
 pub async fn delete_all(context: &Context) -> Result<()> {
    context.sql.execute("DELETE FROM locations;", ()).await?;
-    context.emit_location_changed(None).await?;
+    context.emit_event(EventType::LocationChanged(None));
    Ok(())
 }

@@ -803,7 +802,6 @@ async fn maybe_send_locations(context: &Context) -> Result<Option<u64>> {
            let stock_str = stock_str::msg_location_disabled(context).await;
            chat::add_info_msg(context, chat_id, &stock_str, now).await?;
            context.emit_event(EventType::ChatModified(chat_id));
-            chatlist_events::emit_chatlist_item_changed(context, chat_id);
        }
    }

--- a/src/login_param.rs
+++ b/src/login_param.rs
@@ -80,7 +80,7 @@ impl LoginParam {
        // Only check for IMAP password, SMTP password is an "advanced" setting.
        ensure!(!param.imap.password.is_empty(), "Missing (IMAP) password.");
        if param.smtp.password.is_empty() {
-            param.smtp.password.clone_from(&param.imap.password)
+            param.smtp.password = param.imap.password.clone()
        }
        Ok(param)
    }
--- a/src/message.rs
+++ b/src/message.rs
@@ -9,7 +9,6 @@ use serde::{Deserialize, Serialize};

 use crate::blob::BlobObject;
 use crate::chat::{Chat, ChatId};
-use crate::chatlist_events;
 use crate::config::Config;
 use crate::constants::{
    Blocked, Chattype, VideochatType, DC_CHAT_ID_TRASH, DC_DESIRED_TEXT_LEN, DC_MSG_ID_LAST_SPECIAL,
@@ -83,16 +82,6 @@ impl MsgId {
        Ok(result)
    }

-    pub(crate) async fn get_param(self, context: &Context) -> Result<Params> {
-        let res: Option<String> = context
-            .sql
-            .query_get_value("SELECT param FROM msgs WHERE id=?", (self,))
-            .await?;
-        Ok(res
-            .map(|s| s.parse().unwrap_or_default())
-            .unwrap_or_default())
-    }
-
    /// Put message into trash chat and delete message text.
    ///
    /// It means the message is deleted locally, but not on the server.
@@ -149,7 +138,6 @@ WHERE id=?;
            chat_id,
            msg_id: self,
        });
-        chatlist_events::emit_chatlist_item_changed(context, chat_id);
        Ok(())
    }

@@ -374,7 +362,7 @@ impl rusqlite::types::FromSql for MsgId {
    fn column_result(value: rusqlite::types::ValueRef) -> rusqlite::types::FromSqlResult<Self> {
        // Would be nice if we could use match here, but alas.
        i64::column_result(value).and_then(|val| {
-            if 0 <= val && val <= i64::from(u32::MAX) {
+            if 0 <= val && val <= i64::from(std::u32::MAX) {
                Ok(MsgId::new(val as u32))
            } else {
                Err(rusqlite::types::FromSqlError::OutOfRange(val))
@@ -476,7 +464,7 @@ impl Message {
    pub async fn load_from_db(context: &Context, id: MsgId) -> Result<Message> {
        let message = Self::load_from_db_optional(context, id)
            .await?
-            .with_context(|| format!("Message {id} does not exist"))?;
+            .context("Message {id} does not exist")?;
        Ok(message)
    }

@@ -518,7 +506,7 @@ impl Message {
                    "    m.location_id AS location,",
                    "    c.blocked AS blocked",
                    " FROM msgs m LEFT JOIN chats c ON c.id=m.chat_id",
-                    " WHERE m.id=? AND chat_id!=3;"
+                    " WHERE m.id=?;"
                ),
                (id,),
                |row| {
@@ -1157,8 +1145,13 @@ impl Message {
    pub async fn parent(&self, context: &Context) -> Result<Option<Message>> {
        if let Some(in_reply_to) = &self.in_reply_to {
            if let Some((msg_id, _ts_sent)) = rfc724_mid_exists(context, in_reply_to).await? {
-                let msg = Message::load_from_db_optional(context, msg_id).await?;
-                return Ok(msg);
+                let msg = Message::load_from_db(context, msg_id).await?;
+                return if msg.chat_id.is_trash() {
+                    // If message is already moved to trash chat, pretend it does not exist.
+                    Ok(None)
+                } else {
+                    Ok(Some(msg))
+                };
            }
        }
        Ok(None)
@@ -1539,12 +1532,9 @@ pub async fn delete_msgs(context: &Context, msg_ids: &[MsgId]) -> Result<()> {

    for modified_chat_id in modified_chat_ids {
        context.emit_msgs_changed(modified_chat_id, MsgId::new(0));
-        chatlist_events::emit_chatlist_item_changed(context, modified_chat_id);
    }

    if !msg_ids.is_empty() {
-        context.emit_msgs_changed_without_ids();
-        chatlist_events::emit_chatlist_changed(context);
        // Run housekeeping to delete unused blobs.
        context
            .set_config_internal(Config::LastHousekeeping, None)
@@ -1643,7 +1633,9 @@ pub async fn markseen_msgs(context: &Context, msg_ids: Vec<MsgId>) -> Result<()>
        _curr_ephemeral_timer,
    ) in msgs
    {
-        if curr_state == MessageState::InFresh || curr_state == MessageState::InNoticed {
+        if curr_blocked == Blocked::Not
+            && (curr_state == MessageState::InFresh || curr_state == MessageState::InNoticed)
+        {
            update_msg_state(context, id, MessageState::InSeen).await?;
            info!(context, "Seen message {}.", id);

@@ -1655,11 +1647,7 @@ pub async fn markseen_msgs(context: &Context, msg_ids: Vec<MsgId>) -> Result<()>
            // "Group left by me", a read receipt will quote "Group left by <name>", and the name can
            // be a display name stored in address book rather than the name sent in the From field by
            // the user.
-            //
-            // We also don't send read receipts for contact requests.
-            // Read receipts will not be sent even after accepting the chat.
-            if curr_blocked == Blocked::Not
-                && curr_param.get_bool(Param::WantsMdn).unwrap_or_default()
+            if curr_param.get_bool(Param::WantsMdn).unwrap_or_default()
                && curr_param.get_cmd() == SystemMessage::Unknown
            {
                let mdns_enabled = context.get_config_bool(Config::MdnsEnabled).await?;
@@ -1681,7 +1669,6 @@ pub async fn markseen_msgs(context: &Context, msg_ids: Vec<MsgId>) -> Result<()>

    for updated_chat_id in updated_chat_ids {
        context.emit_event(EventType::MsgsNoticed(updated_chat_id));
-        chatlist_events::emit_chatlist_item_changed(context, updated_chat_id);
    }

    Ok(())
@@ -1742,7 +1729,6 @@ pub(crate) async fn set_msg_failed(
        chat_id: msg.chat_id,
        msg_id: msg.id,
    });
-    chatlist_events::emit_chatlist_item_changed(context, msg.chat_id);

    Ok(())
 }
@@ -1895,7 +1881,8 @@ pub(crate) async fn get_latest_by_rfc724_mids(
 ) -> Result<Option<Message>> {
    for id in mids.iter().rev() {
        if let Some((msg_id, _)) = rfc724_mid_exists(context, id).await? {
-            if let Some(msg) = Message::load_from_db_optional(context, msg_id).await? {
+            let msg = Message::load_from_db(context, msg_id).await?;
+            if msg.chat_id != DC_CHAT_ID_TRASH {
                return Ok(Some(msg));
            }
        }
@@ -2000,9 +1987,8 @@ mod tests {
    use num_traits::FromPrimitive;

    use super::*;
-    use crate::chat::{self, marknoticed_chat, send_text_msg, ChatItem};
+    use crate::chat::{self, marknoticed_chat, ChatItem};
    use crate::chatlist::Chatlist;
-    use crate::reaction::send_reaction;
    use crate::receive_imf::receive_imf;
    use crate::test_utils as test;
    use crate::test_utils::{TestContext, TestContextManager};
@@ -2492,24 +2478,6 @@ mod tests {
        Ok(())
    }

-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_get_message_summary_text() -> Result<()> {
-        let t = TestContext::new_alice().await;
-        let chat = t.get_self_chat().await;
-        let msg_id = send_text_msg(&t, chat.id, "foo".to_string()).await?;
-        let msg = Message::load_from_db(&t, msg_id).await?;
-        let summary = msg.get_summary(&t, None).await?;
-        assert_eq!(summary.text, "foo");
-
-        // message summary does not change when reactions are applied (in contrast to chatlist summary)
-        send_reaction(&t, msg_id, "🫵").await?;
-        let msg = Message::load_from_db(&t, msg_id).await?;
-        let summary = msg.get_summary(&t, None).await?;
-        assert_eq!(summary.text, "foo");
-
-        Ok(())
-    }
-
    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
    async fn test_format_flowed_round_trip() -> Result<()> {
        let mut tcm = TestContextManager::new();
--- a/src/mimefactory.rs
+++ b/src/mimefactory.rs
@@ -93,6 +93,7 @@ pub struct RenderedEmail {
    // pub envelope: Envelope,
    pub is_encrypted: bool,
    pub is_gossiped: bool,
+    pub is_group: bool,
    pub last_added_location_id: Option<u32>,

    /// A comma-separated string of sync-IDs that are used by the rendered email
@@ -613,6 +614,8 @@ impl<'a> MimeFactory<'a> {
            ));
        }

+        let mut is_group = false;
+
        if let Loaded::Message { chat } = &self.loaded {
            if chat.typ == Chattype::Broadcast {
                let encoded_chat_name = encode_words(&chat.name);
@@ -620,6 +623,8 @@ impl<'a> MimeFactory<'a> {
                    "List-ID".into(),
                    format!("{encoded_chat_name} <{}>", chat.grpid),
                ));
+            } else if chat.typ == Chattype::Group {
+                is_group = true;
            }
        }

@@ -891,6 +896,7 @@ impl<'a> MimeFactory<'a> {
            // envelope: Envelope::new,
            is_encrypted,
            is_gossiped,
+            is_group,
            last_added_location_id,
            sync_ids_to_delete: self.sync_ids_to_delete,
            rfc724_mid,
@@ -1582,18 +1588,18 @@ fn maybe_encode_words(words: &str) -> String {

 #[cfg(test)]
 mod tests {
-    use deltachat_contact_tools::ContactAddress;
    use mailparse::{addrparse_header, MailHeaderMap};
    use std::str;

    use super::*;
+    use crate::chat::ChatId;
    use crate::chat::{
-        add_contact_to_chat, create_group_chat, remove_contact_from_chat, send_text_msg, ChatId,
+        self, add_contact_to_chat, create_group_chat, remove_contact_from_chat, send_text_msg,
        ProtectionStatus,
    };
    use crate::chatlist::Chatlist;
    use crate::constants;
-    use crate::contact::Origin;
+    use crate::contact::{ContactAddress, Origin};
    use crate::mimeparser::MimeMessage;
    use crate::receive_imf::receive_imf;
    use crate::test_utils::{get_chat_msg, TestContext, TestContextManager};
--- a/src/mimeparser.rs
+++ b/src/mimeparser.rs
@@ -6,7 +6,6 @@ use std::path::Path;
 use std::str;

 use anyhow::{bail, Context as _, Result};
-use deltachat_contact_tools::{addr_cmp, addr_normalize, strip_rtlo_characters};
 use deltachat_derive::{FromSql, ToSql};
 use format_flowed::unformat_flowed;
 use lettre_email::mime::Mime;
@@ -16,8 +15,8 @@ use crate::aheader::{Aheader, EncryptPreference};
 use crate::blob::BlobObject;
 use crate::chat::{add_info_msg, ChatId};
 use crate::config::Config;
-use crate::constants::{self, Chattype, DC_DESIRED_TEXT_LINES, DC_DESIRED_TEXT_LINE_LEN};
-use crate::contact::{Contact, ContactId, Origin};
+use crate::constants::{Chattype, DC_DESIRED_TEXT_LINES, DC_DESIRED_TEXT_LINE_LEN};
+use crate::contact::{addr_cmp, addr_normalize, Contact, ContactId, Origin};
 use crate::context::Context;
 use crate::decrypt::{
    keyring_from_peerstate, prepare_decryption, try_decrypt, validate_detached_signature,
@@ -33,11 +32,13 @@ use crate::message::{
 use crate::param::{Param, Params};
 use crate::peerstate::Peerstate;
 use crate::simplify::{simplify, SimplifiedText};
+use crate::stock_str;
 use crate::sync::SyncItems;
 use crate::tools::{
-    create_smeared_timestamp, get_filemeta, parse_receive_headers, smeared_time, truncate_by_lines,
+    create_smeared_timestamp, get_filemeta, parse_receive_headers, smeared_time,
+    strip_rtlo_characters, truncate_by_lines,
 };
-use crate::{chatlist_events, location, stock_str, tools};
+use crate::{location, tools};

 /// A parsed MIME message.
 ///
@@ -211,9 +212,7 @@ impl MimeMessage {
            .headers
            .get_header_value(HeaderDef::Date)
            .and_then(|v| mailparse::dateparse(&v).ok())
-            .map_or(timestamp_rcvd, |value| {
-                min(value, timestamp_rcvd + constants::TIMESTAMP_SENT_TOLERANCE)
-            });
+            .map_or(timestamp_rcvd, |value| min(value, timestamp_rcvd + 60));
        let mut hop_info = parse_receive_headers(&mail.get_headers());

        let mut headers = Default::default();
@@ -494,7 +493,7 @@ impl MimeMessage {
            },
        };

-        if parser.mdn_reports.is_empty() && parser.webxdc_status_update.is_none() {
+        if parser.mdn_reports.is_empty() {
            // "Auto-Submitted" is also set by holiday-notices so we also check "chat-version".
            let is_bot = parser.headers.get("auto-submitted")
                == Some(&"auto-generated".to_string())
@@ -603,7 +602,7 @@ impl MimeMessage {
                let mut filepart = self.parts.swap_remove(1);

                // insert new one
-                filepart.msg.clone_from(&self.parts[0].msg);
+                filepart.msg = self.parts[0].msg.clone();
                if let Some(quote) = self.parts[0].param.get(Param::Quote) {
                    filepart.param.set(Param::Quote, quote);
                }
@@ -2152,8 +2151,6 @@ async fn handle_mdn(
    {
        update_msg_state(context, msg_id, MessageState::OutMdnRcvd).await?;
        context.emit_event(EventType::MsgRead { chat_id, msg_id });
-        // note(treefit): only matters if it is the last message in chat (but probably too expensive to check, debounce also solves it)
-        chatlist_events::emit_chatlist_item_changed(context, chat_id);
    }
    Ok(())
 }
--- a/src/param.rs
+++ b/src/param.rs
@@ -187,12 +187,6 @@ pub enum Param {
    /// For Webxdc Message Instances: timestamp of summary update.
    WebxdcSummaryTimestamp = b'Q',

-    /// For Webxdc Message Instances: Webxdc is an integration, see init_webxdc_integration()
-    WebxdcIntegration = b'3',
-
-    /// For Webxdc Message Instances: Chat to integrate the Webxdc for.
-    WebxdcIntegrateFor = b'2',
-
    /// For messages: Whether [crate::message::Viewtype::Sticker] should be forced.
    ForceSticker = b'X',
    // 'L' was defined as ProtectionSettingsTimestamp for Chats, however, never used in production.
--- a/src/peerstate.rs
+++ b/src/peerstate.rs
@@ -3,7 +3,6 @@
 use std::mem;

 use anyhow::{Context as _, Error, Result};
-use deltachat_contact_tools::{addr_cmp, ContactAddress};
 use num_traits::FromPrimitive;

 use crate::aheader::{Aheader, EncryptPreference};
@@ -11,14 +10,14 @@ use crate::chat::{self, Chat};
 use crate::chatlist::Chatlist;
 use crate::config::Config;
 use crate::constants::Chattype;
-use crate::contact::{Contact, Origin};
+use crate::contact::{addr_cmp, Contact, ContactAddress, Origin};
 use crate::context::Context;
 use crate::events::EventType;
 use crate::key::{DcKey, Fingerprint, SignedPublicKey};
 use crate::message::Message;
 use crate::mimeparser::SystemMessage;
 use crate::sql::Sql;
-use crate::{chatlist_events, stock_str};
+use crate::stock_str;

 /// Type of the public key stored inside the peerstate.
 #[derive(Debug)]
@@ -723,9 +722,6 @@ impl Peerstate {
            .await?;
        }

-        chatlist_events::emit_chatlist_changed(context);
-        // update the chats the contact is part of
-        chatlist_events::emit_chatlist_items_changed_for_contact(context, contact_id);
        Ok(())
    }

@@ -788,7 +784,7 @@ pub(crate) async fn maybe_do_aeap_transition(
            .await?;

        let old_addr = mem::take(&mut peerstate.addr);
-        peerstate.addr.clone_from(&info.from);
+        peerstate.addr = info.from.clone();
        let header = info.autocrypt_header.as_ref().context(
            "Internal error: Tried to do an AEAP transition without an autocrypt header??",
        )?;
--- a/src/pgp.rs
+++ b/src/pgp.rs
@@ -5,7 +5,6 @@ use std::io;
 use std::io::Cursor;

 use anyhow::{bail, Context as _, Result};
-use deltachat_contact_tools::EmailAddress;
 use pgp::armor::BlockType;
 use pgp::composed::{
    Deserializable, KeyType as PgpKeyType, Message, SecretKeyParamsBuilder, SignedPublicKey,
@@ -21,6 +20,7 @@ use tokio::runtime::Handle;

 use crate::constants::KeyGenType;
 use crate::key::{DcKey, Fingerprint};
+use crate::tools::EmailAddress;

 #[allow(missing_docs)]
 #[cfg(test)]
@@ -449,8 +449,7 @@ mod tests {
        assert_ne!(keypair0.public, keypair1.public);
    }

-    /// [SignedSecretKey] and [SignedPublicKey] objects
-    /// to use in tests.
+    /// [Key] objects to use in tests.
    struct TestKeys {
        alice_secret: SignedSecretKey,
        alice_public: SignedPublicKey,
--- a/src/provider.rs
+++ b/src/provider.rs
@@ -3,12 +3,12 @@
 mod data;

 use anyhow::Result;
-use deltachat_contact_tools::EmailAddress;
 use hickory_resolver::{config, AsyncResolver, TokioAsyncResolver};

 use crate::config::Config;
 use crate::context::Context;
 use crate::provider::data::{PROVIDER_DATA, PROVIDER_IDS};
+use crate::tools::EmailAddress;

 /// Provider status according to manual testing.
 #[derive(Debug, Display, Copy, Clone, PartialEq, Eq, FromPrimitive, ToPrimitive)]
--- a/src/qr.rs
+++ b/src/qr.rs
@@ -5,7 +5,6 @@ use std::collections::BTreeMap;

 use anyhow::{anyhow, bail, ensure, Context as _, Result};
 pub use dclogin_scheme::LoginOptions;
-use deltachat_contact_tools::{addr_normalize, may_be_valid_addr, ContactAddress};
 use once_cell::sync::Lazy;
 use percent_encoding::percent_decode_str;
 use serde::Deserialize;
@@ -14,7 +13,9 @@ use self::dclogin_scheme::configure_from_login_qr;
 use crate::chat::{get_chat_id_by_grpid, ChatIdBlocked};
 use crate::config::Config;
 use crate::constants::Blocked;
-use crate::contact::{Contact, ContactId, Origin};
+use crate::contact::{
+    addr_normalize, may_be_valid_addr, Contact, ContactAddress, ContactId, Origin,
+};
 use crate::context::Context;
 use crate::events::EventType;
 use crate::key::Fingerprint;
--- a/src/qr/dclogin_scheme.rs
+++ b/src/qr/dclogin_scheme.rs
@@ -1,15 +1,13 @@
 use std::collections::HashMap;

 use anyhow::{bail, Context as _, Result};
-
-use deltachat_contact_tools::may_be_valid_addr;
 use num_traits::cast::ToPrimitive;

 use super::{Qr, DCLOGIN_SCHEME};
 use crate::config::Config;
 use crate::context::Context;
-use crate::login_param::CertificateChecks;
 use crate::provider::Socket;
+use crate::{contact, login_param::CertificateChecks};

 /// Options for `dclogin:` scheme.
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -90,7 +88,7 @@ pub(super) fn decode_login(qr: &str) -> Result<Qr> {
            .collect();

        // check if username is there
-        if !may_be_valid_addr(addr) {
+        if !contact::may_be_valid_addr(addr) {
            bail!("invalid DCLOGIN payload: invalid username E5");
        }

--- a/src/reaction.rs
+++ b/src/reaction.rs
@@ -21,7 +21,6 @@ use std::fmt;
 use anyhow::Result;

 use crate::chat::{send_msg, Chat, ChatId};
-use crate::chatlist_events;
 use crate::contact::ContactId;
 use crate::context::Context;
 use crate::events::EventType;
@@ -215,7 +214,6 @@ async fn set_msg_id_reaction(
        msg_id,
        contact_id,
    });
-    chatlist_events::emit_chatlist_item_changed(context, chat_id);
    Ok(())
 }

@@ -340,55 +338,55 @@ impl Chat {
        context: &Context,
        timestamp: i64,
    ) -> Result<Option<(Message, ContactId, String)>> {
-        if self
-            .param
-            .get_i64(Param::LastReactionTimestamp)
-            .filter(|&reaction_timestamp| reaction_timestamp > timestamp)
-            .is_none()
-        {
-            return Ok(None);
-        };
-        let reaction_msg_id = MsgId::new(
-            self.param
-                .get_int(Param::LastReactionMsgId)
-                .unwrap_or_default() as u32,
-        );
-        let Some(reaction_msg) = Message::load_from_db_optional(context, reaction_msg_id).await?
-        else {
-            // The message reacted to may be deleted.
-            // These are no errors as `Param::LastReaction*` are just weak pointers.
-            // Instead, just return `Ok(None)` and let the caller create another summary.
-            return Ok(None);
-        };
-        let reaction_contact_id = ContactId::new(
-            self.param
-                .get_int(Param::LastReactionContactId)
-                .unwrap_or_default() as u32,
-        );
-        if let Some(reaction) = context
-            .sql
-            .query_get_value(
-                "SELECT reaction FROM reactions WHERE msg_id=? AND contact_id=?",
-                (reaction_msg.id, reaction_contact_id),
-            )
-            .await?
-        {
-            Ok(Some((reaction_msg, reaction_contact_id, reaction)))
-        } else {
-            Ok(None)
+        if let Some(reaction_timestamp) = self.param.get_i64(Param::LastReactionTimestamp) {
+            if reaction_timestamp > timestamp {
+                let reaction_msg_id = MsgId::new(
+                    self.param
+                        .get_int(Param::LastReactionMsgId)
+                        .unwrap_or_default() as u32,
+                );
+                // The message reacted to may be deleted physically (`load_from_db()` fails) or marked as a tombstone (`is_trash()`).
+                // These are no errors as `Param::LastReaction*` are just weak pointers.
+                // Instead, just return `Ok(None)` and let the caller create another summary.
+                if let Some(reaction_msg) =
+                    Message::load_from_db_optional(context, reaction_msg_id).await?
+                {
+                    if !reaction_msg.chat_id.is_trash() {
+                        let reaction_contact_id = ContactId::new(
+                            self.param
+                                .get_int(Param::LastReactionContactId)
+                                .unwrap_or_default() as u32,
+                        );
+                        if let Some(reaction) = context
+                            .sql
+                            .query_row_optional(
+                                r#"SELECT reaction FROM reactions WHERE msg_id=? AND contact_id=?"#,
+                                (reaction_msg.id, reaction_contact_id),
+                                |row| {
+                                    let reaction: String = row.get(0)?;
+                                    Ok(reaction)
+                                },
+                            )
+                            .await?
+                        {
+                            return Ok(Some((reaction_msg, reaction_contact_id, reaction)));
+                        }
+                    }
+                }
+            }
        }
+        Ok(None)
    }
 }

 #[cfg(test)]
 mod tests {
-    use deltachat_contact_tools::ContactAddress;
-
    use super::*;
    use crate::chat::{forward_msgs, get_chat_msgs, send_text_msg};
    use crate::chatlist::Chatlist;
    use crate::config::Config;
-    use crate::contact::{Contact, Origin};
+    use crate::constants::DC_CHAT_ID_TRASH;
+    use crate::contact::{Contact, ContactAddress, Origin};
    use crate::download::DownloadState;
    use crate::message::{delete_msgs, MessageState};
    use crate::receive_imf::{receive_imf, receive_imf_from_inbox};
@@ -596,7 +594,8 @@ Here's my footer -- bob@example.net"
        assert_eq!(get_chat_msgs(&bob, bob_msg.chat_id).await?.len(), 2);

        let bob_reaction_msg = bob.pop_sent_msg().await;
-        alice.recv_msg_trash(&bob_reaction_msg).await;
+        let alice_reaction_msg = alice.recv_msg_opt(&bob_reaction_msg).await.unwrap();
+        assert_eq!(alice_reaction_msg.chat_id, DC_CHAT_ID_TRASH);
        assert_eq!(get_chat_msgs(&alice, chat_alice.id).await?.len(), 2);

        let reactions = get_msg_reactions(&alice, alice_msg.sender_msg_id).await?;
@@ -649,7 +648,8 @@ Here's my footer -- bob@example.net"
        bob_msg1.chat_id.accept(&bob).await?;
        send_reaction(&bob, bob_msg1.id, "👍").await?;
        let bob_send_reaction = bob.pop_sent_msg().await;
-        alice.recv_msg_trash(&bob_send_reaction).await;
+        let alice_rcvd_reaction = alice.recv_msg(&bob_send_reaction).await;
+        assert!(alice_rcvd_reaction.get_timestamp() > bob_msg1.get_timestamp());

        let chatlist = Chatlist::try_load(&bob, 0, None, None).await?;
        let summary = chatlist.get_summary(&bob, 0, None).await?;
@@ -664,7 +664,7 @@ Here's my footer -- bob@example.net"
        SystemTime::shift(Duration::from_secs(10));
        send_reaction(&alice, alice_msg1.sender_msg_id, "🍿").await?;
        let alice_send_reaction = alice.pop_sent_msg().await;
-        bob.recv_msg_opt(&alice_send_reaction).await;
+        bob.recv_msg(&alice_send_reaction).await;

        assert_summary(&alice, "You reacted 🍿 to \"Party?\"").await;
        assert_summary(&bob, "ALICE reacted 🍿 to \"Party?\"").await;
@@ -681,7 +681,7 @@ Here's my footer -- bob@example.net"
        SystemTime::shift(Duration::from_secs(10));
        send_reaction(&alice, alice_msg1.sender_msg_id, "🤘").await?;
        let alice_send_reaction = alice.pop_sent_msg().await;
-        bob.recv_msg_opt(&alice_send_reaction).await;
+        bob.recv_msg(&alice_send_reaction).await;

        assert_summary(&alice, "You reacted 🤘 to \"Party?\"").await;
        assert_summary(&bob, "ALICE reacted 🤘 to \"Party?\"").await;
@@ -690,7 +690,7 @@ Here's my footer -- bob@example.net"
        SystemTime::shift(Duration::from_secs(10));
        send_reaction(&alice, alice_msg1.sender_msg_id, "").await?;
        let alice_remove_reaction = alice.pop_sent_msg().await;
-        bob.recv_msg_opt(&alice_remove_reaction).await;
+        bob.recv_msg(&alice_remove_reaction).await;

        assert_summary(&alice, "kewl").await;
        assert_summary(&bob, "kewl").await;
@@ -807,7 +807,7 @@ Here's my footer -- bob@example.net"
        let bob_reaction_msg = bob.pop_sent_msg().await;

        // Alice receives a reaction.
-        alice.recv_msg_trash(&bob_reaction_msg).await;
+        alice.recv_msg_opt(&bob_reaction_msg).await.unwrap();

        let reactions = get_msg_reactions(&alice, alice_msg_id).await?;
        assert_eq!(reactions.to_string(), "👍1");
@@ -859,7 +859,7 @@ Here's my footer -- bob@example.net"
        {
            send_reaction(&alice2, alice2_msg.id, "👍").await?;
            let msg = alice2.pop_sent_msg().await;
-            alice1.recv_msg_trash(&msg).await;
+            alice1.recv_msg(&msg).await;
        }

        // Check that the status is still the same.
@@ -881,7 +881,7 @@ Here's my footer -- bob@example.net"
        let alice1_msg = alice1.recv_msg(&alice0.pop_sent_msg().await).await;

        send_reaction(&alice0, alice0_msg_id, "👀").await?;
-        alice1.recv_msg_trash(&alice0.pop_sent_msg().await).await;
+        alice1.recv_msg(&alice0.pop_sent_msg().await).await;

        expect_reactions_changed_event(&alice0, chat_id, alice0_msg_id, ContactId::SELF).await?;
        expect_reactions_changed_event(&alice1, alice1_msg.chat_id, alice1_msg.id, ContactId::SELF)
--- a/src/receive_imf.rs
+++ b/src/receive_imf.rs
@@ -3,9 +3,6 @@
 use std::collections::HashSet;

 use anyhow::{Context as _, Result};
-use deltachat_contact_tools::{
-    addr_cmp, may_be_valid_addr, normalize_name, strip_rtlo_characters, ContactAddress,
-};
 use mailparse::{parse_mail, SingleInfo};
 use num_traits::FromPrimitive;
 use once_cell::sync::Lazy;
@@ -14,8 +11,10 @@ use regex::Regex;
 use crate::aheader::EncryptPreference;
 use crate::chat::{self, Chat, ChatId, ChatIdBlocked, ProtectionStatus};
 use crate::config::Config;
-use crate::constants::{self, Blocked, Chattype, ShowEmails, DC_CHAT_ID_TRASH};
-use crate::contact::{Contact, ContactId, Origin};
+use crate::constants::{Blocked, Chattype, ShowEmails, DC_CHAT_ID_TRASH};
+use crate::contact::{
+    addr_cmp, may_be_valid_addr, normalize_name, Contact, ContactAddress, ContactId, Origin,
+};
 use crate::context::Context;
 use crate::debug_logging::maybe_set_logging_xdc_inner;
 use crate::download::DownloadState;
@@ -23,6 +22,7 @@ use crate::ephemeral::{stock_ephemeral_timer_changed, Timer as EphemeralTimer};
 use crate::events::EventType;
 use crate::headerdef::{HeaderDef, HeaderDefMap};
 use crate::imap::{markseen_on_imap_table, GENERATED_PREFIX};
+use crate::location;
 use crate::log::LogExt;
 use crate::message::{
    self, rfc724_mid_exists, rfc724_mid_exists_and, Message, MessageState, MessengerMessage, MsgId,
@@ -37,8 +37,9 @@ use crate::simplify;
 use crate::sql;
 use crate::stock_str;
 use crate::sync::Sync::*;
-use crate::tools::{self, buf_compress, extract_grpid_from_rfc724_mid, validate_id};
-use crate::{chatlist_events, location};
+use crate::tools::{
+    self, buf_compress, extract_grpid_from_rfc724_mid, strip_rtlo_characters, validate_id,
+};
 use crate::{contact, imap};

 /// This is the struct that is returned after receiving one email (aka MIME message).
@@ -475,46 +476,11 @@ pub(crate) async fn receive_imf_inner(
    }

    if let Some(ref status_update) = mime_parser.webxdc_status_update {
-        let can_info_msg;
-        let instance = if mime_parser
-            .parts
-            .first()
-            .filter(|part| part.typ == Viewtype::Webxdc)
-            .is_some()
+        if let Err(err) = context
+            .receive_status_update(from_id, insert_msg_id, status_update)
+            .await
        {
-            can_info_msg = false;
-            Some(Message::load_from_db(context, insert_msg_id).await?)
-        } else if let Some(field) = mime_parser.get_header(HeaderDef::InReplyTo) {
-            if let Some(instance) = get_rfc724_mid_in_list(context, field).await? {
-                can_info_msg = instance.download_state() == DownloadState::Done;
-                Some(instance)
-            } else {
-                can_info_msg = false;
-                None
-            }
-        } else {
-            can_info_msg = false;
-            None
-        };
-
-        if let Some(instance) = instance {
-            if let Err(err) = context
-                .receive_status_update(
-                    from_id,
-                    &instance,
-                    received_msg.sort_timestamp,
-                    can_info_msg,
-                    status_update,
-                )
-                .await
-            {
-                warn!(context, "receive_imf cannot update status: {err:#}.");
-            }
-        } else {
-            warn!(
-                context,
-                "Received webxdc update, but cannot assign it to message."
-            );
+            warn!(context, "receive_imf cannot update status: {err:#}.");
        }
    }

@@ -1687,7 +1653,7 @@ async fn save_locations(
        }
    }
    if send_event {
-        context.emit_location_changed(Some(from_id)).await?;
+        context.emit_event(EventType::LocationChanged(Some(from_id)));
    }
    Ok(())
 }
@@ -1783,19 +1749,7 @@ async fn create_or_lookup_group(
 ) -> Result<Option<(ChatId, Blocked)>> {
    let grpid = if let Some(grpid) = try_getting_grpid(mime_parser) {
        grpid
-    } else if !allow_creation {
-        info!(context, "Creating ad-hoc group prevented from caller.");
-        return Ok(None);
-    } else if is_partial_download {
-        // Partial download may be an encrypted message with protected Subject header.
-        //
-        // We do not want to create a group with "..." or "Encrypted message" as a subject.
-        info!(
-            context,
-            "Ad-hoc group cannot be created from partial download."
-        );
-        return Ok(None);
-    } else {
+    } else if allow_creation {
        let mut member_ids: Vec<ContactId> = to_ids.to_vec();
        if !member_ids.contains(&(from_id)) {
            member_ids.push(from_id);
@@ -1809,6 +1763,9 @@ async fn create_or_lookup_group(
            .context("could not create ad hoc group")?
            .map(|chat_id| (chat_id, create_blocked));
        return Ok(res);
+    } else {
+        info!(context, "Creating ad-hoc group prevented from caller.");
+        return Ok(None);
    };

    let mut chat_id;
@@ -1902,8 +1859,6 @@ async fn create_or_lookup_group(
        chat::add_to_chat_contacts_table(context, new_chat_id, &members).await?;

        context.emit_event(EventType::ChatModified(new_chat_id));
-        chatlist_events::emit_chatlist_changed(context);
-        chatlist_events::emit_chatlist_item_changed(context, new_chat_id);
    }

    if let Some(chat_id) = chat_id {
@@ -1964,24 +1919,18 @@ async fn apply_group_changes(
        HashSet::<ContactId>::from_iter(chat::get_chat_contacts(context, chat_id).await?);
    let is_from_in_chat =
        !chat_contacts.contains(&ContactId::SELF) || chat_contacts.contains(&from_id);
+
    // Reject group membership changes from non-members and old changes.
-    let member_list_ts = match !is_partial_download && is_from_in_chat {
-        true => Some(chat_id.get_member_list_timestamp(context).await?),
-        false => None,
-    };
-    // When we remove a member locally, we shift `MemberListTimestamp` by `TIMESTAMP_SENT_TOLERANCE`
-    // into the future, so add some more tolerance here to allow remote membership changes as well.
-    let timestamp_sent_tolerance = constants::TIMESTAMP_SENT_TOLERANCE * 2;
-    let allow_member_list_changes = member_list_ts
-        .filter(|t| {
-            *t <= mime_parser
-                .timestamp_sent
-                .saturating_add(timestamp_sent_tolerance)
-        })
-        .is_some();
-    let sync_member_list = member_list_ts
-        .filter(|t| *t <= mime_parser.timestamp_sent)
-        .is_some();
+    let allow_member_list_changes = !is_partial_download
+        && is_from_in_chat
+        && chat_id
+            .update_timestamp(
+                context,
+                Param::MemberListTimestamp,
+                mime_parser.timestamp_sent,
+            )
+            .await?;
+
    // Whether to rebuild the member list from scratch.
    let recreate_member_list = {
        // Always recreate membership list if SELF has been added. The older versions of DC
@@ -1996,16 +1945,15 @@ async fn apply_group_changes(
                    .is_none(),
                None => false,
            }
-    } && (
-        // Don't allow the timestamp tolerance here for more reliable leaving of groups.
-        sync_member_list || {
+    } && {
+        if !allow_member_list_changes {
            info!(
                context,
                "Ignoring a try to recreate member list of {chat_id} by {from_id}.",
            );
-            false
        }
-    );
+        allow_member_list_changes
+    };

    if mime_parser.get_header(HeaderDef::ChatVerified).is_some() {
        if let VerifiedEncryption::NotVerified(err) = verified_encryption {
@@ -2118,13 +2066,6 @@ async fn apply_group_changes(
        }

        if !recreate_member_list {
-            let mut diff = HashSet::<ContactId>::new();
-            if sync_member_list {
-                diff = new_members.difference(&chat_contacts).copied().collect();
-            } else if let Some(added_id) = added_id {
-                diff.insert(added_id);
-            }
-            new_members.clone_from(&chat_contacts);
            // Don't delete any members locally, but instead add absent ones to provide group
            // membership consistency for all members:
            // - Classical MUA users usually don't intend to remove users from an email thread, so
@@ -2136,6 +2077,9 @@ async fn apply_group_changes(
            // will likely recreate the member list from the next received message. The problem
            // occurs only if that "somebody" managed to reply earlier. Really, it's a problem for
            // big groups with high message rate, but let it be for now.
+            let mut diff: HashSet<ContactId> =
+                new_members.difference(&chat_contacts).copied().collect();
+            new_members = chat_contacts.clone();
            new_members.extend(diff.clone());
            if let Some(added_id) = added_id {
                diff.remove(&added_id);
@@ -2171,17 +2115,6 @@ async fn apply_group_changes(
            chat_contacts = new_members;
            send_event_chat_modified = true;
        }
-        if sync_member_list {
-            let mut ts = mime_parser.timestamp_sent;
-            if recreate_member_list {
-                // Reject all older membership changes. See `allow_member_list_changes` to know how
-                // this works.
-                ts += timestamp_sent_tolerance;
-            }
-            chat_id
-                .update_timestamp(context, Param::MemberListTimestamp, ts)
-                .await?;
-        }
    }

    if let Some(avatar_action) = &mime_parser.group_avatar {
@@ -2217,7 +2150,6 @@ async fn apply_group_changes(

    if send_event_chat_modified {
        context.emit_event(EventType::ChatModified(chat_id));
-        chatlist_events::emit_chatlist_item_changed(context, chat_id);
    }
    Ok((group_changes_msgs, better_msg))
 }
@@ -2314,7 +2246,7 @@ fn compute_mailinglist_name(
    // and we can detect these lists by a unique `ListId`-suffix.
    if listid.ends_with(".list-id.mcsv.net") {
        if let Some(display_name) = &mime_parser.from.display_name {
-            name.clone_from(display_name);
+            name = display_name.clone();
        }
    }

@@ -2342,7 +2274,7 @@ fn compute_mailinglist_name(
            || listid.ends_with(".xt.local"))
    {
        if let Some(display_name) = &mime_parser.from.display_name {
-            name.clone_from(display_name);
+            name = display_name.clone();
        }
    }

@@ -2520,8 +2452,6 @@ async fn create_adhoc_group(
    chat::add_to_chat_contacts_table(context, new_chat_id, member_ids).await?;

    context.emit_event(EventType::ChatModified(new_chat_id));
-    chatlist_events::emit_chatlist_changed(context);
-    chatlist_events::emit_chatlist_item_changed(context, new_chat_id);

    Ok(Some(new_chat_id))
 }
@@ -2733,6 +2663,8 @@ async fn mark_recipients_as_verified(
 /// Returns the last message referenced from `References` header if it is in the database.
 ///
 /// For Delta Chat messages it is the last message in the chat of the sender.
+///
+/// Note that the returned message may be trashed.
 async fn get_previous_message(
    context: &Context,
    mime_parser: &MimeMessage,
@@ -2740,7 +2672,7 @@ async fn get_previous_message(
    if let Some(field) = mime_parser.get_header(HeaderDef::References) {
        if let Some(rfc724mid) = parse_message_ids(field).last() {
            if let Some((msg_id, _)) = rfc724_mid_exists(context, rfc724mid).await? {
-                return Message::load_from_db_optional(context, msg_id).await;
+                return Ok(Some(Message::load_from_db(context, msg_id).await?));
            }
        }
    }
--- a/src/receive_imf/tests.rs
+++ b/src/receive_imf/tests.rs
@@ -9,7 +9,7 @@ use crate::chat::{
    ChatVisibility,
 };
 use crate::chatlist::Chatlist;
-use crate::constants::{DC_GCL_FOR_FORWARDING, DC_GCL_NO_SPECIALS};
+use crate::constants::{ShowEmails, DC_GCL_FOR_FORWARDING, DC_GCL_NO_SPECIALS};
 use crate::download::MIN_DOWNLOAD_LIMIT;
 use crate::imap::prefetch_should_download;
 use crate::imex::{imex, ImexMode};
@@ -3728,7 +3728,6 @@ async fn test_dont_recreate_contacts_on_add_remove() -> Result<()> {
    alice.recv_msg(&bob.pop_sent_msg().await).await;
    assert_eq!(get_chat_contacts(&alice, alice_chat_id).await?.len(), 3);

-    SystemTime::shift(Duration::from_secs(3600));
    send_text_msg(
        &alice,
        alice_chat_id,
@@ -3811,18 +3810,17 @@ async fn test_dont_readd_with_normal_msg() -> Result<()> {
    remove_contact_from_chat(&bob, bob_chat_id, ContactId::SELF).await?;
    assert_eq!(get_chat_contacts(&bob, bob_chat_id).await?.len(), 1);

-    SystemTime::shift(Duration::from_secs(3600));
    add_contact_to_chat(
        &alice,
        alice_chat_id,
        Contact::create(&alice, "fiora", "fiora@example.net").await?,
    )
    .await?;
+
    bob.recv_msg(&alice.pop_sent_msg().await).await;

-    // Alice didn't receive Bob's leave message although a lot of time has
-    // passed, so Bob must readd themselves otherwise other members would think
-    // Bob is still here while they aren't. Bob should retry to leave if they
+    // Alice didn't receive Bob's leave message, so Bob must readd themselves otherwise other
+    // members would think Bob is still here while they aren't, and then retry to leave if they
    // think that Alice didn't re-add them on purpose (which is possible if Alice uses a classical
    // MUA).
    assert!(is_contact_in_chat(&bob, bob_chat_id, ContactId::SELF).await?);
@@ -4014,7 +4012,8 @@ async fn test_member_left_does_not_create_chat() -> Result<()> {
    // which some members simply deleted and some members left,
    // recreating the chat for others.
    remove_contact_from_chat(&alice, alice_chat_id, ContactId::SELF).await?;
-    bob.recv_msg_trash(&alice.pop_sent_msg().await).await;
+    let bob_chat_id = bob.recv_msg(&alice.pop_sent_msg().await).await.chat_id;
+    assert!(bob_chat_id.is_trash());

    Ok(())
 }
@@ -4041,15 +4040,6 @@ async fn test_recreate_member_list_on_missing_add_of_self() -> Result<()> {
    // Bob missed the message adding them, but must recreate the member list.
    assert_eq!(get_chat_contacts(&bob, bob_chat_id).await?.len(), 2);
    assert!(is_contact_in_chat(&bob, bob_chat_id, ContactId::SELF).await?);
-
-    // But if Bob just left, they mustn't recreate the member list even after missing a message.
-    bob_chat_id.accept(&bob).await?;
-    remove_contact_from_chat(&bob, bob_chat_id, ContactId::SELF).await?;
-    send_text_msg(&alice, alice_chat_id, "3rd message".to_string()).await?;
-    alice.pop_sent_msg().await;
-    send_text_msg(&alice, alice_chat_id, "4th message".to_string()).await?;
-    bob.recv_msg(&alice.pop_sent_msg().await).await;
-    assert!(!is_contact_in_chat(&bob, bob_chat_id, ContactId::SELF).await?);
    Ok(())
 }

@@ -4364,8 +4354,8 @@ async fn test_forged_from() -> Result<()> {
        .payload
        .replace("bob@example.net", "notbob@example.net");

-    let msg = alice.recv_msg_opt(&sent_msg).await;
-    assert!(msg.is_none());
+    let msg = alice.recv_msg(&sent_msg).await;
+    assert!(msg.chat_id.is_trash());
    Ok(())
 }

--- a/src/scheduler.rs
+++ b/src/scheduler.rs
@@ -247,14 +247,6 @@ impl SchedulerState {
        }
    }

-    /// Interrupt optional boxes (mvbox, sentbox) loops.
-    pub(crate) async fn interrupt_oboxes(&self) {
-        let inner = self.inner.read().await;
-        if let InnerSchedulerState::Started(ref scheduler) = *inner {
-            scheduler.interrupt_oboxes();
-        }
-    }
-
    pub(crate) async fn interrupt_smtp(&self) {
        let inner = self.inner.read().await;
        if let InnerSchedulerState::Started(ref scheduler) = *inner {
@@ -573,28 +565,19 @@ async fn fetch_idle(
            .context("store_seen_flags_on_imap")?;
    }

-    if !ctx.should_delete_to_trash().await?
-        || ctx
-            .get_config(Config::ConfiguredTrashFolder)
-            .await?
-            .is_some()
-    {
-        // Fetch the watched folder.
-        connection
-            .fetch_move_delete(ctx, &mut session, &watch_folder, folder_meaning)
-            .await
-            .context("fetch_move_delete")?;
+    // Fetch the watched folder.
+    connection
+        .fetch_move_delete(ctx, &mut session, &watch_folder, folder_meaning)
+        .await
+        .context("fetch_move_delete")?;

-        // Mark expired messages for deletion. Marked messages will be deleted from the server
-        // on the next iteration of `fetch_move_delete`. `delete_expired_imap_messages` is not
-        // called right before `fetch_move_delete` because it is not well optimized and would
-        // otherwise slow down message fetching.
-        delete_expired_imap_messages(ctx)
-            .await
-            .context("delete_expired_imap_messages")?;
-    } else if folder_config == Config::ConfiguredInboxFolder {
-        ctx.last_full_folder_scan.lock().await.take();
-    }
+    // Mark expired messages for deletion. Marked messages will be deleted from the server
+    // on the next iteration of `fetch_move_delete`. `delete_expired_imap_messages` is not
+    // called right before `fetch_move_delete` because it is not well optimized and would
+    // otherwise slow down message fetching.
+    delete_expired_imap_messages(ctx)
+        .await
+        .context("delete_expired_imap_messages")?;

    // Scan additional folders only after finishing fetching the watched folder.
    //
@@ -928,12 +911,6 @@ impl Scheduler {
        self.inbox.conn_state.interrupt();
    }

-    fn interrupt_oboxes(&self) {
-        for b in &self.oboxes {
-            b.conn_state.interrupt();
-        }
-    }
-
    fn interrupt_smtp(&self) {
        self.smtp.interrupt();
    }
@@ -947,7 +924,7 @@ impl Scheduler {
    }

    fn interrupt_recently_seen(&self, contact_id: ContactId, timestamp: i64) {
-        self.recently_seen_loop.try_interrupt(contact_id, timestamp);
+        self.recently_seen_loop.interrupt(contact_id, timestamp);
    }

    /// Halt the scheduler.
--- a/src/scheduler/connectivity.rs
+++ b/src/scheduler/connectivity.rs
@@ -9,8 +9,8 @@ use tokio::sync::Mutex;
 use crate::events::EventType;
 use crate::imap::{scan_folders::get_watched_folder_configs, FolderMeaning};
 use crate::quota::{QUOTA_ERROR_THRESHOLD_PERCENTAGE, QUOTA_WARN_THRESHOLD_PERCENTAGE};
-use crate::stock_str;
 use crate::{context::Context, log::LogExt};
+use crate::{stock_str, tools};

 use super::InnerSchedulerState;

@@ -413,9 +413,7 @@ impl Context {
        //                                [======67%=====       ]
        // =============================================================================================

-        let domain =
-            &deltachat_contact_tools::EmailAddress::new(&self.get_primary_self_addr().await?)?
-                .domain;
+        let domain = &tools::EmailAddress::new(&self.get_primary_self_addr().await?)?.domain;
        let storage_on_domain = stock_str::storage_on_domain(self, domain).await;
        ret += &format!("<h3>{storage_on_domain}</h3><ul>");
        let quota = self.quota.read().await;
--- a/src/securejoin.rs
+++ b/src/securejoin.rs
@@ -1,11 +1,10 @@
-//! Implementation of [SecureJoin protocols](https://securejoin.delta.chat/).
+//! Verified contact protocol implementation as [specified by countermitm project](https://securejoin.readthedocs.io/en/latest/new.html#setup-contact-protocol).

 use anyhow::{bail, Context as _, Error, Result};
 use percent_encoding::{utf8_percent_encode, AsciiSet, NON_ALPHANUMERIC};

 use crate::aheader::EncryptPreference;
 use crate::chat::{self, Chat, ChatId, ChatIdBlocked, ProtectionStatus};
-use crate::chatlist_events;
 use crate::config::Config;
 use crate::constants::Blocked;
 use crate::contact::{Contact, ContactId, Origin};
@@ -681,7 +680,6 @@ async fn secure_connection_established(
        )
        .await?;
    context.emit_event(EventType::ChatModified(chat_id));
-    chatlist_events::emit_chatlist_item_changed(context, chat_id);
    Ok(())
 }

@@ -756,18 +754,17 @@ fn encrypted_and_signed(

 #[cfg(test)]
 mod tests {
-    use deltachat_contact_tools::{ContactAddress, EmailAddress};
-
    use super::*;
    use crate::chat::remove_contact_from_chat;
    use crate::chatlist::Chatlist;
    use crate::constants::Chattype;
+    use crate::contact::ContactAddress;
    use crate::imex::{imex, ImexMode};
    use crate::receive_imf::receive_imf;
    use crate::stock_str::chat_protection_enabled;
    use crate::test_utils::get_chat_msg;
    use crate::test_utils::{TestContext, TestContextManager};
-    use crate::tools::SystemTime;
+    use crate::tools::{EmailAddress, SystemTime};
    use std::collections::HashSet;
    use std::time::Duration;

@@ -836,7 +833,7 @@ mod tests {
        assert!(msg.get_header(HeaderDef::SecureJoinInvitenumber).is_some());

        // Step 3: Alice receives vc-request, sends vc-auth-required
-        alice.recv_msg_trash(&sent).await;
+        alice.recv_msg(&sent).await;
        assert_eq!(
            Chatlist::try_load(&alice, 0, None, None)
                .await
@@ -854,7 +851,7 @@ mod tests {
        );

        // Step 4: Bob receives vc-auth-required, sends vc-request-with-auth
-        bob.recv_msg_trash(&sent).await;
+        bob.recv_msg(&sent).await;

        // Check Bob emitted the JoinerProgress event.
        let event = bob
@@ -936,7 +933,7 @@ mod tests {
        }

        // Step 5+6: Alice receives vc-request-with-auth, sends vc-contact-confirm
-        alice.recv_msg_trash(&sent).await;
+        alice.recv_msg(&sent).await;
        assert_eq!(contact_bob.is_verified(&alice.ctx).await.unwrap(), true);

        // exactly one one-to-one chat should be visible for both now
@@ -985,7 +982,7 @@ mod tests {
        assert_eq!(contact_bob.is_verified(&bob.ctx).await.unwrap(), false);

        // Step 7: Bob receives vc-contact-confirm
-        bob.recv_msg_trash(&sent).await;
+        bob.recv_msg(&sent).await;
        assert_eq!(contact_alice.is_verified(&bob.ctx).await.unwrap(), true);

        // Check Bob got the verified message in his 1:1 chat.
@@ -1086,7 +1083,7 @@ mod tests {
        assert_eq!(contact_bob.is_verified(&alice.ctx).await?, false);

        // Step 5+6: Alice receives vc-request-with-auth, sends vc-contact-confirm
-        alice.recv_msg_trash(&sent).await;
+        alice.recv_msg(&sent).await;
        assert_eq!(contact_bob.is_verified(&alice.ctx).await?, true);

        let sent = alice.pop_sent_msg().await;
@@ -1107,7 +1104,7 @@ mod tests {
        assert_eq!(contact_bob.is_verified(&bob.ctx).await?, false);

        // Step 7: Bob receives vc-contact-confirm
-        bob.recv_msg_trash(&sent).await;
+        bob.recv_msg(&sent).await;
        assert_eq!(contact_alice.is_verified(&bob.ctx).await?, true);

        Ok(())
@@ -1185,7 +1182,7 @@ mod tests {
        assert!(msg.get_header(HeaderDef::SecureJoinGroup).is_none());

        // Step 3: Alice receives vg-request, sends vg-auth-required
-        alice.recv_msg_trash(&sent).await;
+        alice.recv_msg(&sent).await;

        let sent = alice.pop_sent_msg().await;
        let msg = bob.parse_msg(&sent).await;
@@ -1196,7 +1193,7 @@ mod tests {
        );

        // Step 4: Bob receives vg-auth-required, sends vg-request-with-auth
-        bob.recv_msg_trash(&sent).await;
+        bob.recv_msg(&sent).await;
        let sent = bob.pop_sent_msg().await;

        // Check Bob emitted the JoinerProgress event.
@@ -1243,7 +1240,7 @@ mod tests {
        assert_eq!(contact_bob.is_verified(&alice.ctx).await?, false);

        // Step 5+6: Alice receives vg-request-with-auth, sends vg-member-added
-        alice.recv_msg_trash(&sent).await;
+        alice.recv_msg(&sent).await;
        assert_eq!(contact_bob.is_verified(&alice.ctx).await?, true);

        let sent = alice.pop_sent_msg().await;
@@ -1391,15 +1388,15 @@ First thread."#;

        // vc-request
        let sent = bob.pop_sent_msg().await;
-        alice.recv_msg_trash(&sent).await;
+        alice.recv_msg(&sent).await;

        // vc-auth-required
        let sent = alice.pop_sent_msg().await;
-        bob.recv_msg_trash(&sent).await;
+        bob.recv_msg(&sent).await;

        // vc-request-with-auth
        let sent = bob.pop_sent_msg().await;
-        alice.recv_msg_trash(&sent).await;
+        alice.recv_msg(&sent).await;

        // Alice has Bob verified now.
        let contact_bob_id =
--- a/src/sql.rs
+++ b/src/sql.rs
@@ -46,10 +46,12 @@ pub(crate) fn params_iter(
    iter.iter().map(|item| item as &dyn crate::sql::ToSql)
 }

+mod deserialize;
 mod migrations;
 mod pool;
+mod serialize;

-use pool::Pool;
+use pool::{Pool, PooledConnection};

 /// A wrapper around the underlying Sqlite3 object.
 #[derive(Debug)]
@@ -363,6 +365,12 @@ impl Sql {
        self.write_mtx.lock().await
    }

+    pub(crate) async fn get_connection(&self) -> Result<PooledConnection> {
+        let lock = self.pool.read().await;
+        let pool = lock.as_ref().context("no SQL connection")?;
+        pool.get().await
+    }
+
    /// Allocates a connection and calls `function` with the connection. If `function` does write
    /// queries,
    /// - either first take a lock using `write_lock()`
@@ -374,9 +382,7 @@ impl Sql {
        F: 'a + FnOnce(&mut Connection) -> Result<R> + Send,
        R: Send + 'static,
    {
-        let lock = self.pool.read().await;
-        let pool = lock.as_ref().context("no SQL connection")?;
-        let mut conn = pool.get().await?;
+        let mut conn = self.get_connection().await?;
        let res = tokio::task::block_in_place(move || function(&mut conn))?;
        Ok(res)
    }
@@ -1007,6 +1013,8 @@ pub fn repeat_vars(count: usize) -> String {

 #[cfg(test)]
 mod tests {
+    use async_channel as channel;
+
    use super::*;
    use crate::{test_utils::TestContext, EventType};

@@ -1083,7 +1091,8 @@ mod tests {
            .await
            .unwrap();

-        let event_source = t.get_event_emitter();
+        let (event_sink, event_source) = channel::unbounded();
+        t.add_event_sender(event_sink).await;

        let a = t.get_config(Config::Selfavatar).await.unwrap().unwrap();
        assert_eq!(avatar_bytes, &tokio::fs::read(&a).await.unwrap()[..]);
--- a/src/sql/deserialize.rs
+++ b/src/sql/deserialize.rs
--- a/src/sql/migrations.rs
+++ b/src/sql/migrations.rs
@@ -1,7 +1,6 @@
 //! Migrations module.

 use anyhow::{Context as _, Result};
-use deltachat_contact_tools::EmailAddress;
 use rusqlite::OptionalExtension;

 use crate::config::Config;
@@ -11,6 +10,7 @@ use crate::imap;
 use crate::message::MsgId;
 use crate::provider::get_provider_by_domain;
 use crate::sql::Sql;
+use crate::tools::EmailAddress;

 const DBVERSION: i32 = 68;
 const VERSION_CFG: &str = "dbversion";
--- a/src/sql/serialize.rs
+++ b/src/sql/serialize.rs
@@ -0,0 +1,963 @@
+//! Database serialization module.
+//!
+//! The module contains functions to serialize database into a stream.
+//!
+//! Output format is based on [bencoding](http://bittorrent.org/beps/bep_0003.html).
+
+/// Database version supported by the current serialization code.
+///
+/// Serialization code MUST be updated before increasing this number.
+///
+/// If this version is below the actual database version,
+/// serialization code is outdated.
+/// If this version is above the actual database version,
+/// migrations have to be run first to update the database.
+const SERIALIZE_DBVERSION: &str = "99";
+
+use anyhow::{anyhow, Context as _, Result};
+use rusqlite::types::ValueRef;
+use rusqlite::Transaction;
+use tokio::io::{AsyncWrite, AsyncWriteExt};
+
+use super::Sql;
+
+struct Encoder<'a, W: AsyncWrite + Unpin> {
+    tx: Transaction<'a>,
+
+    w: W,
+}
+
+async fn write_bytes(w: &mut (impl AsyncWrite + Unpin), b: &[u8]) -> Result<()> {
+    let bytes_len = format!("{}:", b.len());
+    w.write_all(bytes_len.as_bytes()).await?;
+    w.write_all(b).await?;
+    Ok(())
+}
+
+async fn write_str(w: &mut (impl AsyncWrite + Unpin), s: &str) -> Result<()> {
+    write_bytes(w, s.as_bytes()).await?;
+    Ok(())
+}
+
+async fn write_i64(w: &mut (impl AsyncWrite + Unpin), i: i64) -> Result<()> {
+    let s = format!("{i}");
+    w.write_all(b"i").await?;
+    w.write_all(s.as_bytes()).await?;
+    w.write_all(b"e").await?;
+    Ok(())
+}
+
+async fn write_u32(w: &mut (impl AsyncWrite + Unpin), i: u32) -> Result<()> {
+    let s = format!("{i}");
+    w.write_all(b"i").await?;
+    w.write_all(s.as_bytes()).await?;
+    w.write_all(b"e").await?;
+    Ok(())
+}
+
+async fn write_f64(w: &mut (impl AsyncWrite + Unpin), f: f64) -> Result<()> {
+    write_bytes(w, &f.to_be_bytes()).await?;
+    Ok(())
+}
+
+async fn write_bool(w: &mut (impl AsyncWrite + Unpin), b: bool) -> Result<()> {
+    if b {
+        w.write_all(b"i1e").await?;
+    } else {
+        w.write_all(b"i0e").await?;
+    }
+    Ok(())
+}
+
+impl<'a, W: AsyncWrite + Unpin> Encoder<'a, W> {
+    fn new(tx: Transaction<'a>, w: W) -> Self {
+        Self { tx, w }
+    }
+
+    /// Serializes `config` table.
+    async fn serialize_config(&mut self) -> Result<()> {
+        // FIXME: sort the dictionary in lexicographical order
+        // dbversion should be the first, so store it as "_config._dbversion"
+
+        let mut stmt = self.tx.prepare("SELECT keyname,value FROM config")?;
+        let mut rows = stmt.query(())?;
+        self.w.write_all(b"d").await?;
+        while let Some(row) = rows.next()? {
+            let keyname: String = row.get(0)?;
+            let value: String = row.get(1)?;
+            write_str(&mut self.w, &keyname).await?;
+            write_str(&mut self.w, &value).await?;
+        }
+        self.w.write_all(b"e").await?;
+        Ok(())
+    }
+
+    async fn serialize_acpeerstates(&mut self) -> Result<()> {
+        let mut stmt = self.tx.prepare("SELECT addr, backward_verified_key_id, last_seen, last_seen_autocrypt, public_key, prefer_encrypted, gossip_timestamp, gossip_key, public_key_fingerprint, gossip_key_fingerprint, verified_key, verified_key_fingerprint FROM acpeerstates")?;
+        let mut rows = stmt.query(())?;
+
+        self.w.write_all(b"l").await?;
+        while let Some(row) = rows.next()? {
+            let addr: String = row.get("addr")?;
+            let backward_verified_key_id: Option<i64> = row.get("backward_verified_key_id")?;
+            let prefer_encrypted: i64 = row.get("prefer_encrypted")?;
+
+            let last_seen: i64 = row.get("last_seen")?;
+
+            let last_seen_autocrypt: i64 = row.get("last_seen_autocrypt")?;
+            let public_key: Option<Vec<u8>> = row.get("public_key")?;
+            let public_key_fingerprint: Option<String> = row.get("public_key_fingerprint")?;
+
+            let gossip_timestamp: i64 = row.get("gossip_timestamp")?;
+            let gossip_key: Option<Vec<u8>> = row.get("gossip_key")?;
+            let gossip_key_fingerprint: Option<String> = row.get("gossip_key_fingerprint")?;
+
+            let verified_key: Option<Vec<u8>> = row.get("verified_key")?;
+            let verified_key_fingerprint: Option<String> = row.get("verified_key_fingerprint")?;
+
+            self.w.write_all(b"d").await?;
+
+            write_str(&mut self.w, "addr").await?;
+            write_str(&mut self.w, &addr).await?;
+
+            if let Some(backward_verified_key_id) = backward_verified_key_id {
+                write_str(&mut self.w, "backward_verified_key_id").await?;
+                write_i64(&mut self.w, backward_verified_key_id).await?;
+            }
+
+            if let Some(gossip_key) = gossip_key {
+                write_str(&mut self.w, "gossip_key").await?;
+                write_bytes(&mut self.w, &gossip_key).await?;
+            }
+
+            if let Some(gossip_key_fingerprint) = gossip_key_fingerprint {
+                write_str(&mut self.w, "gossip_key_fingerprint").await?;
+                write_str(&mut self.w, &gossip_key_fingerprint).await?;
+            }
+
+            write_str(&mut self.w, "gossip_timestamp").await?;
+            write_i64(&mut self.w, gossip_timestamp).await?;
+
+            write_str(&mut self.w, "last_seen").await?;
+            write_i64(&mut self.w, last_seen).await?;
+
+            write_str(&mut self.w, "last_seen_autocrypt").await?;
+            write_i64(&mut self.w, last_seen_autocrypt).await?;
+
+            write_str(&mut self.w, "prefer_encrypted").await?;
+            write_i64(&mut self.w, prefer_encrypted).await?;
+
+            if let Some(public_key) = public_key {
+                write_str(&mut self.w, "public_key").await?;
+                write_bytes(&mut self.w, &public_key).await?;
+            }
+
+            if let Some(public_key_fingerprint) = public_key_fingerprint {
+                write_str(&mut self.w, "public_key_fingerprint").await?;
+                write_str(&mut self.w, &public_key_fingerprint).await?;
+            }
+
+            if let Some(verified_key) = verified_key {
+                write_str(&mut self.w, "verified_key").await?;
+                write_bytes(&mut self.w, &verified_key).await?;
+            }
+
+            if let Some(verified_key_fingerprint) = verified_key_fingerprint {
+                write_str(&mut self.w, "verified_key_fingerprint").await?;
+                write_str(&mut self.w, &verified_key_fingerprint).await?;
+            }
+
+            self.w.write_all(b"e").await?;
+        }
+        self.w.write_all(b"e").await?;
+        Ok(())
+    }
+
+    /// Serializes chats.
+    async fn serialize_chats(&mut self) -> Result<()> {
+        let mut stmt = self.tx.prepare(
+            "SELECT \
+        id,\
+        type,\
+        name,\
+        blocked,\
+        grpid,\
+        param,\
+        archived,\
+        gossiped_timestamp,\
+        locations_send_begin,\
+        locations_send_until,\
+        locations_last_sent,\
+        created_timestamp,\
+        muted_until,\
+        ephemeral_timer,\
+        protected FROM chats",
+        )?;
+        let mut rows = stmt.query(())?;
+
+        self.w.write_all(b"l").await?;
+        while let Some(row) = rows.next()? {
+            let id: u32 = row.get("id")?;
+            let typ: u32 = row.get("type")?;
+            let name: String = row.get("name")?;
+            let blocked: u32 = row.get("blocked")?;
+            let grpid: String = row.get("grpid")?;
+            let param: String = row.get("param")?;
+            let archived: bool = row.get("archived")?;
+            let gossiped_timestamp: i64 = row.get("gossiped_timestamp")?;
+            let locations_send_begin: i64 = row.get("locations_send_begin")?;
+            let locations_send_until: i64 = row.get("locations_send_until")?;
+            let locations_last_sent: i64 = row.get("locations_last_sent")?;
+            let created_timestamp: i64 = row.get("created_timestamp")?;
+            let muted_until: i64 = row.get("muted_until")?;
+            let ephemeral_timer: i64 = row.get("ephemeral_timer")?;
+            let protected: u32 = row.get("protected")?;
+
+            self.w.write_all(b"d").await?;
+
+            write_str(&mut self.w, "archived").await?;
+            write_bool(&mut self.w, archived).await?;
+
+            write_str(&mut self.w, "blocked").await?;
+            write_u32(&mut self.w, blocked).await?;
+
+            write_str(&mut self.w, "created_timestamp").await?;
+            write_i64(&mut self.w, created_timestamp).await?;
+
+            write_str(&mut self.w, "ephemeral_timer").await?;
+            write_i64(&mut self.w, ephemeral_timer).await?;
+
+            write_str(&mut self.w, "gossiped_timestamp").await?;
+            write_i64(&mut self.w, gossiped_timestamp).await?;
+
+            write_str(&mut self.w, "grpid").await?;
+            write_str(&mut self.w, &grpid).await?;
+
+            write_str(&mut self.w, "id").await?;
+            write_u32(&mut self.w, id).await?;
+
+            write_str(&mut self.w, "locations_last_sent").await?;
+            write_i64(&mut self.w, locations_last_sent).await?;
+
+            write_str(&mut self.w, "locations_send_begin").await?;
+            write_i64(&mut self.w, locations_send_begin).await?;
+
+            write_str(&mut self.w, "locations_send_until").await?;
+            write_i64(&mut self.w, locations_send_until).await?;
+
+            write_str(&mut self.w, "muted_until").await?;
+            write_i64(&mut self.w, muted_until).await?;
+
+            write_str(&mut self.w, "name").await?;
+            write_str(&mut self.w, &name).await?;
+
+            write_str(&mut self.w, "param").await?;
+            write_str(&mut self.w, &param).await?;
+
+            write_str(&mut self.w, "protected").await?;
+            write_u32(&mut self.w, protected).await?;
+
+            write_str(&mut self.w, "type").await?;
+            write_u32(&mut self.w, typ).await?;
+
+            self.w.write_all(b"e").await?;
+        }
+        self.w.write_all(b"e").await?;
+        Ok(())
+    }
+
+    async fn serialize_chats_contacts(&mut self) -> Result<()> {
+        let mut stmt = self
+            .tx
+            .prepare("SELECT chat_id, contact_id FROM chats_contacts")?;
+        let mut rows = stmt.query(())?;
+
+        self.w.write_all(b"l").await?;
+        while let Some(row) = rows.next()? {
+            let chat_id: u32 = row.get("chat_id")?;
+            let contact_id: u32 = row.get("contact_id")?;
+
+            self.w.write_all(b"d").await?;
+
+            write_str(&mut self.w, "chat_id").await?;
+            write_u32(&mut self.w, chat_id).await?;
+
+            write_str(&mut self.w, "contact_id").await?;
+            write_u32(&mut self.w, contact_id).await?;
+
+            self.w.write_all(b"e").await?;
+        }
+        self.w.write_all(b"e").await?;
+        Ok(())
+    }
+
+    /// Serializes contacts.
+    async fn serialize_contacts(&mut self) -> Result<()> {
+        let mut stmt = self.tx.prepare(
+            "SELECT \
+        id,\
+        name,\
+        addr,\
+        origin,\
+        blocked,\
+        last_seen,\
+        param,\
+        authname,\
+        selfavatar_sent,\
+        status FROM contacts",
+        )?;
+        let mut rows = stmt.query(())?;
+        self.w.write_all(b"l").await?;
+        while let Some(row) = rows.next()? {
+            let id: u32 = row.get("id")?;
+            let name: String = row.get("name")?;
+            let authname: String = row.get("authname")?;
+            let addr: String = row.get("addr")?;
+            let origin: u32 = row.get("origin")?;
+            let blocked: Option<bool> = row.get("blocked")?;
+            let blocked = blocked.unwrap_or_default();
+            let last_seen: i64 = row.get("last_seen")?;
+            let selfavatar_sent: i64 = row.get("selfavatar_sent")?;
+            let param: String = row.get("param")?;
+            let status: Option<String> = row.get("status")?;
+
+            self.w.write_all(b"d").await?;
+
+            write_str(&mut self.w, "addr").await?;
+            write_str(&mut self.w, &addr).await?;
+
+            write_str(&mut self.w, "authname").await?;
+            write_str(&mut self.w, &authname).await?;
+
+            write_str(&mut self.w, "blocked").await?;
+            write_bool(&mut self.w, blocked).await?;
+
+            write_str(&mut self.w, "id").await?;
+            write_u32(&mut self.w, id).await?;
+
+            write_str(&mut self.w, "last_seen").await?;
+            write_i64(&mut self.w, last_seen).await?;
+
+            write_str(&mut self.w, "name").await?;
+            write_str(&mut self.w, &name).await?;
+
+            write_str(&mut self.w, "origin").await?;
+            write_u32(&mut self.w, origin).await?;
+
+            // TODO: parse param instead of serializeing as is
+            write_str(&mut self.w, "param").await?;
+            write_str(&mut self.w, &param).await?;
+
+            write_str(&mut self.w, "selfavatar_sent").await?;
+            write_i64(&mut self.w, selfavatar_sent).await?;
+
+            if let Some(status) = status {
+                if !status.is_empty() {
+                    write_str(&mut self.w, "status").await?;
+                    write_str(&mut self.w, &status).await?;
+                }
+            }
+            self.w.write_all(b"e").await?;
+        }
+        self.w.write_all(b"e").await?;
+        Ok(())
+    }
+
+    async fn serialize_dns_cache(&mut self) -> Result<()> {
+        let mut stmt = self
+            .tx
+            .prepare("SELECT hostname, address, timestamp FROM dns_cache")?;
+        let mut rows = stmt.query(())?;
+
+        self.w.write_all(b"l").await?;
+        while let Some(row) = rows.next()? {
+            let hostname: String = row.get("hostname")?;
+            let address: String = row.get("address")?;
+            let timestamp: i64 = row.get("timestamp")?;
+
+            self.w.write_all(b"d").await?;
+
+            write_str(&mut self.w, "address").await?;
+            write_str(&mut self.w, &address).await?;
+
+            write_str(&mut self.w, "hostname").await?;
+            write_str(&mut self.w, &hostname).await?;
+
+            write_str(&mut self.w, "timestamp").await?;
+            write_i64(&mut self.w, timestamp).await?;
+
+            self.w.write_all(b"e").await?;
+        }
+        self.w.write_all(b"e").await?;
+        Ok(())
+    }
+
+    async fn serialize_imap(&mut self) -> Result<()> {
+        let mut stmt = self
+            .tx
+            .prepare("SELECT id, rfc724_mid, folder, target, uid, uidvalidity FROM imap")?;
+        let mut rows = stmt.query(())?;
+
+        self.w.write_all(b"l").await?;
+        while let Some(row) = rows.next()? {
+            let id: i64 = row.get("id")?;
+            let rfc724_mid: String = row.get("rfc724_mid")?;
+            let folder: String = row.get("folder")?;
+            let target: String = row.get("target")?;
+            let uid: i64 = row.get("uid")?;
+            let uidvalidity: i64 = row.get("uidvalidity")?;
+
+            self.w.write_all(b"d").await?;
+
+            write_str(&mut self.w, "folder").await?;
+            write_str(&mut self.w, &folder).await?;
+
+            write_str(&mut self.w, "id").await?;
+            write_i64(&mut self.w, id).await?;
+
+            write_str(&mut self.w, "rfc724_mid").await?;
+            write_str(&mut self.w, &rfc724_mid).await?;
+
+            write_str(&mut self.w, "target").await?;
+            write_str(&mut self.w, &target).await?;
+
+            write_str(&mut self.w, "uid").await?;
+            write_i64(&mut self.w, uid).await?;
+
+            write_str(&mut self.w, "uidvalidity").await?;
+            write_i64(&mut self.w, uidvalidity).await?;
+
+            self.w.write_all(b"e").await?;
+        }
+        self.w.write_all(b"e").await?;
+        Ok(())
+    }
+
+    async fn serialize_imap_sync(&mut self) -> Result<()> {
+        let mut stmt = self
+            .tx
+            .prepare("SELECT folder, uidvalidity, uid_next, modseq FROM imap_sync")?;
+        let mut rows = stmt.query(())?;
+
+        self.w.write_all(b"l").await?;
+        while let Some(row) = rows.next()? {
+            let folder: String = row.get("folder")?;
+            let uidvalidity: i64 = row.get("uidvalidity")?;
+            let uidnext: i64 = row.get("uid_next")?;
+            let modseq: i64 = row.get("modseq")?;
+
+            self.w.write_all(b"d").await?;
+
+            write_str(&mut self.w, "folder").await?;
+            write_str(&mut self.w, &folder).await?;
+
+            write_str(&mut self.w, "modseq").await?;
+            write_i64(&mut self.w, modseq).await?;
+
+            write_str(&mut self.w, "uidnext").await?;
+            write_i64(&mut self.w, uidnext).await?;
+
+            write_str(&mut self.w, "uidvalidity").await?;
+            write_i64(&mut self.w, uidvalidity).await?;
+
+            self.w.write_all(b"e").await?;
+        }
+        self.w.write_all(b"e").await?;
+        Ok(())
+    }
+
+    async fn serialize_keypairs(&mut self) -> Result<()> {
+        let mut stmt = self
+            .tx
+            .prepare("SELECT id,addr,private_key,public_key,created FROM keypairs")?;
+        let mut rows = stmt.query(())?;
+
+        self.w.write_all(b"l").await?;
+        while let Some(row) = rows.next()? {
+            let id: u32 = row.get("id")?;
+            let addr: String = row.get("addr")?;
+            let private_key: Vec<u8> = row.get("private_key")?;
+            let public_key: Vec<u8> = row.get("public_key")?;
+            let created: i64 = row.get("created")?;
+
+            self.w.write_all(b"d").await?;
+
+            write_str(&mut self.w, "addr").await?;
+            write_str(&mut self.w, &addr).await?;
+
+            write_str(&mut self.w, "created").await?;
+            write_i64(&mut self.w, created).await?;
+
+            write_str(&mut self.w, "id").await?;
+            write_u32(&mut self.w, id).await?;
+
+            write_str(&mut self.w, "private_key").await?;
+            write_bytes(&mut self.w, &private_key).await?;
+
+            write_str(&mut self.w, "public_key").await?;
+            write_bytes(&mut self.w, &public_key).await?;
+
+            self.w.write_all(b"e").await?;
+        }
+        self.w.write_all(b"e").await?;
+        Ok(())
+    }
+
+    async fn serialize_leftgroups(&mut self) -> Result<()> {
+        let mut stmt = self.tx.prepare("SELECT grpid FROM leftgrps")?;
+        let mut rows = stmt.query(())?;
+
+        self.w.write_all(b"l").await?;
+        while let Some(row) = rows.next()? {
+            let grpid: String = row.get("grpid")?;
+            write_str(&mut self.w, &grpid).await?;
+        }
+        self.w.write_all(b"e").await?;
+        Ok(())
+    }
+
+    async fn serialize_locations(&mut self) -> Result<()> {
+        let mut stmt = self
+            .tx
+            .prepare("SELECT id, latitude, longitude, accuracy, timestamp, chat_id, from_id, independent FROM locations")?;
+        let mut rows = stmt.query(())?;
+
+        self.w.write_all(b"l").await?;
+        while let Some(row) = rows.next()? {
+            let id: i64 = row.get("id")?;
+            let latitude: f64 = row.get("latitude")?;
+            let longitude: f64 = row.get("longitude")?;
+            let accuracy: f64 = row.get("accuracy")?;
+            let timestamp: i64 = row.get("timestamp")?;
+            let chat_id: u32 = row.get("chat_id")?;
+            let from_id: u32 = row.get("from_id")?;
+            let independent: u32 = row.get("independent")?;
+
+            self.w.write_all(b"d").await?;
+
+            write_str(&mut self.w, "accuracy").await?;
+            write_f64(&mut self.w, accuracy).await?;
+
+            write_str(&mut self.w, "chat_id").await?;
+            write_u32(&mut self.w, chat_id).await?;
+
+            write_str(&mut self.w, "from_id").await?;
+            write_u32(&mut self.w, from_id).await?;
+
+            write_str(&mut self.w, "id").await?;
+            write_i64(&mut self.w, id).await?;
+
+            write_str(&mut self.w, "independent").await?;
+            write_u32(&mut self.w, independent).await?;
+
+            write_str(&mut self.w, "latitude").await?;
+            write_f64(&mut self.w, latitude).await?;
+
+            write_str(&mut self.w, "longitude").await?;
+            write_f64(&mut self.w, longitude).await?;
+
+            write_str(&mut self.w, "timestamp").await?;
+            write_i64(&mut self.w, timestamp).await?;
+
+            self.w.write_all(b"e").await?;
+        }
+        self.w.write_all(b"e").await?;
+        Ok(())
+    }
+
+    /// Serializes MDNs.
+    async fn serialize_mdns(&mut self) -> Result<()> {
+        let mut stmt = self
+            .tx
+            .prepare("SELECT msg_id, contact_id, timestamp_sent FROM msgs_mdns")?;
+        let mut rows = stmt.query(())?;
+
+        self.w.write_all(b"l").await?;
+        while let Some(row) = rows.next()? {
+            let msg_id: u32 = row.get("msg_id")?;
+            let contact_id: u32 = row.get("contact_id")?;
+            let timestamp_sent: i64 = row.get("timestamp_sent")?;
+
+            self.w.write_all(b"d").await?;
+
+            write_str(&mut self.w, "contact_id").await?;
+            write_u32(&mut self.w, contact_id).await?;
+
+            write_str(&mut self.w, "msg_id").await?;
+            write_u32(&mut self.w, msg_id).await?;
+
+            write_str(&mut self.w, "timestamp_sent").await?;
+            write_i64(&mut self.w, timestamp_sent).await?;
+
+            self.w.write_all(b"e").await?;
+        }
+        self.w.write_all(b"e").await?;
+        Ok(())
+    }
+
+    /// Serializes messages.
+    async fn serialize_messages(&mut self) -> Result<()> {
+        let mut stmt = self.tx.prepare(
+            "SELECT
+                        id,
+                        rfc724_mid,
+                        chat_id,
+                        from_id, to_id,
+                        timestamp,
+                        type,
+                        state,
+                        msgrmsg,
+                        bytes,
+                        txt,
+                        txt_raw,
+                        param,
+                        timestamp_sent,
+                        timestamp_rcvd,
+                        hidden,
+                        mime_compressed,
+                        mime_headers,
+                        mime_in_reply_to,
+                        mime_references,
+                        location_id FROM msgs",
+        )?;
+        let mut rows = stmt.query(())?;
+
+        self.w.write_all(b"l").await?;
+        while let Some(row) = rows.next()? {
+            let id: i64 = row.get("id")?;
+            let rfc724_mid: String = row.get("rfc724_mid")?;
+            let chat_id: i64 = row.get("chat_id")?;
+            let from_id: i64 = row.get("from_id")?;
+            let to_id: i64 = row.get("to_id")?;
+            let timestamp: i64 = row.get("timestamp")?;
+            let typ: i64 = row.get("type")?;
+            let state: i64 = row.get("state")?;
+            let msgrmsg: i64 = row.get("msgrmsg")?;
+            let bytes: i64 = row.get("bytes")?;
+            let txt: String = row.get("txt")?;
+            let txt_raw: String = row.get("txt_raw")?;
+            let param: String = row.get("param")?;
+            let timestamp_sent: i64 = row.get("timestamp_sent")?;
+            let timestamp_rcvd: i64 = row.get("timestamp_rcvd")?;
+            let hidden: i64 = row.get("hidden")?;
+            let mime_compressed: i64 = row.get("mime_compressed")?;
+            let mime_headers: Vec<u8> =
+                row.get("mime_headers")
+                    .or_else(|err| match row.get_ref("mime_headers")? {
+                        ValueRef::Null => Ok(Vec::new()),
+                        ValueRef::Text(text) => Ok(text.to_vec()),
+                        ValueRef::Blob(blob) => Ok(blob.to_vec()),
+                        ValueRef::Integer(_) | ValueRef::Real(_) => Err(err),
+                    })?;
+            let mime_in_reply_to: Option<String> = row.get("mime_in_reply_to")?;
+            let mime_references: Option<String> = row.get("mime_references")?;
+            let location_id: i64 = row.get("location_id")?;
+
+            self.w.write_all(b"d").await?;
+
+            write_str(&mut self.w, "bytes").await?;
+            write_i64(&mut self.w, bytes).await?;
+
+            write_str(&mut self.w, "chat_id").await?;
+            write_i64(&mut self.w, chat_id).await?;
+
+            write_str(&mut self.w, "from_id").await?;
+            write_i64(&mut self.w, from_id).await?;
+
+            write_str(&mut self.w, "hidden").await?;
+            write_i64(&mut self.w, hidden).await?;
+
+            write_str(&mut self.w, "id").await?;
+            write_i64(&mut self.w, id).await?;
+
+            write_str(&mut self.w, "location_id").await?;
+            write_i64(&mut self.w, location_id).await?;
+
+            write_str(&mut self.w, "mime_compressed").await?;
+            write_i64(&mut self.w, mime_compressed).await?;
+
+            write_str(&mut self.w, "mime_headers").await?;
+            write_bytes(&mut self.w, &mime_headers).await?;
+
+            if let Some(mime_in_reply_to) = mime_in_reply_to {
+                write_str(&mut self.w, "mime_in_reply_to").await?;
+                write_str(&mut self.w, &mime_in_reply_to).await?;
+            }
+
+            if let Some(mime_references) = mime_references {
+                write_str(&mut self.w, "mime_references").await?;
+                write_str(&mut self.w, &mime_references).await?;
+            }
+
+            write_str(&mut self.w, "msgrmsg").await?;
+            write_i64(&mut self.w, msgrmsg).await?;
+
+            write_str(&mut self.w, "param").await?;
+            write_str(&mut self.w, &param).await?;
+
+            write_str(&mut self.w, "rfc724_mid").await?;
+            write_str(&mut self.w, &rfc724_mid).await?;
+
+            write_str(&mut self.w, "state").await?;
+            write_i64(&mut self.w, state).await?;
+
+            write_str(&mut self.w, "timestamp").await?;
+            write_i64(&mut self.w, timestamp).await?;
+
+            write_str(&mut self.w, "timestamp_rcvd").await?;
+            write_i64(&mut self.w, timestamp_rcvd).await?;
+
+            write_str(&mut self.w, "timestamp_sent").await?;
+            write_i64(&mut self.w, timestamp_sent).await?;
+
+            write_str(&mut self.w, "to_id").await?;
+            write_i64(&mut self.w, to_id).await?;
+
+            write_str(&mut self.w, "txt").await?;
+            write_str(&mut self.w, &txt).await?;
+
+            write_str(&mut self.w, "txt_raw").await?;
+            write_str(&mut self.w, &txt_raw).await?;
+
+            write_str(&mut self.w, "type").await?;
+            write_i64(&mut self.w, typ).await?;
+
+            self.w.write_all(b"e").await?;
+        }
+        self.w.write_all(b"e").await?;
+        Ok(())
+    }
+
+    async fn serialize_msgs_status_updates(&mut self) -> Result<()> {
+        let mut stmt = self
+            .tx
+            .prepare("SELECT id, msg_id, uid, update_item FROM msgs_status_updates")?;
+        let mut rows = stmt.query(())?;
+
+        self.w.write_all(b"l").await?;
+        while let Some(row) = rows.next()? {
+            let id: i64 = row.get("id")?;
+            let msg_id: i64 = row.get("msg_id")?;
+            let uid: String = row.get("uid")?;
+            let update_item: String = row.get("update_item")?;
+
+            self.w.write_all(b"d").await?;
+
+            write_str(&mut self.w, "id").await?;
+            write_i64(&mut self.w, id).await?;
+
+            write_str(&mut self.w, "msg_id").await?;
+            write_i64(&mut self.w, msg_id).await?;
+
+            write_str(&mut self.w, "uid").await?;
+            write_str(&mut self.w, &uid).await?;
+
+            write_str(&mut self.w, "update_item").await?;
+            write_str(&mut self.w, &update_item).await?;
+
+            self.w.write_all(b"e").await?;
+        }
+        self.w.write_all(b"e").await?;
+        Ok(())
+    }
+
+    /// Serializes reactions.
+    async fn serialize_reactions(&mut self) -> Result<()> {
+        let mut stmt = self
+            .tx
+            .prepare("SELECT msg_id, contact_id, reaction FROM reactions")?;
+        let mut rows = stmt.query(())?;
+
+        self.w.write_all(b"l").await?;
+        while let Some(row) = rows.next()? {
+            let msg_id: u32 = row.get("msg_id")?;
+            let contact_id: u32 = row.get("contact_id")?;
+            let reaction: String = row.get("reaction")?;
+
+            self.w.write_all(b"d").await?;
+
+            write_str(&mut self.w, "contact_id").await?;
+            write_u32(&mut self.w, contact_id).await?;
+
+            write_str(&mut self.w, "msg_id").await?;
+            write_u32(&mut self.w, msg_id).await?;
+
+            write_str(&mut self.w, "reaction").await?;
+            write_str(&mut self.w, &reaction).await?;
+
+            self.w.write_all(b"e").await?;
+        }
+        self.w.write_all(b"e").await?;
+        Ok(())
+    }
+
+    async fn serialize_sending_domains(&mut self) -> Result<()> {
+        let mut stmt = self
+            .tx
+            .prepare("SELECT domain, dkim_works FROM sending_domains")?;
+        let mut rows = stmt.query(())?;
+
+        self.w.write_all(b"l").await?;
+        while let Some(row) = rows.next()? {
+            let domain: String = row.get("domain")?;
+            let dkim_works: i64 = row.get("dkim_works")?;
+
+            self.w.write_all(b"d").await?;
+
+            write_str(&mut self.w, "dkim_works").await?;
+            write_i64(&mut self.w, dkim_works).await?;
+
+            write_str(&mut self.w, "domain").await?;
+            write_str(&mut self.w, &domain).await?;
+
+            self.w.write_all(b"e").await?;
+        }
+        self.w.write_all(b"e").await?;
+        Ok(())
+    }
+
+    async fn serialize_tokens(&mut self) -> Result<()> {
+        let mut stmt = self
+            .tx
+            .prepare("SELECT id, namespc, foreign_id, token, timestamp FROM tokens")?;
+        let mut rows = stmt.query(())?;
+
+        self.w.write_all(b"l").await?;
+        while let Some(row) = rows.next()? {
+            let id: i64 = row.get("id")?;
+            let namespace: u32 = row.get("namespc")?;
+            let foreign_id: u32 = row.get("foreign_id")?;
+            let token: String = row.get("token")?;
+            let timestamp: i64 = row.get("timestamp")?;
+
+            self.w.write_all(b"d").await?;
+
+            write_str(&mut self.w, "foreign_id").await?;
+            write_u32(&mut self.w, foreign_id).await?;
+
+            write_str(&mut self.w, "id").await?;
+            write_i64(&mut self.w, id).await?;
+
+            write_str(&mut self.w, "namespace").await?;
+            write_u32(&mut self.w, namespace).await?;
+
+            write_str(&mut self.w, "timestamp").await?;
+            write_i64(&mut self.w, timestamp).await?;
+
+            write_str(&mut self.w, "token").await?;
+            write_str(&mut self.w, &token).await?;
+
+            self.w.write_all(b"e").await?;
+        }
+        self.w.write_all(b"e").await?;
+        Ok(())
+    }
+
+    async fn serialize(&mut self) -> Result<()> {
+        let dbversion: String = self.tx.query_row(
+            "SELECT value FROM config WHERE keyname='dbversion'",
+            (),
+            |row| row.get(0),
+        )?;
+        if dbversion != SERIALIZE_DBVERSION {
+            return Err(anyhow!(
+                "cannot serialize database version {dbversion}, expected {SERIALIZE_DBVERSION}"
+            ));
+        }
+
+        self.w.write_all(b"d").await?;
+
+        write_str(&mut self.w, "_config").await?;
+        self.serialize_config().await?;
+
+        write_str(&mut self.w, "acpeerstates").await?;
+        self.serialize_acpeerstates()
+            .await
+            .context("serialize autocrypt peerstates")?;
+
+        write_str(&mut self.w, "chats").await?;
+        self.serialize_chats().await?;
+
+        write_str(&mut self.w, "chats_contacts").await?;
+        self.serialize_chats_contacts()
+            .await
+            .context("serialize chats_contacts")?;
+
+        write_str(&mut self.w, "contacts").await?;
+        self.serialize_contacts().await?;
+
+        write_str(&mut self.w, "dns_cache").await?;
+        self.serialize_dns_cache()
+            .await
+            .context("serialize dns_cache")?;
+
+        write_str(&mut self.w, "imap").await?;
+        self.serialize_imap().await.context("serialize imap")?;
+
+        write_str(&mut self.w, "imap_sync").await?;
+        self.serialize_imap_sync()
+            .await
+            .context("serialize imap_sync")?;
+
+        write_str(&mut self.w, "keypairs").await?;
+        self.serialize_keypairs().await?;
+
+        write_str(&mut self.w, "leftgroups").await?;
+        self.serialize_leftgroups().await?;
+
+        write_str(&mut self.w, "locations").await?;
+        self.serialize_locations().await?;
+
+        write_str(&mut self.w, "mdns").await?;
+        self.serialize_mdns().await?;
+
+        write_str(&mut self.w, "messages").await?;
+        self.serialize_messages()
+            .await
+            .context("serialize messages")?;
+
+        write_str(&mut self.w, "msgs_status_updates").await?;
+        self.serialize_msgs_status_updates()
+            .await
+            .context("serialize msgs_status_updates")?;
+
+        write_str(&mut self.w, "reactions").await?;
+        self.serialize_reactions().await?;
+
+        write_str(&mut self.w, "sending_domains").await?;
+        self.serialize_sending_domains()
+            .await
+            .context("serialize sending_domains")?;
+
+        write_str(&mut self.w, "tokens").await?;
+        self.serialize_tokens().await?;
+
+        // jobs table is skipped
+        // multi_device_sync is skipped
+        // imap_markseen is skipped, it is usually empty and the device exporting the
+        // database should still be able to clear it.
+        // smtp, smtp_mdns and smtp_status_updates tables are skipped, they are part of the
+        // outgoing message queue.
+        // devmsglabels is skipped, it is reset in `delete_and_reset_all_device_msgs()` on import
+        // anyway
+        // bobstate is not serialized, it is temporary for joining or adding a contact.
+        //
+        // TODO insert welcome message on import like done in `delete_and_reset_all_device_msgs()`?
+        self.w.write_all(b"e").await?;
+        self.w.flush().await?;
+        Ok(())
+    }
+}
+
+impl Sql {
+    /// Serializes the database into a bytestream.
+    pub async fn serialize(&self, w: impl AsyncWrite + Unpin) -> Result<()> {
+        let mut conn = self.get_connection().await?;
+
+        // Start a read transaction to take a database snapshot.
+        let transaction = conn.transaction()?;
+        let mut encoder = Encoder::new(transaction, w);
+        encoder.serialize().await?;
+        Ok(())
+    }
+}
--- a/src/summary.rs
+++ b/src/summary.rs
@@ -59,7 +59,7 @@ pub struct Summary {
 impl Summary {
    /// Constructs chatlist summary
    /// from the provided message, chat and message author contact snapshots.
-    pub async fn new_with_reaction_details(
+    pub async fn new(
        context: &Context,
        msg: &Message,
        chat: &Chat,
@@ -81,17 +81,7 @@ impl Summary {
                thumbnail_path: None,
            });
        }
-        Self::new(context, msg, chat, contact).await
-    }

-    /// Constructs search result summary
-    /// from the provided message, chat and message author contact snapshots.
-    pub async fn new(
-        context: &Context,
-        msg: &Message,
-        chat: &Chat,
-        contact: Option<&Contact>,
-    ) -> Result<Summary> {
        let prefix = if msg.state == MessageState::OutDraft {
            Some(SummaryPrefix::Draft(stock_str::draft(context).await))
        } else if msg.from_id == ContactId::SELF {
--- a/src/sync.rs
+++ b/src/sync.rs
@@ -571,7 +571,7 @@ mod tests {
        let sent_msg = alice.pop_sent_msg().await;
        let alice2 = TestContext::new_alice().await;
        alice2.set_config_bool(Config::SyncMsgs, true).await?;
-        alice2.recv_msg_trash(&sent_msg).await;
+        alice2.recv_msg(&sent_msg).await;
        assert!(token::exists(&alice2, token::Namespace::Auth, "testtoken").await?);
        assert_eq!(Chatlist::try_load(&alice2, 0, None, None).await?.len(), 0);

--- a/src/test_utils.rs
+++ b/src/test_utils.rs
@@ -13,12 +13,12 @@ use std::time::{Duration, Instant};
 use ansi_term::Color;
 use async_channel::{self as channel, Receiver, Sender};
 use chat::ChatItem;
-use deltachat_contact_tools::{ContactAddress, EmailAddress};
 use once_cell::sync::Lazy;
 use pretty_assertions::assert_eq;
 use rand::Rng;
 use tempfile::{tempdir, TempDir};
 use tokio::runtime::Handle;
+use tokio::sync::RwLock;
 use tokio::{fs, task};

 use crate::chat::{
@@ -27,13 +27,12 @@ use crate::chat::{
 };
 use crate::chatlist::Chatlist;
 use crate::config::Config;
-use crate::constants::DC_CHAT_ID_TRASH;
-use crate::constants::DC_GCL_NO_SPECIALS;
 use crate::constants::{Blocked, Chattype};
-use crate::contact::{Contact, ContactId, Modifier, Origin};
+use crate::constants::{DC_GCL_NO_SPECIALS, DC_MSG_ID_DAYMARKER};
+use crate::contact::{Contact, ContactAddress, ContactId, Modifier, Origin};
 use crate::context::Context;
 use crate::e2ee::EncryptHelper;
-use crate::events::{Event, EventEmitter, EventType, Events};
+use crate::events::{Event, EventType, Events};
 use crate::key::{self, DcKey, KeyPairUse};
 use crate::message::{update_msg_state, Message, MessageState, MsgId, Viewtype};
 use crate::mimeparser::{MimeMessage, SystemMessage};
@@ -42,11 +41,12 @@ use crate::pgp::KeyPair;
 use crate::receive_imf::receive_imf;
 use crate::securejoin::{get_securejoin_qr, join_securejoin};
 use crate::stock_str::StockStrings;
+use crate::tools::EmailAddress;

 #[allow(non_upper_case_globals)]
 pub const AVATAR_900x900_BYTES: &[u8] = include_bytes!("../test-data/image/avatar900x900.png");

-/// Map of context IDs to names for [`TestContext`]s.
+/// Map of [`Context::id`] to names for [`TestContext`]s.
 static CONTEXT_NAMES: Lazy<std::sync::RwLock<BTreeMap<u32, String>>> =
    Lazy::new(|| std::sync::RwLock::new(BTreeMap::new()));

@@ -56,19 +56,20 @@ static CONTEXT_NAMES: Lazy<std::sync::RwLock<BTreeMap<u32, String>>> =
 /// occurred rather than grouped by context like would happen when you use separate
 /// [`TestContext`]s without managing your own [`LogSink`].
 pub struct TestContextManager {
-    log_sink: LogSink,
+    log_tx: Sender<LogEvent>,
+    _log_sink: LogSink,
 }

 impl TestContextManager {
    pub fn new() -> Self {
-        let log_sink = LogSink::new();
-        Self { log_sink }
+        let (log_tx, _log_sink) = LogSink::create();
+        Self { log_tx, _log_sink }
    }

    pub async fn alice(&mut self) -> TestContext {
        TestContext::builder()
            .configure_alice()
-            .with_log_sink(self.log_sink.clone())
+            .with_log_sink(self.log_tx.clone())
            .build()
            .await
    }
@@ -76,7 +77,7 @@ impl TestContextManager {
    pub async fn bob(&mut self) -> TestContext {
        TestContext::builder()
            .configure_bob()
-            .with_log_sink(self.log_sink.clone())
+            .with_log_sink(self.log_tx.clone())
            .build()
            .await
    }
@@ -84,7 +85,7 @@ impl TestContextManager {
    pub async fn fiona(&mut self) -> TestContext {
        TestContext::builder()
            .configure_fiona()
-            .with_log_sink(self.log_sink.clone())
+            .with_log_sink(self.log_tx.clone())
            .build()
            .await
    }
@@ -92,7 +93,7 @@ impl TestContextManager {
    /// Creates a new unconfigured test account.
    pub async fn unconfigured(&mut self) -> TestContext {
        TestContext::builder()
-            .with_log_sink(self.log_sink.clone())
+            .with_log_sink(self.log_tx.clone())
            .build()
            .await
    }
@@ -101,8 +102,7 @@ impl TestContextManager {
    ///
    /// ========== `msg` goes here ==========
    pub fn section(&self, msg: &str) {
-        self.log_sink
-            .sender
+        self.log_tx
            .try_send(LogEvent::Section(msg.to_string()))
            .expect(
            "The events channel should be unbounded and not closed, so try_send() shouldn't fail",
@@ -179,9 +179,9 @@ impl TestContextManager {

        loop {
            if let Some(sent) = scanner.pop_sent_msg_opt(Duration::ZERO).await {
-                scanned.recv_msg_opt(&sent).await;
+                scanned.recv_msg(&sent).await;
            } else if let Some(sent) = scanned.pop_sent_msg_opt(Duration::ZERO).await {
-                scanner.recv_msg_opt(&sent).await;
+                scanner.recv_msg(&sent).await;
            } else {
                break;
            }
@@ -189,31 +189,30 @@ impl TestContextManager {
    }
 }

-/// Builder for the [TestContext].
 #[derive(Debug, Clone, Default)]
 pub struct TestContextBuilder {
    key_pair: Option<KeyPair>,
-    log_sink: LogSink,
+    log_sink: Option<Sender<LogEvent>>,
 }

 impl TestContextBuilder {
    /// Configures as alice@example.org with fixed secret key.
    ///
-    /// This is a shortcut for `.with_key_pair(alice_keypair())`.
+    /// This is a shortcut for `.with_key_pair(alice_keypair()).
    pub fn configure_alice(self) -> Self {
        self.with_key_pair(alice_keypair())
    }

    /// Configures as bob@example.net with fixed secret key.
    ///
-    /// This is a shortcut for `.with_key_pair(bob_keypair())`.
+    /// This is a shortcut for `.with_key_pair(bob_keypair()).
    pub fn configure_bob(self) -> Self {
        self.with_key_pair(bob_keypair())
    }

    /// Configures as fiona@example.net with fixed secret key.
    ///
-    /// This is a shortcut for `.with_key_pair(fiona_keypair())`.
+    /// This is a shortcut for `.with_key_pair(bob_keypair()).
    pub fn configure_fiona(self) -> Self {
        self.with_key_pair(fiona_keypair())
    }
@@ -233,8 +232,8 @@ impl TestContextBuilder {
    /// using a single [`LogSink`] for both contexts.  This shows the log messages in
    /// sequence as they occurred rather than all messages from each context in a single
    /// block.
-    pub fn with_log_sink(mut self, sink: LogSink) -> Self {
-        self.log_sink = sink;
+    pub fn with_log_sink(mut self, sink: Sender<LogEvent>) -> Self {
+        self.log_sink = Some(sink);
        self
    }

@@ -242,7 +241,7 @@ impl TestContextBuilder {
    pub async fn build(self) -> TestContext {
        let name = self.key_pair.as_ref().map(|key| key.addr.local.clone());

-        let test_context = TestContext::new_internal(name, Some(self.log_sink.clone())).await;
+        let test_context = TestContext::new_internal(name, self.log_sink).await;

        if let Some(key_pair) = self.key_pair {
            test_context
@@ -257,24 +256,26 @@ impl TestContextBuilder {
 }

 /// A Context and temporary directory.
+///
+/// The temporary directory can be used to store the SQLite database,
+/// see e.g. [test_context] which does this.
 #[derive(Debug)]
 pub struct TestContext {
    pub ctx: Context,
-
-    /// Temporary directory used to store SQLite database.
    pub dir: TempDir,
-
    pub evtracker: EventTracker,
-
+    /// Channels which should receive events from this context.
+    event_senders: Arc<RwLock<Vec<Sender<Event>>>>,
    /// Reference to implicit [`LogSink`] so it is dropped together with the context.
    ///
    /// Only used if no explicit `log_sender` is passed into [`TestContext::new_internal`]
    /// (which is assumed to be the sending end of a [`LogSink`]).
    ///
    /// This is a convenience in case only a single [`TestContext`] is used to avoid dealing
-    /// with [`LogSink`].  Never read, since the only purpose is to
+    /// with [`LogSink`].  Never read, thus "dead code", since the only purpose is to
    /// control when Drop is invoked.
-    _log_sink: Option<LogSink>,
+    #[allow(dead_code)]
+    log_sink: Option<LogSink>,
 }

 impl TestContext {
@@ -296,7 +297,9 @@ impl TestContext {

    /// Creates a new configured [`TestContext`].
    ///
-    /// This is a shortcut which configures alice@example.org with a fixed key.
+    /// This is a shortcut which automatically calls [`TestContext::configure_alice`] after
+    /// creating the context.
+    /// alice-email: alice@example.org
    pub async fn new_alice() -> Self {
        Self::builder().configure_alice().build().await
    }
@@ -334,7 +337,7 @@ impl TestContext {
    /// `log_sender` is assumed to be the sender for a [`LogSink`].  If not supplied a new
    /// [`LogSink`] will be created so that events are logged to this test when the
    /// [`TestContext`] is dropped.
-    async fn new_internal(name: Option<String>, log_sink: Option<LogSink>) -> Self {
+    async fn new_internal(name: Option<String>, log_sender: Option<Sender<LogEvent>>) -> Self {
        let dir = tempdir().unwrap();
        let dbfile = dir.path().join("db.sqlite");
        let id = rand::thread_rng().gen();
@@ -342,23 +345,35 @@ impl TestContext {
            let mut context_names = CONTEXT_NAMES.write().unwrap();
            context_names.insert(id, name);
        }
-        let events = Events::new();
-        let evtracker_receiver = events.get_emitter();
-        let ctx = Context::new(&dbfile, id, events, StockStrings::new())
+        let ctx = Context::new(&dbfile, id, Events::new(), StockStrings::new())
            .await
            .expect("failed to create context");

-        let _log_sink = if let Some(log_sink) = log_sink {
-            // Subscribe existing LogSink and don't store reference to it.
-            log_sink.subscribe(ctx.get_event_emitter());
-            None
-        } else {
-            // Create new LogSink and store it inside the `TestContext`.
-            let log_sink = LogSink::new();
-            log_sink.subscribe(ctx.get_event_emitter());
-            Some(log_sink)
+        let events = ctx.get_event_emitter();
+
+        let (log_sender, log_sink) = match log_sender {
+            Some(sender) => (sender, None),
+            None => {
+                let (sender, sink) = LogSink::create();
+                (sender, Some(sink))
+            }
        };

+        let (evtracker_sender, evtracker_receiver) = channel::unbounded();
+        let event_senders = Arc::new(RwLock::new(vec![evtracker_sender]));
+        let senders = Arc::clone(&event_senders);
+
+        task::spawn(async move {
+            while let Some(event) = events.recv().await {
+                for sender in senders.read().await.iter() {
+                    // Don't block because someone wanted to use a oneshot receiver, use
+                    // an unbounded channel if you want all events.
+                    sender.try_send(event.clone()).ok();
+                }
+                log_sender.try_send(LogEvent::Event(event.clone())).ok();
+            }
+        });
+
        ctx.set_config(Config::SkipStartMessages, Some("1"))
            .await
            .unwrap();
@@ -368,7 +383,8 @@ impl TestContext {
            ctx,
            dir,
            evtracker: EventTracker(evtracker_receiver),
-            _log_sink,
+            event_senders,
+            log_sink,
        }
    }

@@ -391,6 +407,14 @@ impl TestContext {
        context_names.get(id).unwrap_or(&id.to_string()).to_string()
    }

+    /// Adds a new [`Event`]s sender.
+    ///
+    /// Once added, all events emitted by this context will be sent to this channel.  This
+    /// is useful if you need to wait for events or make assertions on them.
+    pub async fn add_event_sender(&self, sink: Sender<Event>) {
+        self.event_senders.write().await.push(sink)
+    }
+
    /// Configure as a given email address.
    ///
    /// The context will be configured but the key will not be pre-generated so if a key is
@@ -473,7 +497,7 @@ impl TestContext {
    ///
    /// Parsing a message does not run the entire receive pipeline, but is not without
    /// side-effects either.  E.g. if the message includes autocrypt headers the relevant
-    /// peerstates will be updated.  Later receiving the message using [Self.recv_msg()] is
+    /// peerstates will be updated.  Later receiving the message using [recv_msg] is
    /// unlikely to be affected as the peerstate would be processed again in exactly the
    /// same way.
    pub(crate) async fn parse_msg(&self, msg: &SentMessage<'_>) -> MimeMessage {
@@ -513,16 +537,6 @@ impl TestContext {
        receive_imf(self, msg.payload().as_bytes(), false)
            .await
            .unwrap()
-            .filter(|msg| msg.chat_id != DC_CHAT_ID_TRASH)
-    }
-
-    /// Recevies a message and asserts that it goes to trash chat.
-    pub async fn recv_msg_trash(&self, msg: &SentMessage<'_>) {
-        let received = receive_imf(self, msg.payload().as_bytes(), false)
-            .await
-            .unwrap()
-            .unwrap();
-        assert_eq!(received.chat_id, DC_CHAT_ID_TRASH);
    }

    /// Gets the most recent message of a chat.
@@ -687,16 +701,16 @@ impl TestContext {
            chat_id,
            MessageListOptions {
                info_only: false,
-                add_daymarker: false,
+                add_daymarker: true,
            },
        )
        .await
        .unwrap();
        let msglist: Vec<MsgId> = msglist
            .into_iter()
-            .filter_map(|x| match x {
-                ChatItem::Message { msg_id } => Some(msg_id),
-                ChatItem::DayMarker { .. } => None,
+            .map(|x| match x {
+                ChatItem::Message { msg_id } => msg_id,
+                ChatItem::DayMarker { .. } => MsgId::new(DC_MSG_ID_DAYMARKER),
            })
            .collect();

@@ -744,17 +758,23 @@ impl TestContext {

        let mut lines_out = 0;
        for msg_id in msglist {
-            if msg_id.is_special() {
-                continue;
-            }
-            if lines_out == 0 {
+            if msg_id == MsgId::new(DC_MSG_ID_DAYMARKER) {
                writeln!(res,
+                "--------------------------------------------------------------------------------"
+            )
+                .unwrap();
+
+                lines_out += 1
+            } else if !msg_id.is_special() {
+                if lines_out == 0 {
+                    writeln!(res,
                    "--------------------------------------------------------------------------------",
                ).unwrap();
-                lines_out += 1
+                    lines_out += 1
+                }
+                let msg = Message::load_from_db(self, msg_id).await.unwrap();
+                write_msg(self, "", &msg, &mut res).await;
            }
-            let msg = Message::load_from_db(self, msg_id).await.unwrap();
-            write_msg(self, "", &msg, &mut res).await;
        }
        if lines_out > 0 {
            writeln!(
@@ -825,62 +845,22 @@ pub enum LogEvent {
 /// This sink achieves this by printing the events, in the order received, at the time it is
 /// dropped.  Thus to use you must only make sure this sink is dropped in the test itself.
 ///
-/// To use this create an instance using [`LogSink::new`] and then use the
-/// [`TestContextBuilder::with_log_sink`] or use [`TestContextManager`].
-#[derive(Debug, Clone, Default)]
-pub struct LogSink(Arc<InnerLogSink>);
+/// To use this create an instance using [`LogSink::create`] and then use the
+/// [`TestContextBuilder::with_log_sink`].
+#[derive(Debug)]
+pub struct LogSink {
+    events: Receiver<LogEvent>,
+}

 impl LogSink {
    /// Creates a new [`LogSink`] and returns the attached event sink.
-    pub fn new() -> Self {
-        Default::default()
-    }
-}
-
-impl Deref for LogSink {
-    type Target = InnerLogSink;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-#[derive(Debug)]
-pub struct InnerLogSink {
-    events: Receiver<LogEvent>,
-
-    /// Sender side of the log receiver.
-    ///
-    /// It is cloned when log sink is subscribed
-    /// to new event emitter
-    /// and can be used directly from the test to
-    /// add "sections" to the log.
-    sender: Sender<LogEvent>,
-}
-
-impl Default for InnerLogSink {
-    fn default() -> Self {
+    pub fn create() -> (Sender<LogEvent>, Self) {
        let (tx, rx) = channel::unbounded();
-        Self {
-            events: rx,
-            sender: tx,
-        }
+        (tx, Self { events: rx })
    }
 }

-impl InnerLogSink {
-    /// Subscribes this log sink to event emitter.
-    pub fn subscribe(&self, event_emitter: EventEmitter) {
-        let sender = self.sender.clone();
-        task::spawn(async move {
-            while let Some(event) = event_emitter.recv().await {
-                sender.try_send(LogEvent::Event(event.clone())).ok();
-            }
-        });
-    }
-}
-
-impl Drop for InnerLogSink {
+impl Drop for LogSink {
    fn drop(&mut self) {
        while let Ok(event) = self.events.try_recv() {
            print_logevent(&event);
@@ -991,10 +971,10 @@ pub fn fiona_keypair() -> KeyPair {
 /// be attached to a single [`TestContext`] and therefore the context is already known as
 /// you will be accessing it as [`TestContext::evtracker`].
 #[derive(Debug)]
-pub struct EventTracker(EventEmitter);
+pub struct EventTracker(Receiver<Event>);

 impl Deref for EventTracker {
-    type Target = EventEmitter;
+    type Target = Receiver<Event>;

    fn deref(&self) -> &Self::Target {
        &self.0
@@ -1039,11 +1019,6 @@ impl EventTracker {
        self.get_matching(|evt| matches!(evt, EventType::IncomingMsg { .. }))
            .await;
    }
-
-    /// Clears event queue.
-    pub fn clear_events(&self) {
-        while let Ok(_ev) = self.try_recv() {}
-    }
 }

 /// Gets a specific message from a chat and asserts that the chat has a specific length.
@@ -1087,10 +1062,8 @@ pub(crate) async fn mark_as_verified(this: &TestContext, other: &TestContext) {
        0,
    );

-    peerstate.verified_key.clone_from(&peerstate.public_key);
-    peerstate
-        .verified_key_fingerprint
-        .clone_from(&peerstate.public_key_fingerprint);
+    peerstate.verified_key = peerstate.public_key.clone();
+    peerstate.verified_key_fingerprint = peerstate.public_key_fingerprint.clone();
    peerstate.backward_verified_key_id = Some(this.get_config_i64(Config::KeyId).await.unwrap());

    peerstate.save_to_db(&this.sql).await.unwrap();
@@ -1100,8 +1073,7 @@ pub(crate) async fn mark_as_verified(this: &TestContext, other: &TestContext) {
 /// alice0's side that implies sending a sync message.
 pub(crate) async fn sync(alice0: &TestContext, alice1: &TestContext) {
    let sync_msg = alice0.pop_sent_msg().await;
-    let no_msg = alice1.recv_msg_opt(&sync_msg).await;
-    assert!(no_msg.is_none());
+    alice1.recv_msg(&sync_msg).await;
 }

 /// Pretty-print an event to stdout
@@ -1128,10 +1100,7 @@ fn print_event(event: &Event) {
                "Received MSGS_CHANGED(chat_id={chat_id}, msg_id={msg_id})",
            ))
        ),
-        EventType::ContactsChanged(contact) => format!(
-            "{}",
-            green.paint(format!("Received CONTACTS_CHANGED(contact={contact:?})"))
-        ),
+        EventType::ContactsChanged(_) => format!("{}", green.paint("Received CONTACTS_CHANGED()")),
        EventType::LocationChanged(contact) => format!(
            "{}",
            green.paint(format!("Received LOCATION_CHANGED(contact={contact:?})"))
--- a/src/token.rs
+++ b/src/token.rs
@@ -2,7 +2,7 @@
 //!
 //! Functions to read/write token from/to the database. A token is any string associated with a key.
 //!
-//! Tokens are used in SecureJoin verification protocols.
+//! Tokens are used in countermitm verification protocols.

 use anyhow::Result;
 use deltachat_derive::{FromSql, ToSql};
--- a/src/tools.rs
+++ b/src/tools.rs
@@ -4,6 +4,7 @@
 #![allow(missing_docs)]

 use std::borrow::Cow;
+use std::fmt;
 use std::io::{Cursor, Write};
 use std::mem;
 use std::path::{Path, PathBuf};
@@ -22,7 +23,6 @@ pub use std::time::SystemTime;
 use anyhow::{bail, Context as _, Result};
 use base64::Engine as _;
 use chrono::{Local, NaiveDateTime, NaiveTime, TimeZone};
-use deltachat_contact_tools::{strip_rtlo_characters, EmailAddress};
 #[cfg(test)]
 pub use deltachat_time::SystemTimeTools as SystemTime;
 use futures::{StreamExt, TryStreamExt};
@@ -536,6 +536,80 @@ pub fn parse_mailto(mailto_url: &str) -> Option<MailTo> {
    }
 }

+///
+/// Represents an email address, right now just the `name@domain` portion.
+///
+/// # Example
+///
+/// ```
+/// use deltachat::tools::EmailAddress;
+/// let email = match EmailAddress::new("someone@example.com") {
+///     Ok(addr) => addr,
+///     Err(e) => panic!("Error parsing address, error was {}", e),
+/// };
+/// assert_eq!(&email.local, "someone");
+/// assert_eq!(&email.domain, "example.com");
+/// assert_eq!(email.to_string(), "someone@example.com");
+/// ```
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub struct EmailAddress {
+    /// Local part of the email address.
+    pub local: String,
+
+    /// Email address domain.
+    pub domain: String,
+}
+
+impl fmt::Display for EmailAddress {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}@{}", self.local, self.domain)
+    }
+}
+
+impl EmailAddress {
+    /// Performs a dead-simple parse of an email address.
+    pub fn new(input: &str) -> Result<EmailAddress> {
+        if input.is_empty() {
+            bail!("empty string is not valid");
+        }
+        let parts: Vec<&str> = input.rsplitn(2, '@').collect();
+
+        if input
+            .chars()
+            .any(|c| c.is_whitespace() || c == '<' || c == '>')
+        {
+            bail!("Email {:?} must not contain whitespaces, '>' or '<'", input);
+        }
+
+        match &parts[..] {
+            [domain, local] => {
+                if local.is_empty() {
+                    bail!("empty string is not valid for local part in {:?}", input);
+                }
+                if domain.is_empty() {
+                    bail!("missing domain after '@' in {:?}", input);
+                }
+                if domain.ends_with('.') {
+                    bail!("Domain {domain:?} should not contain the dot in the end");
+                }
+                Ok(EmailAddress {
+                    local: (*local).to_string(),
+                    domain: (*domain).to_string(),
+                })
+            }
+            _ => bail!("Email {:?} must contain '@' character", input),
+        }
+    }
+}
+
+impl rusqlite::types::ToSql for EmailAddress {
+    fn to_sql(&self) -> rusqlite::Result<rusqlite::types::ToSqlOutput> {
+        let val = rusqlite::types::Value::Text(self.to_string());
+        let out = rusqlite::types::ToSqlOutput::Owned(val);
+        Ok(out)
+    }
+}
+
 /// Sanitizes user input
 /// - strip newlines
 /// - strip malicious bidi characters
@@ -679,6 +753,13 @@ pub(crate) fn buf_decompress(buf: &[u8]) -> Result<Vec<u8>> {
    Ok(mem::take(decompressor.get_mut()))
 }

+const RTLO_CHARACTERS: [char; 5] = ['\u{202A}', '\u{202B}', '\u{202C}', '\u{202D}', '\u{202E}'];
+/// This method strips all occurrences of the RTLO Unicode character.
+/// [Why is this needed](https://github.com/deltachat/deltachat-core-rust/issues/3479)?
+pub(crate) fn strip_rtlo_characters(input_str: &str) -> String {
+    input_str.replace(|char| RTLO_CHARACTERS.contains(&char), "")
+}
+
 #[cfg(test)]
 mod tests {
    #![allow(clippy::indexing_slicing)]
@@ -961,6 +1042,40 @@ DKIM Results: Passed=true, Works=true, Allow_Keychange=true";
        assert!(extract_grpid_from_rfc724_mid(mid.as_str()).is_none());
    }

+    #[test]
+    fn test_emailaddress_parse() {
+        assert_eq!(EmailAddress::new("").is_ok(), false);
+        assert_eq!(
+            EmailAddress::new("user@domain.tld").unwrap(),
+            EmailAddress {
+                local: "user".into(),
+                domain: "domain.tld".into(),
+            }
+        );
+        assert_eq!(
+            EmailAddress::new("user@localhost").unwrap(),
+            EmailAddress {
+                local: "user".into(),
+                domain: "localhost".into()
+            }
+        );
+        assert_eq!(EmailAddress::new("uuu").is_ok(), false);
+        assert_eq!(EmailAddress::new("dd.tt").is_ok(), false);
+        assert!(EmailAddress::new("tt.dd@uu").is_ok());
+        assert!(EmailAddress::new("u@d").is_ok());
+        assert!(EmailAddress::new("u@d.").is_err());
+        assert!(EmailAddress::new("u@d.t").is_ok());
+        assert_eq!(
+            EmailAddress::new("u@d.tt").unwrap(),
+            EmailAddress {
+                local: "u".into(),
+                domain: "d.tt".into(),
+            }
+        );
+        assert!(EmailAddress::new("u@tt").is_ok());
+        assert_eq!(EmailAddress::new("@d.tt").is_ok(), false);
+    }
+
    use chrono::NaiveDate;
    use proptest::prelude::*;

--- a/src/webxdc.rs
+++ b/src/webxdc.rs
@@ -15,17 +15,12 @@
 //! - `last_serial` - serial number of the last status update to send
 //! - `descr` - text to send along with the updates

-mod integration;
-mod maps_integration;
-
 use std::path::Path;

 use anyhow::{anyhow, bail, ensure, format_err, Context as _, Result};

-use deltachat_contact_tools::strip_rtlo_characters;
 use deltachat_derive::FromSql;
 use lettre_email::PartBuilder;
-use rusqlite::OptionalExtension;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use tokio::io::AsyncReadExt;
@@ -34,6 +29,7 @@ use crate::chat::{self, Chat};
 use crate::constants::Chattype;
 use crate::contact::ContactId;
 use crate::context::Context;
+use crate::download::DownloadState;
 use crate::events::EventType;
 use crate::message::{Message, MessageState, MsgId, Viewtype};
 use crate::mimefactory::wrapped_base64_encode;
@@ -41,6 +37,7 @@ use crate::mimeparser::SystemMessage;
 use crate::param::Param;
 use crate::param::Params;
 use crate::tools::create_id;
+use crate::tools::strip_rtlo_characters;
 use crate::tools::{create_smeared_timestamp, get_abs_path};

 /// The current API version.
@@ -287,14 +284,14 @@ impl Context {
    /// writes it to the database and handles events, info-messages, document name and summary.
    async fn create_status_update_record(
        &self,
-        instance: &Message,
+        instance: &mut Message,
        status_update_item: StatusUpdateItem,
        timestamp: i64,
        can_info_msg: bool,
        from_id: ContactId,
    ) -> Result<Option<StatusUpdateSerial>> {
        let Some(status_update_serial) = self
-            .write_status_update_inner(&instance.id, &status_update_item, timestamp)
+            .write_status_update_inner(&instance.id, &status_update_item)
            .await?
        else {
            return Ok(None);
@@ -331,7 +328,6 @@ impl Context {

        let mut param_changed = false;

-        let mut instance = instance.clone();
        if let Some(ref document) = status_update_item.document {
            if instance
                .param
@@ -376,30 +372,27 @@ impl Context {
        &self,
        instance_id: &MsgId,
        status_update_item: &StatusUpdateItem,
-        timestamp: i64,
    ) -> Result<Option<StatusUpdateSerial>> {
+        let _lock = self.sql.write_lock().await;
        let uid = status_update_item.uid.as_deref();
-        let status_update_item = serde_json::to_string(&status_update_item)?;
-        let trans_fn = |t: &mut rusqlite::Transaction| {
-            t.execute(
-                "UPDATE msgs SET timestamp_rcvd=? WHERE id=?",
-                (timestamp, instance_id),
-            )?;
-            let rowid = t
-                .query_row(
-                    "INSERT INTO msgs_status_updates (msg_id, update_item, uid) VALUES(?, ?, ?)
-                     ON CONFLICT (uid) DO NOTHING
-                     RETURNING id",
-                    (instance_id, status_update_item, uid),
-                    |row| {
-                        let id: u32 = row.get(0)?;
-                        Ok(id)
-                    },
-                )
-                .optional()?;
-            Ok(rowid)
-        };
-        let Some(rowid) = self.sql.transaction(trans_fn).await? else {
+        let Some(rowid) = self
+            .sql
+            .query_row_optional(
+                "INSERT INTO msgs_status_updates (msg_id, update_item, uid) VALUES(?, ?, ?)
+                 ON CONFLICT (uid) DO NOTHING
+                 RETURNING id",
+                (
+                    instance_id,
+                    serde_json::to_string(&status_update_item)?,
+                    uid,
+                ),
+                |row| {
+                    let id: u32 = row.get(0)?;
+                    Ok(id)
+                },
+            )
+            .await?
+        else {
            let uid = uid.unwrap_or("-");
            info!(self, "Ignoring duplicate status update with uid={uid}");
            return Ok(None);
@@ -449,7 +442,7 @@ impl Context {
        mut status_update: StatusUpdateItem,
        descr: &str,
    ) -> Result<()> {
-        let instance = Message::load_from_db(self, instance_msg_id)
+        let mut instance = Message::load_from_db(self, instance_msg_id)
            .await
            .with_context(|| {
                format!("Failed to load message {instance_msg_id} from the database")
@@ -459,12 +452,6 @@ impl Context {
            bail!("send_webxdc_status_update: message {instance_msg_id} is not a webxdc message, but a {viewtype} message.");
        }

-        if instance.param.get_int(Param::WebxdcIntegration).is_some() {
-            return self
-                .intercept_send_webxdc_status_update(instance, status_update)
-                .await;
-        }
-
        let chat_id = instance.chat_id;
        let chat = Chat::load_from_db(self, chat_id)
            .await
@@ -483,7 +470,7 @@ impl Context {
        status_update.uid = Some(create_id());
        let status_update_serial: StatusUpdateSerial = self
            .create_status_update_record(
-                &instance,
+                &mut instance,
                status_update,
                create_smeared_timestamp(self),
                send_now,
@@ -578,22 +565,33 @@ impl Context {
    /// Receives status updates from receive_imf to the database
    /// and sends out an event.
    ///
-    /// `instance` is a webxdc instance.
+    /// `from_id` is the sender
    ///
-    /// `from_id` is the sender.
-    ///
-    /// `timestamp` is the timestamp of the update.
+    /// `msg_id` may be an instance (in case there are initial status updates)
+    /// or a reply to an instance (for all other updates).
    ///
    /// `json` is an array containing one or more update items as created by send_webxdc_status_update(),
    /// the array is parsed using serde, the single payloads are used as is.
    pub(crate) async fn receive_status_update(
        &self,
        from_id: ContactId,
-        instance: &Message,
-        timestamp: i64,
-        can_info_msg: bool,
+        msg_id: MsgId,
        json: &str,
    ) -> Result<()> {
+        let msg = Message::load_from_db(self, msg_id).await?;
+        let (timestamp, mut instance, can_info_msg) = if msg.viewtype == Viewtype::Webxdc {
+            (msg.timestamp_sort, msg, false)
+        } else if let Some(parent) = msg.parent(self).await? {
+            if parent.viewtype == Viewtype::Webxdc {
+                (msg.timestamp_sort, parent, true)
+            } else if parent.download_state() != DownloadState::Done {
+                (msg.timestamp_sort, parent, false)
+            } else {
+                bail!("receive_status_update: message is not the child of a webxdc message.")
+            }
+        } else {
+            bail!("receive_status_update: status message has no parent.")
+        };
        let chat_id = instance.chat_id;

        if from_id != ContactId::SELF && !chat::is_contact_in_chat(self, chat_id, from_id).await? {
@@ -610,7 +608,7 @@ impl Context {
        let updates: StatusUpdates = serde_json::from_str(json)?;
        for update_item in updates.updates {
            self.create_status_update_record(
-                instance,
+                &mut instance,
                update_item,
                timestamp,
                can_info_msg,
@@ -634,14 +632,6 @@ impl Context {
        instance_msg_id: MsgId,
        last_known_serial: StatusUpdateSerial,
    ) -> Result<String> {
-        let param = instance_msg_id.get_param(self).await?;
-        if param.get_int(Param::WebxdcIntegration).is_some() {
-            let instance = Message::load_from_db(self, instance_msg_id).await?;
-            return self
-                .intercept_get_webxdc_status_updates(instance, last_known_serial)
-                .await;
-        }
-
        let json = self
            .sql
            .query_map(
@@ -860,8 +850,6 @@ impl Message {

 #[cfg(test)]
 mod tests {
-    use std::time::Duration;
-
    use serde_json::json;

    use super::*;
@@ -872,11 +860,8 @@ mod tests {
    use crate::chatlist::Chatlist;
    use crate::config::Config;
    use crate::contact::Contact;
-    use crate::download::DownloadState;
-    use crate::ephemeral;
    use crate::receive_imf::{receive_imf, receive_imf_from_inbox};
-    use crate::test_utils::{TestContext, TestContextManager};
-    use crate::tools::{self, SystemTime};
+    use crate::test_utils::TestContext;
    use crate::{message, sql};

    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
@@ -1060,10 +1045,8 @@ mod tests {

    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
    async fn test_resend_webxdc_instance_and_info() -> Result<()> {
-        let mut tcm = TestContextManager::new();
-
        // Alice uses webxdc in a group
-        let alice = tcm.alice().await;
+        let alice = TestContext::new_alice().await;
        alice.set_config_bool(Config::BccSelf, false).await?;
        let alice_grp = create_group_chat(&alice, ProtectionStatus::Unprotected, "grp").await?;
        let alice_instance = send_webxdc_instance(&alice, alice_grp).await?;
@@ -1078,7 +1061,7 @@ mod tests {
        assert_eq!(alice_grp.get_msg_cnt(&alice).await?, 2);
        assert!(alice.get_last_msg_in(alice_grp).await.is_info());

-        // Alice adds Bob and resends already used webxdc
+        // Alice adds Bob and resend already used webxdc
        add_contact_to_chat(
            &alice,
            alice_grp,
@@ -1090,7 +1073,7 @@ mod tests {
        let sent1 = alice.pop_sent_msg().await;

        // Bob received webxdc, legacy info-messages updates are received but not added to the chat
-        let bob = tcm.bob().await;
+        let bob = TestContext::new_bob().await;
        let bob_instance = bob.recv_msg(&sent1).await;
        assert_eq!(bob_instance.viewtype, Viewtype::Webxdc);
        assert!(!bob_instance.is_info());
@@ -1213,7 +1196,7 @@ mod tests {
        .await?;
        let bob_instance = bob.get_last_msg().await;
        bob_instance.chat_id.accept(&bob).await?;
-        bob.recv_msg_trash(&sent2).await;
+        bob.recv_msg(&sent2).await;
        assert_eq!(bob_instance.download_state, DownloadState::Available);

        // Bob downloads instance, updates should be assigned correctly
@@ -1248,12 +1231,9 @@ mod tests {
        let t = TestContext::new_alice().await;
        let chat_id = create_group_chat(&t, ProtectionStatus::Unprotected, "foo").await?;
        let instance = send_webxdc_instance(&t, chat_id).await?;
-        let now = tools::time();
        t.receive_status_update(
            ContactId::SELF,
-            &instance,
-            now,
-            true,
+            instance.id,
            r#"{"updates":[{"payload":1}]}"#,
        )
        .await?;
@@ -1281,12 +1261,9 @@ mod tests {
        let t = TestContext::new_alice().await;
        let chat_id = create_group_chat(&t, ProtectionStatus::Unprotected, "foo").await?;
        let instance = send_webxdc_instance(&t, chat_id).await?;
-        let now = tools::time();
        t.receive_status_update(
            ContactId::SELF,
-            &instance,
-            now,
-            true,
+            instance.id,
            r#"{"updates":[{"payload":1}, {"payload":2}]}"#,
        )
        .await?;
@@ -1351,7 +1328,7 @@ mod tests {
    async fn test_create_status_update_record() -> Result<()> {
        let t = TestContext::new_alice().await;
        let chat_id = create_group_chat(&t, ProtectionStatus::Unprotected, "foo").await?;
-        let instance = send_webxdc_instance(&t, chat_id).await?;
+        let mut instance = send_webxdc_instance(&t, chat_id).await?;

        assert_eq!(
            t.get_webxdc_status_updates(instance.id, StatusUpdateSerial(0))
@@ -1361,7 +1338,7 @@ mod tests {

        let update_id1 = t
            .create_status_update_record(
-                &instance,
+                &mut instance,
                StatusUpdateItem {
                    payload: json!({"foo": "bar"}),
                    info: None,
@@ -1385,7 +1362,7 @@ mod tests {
        // Whatever the payload is, update should be ignored just because ID is duplicate.
        let update_id1_duplicate = t
            .create_status_update_record(
-                &instance,
+                &mut instance,
                StatusUpdateItem {
                    payload: json!({"nothing": "this should be ignored"}),
                    info: None,
@@ -1418,7 +1395,7 @@ mod tests {

        let update_id2 = t
            .create_status_update_record(
-                &instance,
+                &mut instance,
                StatusUpdateItem {
                    payload: json!({"foo2": "bar2"}),
                    info: None,
@@ -1437,7 +1414,7 @@ mod tests {
            r#"[{"payload":{"foo2":"bar2"},"serial":3,"max_serial":3}]"#
        );
        t.create_status_update_record(
-            &instance,
+            &mut instance,
            StatusUpdateItem {
                payload: Value::Bool(true),
                info: None,
@@ -1478,18 +1455,15 @@ mod tests {
        let t = TestContext::new_alice().await;
        let chat_id = create_group_chat(&t, ProtectionStatus::Unprotected, "foo").await?;
        let instance = send_webxdc_instance(&t, chat_id).await?;
-        let now = tools::time();

        assert!(t
-            .receive_status_update(ContactId::SELF, &instance, now, true, r#"foo: bar"#)
+            .receive_status_update(ContactId::SELF, instance.id, r#"foo: bar"#)
            .await
            .is_err()); // no json
        assert!(t
            .receive_status_update(
                ContactId::SELF,
-                &instance,
-                now,
-                true,
+                instance.id,
                r#"{"updada":[{"payload":{"foo":"bar"}}]}"#
            )
            .await
@@ -1497,9 +1471,7 @@ mod tests {
        assert!(t
            .receive_status_update(
                ContactId::SELF,
-                &instance,
-                now,
-                true,
+                instance.id,
                r#"{"updates":[{"foo":"bar"}]}"#
            )
            .await
@@ -1507,9 +1479,7 @@ mod tests {
        assert!(t
            .receive_status_update(
                ContactId::SELF,
-                &instance,
-                now,
-                true,
+                instance.id,
                r#"{"updates":{"payload":{"foo":"bar"}}}"#
            )
            .await
@@ -1517,9 +1487,7 @@ mod tests {

        t.receive_status_update(
            ContactId::SELF,
-            &instance,
-            now,
-            true,
+            instance.id,
            r#"{"updates":[{"payload":{"foo":"bar"}, "someTrash": "definitely TrAsH"}]}"#,
        )
        .await?;
@@ -1531,9 +1499,7 @@ mod tests {

        t.receive_status_update(
            ContactId::SELF,
-            &instance,
-            now,
-            true,
+            instance.id,
            r#" {"updates": [ {"payload" :42} , {"payload": 23} ] } "#,
        )
        .await?;
@@ -1547,9 +1513,7 @@ mod tests {

        t.receive_status_update(
            ContactId::SELF,
-            &instance,
-            now,
-            true,
+            instance.id,
            r#" {"updates": [ {"payload" :"ok", "future_item": "test"}  ], "from": "future" } "#,
        )
        .await?; // ignore members that may be added in the future
@@ -1647,8 +1611,7 @@ mod tests {
        assert_eq!(bob_instance.viewtype, Viewtype::Webxdc);
        assert_eq!(bob_chat_id.get_msg_cnt(&bob).await?, 1);

-        let bob_received_update = bob.recv_msg_opt(sent2).await;
-        assert!(bob_received_update.is_none());
+        bob.recv_msg(sent2).await;
        expect_status_update_event(&bob, bob_instance.id).await?;
        assert_eq!(bob_chat_id.get_msg_cnt(&bob).await?, 1);

@@ -1661,7 +1624,7 @@ mod tests {
        // Alice has a second device and also receives messages there
        let alice2 = TestContext::new_alice().await;
        alice2.recv_msg(sent1).await;
-        alice2.recv_msg_trash(sent2).await;
+        alice2.recv_msg(sent2).await;
        let alice2_instance = alice2.get_last_msg().await;
        let alice2_chat_id = alice2_instance.chat_id;
        assert_eq!(alice2_instance.viewtype, Viewtype::Webxdc);
@@ -2195,8 +2158,8 @@ sth_for_the = "future""#

        // Bob receives the updates
        let bob_instance = bob.recv_msg(sent_instance).await;
-        bob.recv_msg_trash(sent_update1).await;
-        bob.recv_msg_trash(sent_update2).await;
+        bob.recv_msg(sent_update1).await;
+        bob.recv_msg(sent_update2).await;
        let info = Message::load_from_db(&bob, bob_instance.id)
            .await?
            .get_webxdc_info(&bob)
@@ -2206,8 +2169,8 @@ sth_for_the = "future""#
        // Alice has a second device and also receives the updates there
        let alice2 = TestContext::new_alice().await;
        let alice2_instance = alice2.recv_msg(sent_instance).await;
-        alice2.recv_msg_trash(sent_update1).await;
-        alice2.recv_msg_trash(sent_update2).await;
+        alice2.recv_msg(sent_update1).await;
+        alice2.recv_msg(sent_update2).await;
        let info = Message::load_from_db(&alice2, alice2_instance.id)
            .await?
            .get_webxdc_info(&alice2)
@@ -2248,7 +2211,7 @@ sth_for_the = "future""#

        // Bob receives the updates
        let bob_instance = bob.recv_msg(sent_instance).await;
-        bob.recv_msg_trash(sent_update1).await;
+        bob.recv_msg(sent_update1).await;
        let info = Message::load_from_db(&bob, bob_instance.id)
            .await?
            .get_webxdc_info(&bob)
@@ -2300,7 +2263,7 @@ sth_for_the = "future""#
        // Bob receives all messages
        let bob_instance = bob.recv_msg(sent1).await;
        let bob_chat_id = bob_instance.chat_id;
-        bob.recv_msg_trash(sent2).await;
+        bob.recv_msg(sent2).await;
        assert_eq!(bob_chat_id.get_msg_cnt(&bob).await?, 2);
        let info_msg = bob.get_last_msg().await;
        assert!(info_msg.is_info());
@@ -2319,7 +2282,7 @@ sth_for_the = "future""#
        let alice2 = TestContext::new_alice().await;
        let alice2_instance = alice2.recv_msg(sent1).await;
        let alice2_chat_id = alice2_instance.chat_id;
-        alice2.recv_msg_trash(sent2).await;
+        alice2.recv_msg(sent2).await;
        assert_eq!(alice2_chat_id.get_msg_cnt(&alice2).await?, 2);
        let info_msg = alice2.get_last_msg().await;
        assert!(info_msg.is_info());
@@ -2369,9 +2332,9 @@ sth_for_the = "future""#
        // When Bob receives the messages, they should be cleaned up as well
        let bob_instance = bob.recv_msg(sent1).await;
        let bob_chat_id = bob_instance.chat_id;
-        bob.recv_msg_trash(sent2).await;
+        bob.recv_msg(sent2).await;
        assert_eq!(bob_chat_id.get_msg_cnt(&bob).await?, 2);
-        bob.recv_msg_trash(sent3).await;
+        bob.recv_msg(sent3).await;
        assert_eq!(bob_chat_id.get_msg_cnt(&bob).await?, 2);
        let info_msg = bob.get_last_msg().await;
        assert_eq!(info_msg.get_text(), "i2");
@@ -2429,7 +2392,7 @@ sth_for_the = "future""#

        // Bob receives instance+update
        let bob_instance = bob.recv_msg(sent1).await;
-        bob.recv_msg_trash(sent2).await;
+        bob.recv_msg(sent2).await;
        assert!(bob_instance.get_showpadlock());

        // Bob adds Claire with unknown key, update to Alice+Claire cannot be encrypted
@@ -2559,7 +2522,7 @@ sth_for_the = "future""#
        .await?;
        bob.flush_status_updates().await?;
        let msg = bob.pop_sent_msg().await;
-        alice.recv_msg_trash(&msg).await;
+        alice.recv_msg(&msg).await;
        alice
            .get_webxdc_status_updates(alice_instance.id, StatusUpdateSerial(0))
            .await
@@ -2677,8 +2640,7 @@ sth_for_the = "future""#
            )
            .await?;
        alice.flush_status_updates().await?;
-        let received_update = bob.recv_msg_opt(&alice.pop_sent_msg().await).await;
-        assert!(received_update.is_none());
+        bob.recv_msg(&alice.pop_sent_msg().await).await;

        assert_eq!(
            bob.get_webxdc_status_updates(bob_instance.id, StatusUpdateSerial(0))
@@ -2688,48 +2650,4 @@ sth_for_the = "future""#

        Ok(())
    }
-
-    // NB: This test also checks that a contact is not marked as bot after receiving from it a
-    // webxdc instance and status updates.
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_status_update_vs_delete_device_after() -> Result<()> {
-        let alice = &TestContext::new_alice().await;
-        let bob = &TestContext::new_bob().await;
-        bob.set_config(Config::DeleteDeviceAfter, Some("3600"))
-            .await?;
-        let alice_chat = alice.create_chat(bob).await;
-        let alice_instance = send_webxdc_instance(alice, alice_chat.id).await?;
-        let bob_instance = bob.recv_msg(&alice.pop_sent_msg().await).await;
-        assert_eq!(bob.add_or_lookup_contact(alice).await.is_bot(), false);
-
-        SystemTime::shift(Duration::from_secs(1800));
-        let mut update = Message {
-            chat_id: alice_chat.id,
-            viewtype: Viewtype::Text,
-            text: "I'm an update".to_string(),
-            hidden: true,
-            ..Default::default()
-        };
-        update.param.set_cmd(SystemMessage::WebxdcStatusUpdate);
-        update
-            .param
-            .set(Param::Arg, r#"{"updates":[{"payload":{"foo":"bar"}}]}"#);
-        update.set_quote(alice, Some(&alice_instance)).await?;
-        let sent_msg = alice.send_msg(alice_chat.id, &mut update).await;
-        bob.recv_msg_trash(&sent_msg).await;
-        assert_eq!(bob.add_or_lookup_contact(alice).await.is_bot(), false);
-        assert_eq!(
-            bob.get_webxdc_status_updates(bob_instance.id, StatusUpdateSerial(0))
-                .await?,
-            r#"[{"payload":{"foo":"bar"},"serial":1,"max_serial":1}]"#
-        );
-        assert_eq!(bob.add_or_lookup_contact(alice).await.is_bot(), false);
-
-        SystemTime::shift(Duration::from_secs(2700));
-        ephemeral::delete_expired_messages(bob, tools::time()).await?;
-        let bob_instance = Message::load_from_db(bob, bob_instance.id).await?;
-        assert_eq!(bob_instance.chat_id.is_trash(), false);
-
-        Ok(())
-    }
 }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
link2xt	5820c4ce95	Serialize mime_compressed	2024-04-06 16:37:51 +00:00
link2xt	12ba33d9d4	Serialize uid	2024-04-06 15:54:12 +00:00
link2xt	60a7bbc9b5	Do not serialize is_default It is only stored for compatibility with old versions	2024-04-06 15:27:11 +00:00
link2xt	e9f434b562	Serialize backward_verified_key_id	2024-04-06 02:48:27 +00:00
link2xt	2423cb8175	feat: add support for dumping the database to stream	2024-04-06 01:45:14 +00:00
@@ -1 +1 @@
 -04-16
 -04-05