fix exports variable

(nodejs/npm said it must start with `./`)
build(node): migrate from CommonJS to ESM modules
2026-04-03 22:12:11 +03:00 · 2024-04-30 01:36:22 +02:00 · 2024-04-27 06:36:10 +00:00 · 2024-04-25 20:45:54 +00:00 · 2024-04-25 12:15:54 +00:00 · 2024-04-25 09:00:49 +00:00
128 changed files with 4187 additions and 3832 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -105,10 +105,20 @@ 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 test --workspace
+        run: cargo nextest run --workspace
+
+      - name: Doc-Tests
+        env:
+          RUST_BACKTRACE: 1
+        run: cargo test --workspace --doc

      - name: Test cargo vendor
        run: cargo vendor
--- 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, py.delta.chat
+name: Build & deploy documentation on rs.delta.chat, c.delta.chat, and 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 py.delta.chat
+      - name: Upload to c.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_fii` crate documentation
+# to build `deltachat_ffi` 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,5 +1,114 @@
 # Changelog

+## [1.137.4] - 2024-04-24
+
+### API-Changes
+
+- [**breaking**] Remove `Stream` implementation for `EventEmitter`.
+- Experimental Webxdc Integration API, Maps Integration ([#5461](https://github.com/deltachat/deltachat-core-rust/pull/5461)).
+
+### Features / Changes
+
+- Add progressive backoff for failing IMAP connection attempts ([#5443](https://github.com/deltachat/deltachat-core-rust/pull/5443)).
+- Replace event channel with broadcast channel.
+- Mark contact request messages as seen on IMAP.
+
+### Fixes
+
+- Convert images to RGB8 (without alpha) before encoding into JPEG to fix sending of large RGBA images.
+- Don't set `is_bot` for webxdc status updates ([#5445](https://github.com/deltachat/deltachat-core-rust/pull/5445)).
+- Do not fail if Autocrypt Setup Message has no encryption preference to fix key transfer from K-9 Mail to Delta Chat.
+- Use only CRLF in Autocrypt Setup Message.
+- python: Use cached message object if `dc_get_msg()` returns `NULL`.
+- python: `Message::is_outgoing`: Don't reload message from db.
+- python: `_map_ffi_event`: Always check if `get_message_by_id()` returned None.
+- node: Undefine `NAPI_EXPERIMENTAL` to fix build with new clang.
+
+### Build system
+
+- nix: Add `imap-tools` as `deltachat-rpc-client` dependency.
+- nix: Add `./deltachat-contact-tools` to sources.
+- nix: Update nix flake.
+- deps: Update rustls to 0.21.11.
+
+### Documentation
+
+- Update references to SecureJoin protocols.
+- Fix broken references in documentation comments.
+
+### Refactor
+
+- imap: remove `RwLock` from `ratelimit`.
+- deltachat-ffi: Remove unused `ResultNullableExt`.
+- Remove duplicate clippy exceptions.
+- Group `use` at the top of the test modules.
+
+## [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
@@ -3872,3 +3981,5 @@ 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
+[1.137.4]: https://github.com/deltachat/deltachat-core-rust/compare/v1.137.3...v1.137.4
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -12,6 +12,12 @@ 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"
@@ -35,6 +41,6 @@ add_custom_target(
 )

 install(FILES "deltachat-ffi/deltachat.h" DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
-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)
+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)
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -113,12 +113,54 @@ 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"
@@ -185,6 +227,18 @@ 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"
@@ -422,6 +476,12 @@ 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"
@@ -507,9 +567,9 @@ dependencies = [

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

 [[package]]
 name = "brotli-decompressor"
-version = "3.0.0"
+version = "4.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "65622a320492e09b5e0ac436b14c54ff68199bac392d0e89a6832c4518eea525"
+checksum = "e6221fe77a248b9117d431ad93761222e1cf8ff282d9d1d5d9f53d6299a1cf76"
 dependencies = [
 "alloc-no-stdlib",
 "alloc-stdlib",
@@ -759,6 +819,12 @@ 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"
@@ -1091,22 +1157,22 @@ dependencies = [

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

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

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

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

 [[package]]
 name = "deltachat_ffi"
-version = "1.137.2"
+version = "1.137.4"
 dependencies = [
 "anyhow",
 "deltachat",
@@ -1771,6 +1846,16 @@ 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"
@@ -1784,6 +1869,19 @@ 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"
@@ -3601,7 +3699,7 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "865724d4dbe39d9f3dd3b52b88d859d66bcb2d6a0acfd5ea68a65fb66d4bdc1c"
 dependencies = [
- "env_logger",
+ "env_logger 0.10.2",
 "log",
 ]

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

 [[package]]
 name = "rustls"
-version = "0.21.10"
+version = "0.21.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f9d5a6813c0759e4609cd494e8e725babae6a2ca7b62a5536a13daaec6fcb7ba"
+checksum = "7fecbfb7b1444f477b345853b1fce097a2c6fb637b2bfb87e6bc5db0f043fae4"
 dependencies = [
 "ring 0.17.8",
 "rustls-webpki",
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "deltachat"
-version = "1.137.2"
+version = "1.137.4"
 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 = "1"
+anyhow = { workspace = true }
+async-broadcast = "0.7.0"
 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.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"] }
+base64 = "0.22"
+brotli = { version = "5", default-features=false, features = ["std"] }
+chrono = { version = "0.4.37", 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"
+kamadak-exif = "0.5.3"
 lettre_email = { git = "https://github.com/deltachat/lettre", branch = "master" }
 libc = "0.2"
 mailparse = "0.14"
@@ -69,32 +69,31 @@ mime = "0.3.17"
 num_cpus = "1.16"
 num-derive = "0.4"
 num-traits = "0.2"
-once_cell = "1.18.0"
+once_cell = { workspace = true }
 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 = "1.10"
+regex = { workspace = true }
 reqwest = { version = "0.12.2", features = ["json"] }
-rusqlite = { version = "0.31", features = ["sqlcipher"] }
+rusqlite = { workspace = true, 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"
+smallvec = "1.13.2"
 strum = "0.26"
 strum_macros = "0.26"
 tagger = "4.3.4"
 textwrap = "0.16.1"
 thiserror = "1"
-tokio = { version = "1", features = ["fs", "rt-multi-thread", "macros"] }
+tokio = { version = "1.37.0", 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
@@ -121,7 +120,7 @@ pretty_env_logger = "0.5"
 proptest = { version = "1", default-features = false, features = ["std"] }
 tempfile = "3"
 testdir = "0.9.0"
-tokio = { version = "1", features = ["parking_lot", "rt-multi-thread", "macros"] }
+tokio = { version = "1.37.0", features = ["parking_lot", "rt-multi-thread", "macros"] }
 pretty_assertions = "1.3.0"

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

 [[bench]]
@@ -164,6 +164,12 @@ 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,6 +6,9 @@
  <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">
@@ -192,6 +195,7 @@ 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
@@ -0,0 +1,18 @@
+[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
@@ -0,0 +1,280 @@
+//! 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.2"
+version = "1.137.4"
 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", features = ["rt-multi-thread"] }
+tokio = { version = "1.37.0", features = ["rt-multi-thread"] }
 anyhow = "1"
 thiserror = "1"
 rand = "0.8"
--- a/deltachat-ffi/deltachat.h
+++ b/deltachat-ffi/deltachat.h
@@ -17,7 +17,6 @@ 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;
@@ -363,8 +362,12 @@ 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.
- * 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.
+ * 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.
 */
 dc_event_emitter_t* dc_get_event_emitter(dc_context_t* context);

@@ -1117,36 +1120,6 @@ 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.
 *
@@ -1209,6 +1182,65 @@ 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.
 *
@@ -2576,7 +2608,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.readthedocs.io/en/latest/new.html
+ *     See https://securejoin.delta.chat/
 *     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.
@@ -2612,8 +2644,7 @@ 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.readthedocs.io/en/latest/new.html
- * for details about both protocols.
+ * See https://securejoin.delta.chat/ for details about both protocols.
 *
 * @memberof dc_context_t
 * @param context The context object.
@@ -4074,6 +4105,19 @@ char*           dc_msg_get_subject            (const dc_msg_t* msg);
 char*           dc_msg_get_file               (const dc_msg_t* msg);


+/**
+ * Save file copy at the user-provided path.
+ *
+ * Fails if file already exists at the provided path.
+ *
+ * @memberof dc_msg_t
+ * @param msg The message object.
+ * @param path Destination file path with filename and extension.
+ * @return 0 on failure, 1 on success.
+ */
+int             dc_msg_save_file              (const dc_msg_t* msg, const char* path);
+
+
 /**
 * Get an original attachment filename, with extension but without the path. To get the full path,
 * use dc_msg_get_file().
@@ -4138,7 +4182,6 @@ 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.
@@ -5320,52 +5363,6 @@ 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
 *
@@ -6290,7 +6287,24 @@ 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
+#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

 /**
 * @}
--- a/deltachat-ffi/src/lib.rs
+++ b/deltachat-ffi/src/lib.rs
@@ -3,8 +3,6 @@
    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
 )]
@@ -32,7 +30,6 @@ 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::*;
@@ -68,8 +65,6 @@ 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
@@ -567,6 +562,8 @@ 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,
    }
 }

@@ -596,6 +593,7 @@ 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, .. }
@@ -620,6 +618,9 @@ 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
+        }
    }
 }

@@ -656,6 +657,8 @@ 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, .. }
@@ -720,7 +723,9 @@ pub unsafe extern "C" fn dc_event_get_data2_str(event: *mut dc_event_t) -> *mut
        | EventType::WebxdcInstanceDeleted { .. }
        | EventType::AccountsBackgroundFetchDone
        | EventType::ChatEphemeralTimerModified { .. }
-        | EventType::IncomingMsgBunch { .. } => ptr::null_mut(),
+        | EventType::IncomingMsgBunch { .. }
+        | EventType::ChatlistItemChanged { .. }
+        | EventType::ChatlistChanged => ptr::null_mut(),
        EventType::ConfigureProgress { comment, .. } => {
            if let Some(comment) = comment {
                comment.to_c_string().unwrap_or_default().into_raw()
@@ -1015,49 +1020,6 @@ 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,
@@ -1101,6 +1063,43 @@ 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,
@@ -2046,7 +2045,7 @@ pub unsafe extern "C" fn dc_get_msg(context: *mut dc_context_t, msg_id: u32) ->
                    );
                    message::Message::default()
                } else {
-                    error!(ctx, "dc_get_msg could not retrieve msg_id {msg_id}: {e:#}");
+                    warn!(ctx, "dc_get_msg could not retrieve msg_id {msg_id}: {e:#}");
                    return ptr::null_mut();
                }
            }
@@ -3369,6 +3368,34 @@ pub unsafe extern "C" fn dc_msg_get_file(msg: *mut dc_msg_t) -> *mut libc::c_cha
        .unwrap_or_else(|| "".strdup())
 }

+#[no_mangle]
+pub unsafe extern "C" fn dc_msg_save_file(
+    msg: *mut dc_msg_t,
+    path: *const libc::c_char,
+) -> libc::c_int {
+    if msg.is_null() || path.is_null() {
+        eprintln!("ignoring careless call to dc_msg_save_file()");
+        return 0;
+    }
+    let ffi_msg = &*msg;
+    let ctx = &*ffi_msg.context;
+    let path = to_string_lossy(path);
+    let r = block_on(
+        ffi_msg
+            .message
+            .save_file(ctx, &std::path::PathBuf::from(path)),
+    );
+    match r {
+        Ok(()) => 1,
+        Err(_) => {
+            r.context("Failed to save file from message")
+                .log_err(ctx)
+                .unwrap_or_default();
+            0
+        }
+    }
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn dc_msg_get_filename(msg: *mut dc_msg_t) -> *mut libc::c_char {
    if msg.is_null() {
@@ -4244,45 +4271,6 @@ 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 _)
@@ -4483,19 +4471,6 @@ 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
@@ -4975,7 +4950,9 @@ mod jsonrpc {
        }

        let account_manager = &*account_manager;
-        let cmd_api = deltachat_jsonrpc::api::CommandApi::from_arc(account_manager.inner.clone());
+        let cmd_api = block_on(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.2"
+version = "1.137.4"
 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.21"
+base64 = "0.22"

 # optional dependencies
 axum = { version = "0.7", optional = true, features = ["ws"] }
-env_logger = { version = "0.10.0", optional = true }
+env_logger = { version = "0.11.3", 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,5 +1,7 @@
 use std::collections::BTreeMap;
+use std::path::Path;
 use std::sync::Arc;
+use std::time::Duration;
 use std::{collections::HashMap, str::FromStr};

 use anyhow::{anyhow, bail, ensure, Context, Result};
@@ -28,6 +30,7 @@ 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};
@@ -62,14 +65,14 @@ use crate::api::types::qr::QrObject;
 struct AccountState {
    /// The Qr code for current [`CommandApi::provide_backup`] call.
    ///
-    /// If there currently is a call to [`CommandApi::provide_backup`] this will be
-    /// `Pending` or `Ready`, otherwise `NoProvider`.
-    backup_provider_qr: watch::Sender<ProviderQr>,
+    /// If there is currently is a call to [`CommandApi::provide_backup`] this will be
+    /// `Some`, otherwise `None`.
+    backup_provider_qr: watch::Sender<Option<Qr>>,
 }

 impl Default for AccountState {
    fn default() -> Self {
-        let (tx, _rx) = watch::channel(ProviderQr::NoProvider);
+        let tx = watch::Sender::new(None);
        Self {
            backup_provider_qr: tx,
        }
@@ -80,21 +83,30 @@ 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 fn from_arc(accounts: Arc<RwLock<Accounts>>) -> Self {
+    pub async fn from_arc(accounts: Arc<RwLock<Accounts>>) -> Self {
+        let event_emitter = Arc::new(accounts.read().await.get_event_emitter());
        CommandApi {
            accounts,
+            event_emitter,
            states: Arc::new(Mutex::new(BTreeMap::new())),
        }
    }
@@ -123,21 +135,13 @@ impl CommandApi {
            .with_state(account_id, |state| state.backup_provider_qr.subscribe())
            .await;

-        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),
+        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)");
+            }
        }
    }
 }
@@ -165,8 +169,7 @@ impl CommandApi {

    /// Get the next event.
    async fn get_next_event(&self) -> Result<Event> {
-        let event_emitter = self.accounts.read().await.get_event_emitter();
-        event_emitter
+        self.event_emitter
            .recv()
            .await
            .map(|event| event.into())
@@ -697,8 +700,7 @@ 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.readthedocs.io/en/latest/new.html
-    ///     for details about both protocols.
+    ///     See https://securejoin.delta.chat/ for details about both protocols.
    ///
    /// return format: `[code, svg]`
    async fn get_chat_securejoin_qr_code_svg(
@@ -726,8 +728,7 @@ impl CommandApi {
    ///
    /// Subsequent calls of `secure_join()` will abort previous, unfinished handshakes.
    ///
-    /// See https://securejoin.readthedocs.io/en/latest/new.html
-    /// for details about both protocols.
+    /// See https://securejoin.delta.chat/ for details about both protocols.
    ///
    /// **qr**: The text of the scanned QR code. Typically, the same string as given
    ///     to `check_qr()`.
@@ -1569,20 +1570,21 @@ 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(ProviderQr::Ready(provider.qr()));
+            state.backup_provider_qr.send_replace(Some(provider.qr()));
        })
        .await;

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

    /// Returns the text of the QR code for the running [`CommandApi::provide_backup`].
@@ -1590,11 +1592,17 @@ 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 fail if there is currently no concurrent call to
-    /// [`CommandApi::provide_backup`].  This call may block if the QR code is not yet
-    /// ready.
+    /// 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.
    async fn get_backup_qr(&self, account_id: u32) -> Result<String> {
-        let qr = self.inner_get_backup_qr(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")?;
        qr::format_backup(&qr)
    }

@@ -1603,14 +1611,20 @@ 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 fail if there is currently no concurrent call to
-    /// [`CommandApi::provide_backup`].  This call may block if the QR code is not yet
-    /// ready.
+    /// 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.
    ///
    /// 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 = self.inner_get_backup_qr(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")?;
        generate_backup_qr(&ctx, &qr).await
    }

@@ -1620,6 +1634,9 @@ 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?;
@@ -1862,6 +1879,15 @@ impl CommandApi {
        Ok(can_send)
    }

+    /// Saves a file copy at the user-provided path.
+    ///
+    /// Fails if file already exists at the provided path.
+    async fn save_msg_file(&self, account_id: u32, msg_id: u32, path: String) -> Result<()> {
+        let ctx = self.get_context(account_id).await?;
+        let message = Message::load_from_db(&ctx, MsgId::new(msg_id)).await?;
+        message.save_file(&ctx, Path::new(&path)).await
+    }
+
    // ---------------------------------------------
    //           functions for the composer
    //    the composer is the message input field
@@ -1934,19 +1960,21 @@ impl CommandApi {
        );
        let destination_path = account_folder.join("stickers").join(collection);
        fs::create_dir_all(&destination_path).await?;
-        let file = message.get_file(&ctx).context("no file")?;
-        fs::copy(
-            &file,
-            destination_path.join(format!(
-                "{}.{}",
-                msg_id,
-                file.extension()
-                    .unwrap_or_default()
-                    .to_str()
-                    .unwrap_or_default()
-            )),
-        )
-        .await?;
+        let file = message.get_filename().context("no file?")?;
+        message
+            .save_file(
+                &ctx,
+                &destination_path.join(format!(
+                    "{}.{}",
+                    msg_id,
+                    Path::new(&file)
+                        .extension()
+                        .unwrap_or_default()
+                        .to_str()
+                        .unwrap_or_default()
+                )),
+            )
+            .await?;
        Ok(())
    }

@@ -2141,15 +2169,3 @@ 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,6 +250,15 @@ 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 {
@@ -357,6 +366,10 @@ 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.2"
+  "version": "1.137.4"
 }
--- a/deltachat-repl/Cargo.toml
+++ b/deltachat-repl/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "deltachat-repl"
-version = "1.137.2"
+version = "1.137.4"
 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", features = ["fs", "rt-multi-thread", "macros"] }
+tokio = { version = "1.37.0", features = ["fs", "rt-multi-thread", "macros"] }

 [features]
 default = ["vendored"]
--- a/deltachat-repl/src/cmdline.rs
+++ b/deltachat-repl/src/cmdline.rs
@@ -339,8 +339,6 @@ 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\
@@ -516,14 +514,6 @@ 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.2"
+version = "1.137.4"
 description = "Python client for Delta Chat core JSON-RPC interface"
 classifiers = [
    "Development Status :: 5 - Production/Stable",
@@ -21,6 +21,9 @@ classifiers = [
    "Topic :: Communications :: Email"
 ]
 readme = "README.md"
+dependencies = [
+    "imap-tools",
+]

 [tool.setuptools.package-data]
 deltachat_rpc_client = [
@@ -34,7 +37,7 @@ deltachat_rpc_client = [
 line-length = 120

 [tool.ruff]
-select = [
+lint.select = [
  "E", "W", # pycodestyle
  "F", # Pyflakes
  "N", # pep8-naming
--- a/deltachat-rpc-client/src/deltachat_rpc_client/_utils.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/_utils.py
@@ -104,7 +104,11 @@ 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(run=client.configure, kwargs={"email": args.email, "password": args.password})
+            configure_thread = Thread(
+                target=client.configure,
+                daemon=True,
+                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,5 +1,7 @@
+from __future__ import annotations
+
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, List, Optional, Tuple, Union
+from typing import TYPE_CHECKING, Optional, Union
 from warnings import warn

 from ._utils import AttrDict, futuremethod
@@ -28,6 +30,10 @@ 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)
@@ -87,6 +93,14 @@ 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.

@@ -104,6 +118,11 @@ 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)
@@ -113,7 +132,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]
@@ -138,7 +157,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
@@ -173,7 +192,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.
@@ -225,13 +244,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.readthedocs.io/en/latest/new.html for protocol details.
+        See https://securejoin.delta.chat/ 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
@@ -243,15 +262,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.
@@ -261,12 +280,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]
@@ -290,7 +309,13 @@ class Account:
            if event["kind"] == "SecurejoinJoinerProgress" and event["progress"] == 1000:
                break

-    def get_fresh_messages_in_arrival_order(self) -> List[Message]:
+    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]:
        """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,6 +1,8 @@
+from __future__ import annotations
+
 import calendar
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Dict, List, Optional, Tuple, Union
+from typing import TYPE_CHECKING, Optional, Union

 from ._utils import AttrDict
 from .const import ChatVisibility, ViewType
@@ -93,7 +95,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)

@@ -117,7 +119,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:
@@ -142,6 +144,10 @@ 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)
@@ -152,7 +158,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)
@@ -184,7 +190,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]
@@ -219,7 +225,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.
@@ -243,7 +249,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
@@ -251,7 +257,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,14 +1,13 @@
 """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,
 )
@@ -39,16 +38,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,6 +59,8 @@ 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,4 +1,6 @@
-from typing import TYPE_CHECKING, Dict, List
+from __future__ import annotations
+
+from typing import TYPE_CHECKING

 from ._utils import AttrDict
 from .account import Account
@@ -21,7 +23,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]
@@ -44,6 +46,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
@@ -0,0 +1,226 @@
+"""
+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,8 +1,10 @@
 """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, Set, Tuple, Union
+from typing import TYPE_CHECKING, Callable, Iterable, Iterator, Optional, Union

 from .const import EventType

@@ -263,9 +265,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,6 +3,7 @@ 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:
@@ -21,9 +22,10 @@ class Message:
    def _rpc(self) -> "Rpc":
        return self.account._rpc

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

    def get_snapshot(self) -> AttrDict:
        """Get a snapshot with the properties of this message."""
@@ -61,3 +63,10 @@ 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,10 +1,12 @@
+from __future__ import annotations
+
 import os
 import random
-from typing import AsyncGenerator, List, Optional
+from typing import AsyncGenerator, Optional

 import pytest

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

@@ -54,14 +56,10 @@ class ACFactory:
    @futuremethod
    def get_online_account(self):
        account = yield self.new_configured_account.future()
-        account.start_io()
-        while True:
-            event = account.wait_for_event()
-            if event.kind == EventType.IMAP_INBOX_IDLE:
-                break
+        account.bring_online()
        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]

@@ -75,6 +73,10 @@ 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,12 +1,14 @@
+from __future__ import annotations
+
 import itertools
 import json
 import logging
 import os
 import subprocess
 import sys
-from queue import Queue
+from queue import Empty, Queue
 from threading import Event, Thread
-from typing import Any, Dict, Iterator, Optional
+from typing import Any, Iterator, Optional


 class JsonRpcError(Exception):
@@ -67,11 +69,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
@@ -186,5 +188,14 @@ 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
@@ -0,0 +1,218 @@
+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,10 +1,15 @@
 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 EventType, events
+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.rpc import JsonRpcError


@@ -439,3 +444,172 @@ 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 src/ examples/ tests/
+    ruff check 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.2"
+version = "1.137.4"
 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.10.0" }
+env_logger = { version = "0.11.3" }
 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());
+    let state = CommandApi::from_arc(accounts.clone()).await;

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

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

        devShells.default = pkgs.mkShell {
          buildInputs = with pkgs; [
-            (fenixPkgs.complete.withComponents [
-              "cargo"
-              "clippy"
-              "rust-src"
-              "rustc"
-              "rustfmt"
-            ])
+            cargo
+            clippy
+            rustc
+            rustfmt
+            rust-analyzer
            cargo-deny
-            fenixPkgs.rust-analyzer
            perl # needed to build vendored OpenSSL
          ];
        };
--- a/fuzz/Cargo.lock
+++ b/fuzz/Cargo.lock
@@ -94,6 +94,12 @@ 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"
@@ -521,9 +527,9 @@ dependencies = [

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

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

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

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

 [[package]]
 name = "deltachat"
-version = "1.137.2"
+version = "1.137.3"
 dependencies = [
 "anyhow",
 "async-channel 2.1.1",
@@ -968,9 +973,10 @@ dependencies = [
 "async-smtp",
 "async_zip",
 "backtrace",
- "base64 0.21.0",
+ "base64 0.22.0",
 "brotli",
 "chrono",
+ "deltachat-contact-tools",
 "deltachat-time",
 "deltachat_derive",
 "email",
@@ -1030,6 +1036,16 @@ 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"
@@ -2154,7 +2170,7 @@ dependencies = [
 "http-body",
 "hyper",
 "pin-project-lite",
- "socket2 0.5.4",
+ "socket2 0.5.6",
 "tokio",
 "tower",
 "tower-service",
@@ -3339,7 +3355,7 @@ checksum = "055b4e778e8feb9f93c4e439f71dc2156ef13360b432b799e179a8c4cdf0b1d7"
 dependencies = [
 "bytes",
 "libc",
- "socket2 0.5.4",
+ "socket2 0.5.6",
 "tracing",
 "windows-sys 0.48.0",
 ]
@@ -3748,9 +3764,9 @@ dependencies = [

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

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

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

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

 [[package]]
 name = "tokio-macros"
-version = "2.1.0"
+version = "2.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "630bdcf245f78637c13ec01ffae6187cca34625e8c63150d424b59e55af2675e"
+checksum = "5b8a1e28f2deaa14e508979454cb3a223b10b938b45af148bc0986de36f1923b"
 dependencies = [
 "proc-macro2",
 "quote",
--- a/node/constants.js
+++ b/node/constants.js
@@ -30,6 +30,8 @@ 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,5 +37,7 @@ 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'
+  2200: 'DC_EVENT_ACCOUNTS_BACKGROUND_FETCH_DONE',
+  2300: 'DC_EVENT_CHATLIST_CHANGED',
+  2301: 'DC_EVENT_CHATLIST_ITEM_CHANGED'
 }
--- a/node/lib/binding.ts
+++ b/node/lib/binding.ts
@@ -1,9 +1,13 @@
 import { join } from 'path'
+import * as url from 'url'

 /**
 * bindings are not typed yet.
 * if the available function names are required they can be found inside of `../src/module.c`
 */
-export const bindings: any = require('node-gyp-build')(join(__dirname, '../'))
+import build from 'node-gyp-build'
+export const bindings: any = build(
+  join(url.fileURLToPath(new URL('.', import.meta.url)), '../')
+)

 export default bindings
--- a/node/lib/chat.ts
+++ b/node/lib/chat.ts
@@ -1,11 +1,11 @@
 /* eslint-disable camelcase */

-import binding from './binding'
+import binding from './binding.js'
 import rawDebug from 'debug'
 const debug = rawDebug('deltachat:node:chat')
-import { C } from './constants'
-import { integerToHexColor } from './util'
-import { ChatJSON } from './types'
+import { C } from './constants.js'
+import { integerToHexColor } from './util.js'
+import { ChatJSON } from './types.js'

 interface NativeChat {}
 /**
--- a/node/lib/chatlist.ts
+++ b/node/lib/chatlist.ts
@@ -1,9 +1,10 @@
 /* eslint-disable camelcase */

-import binding from './binding'
-import { Lot } from './lot'
-import { Chat } from './chat'
-const debug = require('debug')('deltachat:node:chatlist')
+import binding from './binding.js'
+import { Lot } from './lot.js'
+import { Chat } from './chat.js'
+import rawDebug from 'debug'
+const debug = rawDebug('deltachat:node:chatlist')

 interface NativeChatList {}
 /**
--- a/node/lib/constants.ts
+++ b/node/lib/constants.ts
@@ -30,6 +30,8 @@ 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,
@@ -333,4 +335,6 @@ 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/lib/contact.ts
+++ b/node/lib/contact.ts
@@ -1,9 +1,10 @@
-import { integerToHexColor } from './util'
+import { integerToHexColor } from './util.js'

 /* eslint-disable camelcase */

-import binding from './binding'
-const debug = require('debug')('deltachat:node:contact')
+import binding from './binding.js'
+import rawDebug from 'debug'
+const debug = rawDebug('deltachat:node:contact')

 interface NativeContact {}
 /**
--- a/node/lib/context.ts
+++ b/node/lib/context.ts
@@ -1,17 +1,17 @@
 /* eslint-disable camelcase */

-import binding from './binding'
-import { C, EventId2EventName } from './constants'
-import { Chat } from './chat'
-import { ChatList } from './chatlist'
-import { Contact } from './contact'
-import { Message } from './message'
-import { Lot } from './lot'
-import { Locations } from './locations'
+import binding from './binding.js'
+import { C, EventId2EventName } from './constants.js'
+import { Chat } from './chat.js'
+import { ChatList } from './chatlist.js'
+import { Contact } from './contact.js'
+import { Message } from './message.js'
+import { Lot } from './lot.js'
+import { Locations } from './locations.js'
 import rawDebug from 'debug'
-import { AccountManager } from './deltachat'
+import { AccountManager } from './deltachat.js'
 import { join } from 'path'
-import { EventEmitter } from 'stream'
+import { EventEmitter } from 'events'
 const debug = rawDebug('deltachat:node:index')

 const noop = function () {}
--- a/node/lib/deltachat.ts
+++ b/node/lib/deltachat.ts
@@ -1,13 +1,13 @@
 /* eslint-disable camelcase */

-import binding from './binding'
-import { EventId2EventName } from './constants'
+import binding from './binding.js'
+import { EventId2EventName } from './constants.js'
 import { EventEmitter } from 'events'
 import { existsSync } from 'fs'
 import rawDebug from 'debug'
 import { tmpdir } from 'os'
 import { join } from 'path'
-import { Context } from './context'
+import { Context } from './context.js'
 const debug = rawDebug('deltachat:node:index')

 const noop = function () {}
--- a/node/lib/index.ts
+++ b/node/lib/index.ts
@@ -1,20 +1,20 @@
-import { AccountManager } from './deltachat'
+import { AccountManager } from './deltachat.js'

 export default AccountManager

-export { Context } from './context'
-export { Chat } from './chat'
-export { ChatList } from './chatlist'
-export { C } from './constants'
-export { Contact } from './contact'
+export { Context } from './context.js'
+export { Chat } from './chat.js'
+export { ChatList } from './chatlist.js'
+export { C } from './constants.js'
+export { Contact } from './contact.js'
 export { AccountManager as DeltaChat }
-export { Locations } from './locations'
-export { Lot } from './lot'
+export { Locations } from './locations.js'
+export { Lot } from './lot.js'
 export {
  Message,
  MessageState,
  MessageViewType,
  MessageDownloadState,
-} from './message'
+} from './message.js'

-export * from './types'
+export * from './types.js'
--- a/node/lib/locations.ts
+++ b/node/lib/locations.ts
@@ -1,7 +1,8 @@
 /* eslint-disable camelcase */

-const binding = require('../binding')
-const debug = require('debug')('deltachat:node:locations')
+import binding from './binding.js'
+import rawDebug from 'debug'
+const debug = rawDebug('deltachat:node:locations')

 interface NativeLocations {}
 /**
--- a/node/lib/lot.ts
+++ b/node/lib/lot.ts
@@ -1,7 +1,8 @@
 /* eslint-disable camelcase */

-const binding = require('../binding')
-const debug = require('debug')('deltachat:node:lot')
+import binding from './binding.js'
+import rawDebug from 'debug'
+const debug = rawDebug('deltachat:node:lot')

 interface NativeLot {}
 /**
--- a/node/lib/message.ts
+++ b/node/lib/message.ts
@@ -1,11 +1,12 @@
 /* eslint-disable camelcase */

-import binding from './binding'
-import { C } from './constants'
-import { Lot } from './lot'
-import { Chat } from './chat'
-import { WebxdcInfo } from './context'
-const debug = require('debug')('deltachat:node:message')
+import binding from './binding.js'
+import { C } from './constants.js'
+import { Lot } from './lot.js'
+import { Chat } from './chat.js'
+import { WebxdcInfo } from './context.js'
+import rawDebug from 'debug'
+const debug = rawDebug('deltachat:node:message')

 export enum MessageDownloadState {
  Available = C.DC_DOWNLOAD_AVAILABLE,
--- a/node/lib/node-gyp-build.d.ts
+++ b/node/lib/node-gyp-build.d.ts
@@ -0,0 +1 @@
+declare module 'node-gyp-build'
--- a/node/lib/types.ts
+++ b/node/lib/types.ts
@@ -1,4 +1,4 @@
-import { C } from './constants'
+import { C } from './constants.js'

 export type ChatTypes =
  | C.DC_CHAT_TYPE_GROUP
--- a/node/scripts/common.js
+++ b/node/scripts/common.js
@@ -1,4 +1,4 @@
-const spawnSync = require('child_process').spawnSync
+import { spawnSync } from 'child_process'

 const verbose = isVerbose()

@@ -23,4 +23,4 @@ function isVerbose () {
  return loglevel === 'verbose' || process.env.CI === 'true'
 }

-module.exports = { spawn, log, isVerbose, verbose }
+export { spawn, log, isVerbose, verbose }
--- a/node/scripts/generate-constants.js
+++ b/node/scripts/generate-constants.js
@@ -1,14 +1,16 @@
 #!/usr/bin/env node
-const fs = require('fs')
-const path = require('path')
+import fs from 'fs'
+import path from 'path'
+import * as url from 'url'

 const data = []
-const header = path.resolve(__dirname, '../../deltachat-ffi/deltachat.h')
+const header = path.resolve(url.fileURLToPath(new URL('.', import.meta.url)), '../../deltachat-ffi/deltachat.h')

 console.log('Generating constants...')

 const header_data = fs.readFileSync(header, 'UTF-8')
 const regex = /^#define\s+(\w+)\s+(\w+)/gm
+var match
 while (null != (match = regex.exec(header_data))) {
  const key = match[1]
  const value = parseInt(match[2])
@@ -17,8 +19,6 @@ while (null != (match = regex.exec(header_data))) {
  }
 }

-delete header_data
-
 const constants = data
  .filter(
    ({ key }) => key.toUpperCase()[0] === key[0] // check if define name is uppercase
@@ -49,17 +49,17 @@ const events = data

 // backwards compat
 fs.writeFileSync(
-  path.resolve(__dirname, '../constants.js'),
+  path.resolve(url.fileURLToPath(new URL('.', import.meta.url)), '../constants.js'),
  `// Generated!\n\nmodule.exports = {\n${constants}\n}\n`
 )
 // backwards compat
 fs.writeFileSync(
-  path.resolve(__dirname, '../events.js'),
+  path.resolve(url.fileURLToPath(new URL('.', import.meta.url)), '../events.js'),
  `/* eslint-disable quotes */\n// Generated!\n\nmodule.exports = {\n${events}\n}\n`
 )

 fs.writeFileSync(
-  path.resolve(__dirname, '../lib/constants.ts'),
+  path.resolve(url.fileURLToPath(new URL('.', import.meta.url)), '../lib/constants.js'),
  `// Generated!\n\nexport enum C {\n${constants.replace(/:/g, ' =')},\n}\n
 // Generated!\n\nexport const EventId2EventName: { [key: number]: string } = {\n${events},\n}\n`
 )
--- a/node/scripts/install.js
+++ b/node/scripts/install.js
@@ -1,6 +1,7 @@
-const {execSync} = require('child_process')
-const {existsSync} = require('fs')
-const {join} = require('path')
+import {execSync} from 'child_process'
+import {existsSync} from 'fs'
+import {join} from 'path'
+import * as url from 'url'

 const run = (cmd) => {
  console.log('[i] running `' + cmd + '`')
@@ -16,7 +17,7 @@ if (process.env.USE_SYSTEM_LIBDELTACHAT === 'true') {
  run('npm run install:prebuilds')
 }

-if (!existsSync(join(__dirname, '..', 'dist'))) {
+if (!existsSync(join(url.fileURLToPath(new URL('.', import.meta.url)), '..', 'dist'))) {
  console.log('[i] Didn\'t find already built typescript bindings. Trying to transpile them. If this fail, make sure typescript is installed ;)')
  run('npm run build:bindings:ts')
 }
--- a/node/scripts/postLinksToDetails.js
+++ b/node/scripts/postLinksToDetails.js
@@ -1,4 +1,5 @@
-const { readFileSync } = require('fs')
+import { readFileSync } from 'fs'
+import { request } from 'https'

 const sha = JSON.parse(
  readFileSync(process.env['GITHUB_EVENT_PATH'], 'utf8')
@@ -21,8 +22,6 @@ const STATUS_DATA = {
  target_url: base_url + file_url,
 }

-const http = require('https')
-
 const options = {
  method: 'POST',
  headers: {
@@ -32,7 +31,7 @@ const options = {
  },
 }

-const req = http.request(GITHUB_API_URL, options, function(res) {
+const req = request(GITHUB_API_URL, options, function (res) {
  var chunks = []
  res.on('data', function(chunk) {
    chunks.push(chunk)
--- a/node/scripts/postinstall.js
+++ b/node/scripts/postinstall.js
@@ -1,5 +1,6 @@
-const fs = require('fs')
-const path = require('path')
+import fs from 'fs'
+import path from 'path'
+import * as url from 'url'

 if (process.platform !== 'win32') {
  console.log('postinstall: not windows, so skipping!')
@@ -7,7 +8,7 @@ if (process.platform !== 'win32') {
 }

 const from = path.resolve(
-  __dirname,
+  url.fileURLToPath(new URL('.', import.meta.url)),
  '..',
  '..',
  'target',
@@ -19,7 +20,7 @@ const getDestination = () => {
  const argv = process.argv
  if (argv.length === 3 && argv[2] === '--prebuild') {
    return path.resolve(
-      __dirname,
+      url.fileURLToPath(new URL('.', import.meta.url)),
      '..',
      'prebuilds',
      'win32-x64',
@@ -27,7 +28,7 @@ const getDestination = () => {
    )
  } else {
    return path.resolve(
-      __dirname,
+      url.fileURLToPath(new URL('.', import.meta.url)),
      '..',
      'build',
      'Release',
--- a/node/scripts/rebuild-core.js
+++ b/node/scripts/rebuild-core.js
@@ -1,7 +1,8 @@
-const path = require('path')
-const { spawn } = require('./common')
+import path from 'path'
+import { spawn } from './common.js'
+import * as url from 'url'
 const opts = {
-  cwd: path.resolve(__dirname, '../..'),
+  cwd: path.resolve(url.fileURLToPath(new URL('.', import.meta.url)), '../..'),
  stdio: 'inherit'
 }

--- a/node/src/module.c
+++ b/node/src/module.c
@@ -1,5 +1,4 @@
 #define NAPI_VERSION 4
-#define NAPI_EXPERIMENTAL

 #include <stdlib.h>
 #include <stdio.h>
--- a/node/test/test.mjs
+++ b/node/test/test.mjs
@@ -26,6 +26,8 @@ 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)
@@ -701,7 +703,7 @@ describe('Offline Tests with unconfigured account', function () {
 })

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

  let [dc, context, accountId, directory, account] = [
    null,
--- a/node/tsconfig.json
+++ b/node/tsconfig.json
@@ -3,7 +3,8 @@
        "outDir": "dist",
        "rootDir": "./lib",
        "sourceMap": true,
-        "module": "commonjs",
+        "module": "nodenext",
+        "moduleResolution": "nodenext",
        "target": "es5",
        "esModuleInterop": true,
        "declaration": true,
--- a/package.json
+++ b/package.json
@@ -1,4 +1,5 @@
 {
+  "type": "module",
  "dependencies": {
    "debug": "^4.1.1",
    "napi-macros": "^2.0.0",
@@ -10,7 +11,7 @@
    "@types/node": "^20.8.10",
    "chai": "~4.3.10",
    "chai-as-promised": "^7.1.1",
-    "mocha": "^8.2.1",
+    "mocha": "^10.2.0",
    "node-gyp": "^10.0.0",
    "prebuildify": "^5.0.1",
    "prebuildify-ci": "^1.0.5",
@@ -27,7 +28,7 @@
  ],
  "homepage": "https://github.com/deltachat/deltachat-core-rust/tree/master/node",
  "license": "GPL-3.0-or-later",
-  "main": "node/dist/index.js",
+  "exports": "./node/dist/index.js",
  "name": "deltachat-node",
  "repository": {
    "type": "git",
@@ -55,5 +56,5 @@
    "test:mocha": "mocha node/test/test.mjs --growl --reporter=spec --bail --exit"
  },
  "types": "node/dist/index.d.ts",
-  "version": "1.137.2"
+  "version": "1.137.4"
 }
--- a/python/pyproject.toml
+++ b/python/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"

 [project]
 name = "deltachat"
-version = "1.137.2"
+version = "1.137.4"
 description = "Python bindings for the Delta Chat Core library using CFFI against the Rust-implemented libdeltachat"
 readme = "README.rst"
 requires-python = ">=3.7"
@@ -46,7 +46,7 @@ deltachat = [
 line-length = 120

 [tool.ruff]
-select = ["E", "F", "W", "YTT", "C4", "ISC", "ICN", "TID", "DTZ", "PLC", "PLE", "PLW", "PIE", "COM", "UP004", "UP010", "UP031", "UP032", "ANN204"]
+lint.select = ["E", "F", "W", "YTT", "C4", "ISC", "ICN", "TID", "DTZ", "PLC", "PLE", "PLW", "PIE", "COM", "UP004", "UP010", "UP031", "UP032", "ANN204"]
 line-length = 120

 [tool.isort]
--- a/python/src/deltachat/events.py
+++ b/python/src/deltachat/events.py
@@ -328,10 +328,12 @@ class EventThread(threading.Thread):
        elif name == "DC_EVENT_REACTIONS_CHANGED":
            assert ffi_event.data1 > 0
            msg = account.get_message_by_id(ffi_event.data2)
-            yield "ac_reactions_changed", {"message": msg}
+            if msg is not None:
+                yield "ac_reactions_changed", {"message": msg}
        elif name == "DC_EVENT_MSG_DELIVERED":
            msg = account.get_message_by_id(ffi_event.data2)
-            yield "ac_message_delivered", {"message": msg}
+            if msg is not None:
+                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,6 +364,9 @@ 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):
@@ -392,7 +395,7 @@ class Message:

    def is_outgoing(self):
        """Return True if Message is outgoing."""
-        return self._msgstate in (
+        return lib.dc_msg_get_state(self._dc_msg) in (
            const.DC_STATE_OUT_PREPARING,
            const.DC_STATE_OUT_PENDING,
            const.DC_STATE_OUT_FAILED,
@@ -484,6 +487,9 @@ 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/stress_test_db.py
+++ b/python/tests/stress_test_db.py
@@ -18,14 +18,14 @@ def test_db_busy_error(acfactory):

    # make a number of accounts
    accounts = acfactory.get_many_online_accounts(3)
-    log("created %s accounts" % len(accounts))
+    log(f"created {len(accounts)} accounts")

    # put a bigfile into each account
    for acc in accounts:
        acc.bigfile = os.path.join(acc.get_blobdir(), "bigfile")
        with open(acc.bigfile, "wb") as f:
            f.write(b"01234567890" * 1000_000)
-    log("created %s bigfiles" % len(accounts))
+    log(f"created {len(accounts)} bigfiles")

    contact_addrs = [acc.get_self_contact().addr for acc in accounts]
    chat = accounts[0].create_group_chat("stress-group")
--- a/python/tests/test_1_online.py
+++ b/python/tests/test_1_online.py
@@ -1,7 +1,6 @@
 import os
 import queue
 import sys
-import time
 import base64
 from datetime import datetime, timezone

@@ -1344,7 +1343,6 @@ def test_quote_encrypted(acfactory, lp):

    for quoted_msg in msg1, msg3:
        # Save the draft with a quote.
-        # It should be encrypted if quoted message is encrypted.
        msg_draft = Message.new_empty(ac1, "text")
        msg_draft.set_text("message reply")
        msg_draft.quote = quoted_msg
@@ -1358,10 +1356,14 @@ def test_quote_encrypted(acfactory, lp):
        chat.set_draft(None)
        assert chat.get_draft() is None

+        # Quote should be replaced with "..." if quoted message is encrypted.
        msg_in = ac2._evtracker.wait_next_incoming_message()
        assert msg_in.text == "message reply"
-        assert msg_in.quoted_text == quoted_msg.text
-        assert msg_in.is_encrypted() == quoted_msg.is_encrypted()
+        assert not msg_in.is_encrypted()
+        if quoted_msg.is_encrypted():
+            assert msg_in.quoted_text == "..."
+        else:
+            assert msg_in.quoted_text == quoted_msg.text


 def test_quote_attachment(tmp_path, acfactory, lp):
@@ -1493,107 +1495,6 @@ 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)

@@ -2230,17 +2131,21 @@ 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 recreate the account so Trash folder is configured.
+    # 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.
    lp.sec("Creating trash folder")
    ac2.direct_imap.create_folder("Trash")
-    lp.sec("Creating new accounts")
-    ac2 = acfactory.new_online_configuring_account(cloned_from=ac2)
-    acfactory.bring_accounts_online()
-
    ac2.set_config("delete_to_trash", "1")
-    assert ac2.get_config("configured_trash_folder")
+
+    lp.sec("Check that Trash can be configured initially as well")
+    ac3 = 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()
    chat12 = acfactory.get_accepted_chat(ac1, ac2)

    lp.sec("ac1: sending 3 messages")
@@ -2255,6 +2160,9 @@ 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 src/deltachat tests/ examples/
+    ruff check src/deltachat tests/ examples/
    rst-lint --encoding 'utf-8' README.rst

 [testenv:mypy]
@@ -62,7 +62,8 @@ commands =
 [testenv:doc]
 changedir=doc
 deps =
-    sphinx
+# Pinned version, workaround for <https://github.com/breathe-doc/breathe/issues/981>
+    sphinx<7.3
    breathe
    sphinx_rtd_theme
 commands =
--- a/release-date.in
+++ b/release-date.in
@@ -1 +1 @@
-2024-04-05
+2024-04-24
--- a/src/authres.rs
+++ b/src/authres.rs
@@ -6,6 +6,7 @@ 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;
@@ -14,7 +15,6 @@ 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
@@ -698,7 +698,10 @@ fn encode_img(
        ImageOutputFormat::Png => img.write_to(&mut buf, ImageFormat::Png)?,
        ImageOutputFormat::Jpeg { quality } => {
            let encoder = JpegEncoder::new_with_quality(&mut buf, quality);
-            img.write_with_encoder(encoder)?;
+            // Convert image into RGB8 to avoid the error
+            // "The encoder or decoder for Jpeg does not support the color type Rgba8"
+            // (<https://github.com/image-rs/image/issues/2211>).
+            img.clone().into_rgb8().write_with_encoder(encoder)?;
        }
    }
    Ok(())
@@ -740,7 +743,6 @@ 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};
@@ -1206,6 +1208,28 @@ mod tests {
        .unwrap();
    }

+    /// Tests that RGBA PNG can be recoded into JPEG
+    /// by dropping alpha channel.
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn test_recode_image_rgba_png_to_jpeg() {
+        let bytes = include_bytes!("../test-data/image/screenshot-rgba.png");
+
+        send_image_check_mediaquality(
+            Viewtype::Image,
+            Some("1"),
+            bytes,
+            "png",
+            false, // no Exif
+            1920,
+            1080,
+            0,
+            constants::WORSE_IMAGE_SIZE,
+            constants::WORSE_IMAGE_SIZE * 1080 / 1920,
+        )
+        .await
+        .unwrap();
+    }
+
    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
    async fn test_recode_image_huge_jpg() {
        let bytes = include_bytes!("../test-data/image/screenshot.jpg");
@@ -1283,23 +1307,26 @@ mod tests {
        let alice_msg = alice.get_last_msg().await;
        assert_eq!(alice_msg.get_width() as u32, compressed_width);
        assert_eq!(alice_msg.get_height() as u32, compressed_height);
-        check_image_size(
-            alice_msg.get_file(&alice).unwrap(),
-            compressed_width,
-            compressed_height,
-        );
+        let file_saved = alice
+            .get_blobdir()
+            .join("saved-".to_string() + &alice_msg.get_filename().unwrap());
+        alice_msg.save_file(&alice, &file_saved).await?;
+        check_image_size(file_saved, compressed_width, compressed_height);

        let bob_msg = bob.recv_msg(&sent).await;
        assert_eq!(bob_msg.get_viewtype(), Viewtype::Image);
        assert_eq!(bob_msg.get_width() as u32, compressed_width);
        assert_eq!(bob_msg.get_height() as u32, compressed_height);
-        let file = bob_msg.get_file(&bob).unwrap();
+        let file_saved = bob
+            .get_blobdir()
+            .join("saved-".to_string() + &bob_msg.get_filename().unwrap());
+        bob_msg.save_file(&bob, &file_saved).await?;

-        let blob = BlobObject::new_from_path(&bob, &file).await?;
+        let blob = BlobObject::new_from_path(&bob, &file_saved).await?;
        let (_, exif) = blob.metadata()?;
        assert!(exif.is_none());

-        let img = check_image_size(file, compressed_width, compressed_height);
+        let img = check_image_size(file_saved, compressed_width, compressed_height);
        Ok(img)
    }

--- a/src/chat.rs
+++ b/src/chat.rs
@@ -8,6 +8,7 @@ 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;
@@ -15,13 +16,14 @@ 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, ContactAddress, ContactId, Origin};
+use crate::contact::{self, Contact, ContactId, Origin};
 use crate::context::Context;
 use crate::debug_logging::maybe_set_logging_xdc;
 use crate::download::DownloadState;
@@ -43,7 +45,7 @@ use crate::sync::{self, Sync::*, SyncData};
 use crate::tools::{
    buf_compress, create_id, create_outgoing_rfc724_mid, create_smeared_timestamp,
    create_smeared_timestamps, get_abs_path, gm2local_offset, improve_single_line_input,
-    smeared_time, strip_rtlo_characters, time, IsNoneOrEmpty, SystemTime,
+    smeared_time, time, IsNoneOrEmpty, SystemTime,
 };
 use crate::webxdc::WEBXDC_SUFFIX;

@@ -209,24 +211,11 @@ 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::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).
+        if msg.download_state == DownloadState::Undecipherable {
            return None;
        }
        Some(msg.chat_id)
@@ -308,6 +297,8 @@ 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)
    }

@@ -424,6 +415,7 @@ 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.
@@ -446,6 +438,8 @@ 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.
@@ -456,6 +450,7 @@ impl ChatId {
                .log_err(context)
                .ok();
        }
+
        Ok(())
    }

@@ -499,6 +494,7 @@ 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() {
@@ -541,6 +537,7 @@ 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?;
@@ -589,6 +586,7 @@ 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(())
            }
@@ -675,6 +673,8 @@ 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,6 +781,7 @@ impl ChatId {
            .await?;

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

        context
            .set_config_internal(Config::LastHousekeeping, None)
@@ -792,6 +793,7 @@ 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(())
    }
@@ -1172,6 +1174,15 @@ 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,
@@ -1430,7 +1441,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(std::u32::MAX) {
+            if 0 <= val && val <= i64::from(u32::MAX) {
                Ok(ChatId::new(val as u32))
            } else {
                Err(rusqlite::types::FromSqlError::OutOfRange(val))
@@ -1518,7 +1529,7 @@ impl Chat {
                    Ok(contacts) => {
                        if let Some(contact_id) = contacts.first() {
                            if let Ok(contact) = Contact::get_by_id(context, *contact_id).await {
-                                chat_name = contact.get_display_name().to_owned();
+                                contact.get_display_name().clone_into(&mut chat_name);
                            }
                        }
                    }
@@ -2038,6 +2049,7 @@ 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)
@@ -2703,7 +2715,7 @@ async fn send_msg_inner(context: &Context, chat_id: ChatId, msg: &mut Message) -
        }

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

        context.scheduler.interrupt_smtp().await;
@@ -2770,6 +2782,11 @@ 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!(
@@ -2804,15 +2821,21 @@ pub(crate) async fn create_send_msg_jobs(context: &Context, msg: &mut Message) -
        );
    }

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

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

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

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

-    msg.subject = rendered_msg.subject.clone();
+    msg.subject.clone_from(&rendered_msg.subject);
    msg.update_subject(context).await?;
    let chunk_size = context
        .get_configured_provider()
@@ -3101,7 +3124,9 @@ 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
@@ -3128,6 +3153,7 @@ 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(())
 }
@@ -3195,6 +3221,7 @@ 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(())
@@ -3357,6 +3384,8 @@ 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
@@ -3444,11 +3473,14 @@ 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)
 }

@@ -3719,6 +3751,7 @@ 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))
@@ -3879,6 +3912,7 @@ async fn rename_ex(
                sync = Nosync;
            }
            context.emit_event(EventType::ChatModified(chat_id));
+            chatlist_events::emit_chatlist_item_changed(context, chat_id);
            success = true;
        }
    }
@@ -3939,6 +3973,7 @@ 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(())
 }

@@ -4085,6 +4120,8 @@ 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;
        }
@@ -4777,9 +4814,9 @@ mod tests {
        Ok(())
    }

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

        let alice = tcm.alice().await;
@@ -4810,20 +4847,25 @@ 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_simultaneous_member_remove")
+        bob.golden_test_chat(bob_chat_id, "chat_test_parallel_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;

@@ -4860,8 +4902,13 @@ 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(context, &lastmsg, chat, lastcontact.as_ref()).await
+            Summary::new_with_reaction_details(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,6 +6,7 @@ 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};
@@ -13,7 +14,6 @@ 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,6 +356,9 @@ 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 {
@@ -668,7 +671,7 @@ impl Context {
        {
            return Ok(());
        }
-        self.send_sync_msg().await.log_err(self).ok();
+        Box::pin(self.send_sync_msg()).await.log_err(self).ok();
        Ok(())
    }

--- a/src/configure.rs
+++ b/src/configure.rs
@@ -16,6 +16,7 @@ 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};
@@ -23,7 +24,6 @@ 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,8 +35,9 @@ use crate::smtp::Smtp;
 use crate::socks::Socks5Config;
 use crate::stock_str;
 use crate::sync::Sync::*;
-use crate::tools::{time, EmailAddress};
+use crate::tools::time;
 use crate::{chat, e2ee, provider};
+use deltachat_contact_tools::addr_cmp;

 macro_rules! progress {
    ($context:tt, $progress:expr, $comment:expr) => {
@@ -356,8 +357,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 = smtp_server.username.clone();
-            smtp_param.server = smtp_server.hostname.clone();
+            smtp_param.user.clone_from(&smtp_server.username);
+            smtp_param.server.clone_from(&smtp_server.hostname);
            smtp_param.port = smtp_server.port;
            smtp_param.security = smtp_server.socket;
            smtp_param.certificate_checks = match smtp_server.strict_tls {
@@ -403,8 +404,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 = imap_server.username.clone();
-        param.imap.server = imap_server.hostname.clone();
+        param.imap.user.clone_from(&imap_server.username);
+        param.imap.server.clone_from(&imap_server.hostname);
        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,6 +219,10 @@ 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,15 +3,17 @@
 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;
@@ -33,60 +35,12 @@ 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, strip_rtlo_characters, time,
-    EmailAddress, SystemTime,
-};
-use crate::{chat, stock_str};
+use crate::tools::{duration_to_str, get_abs_path, improve_single_line_input, time, SystemTime};
+use crate::{chat, chatlist_events, 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
@@ -760,6 +714,7 @@ 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);
                            }
                        }
                    }
@@ -796,7 +751,9 @@ impl Contact {
            Ok(row_id)
        }).await?;

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

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

-        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 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?;

-            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 Some(peerstate) = peerstate.filter(|peerstate| peerstate.peek_key(false).is_some())
+        else {
+            return Ok(stock_str::encr_none(context).await);
+        };

-                let finger_prints = stock_str::finger_prints(context).await;
-                ret += &format!("{stock_message}.\n{finger_prints}:");
+        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 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;
-            }
+        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, "");
        }

        Ok(ret)
@@ -1415,46 +1369,6 @@ 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,
@@ -1527,6 +1441,7 @@ WHERE type=? AND id IN (
        }
    }

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

@@ -1577,6 +1492,7 @@ 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(())
 }
@@ -1632,6 +1548,7 @@ 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)
@@ -1640,26 +1557,6 @@ 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,
@@ -1683,14 +1580,6 @@ 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>>()
@@ -1762,6 +1651,7 @@ impl RecentlySeenLoop {
            .unwrap_or_default();

        loop {
+            let now = SystemTime::now();
            let (until, contact_id) =
                if let Some((Reverse(timestamp), contact_id)) = unseen_queue.peek() {
                    (
@@ -1787,6 +1677,11 @@ 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();
                        }
                    }
@@ -1804,7 +1699,10 @@ impl RecentlySeenLoop {
                        timestamp,
                    })) => {
                        // Received an interrupt.
-                        unseen_queue.push((Reverse(timestamp + SEEN_RECENTLY_SECONDS), contact_id));
+                        if contact_id != ContactId::UNDEFINED {
+                            unseen_queue
+                                .push((Reverse(timestamp + SEEN_RECENTLY_SECONDS), contact_id));
+                        }
                    }
                }
            } else {
@@ -1816,13 +1714,18 @@ 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 interrupt(&self, contact_id: ContactId, timestamp: i64) {
+    pub(crate) fn try_interrupt(&self, contact_id: ContactId, timestamp: i64) {
        self.interrupt_send
            .try_send(RecentlySeenInterrupt {
                contact_id,
@@ -1831,6 +1734,17 @@ 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();
    }
@@ -1838,6 +1752,8 @@ 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;
@@ -1977,18 +1893,6 @@ 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()
@@ -2804,7 +2708,19 @@ Hi."#;

        bob.recv_msg(&sent_msg).await;
        let contact = Contact::get_by_id(&bob, *contacts.first().unwrap()).await?;
-        assert!(contact.was_seen_recently());
+
+        let green = ansi_term::Color::Green.normal();
+        assert!(
+            contact.was_seen_recently(),
+            "{}",
+            green.paint(
+                "\nNOTE: This test failure is probably a false-positive, caused by tests running in parallel.
+The issue is that `SystemTime::shift()` (a utility function for tests) changes the time for all threads doing tests, and not only for the running test.
+Until the false-positive is fixed:
+- Use `cargo test -- --test-threads 1` instead of `cargo test`
+- Or use `cargo nextest run` (install with `cargo install cargo-nextest --locked`)\n"
+            )
+        );

        let self_contact = Contact::get_by_id(&bob, ContactId::SELF).await?;
        assert!(!self_contact.was_seen_recently());
@@ -2812,6 +2728,44 @@ 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,6 +16,7 @@ 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,
@@ -593,11 +594,32 @@ 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.
@@ -1626,6 +1648,7 @@ 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,6 +64,7 @@ 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::{stock_str, EventType};
+use crate::{chatlist_events, stock_str, EventType};

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

        Ok(())
    }
@@ -507,10 +507,9 @@ 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(&bob, msg.id)
+        assert!(Message::load_from_db_optional(&bob, msg.id)
            .await?
-            .chat_id
-            .is_trash());
+            .is_none());

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

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

        // 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,8 +1,9 @@
 //! # Events specification.

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

+pub(crate) mod chatlist_events;
 mod payload;

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

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

-        Self { receiver, sender }
+        // 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 }
    }

    /// Emits an event into event channel.
    ///
    /// If the channel is full, deletes the oldest event first.
    pub fn emit(&self, event: Event) {
-        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");
-            }
-        }
+        self.sender.try_broadcast(event).ok();
    }

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

@@ -59,30 +60,34 @@ 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
-/// [`Stream`]: futures::stream::Stream
-#[derive(Debug, Clone)]
-#[pin_project]
-pub struct EventEmitter(#[pin] Receiver<Event>);
+#[derive(Debug)]
+pub struct EventEmitter(Mutex<async_broadcast::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> {
-        self.0.recv().await.ok()
+        let mut lock = self.0.lock().await;
+        lock.recv().await.ok()
    }
-}

-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)
+    /// 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)
    }
 }

--- a/src/events/chatlist_events.rs
+++ b/src/events/chatlist_events.rs
@@ -0,0 +1,643 @@
+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 or deleted.
+    /// Contact(s) created, renamed, blocked, deleted or changed their "recently seen" status.
    ///
    /// @param data1 (int) If set, this is the contact_id of an added contact that should be selected.
    ContactsChanged(Option<ContactId>),
@@ -291,4 +291,15 @@ 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
@@ -5,26 +5,29 @@

 use std::{
    cmp::max,
+    cmp::min,
    collections::{BTreeMap, BTreeSet, HashMap},
    iter::Peekable,
    mem::take,
    sync::atomic::Ordering,
-    time::Duration,
+    time::{Duration, UNIX_EPOCH},
 };

 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;
+use rand::Rng;
 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::{normalize_name, Contact, ContactAddress, ContactId, Modifier, Origin};
+use crate::contact::{Contact, ContactId, Modifier, Origin};
 use crate::context::Context;
 use crate::events::EventType;
 use crate::headerdef::{HeaderDef, HeaderDefMap};
@@ -40,7 +43,7 @@ use crate::scheduler::connectivity::ConnectivityStore;
 use crate::socks::Socks5Config;
 use crate::sql;
 use crate::stock_str;
-use crate::tools::{create_id, duration_to_str};
+use crate::tools::{self, create_id, duration_to_str};

 pub(crate) mod capabilities;
 mod client;
@@ -80,15 +83,17 @@ pub(crate) struct Imap {

    pub(crate) connectivity: ConnectivityStore,

-    /// Rate limit for IMAP connection attempts.
+    conn_last_try: tools::Time,
+    conn_backoff_ms: u64,
+
+    /// Rate limit for successful IMAP connections.
    ///
-    /// This rate limit prevents busy loop
-    /// in case the server refuses connections
+    /// This rate limit prevents busy loop in case the server refuses logins
    /// or in case connection gets dropped over and over due to IMAP bug,
    /// e.g. the server returning invalid response to SELECT command
    /// immediately after logging in or returning an error in response to LOGIN command
    /// due to internal server error.
-    ratelimit: RwLock<Ratelimit>,
+    ratelimit: Ratelimit,
 }

 #[derive(Debug)]
@@ -246,8 +251,10 @@ impl Imap {
            strict_tls,
            login_failed_once: false,
            connectivity: Default::default(),
+            conn_last_try: UNIX_EPOCH,
+            conn_backoff_ms: 0,
            // 1 connection per minute + a burst of 2.
-            ratelimit: RwLock::new(Ratelimit::new(Duration::new(120, 0), 2.0)),
+            ratelimit: Ratelimit::new(Duration::new(120, 0), 2.0),
        };

        Ok(imap)
@@ -291,7 +298,15 @@ impl Imap {
            bail!("IMAP operation attempted while it is torn down");
        }

-        let ratelimit_duration = self.ratelimit.read().await.until_can_send();
+        let now = tools::Time::now();
+        let until_can_send = max(
+            min(self.conn_last_try, now)
+                .checked_add(Duration::from_millis(self.conn_backoff_ms))
+                .unwrap_or(now),
+            now,
+        )
+        .duration_since(now)?;
+        let ratelimit_duration = max(until_can_send, self.ratelimit.until_can_send());
        if !ratelimit_duration.is_zero() {
            warn!(
                context,
@@ -314,7 +329,16 @@ impl Imap {

        info!(context, "Connecting to IMAP server");
        self.connectivity.set_connecting(context).await;
-        self.ratelimit.write().await.send();
+
+        self.conn_last_try = tools::Time::now();
+        const BACKOFF_MIN_MS: u64 = 2000;
+        const BACKOFF_MAX_MS: u64 = 80_000;
+        self.conn_backoff_ms = min(self.conn_backoff_ms, BACKOFF_MAX_MS / 2);
+        self.conn_backoff_ms = self.conn_backoff_ms.saturating_add(
+            rand::thread_rng().gen_range((self.conn_backoff_ms / 2)..=self.conn_backoff_ms),
+        );
+        self.conn_backoff_ms = max(BACKOFF_MIN_MS, self.conn_backoff_ms);
+
        let connection_res: Result<Client> =
            if self.lp.security == Socket::Starttls || self.lp.security == Socket::Plain {
                let imap_server: &str = self.lp.server.as_ref();
@@ -362,6 +386,8 @@ impl Imap {
                }
            };
        let client = connection_res?;
+        self.conn_backoff_ms = BACKOFF_MIN_MS;
+        self.ratelimit.send();

        let imap_user: &str = self.lp.user.as_ref();
        let imap_pw: &str = self.lp.password.as_ref();
@@ -388,7 +414,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 = session.capabilities.server_id.clone();
+                lock.clone_from(&session.capabilities.server_id);

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

                    let mut msg = Message::new(Viewtype::Text);
-                    msg.text = message.clone();
+                    msg.text.clone_from(&message);
                    if let Err(e) =
                        chat::add_device_msg_with_importance(context, None, Some(&mut msg), true)
                            .await
@@ -1170,6 +1196,7 @@ 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,9 +89,16 @@ impl Imap {
            Config::ConfiguredSentboxFolder,
            Config::ConfiguredTrashFolder,
        ] {
-            context
-                .set_config_internal(conf, folder_configs.get(&conf).map(|s| s.as_str()))
-                .await?;
+            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;
+            }
        }

        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,7 +32,6 @@ 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;
@@ -194,7 +193,9 @@ pub async fn render_setup_file(context: &Context, passphrase: &str) -> Result<St
        true => Some(("Autocrypt-Prefer-Encrypt", "mutual")),
    };
    let private_key_asc = private_key.to_asc(ac_headers);
-    let encr = pgp::symm_encrypt(passphrase, private_key_asc.as_bytes()).await?;
+    let encr = pgp::symm_encrypt(passphrase, private_key_asc.as_bytes())
+        .await?
+        .replace('\n', "\r\n");

    let replacement = format!(
        concat!(
@@ -285,7 +286,7 @@ pub async fn continue_key_transfer(
        let file = open_file_std(context, filename)?;
        let sc = normalize_setup_code(setup_code);
        let armored_key = decrypt_setup_file(&sc, file).await?;
-        set_self_key(context, &armored_key, true, true).await?;
+        set_self_key(context, &armored_key, true).await?;
        maybe_add_bcc_self_device_msg(context).await?;

        Ok(())
@@ -294,35 +295,32 @@ pub async fn continue_key_transfer(
    }
 }

-async fn set_self_key(
-    context: &Context,
-    armored: &str,
-    set_default: bool,
-    prefer_encrypt_required: bool,
-) -> Result<()> {
+async fn set_self_key(context: &Context, armored: &str, set_default: bool) -> Result<()> {
    // try hard to only modify key-state
    let (private_key, header) = SignedSecretKey::from_asc(armored)?;
    let public_key = private_key.split_public_key()?;
-    let preferencrypt = header.get("Autocrypt-Prefer-Encrypt");
-    match preferencrypt.map(|s| s.as_str()) {
-        Some(headerval) => {
-            let e2ee_enabled = match headerval {
-                "nopreference" => 0,
-                "mutual" => 1,
-                _ => {
-                    bail!("invalid Autocrypt-Prefer-Encrypt header: {:?}", header);
-                }
-            };
-            context
-                .sql
-                .set_raw_config_int("e2ee_enabled", e2ee_enabled)
-                .await?;
-        }
-        None => {
-            if prefer_encrypt_required {
-                bail!("missing Autocrypt-Prefer-Encrypt header");
+    if let Some(preferencrypt) = header.get("Autocrypt-Prefer-Encrypt") {
+        let e2ee_enabled = match preferencrypt.as_str() {
+            "nopreference" => 0,
+            "mutual" => 1,
+            _ => {
+                bail!("invalid Autocrypt-Prefer-Encrypt header: {:?}", header);
            }
-        }
+        };
+        context
+            .sql
+            .set_raw_config_int("e2ee_enabled", e2ee_enabled)
+            .await?;
+    } else {
+        // `Autocrypt-Prefer-Encrypt` is not included
+        // in keys exported to file.
+        //
+        // `Autocrypt-Prefer-Encrypt` also SHOULD be sent
+        // in Autocrypt Setup Message according to Autocrypt specification,
+        // but K-9 6.802 does not include this header.
+        //
+        // We keep current setting in this case.
+        info!(context, "No Autocrypt-Prefer-Encrypt header.");
    };

    let self_addr = context.get_primary_self_addr().await?;
@@ -605,7 +603,7 @@ async fn export_backup_inner(
 async fn import_secret_key(context: &Context, path: &Path, set_default: bool) -> Result<()> {
    let buf = read_file(context, &path).await?;
    let armored = std::string::String::from_utf8_lossy(&buf);
-    set_self_key(context, &armored, set_default, false).await?;
+    set_self_key(context, &armored, set_default).await?;
    Ok(())
 }

@@ -817,20 +815,6 @@ 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;
@@ -840,6 +824,7 @@ mod tests {

    use super::*;
    use crate::pgp::{split_armored_data, HEADER_AUTOCRYPT, HEADER_SETUPCODE};
+    use crate::receive_imf::receive_imf;
    use crate::stock_str::StockMessage;
    use crate::test_utils::{alice_keypair, TestContext, TestContextManager};

@@ -849,15 +834,17 @@ mod tests {
        let msg = render_setup_file(&t, "hello").await.unwrap();
        println!("{}", &msg);
        // Check some substrings, indicating things got substituted.
-        // In particular note the mixing of `\r\n` and `\n` depending
-        // on who generated the strings.
        assert!(msg.contains("<title>Autocrypt Setup Message</title"));
        assert!(msg.contains("<h1>Autocrypt Setup Message</h1>"));
        assert!(msg.contains("<p>This is the Autocrypt Setup Message used to"));
        assert!(msg.contains("-----BEGIN PGP MESSAGE-----\r\n"));
        assert!(msg.contains("Passphrase-Format: numeric9x4\r\n"));
-        assert!(msg.contains("Passphrase-Begin: he\n"));
-        assert!(msg.contains("-----END PGP MESSAGE-----\n"));
+        assert!(msg.contains("Passphrase-Begin: he\r\n"));
+        assert!(msg.contains("-----END PGP MESSAGE-----\r\n"));
+
+        for line in msg.rsplit_terminator('\n') {
+            assert!(line.ends_with('\r'));
+        }
    }

    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
@@ -1173,7 +1160,8 @@ 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;
-        alice.recv_msg(&sent).await;
+        let trashed_message = alice.recv_msg_opt(&sent).await;
+        assert!(trashed_message.is_none());
        assert_ne!(alice.get_last_msg().await.get_text(), "Test");

        // Transfer the key.
@@ -1207,4 +1195,22 @@ mod tests {

        Ok(())
    }
+
+    /// Tests reception of Autocrypt Setup Message from K-9 6.802.
+    ///
+    /// Unlike Autocrypt Setup Message sent by Delta Chat,
+    /// this message does not contain `Autocrypt-Prefer-Encrypt` header.
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn test_key_transfer_k_9() -> Result<()> {
+        let t = &TestContext::new().await;
+        t.configure_addr("autocrypt@nine.testrun.org").await;
+
+        let raw = include_bytes!("../test-data/message/k-9-autocrypt-setup-message.eml");
+        let received = receive_imf(t, raw, false).await?.unwrap();
+
+        let setup_code = "0655-9868-8252-5455-4232-5158-1237-5333-2638";
+        continue_key_transfer(t, *received.msg_ids.last().unwrap(), setup_code).await?;
+
+        Ok(())
+    }
 }
--- a/src/imex/transfer.rs
+++ b/src/imex/transfer.rs
@@ -656,6 +656,12 @@ mod tests {
        let text = fs::read_to_string(&path).await.unwrap();
        assert_eq!(text, "i am attachment");

+        let path = path.with_file_name("saved.txt");
+        msg.save_file(&ctx1, &path).await.unwrap();
+        let text = fs::read_to_string(&path).await.unwrap();
+        assert_eq!(text, "i am attachment");
+        assert!(msg.save_file(&ctx1, &path).await.is_err());
+
        // Check that both received the ImexProgress events.
        ctx0.evtracker
            .get_matching(|ev| matches!(ev, EventType::ImexProgress(1000)))
--- a/src/key.rs
+++ b/src/key.rs
@@ -6,6 +6,7 @@ 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};
@@ -18,7 +19,7 @@ use crate::constants::KeyGenType;
 use crate::context::Context;
 use crate::log::LogExt;
 use crate::pgp::KeyPair;
-use crate::tools::{self, time_elapsed, EmailAddress};
+use crate::tools::{self, time_elapsed};

 /// 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,6 +290,7 @@ 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;
    }
@@ -366,7 +367,7 @@ pub async fn set(context: &Context, latitude: f64, longitude: f64, accuracy: f64
        continue_streaming = true;
    }
    if continue_streaming {
-        context.emit_event(EventType::LocationChanged(Some(ContactId::SELF)));
+        context.emit_location_changed(Some(ContactId::SELF)).await?;
    };

    Ok(continue_streaming)
@@ -456,7 +457,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_event(EventType::LocationChanged(None));
+    context.emit_location_changed(None).await?;
    Ok(())
 }

@@ -802,6 +803,7 @@ 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 = param.imap.password.clone()
+            param.smtp.password.clone_from(&param.imap.password)
        }
        Ok(param)
    }
--- a/src/message.rs
+++ b/src/message.rs
@@ -6,9 +6,11 @@ use std::path::{Path, PathBuf};
 use anyhow::{ensure, format_err, Context as _, Result};
 use deltachat_derive::{FromSql, ToSql};
 use serde::{Deserialize, Serialize};
+use tokio::{fs, io};

 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,
@@ -82,6 +84,16 @@ 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.
@@ -138,6 +150,7 @@ WHERE id=?;
            chat_id,
            msg_id: self,
        });
+        chatlist_events::emit_chatlist_item_changed(context, chat_id);
        Ok(())
    }

@@ -362,7 +375,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(std::u32::MAX) {
+            if 0 <= val && val <= i64::from(u32::MAX) {
                Ok(MsgId::new(val as u32))
            } else {
                Err(rusqlite::types::FromSqlError::OutOfRange(val))
@@ -464,7 +477,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?
-            .context("Message {id} does not exist")?;
+            .with_context(|| format!("Message {id} does not exist"))?;
        Ok(message)
    }

@@ -506,7 +519,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=?;"
+                    " WHERE m.id=? AND chat_id!=3;"
                ),
                (id,),
                |row| {
@@ -593,6 +606,19 @@ impl Message {
        self.param.get_path(Param::File, context).unwrap_or(None)
    }

+    /// Save file copy at the user-provided path.
+    pub async fn save_file(&self, context: &Context, path: &Path) -> Result<()> {
+        let path_src = self.get_file(context).context("No file")?;
+        let mut src = fs::OpenOptions::new().read(true).open(path_src).await?;
+        let mut dst = fs::OpenOptions::new()
+            .write(true)
+            .create_new(true)
+            .open(path)
+            .await?;
+        io::copy(&mut src, &mut dst).await?;
+        Ok(())
+    }
+
    /// If message is an image or gif, set Param::Width and Param::Height
    pub(crate) async fn try_calc_and_set_dimensions(&mut self, context: &Context) -> Result<()> {
        if self.viewtype.has_file() {
@@ -1031,6 +1057,7 @@ impl Message {
        filemime: Option<&str>,
    ) -> Result<()> {
        let blob = BlobObject::create(context, suggested_name, data).await?;
+        self.param.set(Param::Filename, suggested_name);
        self.param.set(Param::File, blob.as_name());
        self.param.set_optional(Param::MimeType, filemime);
        Ok(())
@@ -1100,7 +1127,7 @@ impl Message {
                .get_bool(Param::GuaranteeE2ee)
                .unwrap_or_default()
            {
-                self.param.set(Param::GuaranteeE2ee, "1");
+                self.param.set(Param::ProtectQuote, "1");
            }

            let text = quote.get_text();
@@ -1145,13 +1172,8 @@ 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(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))
-                };
+                let msg = Message::load_from_db_optional(context, msg_id).await?;
+                return Ok(msg);
            }
        }
        Ok(None)
@@ -1532,9 +1554,12 @@ 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)
@@ -1633,9 +1658,7 @@ pub async fn markseen_msgs(context: &Context, msg_ids: Vec<MsgId>) -> Result<()>
        _curr_ephemeral_timer,
    ) in msgs
    {
-        if curr_blocked == Blocked::Not
-            && (curr_state == MessageState::InFresh || curr_state == MessageState::InNoticed)
-        {
+        if curr_state == MessageState::InFresh || curr_state == MessageState::InNoticed {
            update_msg_state(context, id, MessageState::InSeen).await?;
            info!(context, "Seen message {}.", id);

@@ -1647,7 +1670,11 @@ 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.
-            if curr_param.get_bool(Param::WantsMdn).unwrap_or_default()
+            //
+            // 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()
                && curr_param.get_cmd() == SystemMessage::Unknown
            {
                let mdns_enabled = context.get_config_bool(Config::MdnsEnabled).await?;
@@ -1669,6 +1696,7 @@ 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(())
@@ -1729,6 +1757,7 @@ 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(())
 }
@@ -1881,8 +1910,7 @@ 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? {
-            let msg = Message::load_from_db(context, msg_id).await?;
-            if msg.chat_id != DC_CHAT_ID_TRASH {
+            if let Some(msg) = Message::load_from_db_optional(context, msg_id).await? {
                return Ok(Some(msg));
            }
        }
@@ -1987,8 +2015,12 @@ mod tests {
    use num_traits::FromPrimitive;

    use super::*;
-    use crate::chat::{self, marknoticed_chat, ChatItem};
+    use crate::chat::{
+        self, add_contact_to_chat, marknoticed_chat, send_text_msg, ChatItem, ProtectionStatus,
+    };
    use crate::chatlist::Chatlist;
+    use crate::config::Config;
+    use crate::reaction::send_reaction;
    use crate::receive_imf::receive_imf;
    use crate::test_utils as test;
    use crate::test_utils::{TestContext, TestContextManager};
@@ -2011,8 +2043,6 @@ mod tests {

    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
    async fn test_prepare_message_and_send() {
-        use crate::config::Config;
-
        let d = test::TestContext::new().await;
        let ctx = &d.ctx;

@@ -2151,8 +2181,6 @@ mod tests {

    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
    async fn test_quote() {
-        use crate::config::Config;
-
        let d = test::TestContext::new().await;
        let ctx = &d.ctx;

@@ -2185,6 +2213,42 @@ mod tests {
        assert_eq!(quoted_msg.get_text(), msg2.quoted_text().unwrap());
    }

+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn test_unencrypted_quote_encrypted_message() -> Result<()> {
+        let mut tcm = TestContextManager::new();
+
+        let alice = &tcm.alice().await;
+        let bob = &tcm.bob().await;
+
+        let alice_group = alice
+            .create_group_with_members(ProtectionStatus::Unprotected, "Group chat", &[bob])
+            .await;
+        let sent = alice.send_text(alice_group, "Hi! I created a group").await;
+        let bob_received_message = bob.recv_msg(&sent).await;
+
+        let bob_group = bob_received_message.chat_id;
+        bob_group.accept(bob).await?;
+        let sent = bob.send_text(bob_group, "Encrypted message").await;
+        let alice_received_message = alice.recv_msg(&sent).await;
+        assert!(alice_received_message.get_showpadlock());
+
+        // Alice adds contact without key so chat becomes unencrypted.
+        let alice_flubby_contact_id =
+            Contact::create(alice, "Flubby", "flubby@example.org").await?;
+        add_contact_to_chat(alice, alice_group, alice_flubby_contact_id).await?;
+
+        // Alice quotes encrypted message in unencrypted chat.
+        let mut msg = Message::new(Viewtype::Text);
+        msg.set_quote(alice, Some(&alice_received_message)).await?;
+        chat::send_msg(alice, alice_group, &mut msg).await?;
+
+        let bob_received_message = bob.recv_msg(&alice.pop_sent_msg().await).await;
+        assert_eq!(bob_received_message.quoted_text().unwrap(), "...");
+        assert_eq!(bob_received_message.get_showpadlock(), false);
+
+        Ok(())
+    }
+
    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
    async fn test_get_chat_id() {
        // Alice receives a message that pops up as a contact request
@@ -2478,6 +2542,24 @@ 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,7 +93,6 @@ 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
@@ -614,8 +613,6 @@ 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);
@@ -623,8 +620,6 @@ impl<'a> MimeFactory<'a> {
                    "List-ID".into(),
                    format!("{encoded_chat_name} <{}>", chat.grpid),
                ));
-            } else if chat.typ == Chattype::Group {
-                is_group = true;
            }
        }

@@ -674,19 +669,19 @@ impl<'a> MimeFactory<'a> {

        let mut is_gossiped = false;

-        let (main_part, parts) = match self.loaded {
-            Loaded::Message { .. } => {
-                self.render_message(context, &mut headers, &grpimage)
-                    .await?
-            }
-            Loaded::Mdn { .. } => (self.render_mdn(context).await?, Vec::new()),
-        };
-
        let peerstates = self.peerstates_for_recipients(context).await?;
        let should_encrypt =
            encrypt_helper.should_encrypt(context, e2ee_guaranteed, &peerstates)?;
        let is_encrypted = should_encrypt && !force_plaintext;

+        let (main_part, parts) = match self.loaded {
+            Loaded::Message { .. } => {
+                self.render_message(context, &mut headers, &grpimage, is_encrypted)
+                    .await?
+            }
+            Loaded::Mdn { .. } => (self.render_mdn(context).await?, Vec::new()),
+        };
+
        let message = if parts.is_empty() {
            // Single part, render as regular message.
            main_part
@@ -896,7 +891,6 @@ 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,
@@ -966,6 +960,7 @@ impl<'a> MimeFactory<'a> {
        context: &Context,
        headers: &mut MessageHeaders,
        grpimage: &Option<String>,
+        is_encrypted: bool,
    ) -> Result<(PartBuilder, Vec<PartBuilder>)> {
        let chat = match &self.loaded {
            Loaded::Message { chat } => chat,
@@ -1227,6 +1222,16 @@ impl<'a> MimeFactory<'a> {
            .msg
            .quoted_text()
            .map(|quote| format_flowed_quote(&quote) + "\r\n\r\n");
+        if !is_encrypted
+            && self
+                .msg
+                .param
+                .get_bool(Param::ProtectQuote)
+                .unwrap_or_default()
+        {
+            // Message is not encrypted but quotes encrypted message.
+            quoted_text = Some("> ...\r\n\r\n".to_string());
+        }
        if quoted_text.is_none() && final_text.starts_with('>') {
            // Insert empty line to avoid receiver treating user-sent quote as topquote inserted by
            // Delta Chat.
@@ -1588,18 +1593,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::{
-        self, add_contact_to_chat, create_group_chat, remove_contact_from_chat, send_text_msg,
+        add_contact_to_chat, create_group_chat, remove_contact_from_chat, send_text_msg, ChatId,
        ProtectionStatus,
    };
    use crate::chatlist::Chatlist;
    use crate::constants;
-    use crate::contact::{ContactAddress, Origin};
+    use crate::contact::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,6 +6,7 @@ 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;
@@ -15,8 +16,8 @@ use crate::aheader::{Aheader, EncryptPreference};
 use crate::blob::BlobObject;
 use crate::chat::{add_info_msg, ChatId};
 use crate::config::Config;
-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::constants::{self, Chattype, DC_DESIRED_TEXT_LINES, DC_DESIRED_TEXT_LINE_LEN};
+use crate::contact::{Contact, ContactId, Origin};
 use crate::context::Context;
 use crate::decrypt::{
    keyring_from_peerstate, prepare_decryption, try_decrypt, validate_detached_signature,
@@ -32,13 +33,11 @@ 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,
-    strip_rtlo_characters, truncate_by_lines,
+    create_smeared_timestamp, get_filemeta, parse_receive_headers, smeared_time, truncate_by_lines,
 };
-use crate::{location, tools};
+use crate::{chatlist_events, location, stock_str, tools};

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

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

-        if parser.mdn_reports.is_empty() {
+        if parser.mdn_reports.is_empty() && parser.webxdc_status_update.is_none() {
            // "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())
@@ -602,7 +603,7 @@ impl MimeMessage {
                let mut filepart = self.parts.swap_remove(1);

                // insert new one
-                filepart.msg = self.parts[0].msg.clone();
+                filepart.msg.clone_from(&self.parts[0].msg);
                if let Some(quote) = self.parts[0].param.get(Param::Quote) {
                    filepart.param.set(Param::Quote, quote);
                }
@@ -661,32 +662,34 @@ impl MimeMessage {
            self.squash_attachment_parts();
        }

-        if let Some(ref subject) = self.get_subject() {
-            let mut prepend_subject = true;
-            if !self.decrypting_failed {
-                let colon = subject.find(':');
-                if colon == Some(2)
-                    || colon == Some(3)
-                    || self.has_chat_version()
-                    || subject.contains("Chat:")
-                {
-                    prepend_subject = false
+        if !context.get_config_bool(Config::Bot).await? {
+            if let Some(ref subject) = self.get_subject() {
+                let mut prepend_subject = true;
+                if !self.decrypting_failed {
+                    let colon = subject.find(':');
+                    if colon == Some(2)
+                        || colon == Some(3)
+                        || self.has_chat_version()
+                        || subject.contains("Chat:")
+                    {
+                        prepend_subject = false
+                    }
                }
-            }

-            // For mailing lists, always add the subject because sometimes there are different topics
-            // and otherwise it might be hard to keep track:
-            if self.is_mailinglist_message() && !self.has_chat_version() {
-                prepend_subject = true;
-            }
+                // For mailing lists, always add the subject because sometimes there are different topics
+                // and otherwise it might be hard to keep track:
+                if self.is_mailinglist_message() && !self.has_chat_version() {
+                    prepend_subject = true;
+                }

-            if prepend_subject && !subject.is_empty() {
-                let part_with_text = self
-                    .parts
-                    .iter_mut()
-                    .find(|part| !part.msg.is_empty() && !part.is_reaction);
-                if let Some(part) = part_with_text {
-                    part.msg = format!("{} – {}", subject, part.msg);
+                if prepend_subject && !subject.is_empty() {
+                    let part_with_text = self
+                        .parts
+                        .iter_mut()
+                        .find(|part| !part.msg.is_empty() && !part.is_reaction);
+                    if let Some(part) = part_with_text {
+                        part.msg = format!("{} – {}", subject, part.msg);
+                    }
                }
            }
        }
@@ -2151,6 +2154,8 @@ 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(())
 }
@@ -3930,4 +3935,31 @@ Content-Disposition: reaction\n\

        Ok(())
    }
+
+    /// Tests that subject is not prepended to the message
+    /// when bot receives it.
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn test_bot_no_subject() {
+        let context = TestContext::new().await;
+        context.set_config(Config::Bot, Some("1")).await.unwrap();
+        let raw = br#"Message-ID: <foobar@example.org>
+From: foo <foo@example.org>
+Subject: Some subject
+To: bar@example.org
+MIME-Version: 1.0
+Content-Type: text/plain; charset=utf-8
+
+/help
+"#;
+
+        let message = MimeMessage::from_bytes(&context.ctx, &raw[..], None)
+            .await
+            .unwrap();
+        assert_eq!(message.get_subject(), Some("Some subject".to_string()));
+
+        assert_eq!(message.parts.len(), 1);
+        assert_eq!(message.parts[0].typ, Viewtype::Text);
+        // Not "Some subject – /help"
+        assert_eq!(message.parts[0].msg, "/help");
+    }
 }
--- a/src/param.rs
+++ b/src/param.rs
@@ -48,6 +48,11 @@ pub enum Param {
    /// For Messages: message is encrypted, outgoing: guarantee E2EE or the message is not send
    GuaranteeE2ee = b'c',

+    /// For Messages: quoted message is encrypted.
+    ///
+    /// If this message is sent unencrypted, quote text should be replaced.
+    ProtectQuote = b'0',
+
    /// For Messages: decrypted with validation errors or without mutual set, if neither
    /// 'c' nor 'e' are preset, the messages is only transport encrypted.
    ErroneousE2ee = b'e',
@@ -187,6 +192,12 @@ 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,6 +3,7 @@
 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};
@@ -10,14 +11,14 @@ use crate::chat::{self, Chat};
 use crate::chatlist::Chatlist;
 use crate::config::Config;
 use crate::constants::Chattype;
-use crate::contact::{addr_cmp, Contact, ContactAddress, Origin};
+use crate::contact::{Contact, 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::stock_str;
+use crate::{chatlist_events, stock_str};

 /// Type of the public key stored inside the peerstate.
 #[derive(Debug)]
@@ -722,6 +723,9 @@ 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(())
    }

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

        let old_addr = mem::take(&mut peerstate.addr);
-        peerstate.addr = info.from.clone();
+        peerstate.addr.clone_from(&info.from);
        let header = info.autocrypt_header.as_ref().context(
            "Internal error: Tried to do an AEAP transition without an autocrypt header??",
        )?;
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Simon Laux	eb89acb70a	fix exports variable (nodejs/npm said it must start with `./`)	2024-04-30 01:36:22 +02:00
link2xt	b607f12b0e	build(node): migrate from CommonJS to ESM modules	2024-04-27 06:36:10 +00:00
link2xt	94dc65c1a2	refactor(python): fix ruff 0.4.2 warnings	2024-04-25 20:45:54 +00:00
link2xt	4fe7fa3148	fix: never prepend subject to message text when bot receives it	2024-04-25 12:15:54 +00:00
link2xt	4cf923ccb9	fix: do not fail to send encrypted quotes to unencrypted chats Replace quote text with "..." instead.	2024-04-25 09:00:49 +00:00
iequidoo	56b86adf18	api: Add dc_msg_save_file() which saves file copy at the provided path (#4309 ) ... and fails if file already exists. The UI should open the file saving dialog, defaulting to Downloads and original filename, when asked to save the file. After confirmation it should call dc_msg_save_file().	2024-04-24 16:38:25 -03:00
iequidoo	cfccee2ad4	fix: Message::set_file_from_bytes(): Set Param::Filename	2024-04-24 16:38:25 -03:00
Hocuri	37d92e3fa5	test: Explain test_was_seen_recently false-positive and give workaround instructions (#5474 ) Until the issue is fixed, keep others from running into the same issue.	2024-04-24 14:55:15 +00:00
link2xt	a1ee2b463f	chore(release): prepare for 1.137.4	2024-04-24 11:10:25 +00:00
link2xt	8df3b1bb1b	fix: use only CRLF in Autocrypt Setup Message	2024-04-24 01:50:28 +00:00
iequidoo	22f240dd4d	feat: Add progressive backoff for failing IMAP connection attempts (#5443 ) This way we avoid an immediate retry if the network is not yet ready exhausting the ratelimiter's quota of two connection attempts. Also notify the ratelimiter only after a successful connection so that it only limits the server load, but not connection attempts.	2024-04-23 22:00:47 -03:00
iequidoo	ae10ed5c40	refactor: Imap: remove `RwLock` from `ratelimit`	2024-04-23 22:00:47 -03:00
link2xt	aff6bf9402	fix: convert images to RGB8 (without alpha) before encoding into JPEG Otherwise an error "The encoder or decoder for Jpeg does not support the color type `Rgba8`" is returned if image has an alpha channel. This is caused by the recent change of JPEG encoder in `image` crate: <https://github.com/image-rs/image/issues/2211>	2024-04-23 23:37:58 +00:00
link2xt	43fc55e542	test: test recoding RGBA image	2024-04-23 23:37:58 +00:00
link2xt	7ea05cb8a0	test: add screenshot-rgba.png Created by `convert -alpha deactivate screenshot.png screenshot-rbga.png`.	2024-04-23 23:37:58 +00:00
link2xt	d036ad5853	fix: do not fail if Autocrypt Setup Message has no encryption preference According to Autocrypt specification Autocrypt Setup Message SHOULD contain Autocrypt-Prefer-Encrypt header, but K-9 6.802 does not include it.	2024-04-23 22:16:54 +00:00
link2xt	e9280b8413	refactor: group `use` at the top of the test modules	2024-04-23 21:07:50 +00:00
link2xt	2108a8ba94	fix(node): undefine NAPI_EXPERIMENTAL This fixes build with new clang which treats -Wincompatible-function-pointer-types as an error. Related upstream issue: <https://github.com/nodejs/node/issues/52229>	2024-04-23 11:34:03 +00:00
link2xt	34f4ec02f6	feat: replace event channel with broadcast channel This makes `EventTracker` receive events immediately instead of being moved from event emitter to event tracker by a task spawned from `TestContext::new_internal`. This makes `EventTracker.clear_events` reliable as it is guaranteed to remove all events emitted by the time it is called rather than only events that have been moved already.	2024-04-22 07:44:21 +00:00
link2xt	72d5a387fb	api!: remove Stream implementation for EventEmitter	2024-04-22 07:44:21 +00:00
link2xt	d17d89ea8f	fix: mark contact request messages as seen on IMAP	2024-04-21 02:17:52 +00:00
link2xt	d2aa76c0ca	refactor(deltachat-ffi): remove ResultNullableExt	2024-04-20 21:04:01 +00:00
link2xt	406031773b	docs: update references to SecureJoin protocols	2024-04-20 20:17:56 +02:00
bjoern	242547f1e9	feat: experimental Webxdc Integration API, Maps Integration (#5461 ) as discussed in several chats, this PR starts making it possible to use Webxdc as integrations to the main app. In other word: selected parts of the main app can be integrated as Webxdc, eg. Maps [^1] this PR contains two parts: - draft an Webxdc Integration API - use the Webxdc Integration API to create a Maps Integration to be clear: a Webxdc is not part of this PR. the PR is about marking a Webxdc being used as a Map - and core then feeds the Webxdc with location data. from the view of the Webxdc, the normal `sendUpdate()`/`setUpdateListener()` is used. things are still marked as "experimental", idea is to get that in to allow @adbenitez and @nicodh to move forward on the integrations into android and desktop, as well as improving the maps.xdc itself. good news is that we currently can change the protocol between Webxdc and core at any point :) # Webxdc Integration API see `dc_init_webxdc_integration()` in `deltachat.h` for overview and documentation. rust code is mostly in `webxdc/integration.rs` that is called by other places as needed. current [user of the API is deltachat-ios](https://github.com/deltachat/deltachat-ios/pull/1912), android/desktop will probably follow. the jsonrpc part is missing and can come in another PR when things are settled and desktop is really starting [^2] (so we won't need to do all iterations twice :) makes also sense, when this is done by someone actually trying that out on desktop while the API is prepared to allow other types of integrations (photo editor, compose tools ...) internally, we currently ignore the type. if that gets more crazy, we probably also need a dedicated table for the integrations and not just a single param. # Maps Integration rust code is mostly in `webxdc/maps_integration.rs` that is called by `webxdc/integration.rs` as needed. EDIT: the idea of having a split here, is that `webxdc/maps_integration.rs` really can focus on the json part, on the communication with the .xdc, including tests this PR is basic implementation, enabling to move forward on integrations on iOS, but also on desktop and android. the current implementation allows already the following: - global and per-chat maps - add and display POIs - show positions and tracks of the last 24 hours the current maps.xdc uses leaflet, and is in some regards better than the current android/desktop implementations (much faster, show age of positions, fade out positions, always show names of POIs, clearer UI). however, we are also not bound to leaflet, it can be anything > [screenshots of the current state](https://github.com/deltachat/deltachat-ios/pull/1912) > 👆 to move forward faster and to keep this PR small, the following will go to a subsequent PR: - consider allowing webxdc to use a different timewindow for the location - delete POIs - jsonrpc [^1]: maps are a good example as anyways barely native (see android app), did cause a lot of pain on many levels in the past (technically, bureaucratically), and have a comparable simple api [^2]: only going for jsonrpc would only make sense if large parts of android/ios would use jsonrpc, we're not there --------- Co-authored-by: link2xt <link2xt@testrun.org>	2024-04-20 18:09:35 +02:00
link2xt	f43f5c6c0f	build(nix): add ./deltachat-contact-tools to sources	2024-04-20 06:01:53 +00:00
link2xt	910e4bfa37	docs: fix broken references in documentation comments	2024-04-20 05:57:26 +00:00
link2xt	ecf4e651ee	bulid(nix): update nix flake	2024-04-20 05:56:34 +00:00
link2xt	7b724fa75a	build(nix): add imap-tools as deltachat-rpc-client dependency	2024-04-20 05:56:26 +00:00
link2xt	09776ae71c	chore(deps): update rustls to 0.21.11	2024-04-20 05:35:26 +00:00
iequidoo	47bea5f8fb	feat(ffi): Warning instead of error if dc_get_msg() could not retrieve message As trashed messages can't be loaded from the db now by `Message::load_from_db()` returning an error for such messages, errors from `Message::load_from_db()` should be logged as warnings. If it's really an error like a db failure, it should be logged internally.	2024-04-20 05:33:56 +00:00
iequidoo	99cd6d10da	fix(python): _map_ffi_event: Always check if get_message_by_id() returned None As trashed messages can't be loaded from the db now, `get_message_by_id()` returns None in some tests e.g. in `test_deleted_msgs_dont_reappear()`. A `PerAccount` hook shouldn't be called if so.	2024-04-20 05:33:56 +00:00
iequidoo	fae4cb33bc	fix(python): Message::is_outgoing: Don't reload message from db There's no need to load an updated message state from the db to implement `is_outgoing()` and also this function is implicitly called in some tests where a message is already trashed and a call to `dc_get_msg()` generates an unexpected error.	2024-04-20 05:33:56 +00:00
iequidoo	7a3be74350	fix(python): Use cached message object if dc_get_msg() returns NULL Particularly, in _msgstate() and download_state(). If the message has been trashed, dc_get_msg() returns NULL now.	2024-04-20 05:33:56 +00:00
link2xt	20a64ec357	refactor: remove duplicate clippy exceptions	2024-04-20 03:04:24 +00:00
iequidoo	92bf48684a	fix: Don't set is_bot for webxdc status updates (#5445 ) Webxdc status update messages are always "Auto-Submitted: auto-generated", so they must be excluded for is_bot flag calculation.	2024-04-18 23:19:34 -03:00
link2xt	17701b78d6	chore(release): prepare for 1.137.3	2024-04-18 02:33:34 +00:00
link2xt	ff0d506c95	ci: allow older versions of Sphinx than 7.2.6 Version 7.2.6 does not supported by older Python.	2024-04-18 02:32:37 +00:00
link2xt	8ff3f08c2f	test: make EventTracker.clear_events() reliable	2024-04-18 02:32:37 +00:00
link2xt	7a32bcc1f4	test: fix flaky chatlist_events test test_update_after_ephemeral_messages Previously test did not trigger deletion of ephemeral messages and worked because clear_events() did not remove just emitted events from `send_text_msg`.	2024-04-18 02:32:37 +00:00
link2xt	65822e53e6	build(python): pin `sphinx` version	2024-04-17 11:54:45 +00:00
Simon Laux	ac508a9e9c	replace tokio sleep with `SystemTime::shift`	2024-04-17 10:29:53 +00:00
Simon Laux	225112a8fe	fix test events::chatlist_events::test_chatlist_events::test_secure_join_group	2024-04-17 10:29:53 +00:00
Hocuri	5d34b225b7	Split off functional contact tools into its own crate (#5444 ) I would like to implement https://github.com/deltachat/deltachat-core-rust/issues/5422 in its own crate, but it will depend on some functions that are in the `deltachat` crate. So, this PR extracts these functions into its own crate so that I can add https://github.com/deltachat/deltachat-core-rust/issues/5422 into the new crate.	2024-04-16 19:01:25 +02:00
link2xt	6ca6a439bd	test(node): increase 'static tests' timeout to 5 minutes It keeps timing out with the default timeout of 2 s on macOS runners. Also fix comment in the integration test which said that timeout is 1 minute but sets it to 3 minutes. Set this timeout to 5 minutes as well.	2024-04-16 10:08:00 +00:00
Simon Laux	f9465f7512	api: add `ChatListChanged` and `ChatListItemChanged` events (#4476 )	2024-04-15 22:35:19 +00:00
link2xt	489eae5d66	fix: format error context in Message::load_from_db	2024-04-14 20:40:27 +00:00
link2xt	b6c6a63a39	refactor: do not check for is_trash() in get_last_reaction_if_newer_than() `Message::load_from_db_optional` does not return trashed messages anymore.	2024-04-14 18:46:40 +00:00
link2xt	c069190b68	api: don't load trashed messages with Message::load_from_db API now pretends that trashed messages don't exist. This way callers don't have to check if loaded message belongs to trash chat. If message may be trashed by the time it is attempted to be loaded, callers should use Message::load_from_db_optional. Most changes are around receive_status_update() function because previously it relied on loading trashed status update messages immediately after adding them to the database.	2024-04-14 17:43:41 +00:00
Hocuri	94ac2b1097	ci: Run doc tests with cargo test --workspace --doc (#5459 ) Nextest doesn't run doc tests, so we need to run them with `cargo test --workspace --doc`. See https://github.com/nextest-rs/nextest/issues/16 Follow-up for #5457	2024-04-14 18:54:20 +02:00
link2xt	6080a52024	chore(cargo): update brotli from 4 to 5	2024-04-13 18:27:26 +00:00
link2xt	0aea7d1e02	fix: do not create ad-hoc groups from partial downloads	2024-04-12 01:19:16 +00:00
link2xt	08cbc54c00	fix: assign messages to chats based on not fully downloaded references	2024-04-12 01:19:16 +00:00
link2xt	9731ec419e	build(nix): use stable Rust in flake.nix devshell This way nightly clippy warnings are not generated when devshell is used. Nighly Rust is also not cached, e.g. rust-analyzer has to be rebuilt if version from fenix is used.	2024-04-11 22:25:06 +00:00
iequidoo	e9cfcd9d1b	fix: Don't try to do fetch_move_delete() if Trash is needed but not yet configured This fixes things for Gmail f.e. Before, `Imap::fetch_move_delete()` was called before looking for Trash and returned an error because of that failing the whole `fetch_idle()` which prevented configuring Trash in turn.	2024-04-10 21:06:43 -03:00
link2xt	d39cbcdc8d	ci: use cargo-nextest instead of cargo-test	2024-04-10 23:57:43 +00:00
link2xt	fbbefe6b49	chore: fix nightly clippy warnings	2024-04-10 15:41:48 +00:00
Sebastian Klähn	bab311730c	ci: typos in ci files (#5453 )	2024-04-10 15:20:48 +02:00
Sebastian Klähn	b47cad7e68	refactore: use clone_from() (#5451 ) `a.clone_from(&b)` is equivalent to `a = b.clone()` in functionality, but can be overridden to reuse the resources of a to avoid unnecessary allocations.	2024-04-10 15:01:11 +02:00
link2xt	a3b62b9743	fix(deltachat-rpc-client): construct Thread with `target` keyword argument `run` argument does not exist. Also add `daemon=True`.	2024-04-09 05:55:38 +00:00
link2xt	9aa4c0e56b	refactor(deltachat-rpc-client): use `list`, `set` and `tuple` instead of `typing` `typing.List` is deprecated according to https://docs.python.org/3/library/typing.html#typing.List Similar for `Set` and `Dict`. `from __future__ import annotations` is for compatibility with Python 3.7.	2024-04-09 00:56:10 +00:00
Lothar	27d2b12e8d	Adapt target install path if env var CARGO_BUILD_TARGET is set When the env var CARGO_BUILD_TARGET is set, cargo will crossbuild for the given arch triplet. In this case, the targets will not be put into target/release/, but target/$CARGO_BUILD_TARGET/release/. Add this subdirectory, if neccessary.	2024-04-08 20:07:20 +00:00
link2xt	c1148e4117	chore(cargo): update env_logger	2024-04-08 19:44:35 +00:00
B. Petersen	295f7a291b	api!: remove reactions ffi; all implementations use jsonrpc	2024-04-08 19:11:16 +00:00
link2xt	2be28f1311	test: move reaction tests to JSON-RPC	2024-04-08 19:11:16 +00:00
link2xt	2e42243de8	feat: port direct_imap.py into deltachat-rpc-client	2024-04-08 19:11:16 +00:00
link2xt	00f2585d8c	api(deltachat-rpc-client): add ACFactory.get_accepted_chat()	2024-04-08 19:11:16 +00:00
link2xt	0b73f9cebd	api(deltachat-rpc-client): add Account.bring_online()	2024-04-08 19:11:16 +00:00
link2xt	f5e8a04fd0	api(deltachat-rpc-client): return Message from Message.send_reaction()	2024-04-08 19:11:16 +00:00
link2xt	6721df7d57	api(deltachat-rpc-client): add Account.wait_for_reactions_changed()	2024-04-08 19:11:16 +00:00
link2xt	18d98d643b	api(deltachat-rpc-client): add Chat.send_file()	2024-04-08 19:11:16 +00:00
link2xt	62758658ed	api(deltachat-rpc-client): add Message.wait_until_delivered()	2024-04-08 19:11:16 +00:00
link2xt	03bb751a9b	api(deltachat-rpc-client): add Account.create_chat()	2024-04-08 19:11:16 +00:00
link2xt	3ebb1ea95f	chore(cargo): require tokio 1.37 and chrono 0.4.37 Make deps.rs happy about RUSTSEC-2020-0159 and RUSTSEC-2023-0001	2024-04-08 16:39:30 +00:00
iequidoo	c1d251010f	fix: Keep webxdc instance for delete_device_after period after a status update (#5365 ) If `delete_device_after` is configured, that period should be counted for webxdc instances from the last status update, otherwise nothing prevents from deleting them. Use `msgs.timestamp_rcvd` to store the last status update timestamp, it anyway isn't used for anything except displaying a detailed message info. Also, as `ephemeral::select_expired_messages()` now also checks `timestamp_rcvd`, we have an improvement that a message is guaranteed not to be deleted for the `delete_device_after` period since its receipt. Before only the sort timestamp was checked which is derived from the "sent" timestamp.	2024-04-07 22:08:48 -03:00
iequidoo	7e5959e495	test: display_chat(): Don't add day markers Otherwise golden_test_chat() fails when run around midnight.	2024-04-07 21:03:33 -03:00
iequidoo	823da56f2d	fix: Add tolerance to MemberListTimestamp (#5366 ) Let's add a 1-minute tolerance to `Params::MemberListTimestamp`. This adds to the group membership consistency algo the following properties: - If remote group membership changes were made by two members in parallel, both of them are applied, no matter in which order the messages are received. - If we remove a member locally, only explicit remote member additions/removals made in parallel are allowed, but not the synchronisation of the member list from "To". Before, if somebody managed to reply earlier than receiving our removal of a member, we added it back which doesn't look good.	2024-04-07 21:03:33 -03:00
link2xt	5bcc44ca9b	chore: use `ruff check` instead of `ruff` `ruff` without `check` is deprecated.	2024-04-07 19:57:05 +00:00
link2xt	4304e3f0be	chore(cargo): require tokio 1.37.0 Make deps.rs happy about RUSTSEC-2023-0001	2024-04-07 19:18:44 +00:00
link2xt	e2e3abdf03	chore(cargo): update base64 to 0.22	2024-04-07 19:16:44 +00:00
link2xt	dcea188b62	chore(cargo): require smallvec 1.13.2 Make deps.rs happy about RUSTSEC-2021-0003	2024-04-07 19:12:34 +00:00
link2xt	5cf725a378	chore(cargo): require kamadak-exif 0.5.3 Make deps.rs happy about RUSTSEC-2021-0143	2024-04-07 19:09:58 +00:00
link2xt	2bf0ea9d91	docs: add deps.rs badge	2024-04-07 19:06:42 +00:00
B. Petersen	1df936aeac	add 'Ubuntu Touch' to the list of 'frontend projects'	2024-04-07 16:20:45 +00:00
link2xt	9ab2c6df16	fix(deltachat-jsonrpc): block in `inner_get_backup_qr` This change avoids the race between `provide_backup` changing the state from NoProvider to Pending and a call to `get_backup_qr` or `get_backup_qr_svg`. With this change `get_backup_qr` and `get_backup_qr_svg` always block until QR code is available, even if `provide_backup` was not called yet.	2024-04-07 14:20:39 +00:00
link2xt	cf11741a8c	refactor: do not ignore Contact::get_by_id errors in get_encrinfo	2024-04-07 10:12:17 +00:00
iequidoo	b6a12e3914	fix: Fix emitting ContactsChanged events on "recently seen" status change (#5377 ) - Always emit `ContactsChanged` from `contact::update_last_seen()` if a contact was seen recently just for simplicity and symmetry with `RecentlySeenLoop::run()` which also may emit several events for single contact. - Fix sleep time calculation in `RecentlySeenLoop::run()` -- `now` must be updated on every iteration, before the initial value was used every time which led to progressively long sleeps.	2024-04-06 18:21:12 -03:00
B. Petersen	b753440a68	fix: Message::get_summary() must not return reaction summary	2024-04-06 20:16:18 +02:00
B. Petersen	39abc8344c	add a test for Message::get_summary()	2024-04-06 20:16:18 +02:00
@@ -1 +1 @@
 -04-05
 -04-24