fix: Remove unsigned Chat-* headers from Autocrypt-encrypted messages

This fixes e.g. a case when the server injects a "Chat-Version" IMF header tricking Delta Chat into thinking that it's a chat message. The test checks this for some nonexistent "Chat-*" header to protect the code from future breakages.
2026-05-17 22:06:33 +03:00 · 2025-03-13 22:31:45 -03:00
50 changed files with 981 additions and 992 deletions
--- a/.github/workflows/jsonrpc.yml
+++ b/.github/workflows/jsonrpc.yml
@@ -37,6 +37,9 @@ jobs:
        run: npm run test
        env:
          CHATMAIL_DOMAIN: ${{ vars.CHATMAIL_DOMAIN }}
+      - name: make sure websocket server version still builds
+        working-directory: deltachat-jsonrpc
+        run: cargo build --bin deltachat-jsonrpc-server --features webserver
      - name: Run linter
        working-directory: deltachat-jsonrpc/typescript
        run: npm run prettier:check
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,56 +1,5 @@
 # Changelog

-## [1.157.3] - 2025-03-19
-
-### API-Changes
-
- jsonrpc: Add `copy_to_blob_dir` api ([#6660](https://github.com/chatmail/core/pull/6660)).
- Add "delete_for_all" function in json-rpc ([#6672](https://github.com/chatmail/core/pull/6672)).
- Sketch add_transport_from_qr(), add_transport(), list_transports(), delete_transport() APIs ([#6589](https://github.com/chatmail/core/pull/6589)).
-
-### Build system
-
- Remove websocket support from deltachat-jsonrpc.
- Remove encoded-words dependency.
-
-### Fixes
-
- Never send empty `To:` header ([#6663](https://github.com/chatmail/core/pull/6663)).
- Use protected `Date` header for signed messages.
- Fix setting up a profile and immediately transferring to a second device ([#6657](https://github.com/chatmail/core/pull/6657)).
- Don't SMTP-send self-only messages if DeleteServerAfter is "immediate" ([#6661](https://github.com/chatmail/core/pull/6661)).
- Use protected `Date` with protected Autocrypt.
-
-### Miscellaneous Tasks
-
- cargo: Bump uuid from 1.12.1 to 1.15.1.
- Update `strum` dependency.
-
-### Refactor
-
- deltachat-rpc-client: Use wait_for_event() type argument.
-
-### Tests
-
- Avoid creating contacts in `test_sync_{accept,block}_before_first_msg()`.
- Fix `test_no_old_msg_is_fresh` flakiness.
-
-## [1.157.2] - 2025-03-15
-
-### Fixes
-
- Prefer hidden Message-ID header if any.
- Update async-compression to 0.4.21 to fix IMAP COMPRESS getting stuck.
-
-### Refactor
-
- Extract handle_edit_delete() function for message edit/delete  ([#6664](https://github.com/chatmail/core/pull/6664)).
-
-### Tests
-
- test_secure_join: Bob should not create a 1:1 chat before sending a message.
- Return chat ID from TestContext.exec_securejoin_qr().
-
 ## [1.157.1] - 2025-03-13

 ### Miscellaneous Tasks
@@ -6049,5 +5998,3 @@ https://github.com/chatmail/core/pulls?q=is%3Apr+is%3Aclosed
 [1.156.3]: https://github.com/chatmail/core/compare/v1.156.2..v1.156.3
 [1.157.0]: https://github.com/chatmail/core/compare/v1.156.3..v1.157.0
 [1.157.1]: https://github.com/chatmail/core/compare/v1.157.0..v1.157.1
-[1.157.2]: https://github.com/chatmail/core/compare/v1.157.1..v1.157.2
-[1.157.3]: https://github.com/chatmail/core/compare/v1.157.2..v1.157.3
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -125,12 +125,54 @@ version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299"

+[[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.96"
@@ -241,9 +283,9 @@ dependencies = [

 [[package]]
 name = "async-compression"
-version = "0.4.21"
+version = "0.4.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0cf008e5e1a9e9e22a7d3c9a4992e21a350290069e36d8fb72304ed17e8f2d2"
+checksum = "df895a515f70646414f4b45c0b79082783b80552b373a68283012928df56f522"
 dependencies = [
 "flate2",
 "futures-core",
@@ -374,6 +416,64 @@ version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26"

+[[package]]
+name = "axum"
+version = "0.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a6c9af12842a67734c9a2e355436e5d03b22383ed60cf13cd0c18fbfe3dcbcf"
+dependencies = [
+ "async-trait",
+ "axum-core",
+ "base64 0.21.7",
+ "bytes",
+ "futures-util",
+ "http 1.1.0",
+ "http-body",
+ "http-body-util",
+ "hyper",
+ "hyper-util",
+ "itoa",
+ "matchit",
+ "memchr",
+ "mime",
+ "percent-encoding",
+ "pin-project-lite",
+ "rustversion",
+ "serde",
+ "serde_json",
+ "serde_path_to_error",
+ "serde_urlencoded",
+ "sha1",
+ "sync_wrapper 1.0.0",
+ "tokio",
+ "tokio-tungstenite 0.21.0",
+ "tower",
+ "tower-layer",
+ "tower-service",
+ "tracing",
+]
+
+[[package]]
+name = "axum-core"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a15c63fd72d41492dc4f497196f5da1fb04fb7529e631d73630d1b491e47a2e3"
+dependencies = [
+ "async-trait",
+ "bytes",
+ "futures-util",
+ "http 1.1.0",
+ "http-body",
+ "http-body-util",
+ "mime",
+ "pin-project-lite",
+ "rustversion",
+ "sync_wrapper 0.1.2",
+ "tower-layer",
+ "tower-service",
+ "tracing",
+]
+
 [[package]]
 name = "backoff"
 version = "0.4.0"
@@ -408,6 +508,12 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf"

+[[package]]
+name = "base64"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3441f0f7b02788e948e47f457ca01f1d7e6d92c693bc132c22b087d3141c03ff"
+
 [[package]]
 name = "base64"
 version = "0.13.1"
@@ -909,6 +1015,12 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b"

+[[package]]
+name = "colorchoice"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b63caa9aa9397e2d9480a9b13673856c78d8ac123288526c37d7839f2a86990"
+
 [[package]]
 name = "combine"
 version = "4.6.7"
@@ -1266,7 +1378,7 @@ dependencies = [

 [[package]]
 name = "deltachat"
-version = "1.157.3"
+version = "1.157.1"
 dependencies = [
 "anyhow",
 "async-broadcast",
@@ -1285,6 +1397,7 @@ dependencies = [
 "deltachat-contact-tools",
 "deltachat-time",
 "deltachat_derive",
+ "encoded-words",
 "escaper",
 "fast-socks5",
 "fd-lock",
@@ -1335,8 +1448,8 @@ dependencies = [
 "sha2",
 "shadowsocks",
 "smallvec",
- "strum 0.27.1",
- "strum_macros 0.27.1",
+ "strum",
+ "strum_macros",
 "tagger",
 "tempfile",
 "testdir",
@@ -1377,13 +1490,15 @@ dependencies = [

 [[package]]
 name = "deltachat-jsonrpc"
-version = "1.157.3"
+version = "1.157.1"
 dependencies = [
 "anyhow",
 "async-channel 2.3.1",
+ "axum",
 "base64 0.22.1",
 "deltachat",
 "deltachat-contact-tools",
+ "env_logger",
 "futures",
 "log",
 "num-traits",
@@ -1400,7 +1515,7 @@ dependencies = [

 [[package]]
 name = "deltachat-repl"
-version = "1.157.3"
+version = "1.157.1"
 dependencies = [
 "anyhow",
 "deltachat",
@@ -1416,7 +1531,7 @@ dependencies = [

 [[package]]
 name = "deltachat-rpc-server"
-version = "1.157.3"
+version = "1.157.1"
 dependencies = [
 "anyhow",
 "deltachat",
@@ -1445,7 +1560,7 @@ dependencies = [

 [[package]]
 name = "deltachat_ffi"
-version = "1.157.3"
+version = "1.157.1"
 dependencies = [
 "anyhow",
 "deltachat",
@@ -1779,6 +1894,21 @@ version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "edd0f118536f44f5ccd48bcb8b111bdc3de888b58c74639dfb034a357d0f206d"

+[[package]]
+name = "encoded-words"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c1693107e6084e2b9444d34a985697f56c8832d314924d5cfb1fb7793154bef"
+dependencies = [
+ "base64 0.12.3",
+ "charset",
+ "encoding_rs",
+ "hex",
+ "lazy_static",
+ "regex",
+ "thiserror 1.0.69",
+]
+
 [[package]]
 name = "encoding_rs"
 version = "0.8.35"
@@ -1806,7 +1936,7 @@ version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5ffccbb6966c05b32ef8fbac435df276c4ae4d3dc55a8cd0eb9745e6c12f546a"
 dependencies = [
- "heck 0.4.1",
+ "heck",
 "proc-macro2",
 "quote",
 "syn 2.0.98",
@@ -1832,6 +1962,29 @@ dependencies = [
 "syn 2.0.98",
 ]

+[[package]]
+name = "env_filter"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "186e05a59d4c50738528153b83b0b0194d3a29507dfec16eccd4b342903397d0"
+dependencies = [
+ "log",
+ "regex",
+]
+
+[[package]]
+name = "env_logger"
+version = "0.11.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3716d7a920fb4fac5d84e9d4bce8ceb321e9414b4409da61b07b75c1e3d0697"
+dependencies = [
+ "anstream",
+ "anstyle",
+ "env_filter",
+ "jiff",
+ "log",
+]
+
 [[package]]
 name = "equivalent"
 version = "1.0.2"
@@ -2335,12 +2488,6 @@ version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"

-[[package]]
-name = "heck"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
-
 [[package]]
 name = "hermit-abi"
 version = "0.3.9"
@@ -2924,7 +3071,7 @@ dependencies = [
 "rustls-webpki",
 "serde",
 "smallvec",
- "strum 0.26.2",
+ "strum",
 "stun-rs",
 "thiserror 2.0.11",
 "time",
@@ -3128,7 +3275,7 @@ dependencies = [
 "rustls",
 "rustls-webpki",
 "serde",
- "strum 0.26.2",
+ "strum",
 "stun-rs",
 "thiserror 2.0.11",
 "tokio",
@@ -3173,6 +3320,30 @@ version = "1.0.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b1a46d1a171d865aa5f83f92695765caa047a9b4cbae2cbf37dbd613a793fd4c"

+[[package]]
+name = "jiff"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d699bc6dfc879fb1bf9bdff0d4c56f0884fc6f0d0eb0fba397a6d00cd9a6b85e"
+dependencies = [
+ "jiff-static",
+ "log",
+ "portable-atomic",
+ "portable-atomic-util",
+ "serde",
+]
+
+[[package]]
+name = "jiff-static"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8d16e75759ee0aa64c57a56acbf43916987b20c77373cb7e808979e02b93c9f9"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.98",
+]
+
 [[package]]
 name = "jni"
 version = "0.21.1"
@@ -3387,6 +3558,12 @@ dependencies = [
 "regex-automata 0.1.10",
 ]

+[[package]]
+name = "matchit"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e7465ac9959cc2b1404e8e2367b43684a6d13790fe23056cc8c6c5a6b7bcb94"
+
 [[package]]
 name = "md-5"
 version = "0.10.6"
@@ -4366,6 +4543,15 @@ version = "1.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "280dc24453071f1b63954171985a0b0d30058d287960968b9b2aca264c8d4ee6"

+[[package]]
+name = "portable-atomic-util"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8a2f0d8d040d7848a709caf78912debcc3f33ee4b3cac47d73d1e1069e83507"
+dependencies = [
+ "portable-atomic",
+]
+
 [[package]]
 name = "portmapper"
 version = "0.3.1"
@@ -4894,7 +5080,7 @@ dependencies = [
 "serde",
 "serde_json",
 "serde_urlencoded",
- "sync_wrapper",
+ "sync_wrapper 1.0.0",
 "tokio",
 "tokio-rustls",
 "tokio-util",
@@ -5412,6 +5598,16 @@ dependencies = [
 "serde",
 ]

+[[package]]
+name = "serde_path_to_error"
+version = "0.1.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebd154a240de39fdebcf5775d2675c204d7c13cf39a4c697be6493c8e734337c"
+dependencies = [
+ "itoa",
+ "serde",
+]
+
 [[package]]
 name = "serde_spanned"
 version = "0.6.7"
@@ -5710,35 +5906,16 @@ version = "0.26.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5d8cec3501a5194c432b2b7976db6b7d10ec95c253208b45f83f7136aa985e29"
 dependencies = [
- "strum_macros 0.26.2",
+ "strum_macros",
 ]

-[[package]]
-name = "strum"
-version = "0.27.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f64def088c51c9510a8579e3c5d67c65349dcf755e5479ad3d010aa6454e2c32"
-
 [[package]]
 name = "strum_macros"
 version = "0.26.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c6cf59daf282c0a494ba14fd21610a0325f9f90ec9d1231dea26bcb1d696c946"
 dependencies = [
- "heck 0.4.1",
- "proc-macro2",
- "quote",
- "rustversion",
- "syn 2.0.98",
-]
-
-[[package]]
-name = "strum_macros"
-version = "0.27.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c77a8c5abcaf0f9ce05d62342b7d298c346515365c36b673df4ebe3ced01fde8"
-dependencies = [
- "heck 0.5.0",
+ "heck",
 "proc-macro2",
 "quote",
 "rustversion",
@@ -5813,6 +5990,12 @@ dependencies = [
 "unicode-ident",
 ]

+[[package]]
+name = "sync_wrapper"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2047c6ded9c721764247e62cd3b03c09ffc529b2ba5b10ec482ae507a4a70160"
+
 [[package]]
 name = "sync_wrapper"
 version = "1.0.0"
@@ -6129,6 +6312,18 @@ dependencies = [
 "windows-sys 0.52.0",
 ]

+[[package]]
+name = "tokio-tungstenite"
+version = "0.21.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c83b561d025642014097b66e6c1bb422783339e0909e4429cde4749d1990bc38"
+dependencies = [
+ "futures-util",
+ "log",
+ "tokio",
+ "tungstenite 0.21.0",
+]
+
 [[package]]
 name = "tokio-tungstenite"
 version = "0.24.0"
@@ -6138,7 +6333,7 @@ dependencies = [
 "futures-util",
 "log",
 "tokio",
- "tungstenite",
+ "tungstenite 0.24.0",
 ]

 [[package]]
@@ -6154,7 +6349,7 @@ dependencies = [
 "js-sys",
 "thiserror 1.0.69",
 "tokio",
- "tokio-tungstenite",
+ "tokio-tungstenite 0.24.0",
 "wasm-bindgen",
 "web-sys",
 ]
@@ -6210,10 +6405,32 @@ dependencies = [
 ]

 [[package]]
-name = "tower-service"
-version = "0.3.3"
+name = "tower"
+version = "0.4.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3"
+checksum = "b8fa9be0de6cf49e536ce1851f987bd21a43b771b09473c3549a6c853db37c1c"
+dependencies = [
+ "futures-core",
+ "futures-util",
+ "pin-project",
+ "pin-project-lite",
+ "tokio",
+ "tower-layer",
+ "tower-service",
+ "tracing",
+]
+
+[[package]]
+name = "tower-layer"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c20c8dbed6283a09604c3e69b4b7eeb54e298b8a600d4d5ecb5ad39de609f1d0"
+
+[[package]]
+name = "tower-service"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6bc1c9ce2b5135ac7f93c72918fc37feb872bdc6a5533a8b85eb4b86bfdae52"

 [[package]]
 name = "tracing"
@@ -6294,6 +6511,25 @@ version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"

+[[package]]
+name = "tungstenite"
+version = "0.21.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ef1a641ea34f399a848dea702823bbecfb4c486f911735368f1f137cb8257e1"
+dependencies = [
+ "byteorder",
+ "bytes",
+ "data-encoding",
+ "http 1.1.0",
+ "httparse",
+ "log",
+ "rand 0.8.5",
+ "sha1",
+ "thiserror 1.0.69",
+ "url",
+ "utf-8",
+]
+
 [[package]]
 name = "tungstenite"
 version = "0.24.0"
@@ -6486,11 +6722,11 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"

 [[package]]
 name = "uuid"
-version = "1.15.1"
+version = "1.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0f540e3240398cce6128b64ba83fdbdd86129c16a3aa1a3a252efd66eb3d587"
+checksum = "b3758f5e68192bb96cc8f9b7e2c2cfdabb435499a28499a42f8f984092adad4b"
 dependencies = [
- "getrandom 0.3.1",
+ "getrandom 0.2.12",
 "serde",
 ]

@@ -7302,12 +7538,15 @@ dependencies = [
 "async-channel 1.9.0",
 "async-mutex",
 "async-trait",
+ "axum",
 "futures",
 "futures-util",
 "log",
 "schemars",
 "serde",
 "serde_json",
+ "tokio",
+ "tracing",
 "typescript-type-def",
 "yerpc_derive",
 ]
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "deltachat"
-version = "1.157.3"
+version = "1.157.1"
 edition = "2021"
 license = "MPL-2.0"
 rust-version = "1.81"
@@ -50,6 +50,7 @@ brotli = { version = "7", default-features=false, features = ["std"] }
 bytes = "1"
 chrono = { workspace = true, features = ["alloc", "clock", "std"] }
 data-encoding = "2.7.0"
+encoded-words = "0.2"
 escaper = "0.1"
 fast-socks5 = "0.10"
 fd-lock = "4"
@@ -94,8 +95,8 @@ sha-1 = "0.10"
 sha2 = "0.10"
 shadowsocks = { version = "1.22.0", default-features = false, features = ["aead-cipher", "aead-cipher-2022"] }
 smallvec = "1.14.0"
-strum = "0.27"
-strum_macros = "0.27"
+strum = "0.26"
+strum_macros = "0.26"
 tagger = "4.3.4"
 textwrap = "0.16.1"
 thiserror = { workspace = true }
--- a/deltachat-ffi/Cargo.toml
+++ b/deltachat-ffi/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "deltachat_ffi"
-version = "1.157.3"
+version = "1.157.1"
 description = "Deltachat FFI"
 edition = "2018"
 readme = "README.md"
--- a/deltachat-jsonrpc/Cargo.toml
+++ b/deltachat-jsonrpc/Cargo.toml
@@ -1,11 +1,17 @@
 [package]
 name = "deltachat-jsonrpc"
-version = "1.157.3"
+version = "1.157.1"
 description = "DeltaChat JSON-RPC API"
 edition = "2021"
+default-run = "deltachat-jsonrpc-server"
 license = "MPL-2.0"
 repository = "https://github.com/chatmail/core"

+[[bin]]
+name = "deltachat-jsonrpc-server"
+path = "src/webserver.rs"
+required-features = ["webserver"]
+
 [dependencies]
 anyhow = { workspace = true }
 deltachat = { workspace = true }
@@ -25,10 +31,15 @@ sanitize-filename = { workspace = true }
 walkdir = "2.5.0"
 base64 = { workspace = true }

+# optional dependencies
+axum = { version = "0.7", optional = true, features = ["ws"] }
+env_logger = { version = "0.11.6", optional = true }
+
 [dev-dependencies]
 tokio = { workspace = true, features = ["full", "rt-multi-thread"] }


 [features]
 default = ["vendored"]
+webserver = ["dep:env_logger", "dep:axum", "tokio/full", "yerpc/support-axum"]
 vendored = ["deltachat/vendored"]
--- a/deltachat-jsonrpc/README.md
+++ b/deltachat-jsonrpc/README.md
@@ -4,16 +4,46 @@ This crate provides a [JSON-RPC 2.0](https://www.jsonrpc.org/specification) inte

 The JSON-RPC API is exposed in two fashions:

-* A executable `deltachat-rpc-server` that exposes the JSON-RPC API through stdio.
-* The JSON-RPC API can also be called through the [C FFI](../deltachat-ffi). It exposes the functions `dc_jsonrpc_init`, `dc_jsonrpc_request`, `dc_jsonrpc_next_response` and `dc_jsonrpc_unref`. See the docs in the [header file](../deltachat-ffi/deltachat.h) for details.
+* A executable that exposes the JSON-RPC API through a [WebSocket](https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API) server running on localhost.
+* The JSON-RPC API can also be called through the [C FFI](../deltachat-ffi). The C FFI needs to be built with the `jsonrpc` feature. It will then expose the functions `dc_jsonrpc_init`, `dc_jsonrpc_request`, `dc_jsonrpc_next_response` and `dc_jsonrpc_unref`. See the docs in the [header file](../deltachat-ffi/deltachat.h) for details.

-We also include a JavaScript and TypeScript client for the JSON-RPC API. The source for this is in the [`typescript`](typescript) folder.
+We also include a JavaScript and TypeScript client for the JSON-RPC API. The source for this is in the [`typescript`](typescript) folder. The client can easily be used with the WebSocket server to build DeltaChat apps for web browsers or Node.js. See the [examples](typescript/example) for details.

 ## Usage

+#### Running the WebSocket server
+
+From within this folder, you can start the WebSocket server with the following command:
+
+```sh
+cargo run --features webserver
+```
+
+If you want to use the server in a production setup, first build it in release mode:
+
+```sh
+cargo build --features webserver --release
+```
+You will then find the `deltachat-jsonrpc-server` executable in your `target/release` folder.
+
+The executable currently does not support any command-line arguments. By default, once started it will accept WebSocket connections on `ws://localhost:20808/ws`. It will store the persistent configuration and databases in a `./accounts` folder relative to the directory from where it is started.
+
+The server can be configured with environment variables:
+
+|variable|default|description|
+|-|-|-|
+|`DC_PORT`|`20808`|port to listen on|
+|`DC_ACCOUNTS_PATH`|`./accounts`|path to storage directory|
+
+If you are targeting other architectures (like KaiOS or Android), the webserver binary can be cross-compiled easily with [rust-cross](https://github.com/cross-rs/cross):
+
+```sh
+cross build --features=webserver --target armv7-linux-androideabi --release
+```
+
 #### Using the TypeScript/JavaScript client

-The package includes a JavaScript/TypeScript client which is partially auto-generated through the JSON-RPC library used by this crate ([yerpc](https://github.com/chatmail/yerpc)). Find the source in the [`typescript`](typescript) folder. 
+The package includes a JavaScript/TypeScript client which is partially auto-generated through the JSON-RPC library used by this crate ([yerpc](https://github.com/Frando/yerpc/)). Find the source in the [`typescript`](typescript) folder. 

 To use it locally, first install the dependencies and compile the TypeScript code to JavaScript:
 ```sh
@@ -22,7 +52,15 @@ npm install
 npm run build
 ```

-The JavaScript client is [published on NPM](https://www.npmjs.com/package/@deltachat/jsonrpc-client).
+The JavaScript client is not yet published on NPM (but will likely be soon). Currently, it is recommended to vendor the bundled build. After running `npm run build` as documented above, there will be a file `dist/deltachat.bundle.js`. This is an ESM module containing all dependencies. Copy this file to your project and import the DeltaChat class.
+
+
+```typescript
+import { DeltaChat } from './deltachat.bundle.js'
+const dc = new DeltaChat('ws://localhost:20808/ws')
+const accounts = await dc.rpc.getAllAccounts()
+console.log('accounts', accounts)
+```

 A script is included to build autogenerated documentation, which includes all RPC methods:
 ```sh
@@ -35,6 +73,18 @@ Then open the [`typescript/docs`](typescript/docs) folder in a web browser.

 #### Running the example app

+We include a small demo web application that talks to the WebSocket server. It can be used for testing. Feel invited to expand this.
+
+```sh
+cd typescript
+npm run build
+npm run example:build
+npm run example:start
+```
+Then, open [`http://localhost:8080/example.html`](http://localhost:8080/example.html) in a web browser.
+
+Run `npm run example:dev` to live-rebuild the example app when files changes.
+
 ### Testing

 The crate includes both a basic Rust smoke test and more featureful integration tests that use the TypeScript client.
@@ -54,12 +104,14 @@ cd typescript
 npm run test
 ```

-This will build the `deltachat-jsonrpc-server` binary and then run a test suite.
+This will build the `deltachat-jsonrpc-server` binary and then run a test suite against the WebSocket server.

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

 ```
-CHATMAIL_DOMAIN=ci-chatmail.testrun.org npm run test
+CHATMAIL_DOMAIN=chat.example.org npm run test
 ```

 #### Test Coverage
--- a/deltachat-jsonrpc/TODO.md
+++ b/deltachat-jsonrpc/TODO.md
@@ -0,0 +1,28 @@
+# TODO
+
+- [ ] different test type to simulate two devices: to test autocrypt_initiate_key_transfer & autocrypt_continue_key_transfer
+
+## MVP - Websocket server&client
+
+For kaiOS and other experiments, like a deltachat "web" over network from an android phone.
+
+- [ ] coverage for a majority of the API
+- [ ] Blobs served
+- [ ] Blob upload (for attachments, setting profile-picture, importing backup and so on)
+- [ ] other way blobs can be addressed when using websocket vs. jsonrpc over dc-node
+- [ ] Web push API? At least some kind of notification hook closure this lib can accept.
+
+### Other Ideas for the Websocket server
+
+- [ ] make sure there can only be one connection at a time to the ws
+  - why? , it could give problems if its commanded from multiple connections
+- [ ] encrypted connection?
+- [ ] authenticated connection?
+- [ ] Look into unit-testing for the proc macros?
+- [ ] proc macro taking over doc comments to generated typescript file
+
+## Desktop Apis
+
+Incomplete todo for desktop api porting, just some remainders for points that might need more work:
+
+- [ ] manual start/stop io functions in the api for context and accounts, so "not syncing all accounts" can still be done in desktop -> webserver should then not do start io on all accounts by default
--- a/deltachat-jsonrpc/src/api.rs
+++ b/deltachat-jsonrpc/src/api.rs
@@ -1,5 +1,5 @@
 use std::collections::BTreeMap;
-use std::path::{Path, PathBuf};
+use std::path::Path;
 use std::str;
 use std::sync::Arc;
 use std::time::Duration;
@@ -7,7 +7,6 @@ use std::{collections::HashMap, str::FromStr};

 use anyhow::{anyhow, bail, ensure, Context, Result};
 pub use deltachat::accounts::Accounts;
-use deltachat::blob::BlobObject;
 use deltachat::chat::{
    self, add_contact_to_chat, forward_msgs, get_chat_media, get_chat_msgs, get_chat_msgs_ex,
    marknoticed_chat, remove_contact_from_chat, Chat, ChatId, ChatItem, MessageListOptions,
@@ -22,7 +21,7 @@ use deltachat::ephemeral::Timer;
 use deltachat::location;
 use deltachat::message::get_msg_read_receipts;
 use deltachat::message::{
-    self, delete_msgs_ex, markseen_msgs, Message, MessageState, MsgId, Viewtype,
+    self, delete_msgs, markseen_msgs, Message, MessageState, MsgId, Viewtype,
 };
 use deltachat::peer_channels::{
    leave_webxdc_realtime, send_webxdc_realtime_advertisement, send_webxdc_realtime_data,
@@ -39,7 +38,6 @@ use deltachat::{imex, info};
 use sanitize_filename::is_sanitized;
 use tokio::fs;
 use tokio::sync::{watch, Mutex, RwLock};
-use types::login_param::EnteredLoginParam;
 use walkdir::WalkDir;
 use yerpc::rpc;

@@ -343,19 +341,11 @@ impl CommandApi {
        ctx.get_info().await
    }

-    /// Get the blob dir.
    async fn get_blob_dir(&self, account_id: u32) -> Result<Option<String>> {
        let ctx = self.get_context(account_id).await?;
        Ok(ctx.get_blobdir().to_str().map(|s| s.to_owned()))
    }

-    /// Copy file to blob dir.
-    async fn copy_to_blob_dir(&self, account_id: u32, path: String) -> Result<PathBuf> {
-        let ctx = self.get_context(account_id).await?;
-        let file = Path::new(&path);
-        Ok(BlobObject::create_and_deduplicate(&ctx, file, file)?.to_abs_path())
-    }
-
    async fn draft_self_report(&self, account_id: u32) -> Result<u32> {
        let ctx = self.get_context(account_id).await?;
        Ok(ctx.draft_self_report().await?.to_u32())
@@ -432,9 +422,6 @@ impl CommandApi {

    /// Configures this account with the currently set parameters.
    /// Setup the credential config before calling this.
-    ///
-    /// Deprecated as of 2025-02; use `add_transport_from_qr()`
-    /// or `add_transport()` instead.
    async fn configure(&self, account_id: u32) -> Result<()> {
        let ctx = self.get_context(account_id).await?;
        ctx.stop_io().await;
@@ -449,69 +436,6 @@ impl CommandApi {
        Ok(())
    }

-    /// Configures a new email account using the provided parameters
-    /// and adds it as a transport.
-    ///
-    /// If the email address is the same as an existing transport,
-    /// then this existing account will be reconfigured instead of a new one being added.
-    ///
-    /// This function stops and starts IO as needed.
-    ///
-    /// Usually it will be enough to only set `addr` and `imap.password`,
-    /// and all the other settings will be autoconfigured.
-    ///
-    /// During configuration, ConfigureProgress events are emitted;
-    /// they indicate a successful configuration as well as errors
-    /// and may be used to create a progress bar.
-    /// This function will return after configuration is finished.
-    ///
-    /// If configuration is successful,
-    /// the working server parameters will be saved
-    /// and used for connecting to the server.
-    /// The parameters entered by the user will be saved separately
-    /// so that they can be prefilled when the user opens the server-configuration screen again.
-    ///
-    /// See also:
-    /// - [Self::is_configured()] to check whether there is
-    ///   at least one working transport.
-    /// - [Self::add_transport_from_qr()] to add a transport
-    ///   from a server encoded in a QR code.
-    /// - [Self::list_transports()] to get a list of all configured transports.
-    /// - [Self::delete_transport()] to remove a transport.
-    async fn add_transport(&self, account_id: u32, param: EnteredLoginParam) -> Result<()> {
-        let ctx = self.get_context(account_id).await?;
-        ctx.add_transport(&param.try_into()?).await
-    }
-
-    /// Adds a new email account as a transport
-    /// using the server encoded in the QR code.
-    /// See [Self::add_transport].
-    async fn add_transport_from_qr(&self, account_id: u32, qr: String) -> Result<()> {
-        let ctx = self.get_context(account_id).await?;
-        ctx.add_transport_from_qr(&qr).await
-    }
-
-    /// Returns the list of all email accounts that are used as a transport in the current profile.
-    /// Use [Self::add_transport()] to add or change a transport
-    /// and [Self::delete_transport()] to delete a transport.
-    async fn list_transports(&self, account_id: u32) -> Result<Vec<EnteredLoginParam>> {
-        let ctx = self.get_context(account_id).await?;
-        let res = ctx
-            .list_transports()
-            .await?
-            .into_iter()
-            .map(|t| t.into())
-            .collect();
-        Ok(res)
-    }
-
-    /// Removes the transport with the specified email address
-    /// (i.e. [EnteredLoginParam::addr]).
-    async fn delete_transport(&self, account_id: u32, addr: String) -> Result<()> {
-        let ctx = self.get_context(account_id).await?;
-        ctx.delete_transport(&addr).await
-    }
-
    /// Signal an ongoing process to stop.
    async fn stop_ongoing_process(&self, account_id: u32) -> Result<()> {
        let ctx = self.get_context(account_id).await?;
@@ -1281,15 +1205,7 @@ impl CommandApi {
    async fn delete_messages(&self, account_id: u32, message_ids: Vec<u32>) -> Result<()> {
        let ctx = self.get_context(account_id).await?;
        let msgs: Vec<MsgId> = message_ids.into_iter().map(MsgId::new).collect();
-        delete_msgs_ex(&ctx, &msgs, false).await
-    }
-
-    /// Delete messages. The messages are deleted on the current device,
-    /// on the IMAP server and also for all chat members
-    async fn delete_messages_for_all(&self, account_id: u32, message_ids: Vec<u32>) -> Result<()> {
-        let ctx = self.get_context(account_id).await?;
-        let msgs: Vec<MsgId> = message_ids.into_iter().map(MsgId::new).collect();
-        delete_msgs_ex(&ctx, &msgs, true).await
+        delete_msgs(&ctx, &msgs).await
    }

    /// Get an informational text for a single message. The text is multiline and may
--- a/deltachat-jsonrpc/src/api/types/login_param.rs
+++ b/deltachat-jsonrpc/src/api/types/login_param.rs
@@ -1,179 +0,0 @@
-use anyhow::Result;
-use deltachat::login_param as dc;
-use serde::Deserialize;
-use serde::Serialize;
-use yerpc::TypeDef;
-
-#[derive(Serialize, Deserialize, TypeDef, schemars::JsonSchema)]
-#[serde(rename_all = "camelCase")]
-pub struct EnteredServerLoginParam {
-    /// Server hostname or IP address.
-    pub server: String,
-
-    /// Server port.
-    ///
-    /// 0 if not specified.
-    pub port: u16,
-
-    /// Socket security.
-    pub security: Socket,
-
-    /// Username.
-    ///
-    /// Empty string if not specified.
-    pub user: String,
-
-    /// Password.
-    pub password: String,
-}
-
-impl From<dc::EnteredServerLoginParam> for EnteredServerLoginParam {
-    fn from(param: dc::EnteredServerLoginParam) -> Self {
-        Self {
-            server: param.server,
-            port: param.port,
-            security: param.security.into(),
-            user: param.user,
-            password: param.password,
-        }
-    }
-}
-
-impl From<EnteredServerLoginParam> for dc::EnteredServerLoginParam {
-    fn from(param: EnteredServerLoginParam) -> Self {
-        Self {
-            server: param.server,
-            port: param.port,
-            security: param.security.into(),
-            user: param.user,
-            password: param.password,
-        }
-    }
-}
-
-/// Login parameters entered by the user.
-
-#[derive(Serialize, Deserialize, TypeDef, schemars::JsonSchema)]
-#[serde(rename_all = "camelCase")]
-pub struct EnteredLoginParam {
-    /// Email address.
-    pub addr: String,
-
-    /// IMAP settings.
-    pub imap: EnteredServerLoginParam,
-
-    /// SMTP settings.
-    pub smtp: EnteredServerLoginParam,
-
-    /// TLS options: whether to allow invalid certificates and/or
-    /// invalid hostnames
-    pub certificate_checks: EnteredCertificateChecks,
-
-    /// If true, login via OAUTH2 (not recommended anymore)
-    pub oauth2: bool,
-}
-
-impl From<dc::EnteredLoginParam> for EnteredLoginParam {
-    fn from(param: dc::EnteredLoginParam) -> Self {
-        Self {
-            addr: param.addr,
-            imap: param.imap.into(),
-            smtp: param.smtp.into(),
-            certificate_checks: param.certificate_checks.into(),
-            oauth2: param.oauth2,
-        }
-    }
-}
-
-impl TryFrom<EnteredLoginParam> for dc::EnteredLoginParam {
-    type Error = anyhow::Error;
-
-    fn try_from(param: EnteredLoginParam) -> Result<Self> {
-        Ok(Self {
-            addr: param.addr,
-            imap: param.imap.into(),
-            smtp: param.smtp.into(),
-            certificate_checks: param.certificate_checks.into(),
-            oauth2: param.oauth2,
-        })
-    }
-}
-
-#[derive(Serialize, Deserialize, TypeDef, schemars::JsonSchema)]
-#[serde(rename_all = "camelCase")]
-pub enum Socket {
-    /// Unspecified socket security, select automatically.
-    Automatic,
-
-    /// TLS connection.
-    Ssl,
-
-    /// STARTTLS connection.
-    Starttls,
-
-    /// No TLS, plaintext connection.
-    Plain,
-}
-
-impl From<dc::Socket> for Socket {
-    fn from(value: dc::Socket) -> Self {
-        match value {
-            dc::Socket::Automatic => Self::Automatic,
-            dc::Socket::Ssl => Self::Ssl,
-            dc::Socket::Starttls => Self::Starttls,
-            dc::Socket::Plain => Self::Plain,
-        }
-    }
-}
-
-impl From<Socket> for dc::Socket {
-    fn from(value: Socket) -> Self {
-        match value {
-            Socket::Automatic => Self::Automatic,
-            Socket::Ssl => Self::Ssl,
-            Socket::Starttls => Self::Starttls,
-            Socket::Plain => Self::Plain,
-        }
-    }
-}
-
-#[derive(Serialize, Deserialize, TypeDef, schemars::JsonSchema)]
-#[serde(rename_all = "camelCase")]
-pub enum EnteredCertificateChecks {
-    /// `Automatic` means that provider database setting should be taken.
-    /// If there is no provider database setting for certificate checks,
-    /// check certificates strictly.
-    Automatic,
-
-    /// Ensure that TLS certificate is valid for the server hostname.
-    Strict,
-
-    /// Accept certificates that are expired, self-signed
-    /// or otherwise not valid for the server hostname.
-    AcceptInvalidCertificates,
-}
-
-impl From<dc::EnteredCertificateChecks> for EnteredCertificateChecks {
-    fn from(value: dc::EnteredCertificateChecks) -> Self {
-        match value {
-            dc::EnteredCertificateChecks::Automatic => Self::Automatic,
-            dc::EnteredCertificateChecks::Strict => Self::Strict,
-            dc::EnteredCertificateChecks::AcceptInvalidCertificates => {
-                Self::AcceptInvalidCertificates
-            }
-            dc::EnteredCertificateChecks::AcceptInvalidCertificates2 => {
-                Self::AcceptInvalidCertificates
-            }
-        }
-    }
-}
-
-impl From<EnteredCertificateChecks> for dc::EnteredCertificateChecks {
-    fn from(value: EnteredCertificateChecks) -> Self {
-        match value {
-            EnteredCertificateChecks::Automatic => Self::Automatic,
-            EnteredCertificateChecks::Strict => Self::Strict,
-            EnteredCertificateChecks::AcceptInvalidCertificates => Self::AcceptInvalidCertificates,
-        }
-    }
-}
--- a/deltachat-jsonrpc/src/api/types/mod.rs
+++ b/deltachat-jsonrpc/src/api/types/mod.rs
@@ -5,7 +5,6 @@ pub mod contact;
 pub mod events;
 pub mod http;
 pub mod location;
-pub mod login_param;
 pub mod message;
 pub mod provider_info;
 pub mod qr;
--- a/deltachat-jsonrpc/src/webserver.rs
+++ b/deltachat-jsonrpc/src/webserver.rs
@@ -0,0 +1,47 @@
+#![recursion_limit = "256"]
+use std::net::SocketAddr;
+use std::path::PathBuf;
+
+use axum::{extract::ws::WebSocketUpgrade, response::Response, routing::get, Extension, Router};
+use yerpc::axum::handle_ws_rpc;
+use yerpc::{RpcClient, RpcSession};
+
+mod api;
+use api::{Accounts, CommandApi};
+
+const DEFAULT_PORT: u16 = 20808;
+
+#[tokio::main(flavor = "multi_thread")]
+async fn main() -> Result<(), std::io::Error> {
+    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();
+
+    let path = std::env::var("DC_ACCOUNTS_PATH").unwrap_or_else(|_| "./accounts".to_string());
+    let port = std::env::var("DC_PORT")
+        .map(|port| port.parse::<u16>().expect("DC_PORT must be a number"))
+        .unwrap_or(DEFAULT_PORT);
+    log::info!("Starting with accounts directory `{path}`.");
+    let writable = true;
+    let accounts = Accounts::new(PathBuf::from(&path), writable).await.unwrap();
+    let state = CommandApi::new(accounts);
+
+    let app = Router::new()
+        .route("/ws", get(handler))
+        .layer(Extension(state.clone()));
+
+    tokio::spawn(async move {
+        state.accounts.write().await.start_io().await;
+    });
+
+    let addr = SocketAddr::from(([127, 0, 0, 1], port));
+    log::info!("JSON-RPC WebSocket server listening on {}", addr);
+    let listener = tokio::net::TcpListener::bind(addr).await.unwrap();
+    axum::serve(listener, app).await.unwrap();
+
+    Ok(())
+}
+
+async fn handler(ws: WebSocketUpgrade, Extension(api): Extension<CommandApi>) -> Response {
+    let (client, out_receiver) = RpcClient::new();
+    let session = RpcSession::new(client.clone(), api.clone());
+    handle_ws_rpc(ws, out_receiver, session).await
+}
--- a/deltachat-jsonrpc/typescript/example.html
+++ b/deltachat-jsonrpc/typescript/example.html
@@ -0,0 +1,56 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <title>DeltaChat JSON-RPC example</title>
+    <style>
+      body {
+        font-family: monospace;
+        background: black;
+        color: grey;
+      }
+      .grid {
+        display: grid;
+        grid-template-columns: 3fr 1fr;
+        grid-template-areas: "a a" "b c";
+      }
+      .message {
+        color: red;
+      }
+      #header {
+        grid-area: a;
+        color: white;
+        font-size: 1.2rem;
+      }
+      #header a {
+        color: white;
+        font-weight: bold;
+      }
+      #main {
+        grid-area: b;
+        color: green;
+      }
+      #main h2,
+      #main h3 {
+        color: blue;
+      }
+      #side {
+        grid-area: c;
+        color: #777;
+        overflow-y: auto;
+      }
+    </style>
+    <script type="module" src="dist/example.bundle.js"></script>
+  </head>
+  <body>
+    <h1>DeltaChat JSON-RPC example</h1>
+    <div class="grid">
+      <div id="header"></div>
+      <div id="main"></div>
+      <div id="side"><h2>log</h2></div>
+    </div>
+    <p>
+      Tip: open the dev console and use the client with
+      <code>window.client</code>
+    </p>
+  </body>
+</html>
--- a/deltachat-jsonrpc/typescript/example/example.ts
+++ b/deltachat-jsonrpc/typescript/example/example.ts
@@ -0,0 +1,109 @@
+import { DcEvent, DeltaChat } from "../deltachat.js";
+
+var SELECTED_ACCOUNT = 0;
+
+window.addEventListener("DOMContentLoaded", (_event) => {
+  (window as any).selectDeltaAccount = (id: string) => {
+    SELECTED_ACCOUNT = Number(id);
+    window.dispatchEvent(new Event("account-changed"));
+  };
+  console.log("launch run script...");
+  run().catch((err) => console.error("run failed", err));
+});
+
+async function run() {
+  const $main = document.getElementById("main")!;
+  const $side = document.getElementById("side")!;
+  const $head = document.getElementById("header")!;
+
+  const client = new DeltaChat("ws://localhost:20808/ws");
+
+  (window as any).client = client.rpc;
+
+  client.on("ALL", (accountId, event) => {
+    onIncomingEvent(accountId, event);
+  });
+
+  window.addEventListener("account-changed", async (_event: Event) => {
+    listChatsForSelectedAccount();
+  });
+
+  await Promise.all([loadAccountsInHeader(), listChatsForSelectedAccount()]);
+
+  async function loadAccountsInHeader() {
+    console.log("load accounts");
+    const accounts = await client.rpc.getAllAccounts();
+    console.log("accounts loaded", accounts);
+    for (const account of accounts) {
+      if (account.kind === "Configured") {
+        write(
+          $head,
+          `<a href="#" onclick="selectDeltaAccount(${account.id})">
+          ${account.id}: ${account.addr!}
+          </a>&nbsp;`
+        );
+      } else {
+        write(
+          $head,
+          `<a href="#">
+          ${account.id}: (unconfigured)
+          </a>&nbsp;`
+        );
+      }
+    }
+  }
+
+  async function listChatsForSelectedAccount() {
+    clear($main);
+    const selectedAccount = SELECTED_ACCOUNT;
+    const info = await client.rpc.getAccountInfo(selectedAccount);
+    if (info.kind !== "Configured") {
+      return write($main, "Account is not configured");
+    }
+    write($main, `<h2>${info.addr!}</h2>`);
+    const chats = await client.rpc.getChatlistEntries(
+      selectedAccount,
+      0,
+      null,
+      null
+    );
+    for (const chatId of chats) {
+      const chat = await client.rpc.getFullChatById(selectedAccount, chatId);
+      write($main, `<h3>${chat.name}</h3>`);
+      const messageIds = await client.rpc.getMessageIds(
+        selectedAccount,
+        chatId,
+        false,
+        false
+      );
+      const messages = await client.rpc.getMessages(
+        selectedAccount,
+        messageIds
+      );
+      for (const [_messageId, message] of Object.entries(messages)) {
+        if (message.kind === "message") write($main, `<p>${message.text}</p>`);
+        else write($main, `<p>loading error: ${message.error}</p>`);
+      }
+    }
+  }
+
+  function onIncomingEvent(accountId: number, event: DcEvent) {
+    write(
+      $side,
+      `
+        <p class="message">
+          [<strong>${event.kind}</strong> on account ${accountId}]<br>
+          <em>f1:</em> ${JSON.stringify(
+            Object.assign({}, event, { kind: undefined })
+          )}
+        </p>`
+    );
+  }
+}
+
+function write(el: HTMLElement, html: string) {
+  el.innerHTML += html;
+}
+function clear(el: HTMLElement) {
+  el.innerHTML = "";
+}
--- a/deltachat-jsonrpc/typescript/example/node-add-account.js
+++ b/deltachat-jsonrpc/typescript/example/node-add-account.js
@@ -0,0 +1,29 @@
+import { DeltaChat } from "../dist/deltachat.js";
+
+run().catch(console.error);
+
+async function run() {
+  const delta = new DeltaChat("ws://localhost:20808/ws");
+  delta.on("event", (event) => {
+    console.log("event", event.data);
+  });
+
+  const email = process.argv[2];
+  const password = process.argv[3];
+  if (!email || !password)
+    throw new Error(
+      "USAGE: node node-add-account.js <EMAILADDRESS> <PASSWORD>"
+    );
+  console.log(`creating account for ${email}`);
+  const id = await delta.rpc.addAccount();
+  console.log(`created account id ${id}`);
+  await delta.rpc.setConfig(id, "addr", email);
+  await delta.rpc.setConfig(id, "mail_pw", password);
+  console.log("configuration updated");
+  await delta.rpc.configure(id);
+  console.log("account configured!");
+
+  const accounts = await delta.rpc.getAllAccounts();
+  console.log("accounts", accounts);
+  console.log("waiting for events...");
+}
--- a/deltachat-jsonrpc/typescript/example/node-demo.js
+++ b/deltachat-jsonrpc/typescript/example/node-demo.js
@@ -0,0 +1,14 @@
+import { DeltaChat } from "../dist/deltachat.js";
+
+run().catch(console.error);
+
+async function run() {
+  const delta = new DeltaChat();
+  delta.on("event", (event) => {
+    console.log("event", event.data);
+  });
+
+  const accounts = await delta.rpc.getAllAccounts();
+  console.log("accounts", accounts);
+  console.log("waiting for events...");
+}
--- a/deltachat-jsonrpc/typescript/package.json
+++ b/deltachat-jsonrpc/typescript/package.json
@@ -42,6 +42,10 @@
    "build:cjs": "esbuild --format=cjs --bundle --packages=external dist/deltachat.js --outfile=dist/deltachat.cjs",
    "build:tsc": "tsc",
    "docs": "typedoc --out docs deltachat.ts",
+    "example": "run-s build example:build example:start",
+    "example:build": "esbuild --bundle dist/example/example.js --outfile=dist/example.bundle.js",
+    "example:dev": "esbuild example/example.ts --bundle --outfile=dist/example.bundle.js --servedir=.",
+    "example:start": "http-server .",
    "extract-constants": "node ./scripts/generate-constants.js",
    "generate-bindings": "cargo test",
    "prettier:check": "prettier --check .",
@@ -54,5 +58,5 @@
  },
  "type": "module",
  "types": "dist/deltachat.d.ts",
-  "version": "1.157.3"
+  "version": "1.157.1"
 }
--- a/deltachat-jsonrpc/typescript/src/client.ts
+++ b/deltachat-jsonrpc/typescript/src/client.ts
@@ -2,7 +2,7 @@ import * as T from "../generated/types.js";
 import { EventType } from "../generated/types.js";
 import * as RPC from "../generated/jsonrpc.js";
 import { RawClient } from "../generated/client.js";
-import { BaseTransport, Request } from "yerpc";
+import { WebsocketTransport, BaseTransport, Request } from "yerpc";
 import { TinyEmitter } from "@deltachat/tiny-emitter";

 type Events = { ALL: (accountId: number, event: EventType) => void } & {
@@ -74,6 +74,34 @@ export class BaseDeltaChat<
  }
 }

+export type Opts = {
+  url: string;
+  startEventLoop: boolean;
+};
+
+export const DEFAULT_OPTS: Opts = {
+  url: "ws://localhost:20808/ws",
+  startEventLoop: true,
+};
+export class DeltaChat extends BaseDeltaChat<WebsocketTransport> {
+  opts: Opts;
+  close() {
+    this.transport.close();
+  }
+  constructor(opts?: Opts | string) {
+    if (typeof opts === "string") {
+      opts = { ...DEFAULT_OPTS, url: opts };
+    } else if (opts) {
+      opts = { ...DEFAULT_OPTS, ...opts };
+    } else {
+      opts = { ...DEFAULT_OPTS };
+    }
+    const transport = new WebsocketTransport(opts.url);
+    super(transport, opts.startEventLoop);
+    this.opts = opts;
+  }
+}
+
 export class StdioDeltaChat extends BaseDeltaChat<StdioTransport> {
  close() {}
  constructor(input: any, output: any, startEventLoop: boolean) {
--- a/deltachat-jsonrpc/typescript/tsconfig.json
+++ b/deltachat-jsonrpc/typescript/tsconfig.json
@@ -15,6 +15,6 @@
    "noImplicitAny": true,
    "isolatedModules": true
  },
-  "include": ["*.ts", "test/*.ts"],
+  "include": ["*.ts", "example/*.ts", "test/*.ts"],
  "compileOnSave": false
 }
--- a/deltachat-repl/Cargo.toml
+++ b/deltachat-repl/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "deltachat-repl"
-version = "1.157.3"
+version = "1.157.1"
 license = "MPL-2.0"
 edition = "2021"
 repository = "https://github.com/chatmail/core"
--- 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.157.3"
+version = "1.157.1"
 description = "Python client for Delta Chat core JSON-RPC interface"
 classifiers = [
    "Development Status :: 5 - Production/Stable",
--- a/deltachat-rpc-client/src/deltachat_rpc_client/account.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/account.py
@@ -1,6 +1,8 @@
 from __future__ import annotations

 from dataclasses import dataclass
+from pathlib import Path
+from tempfile import TemporaryDirectory
 from typing import TYPE_CHECKING, Optional, Union
 from warnings import warn

@@ -26,12 +28,9 @@ class Account:
    def _rpc(self) -> "Rpc":
        return self.manager.rpc

-    def wait_for_event(self, event_type=None) -> AttrDict:
+    def wait_for_event(self) -> AttrDict:
        """Wait until the next event and return it."""
-        while True:
-            next_event = AttrDict(self._rpc.wait_for_event(self.id))
-            if event_type is None or next_event.kind == event_type:
-                return next_event
+        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."""
@@ -42,14 +41,14 @@ class Account:
        self._rpc.remove_account(self.id)

    def clone(self) -> "Account":
-        """Clone given account.
-        This uses backup-transfer via iroh, i.e. the 'Add second device' feature."""
-        future = self._rpc.provide_backup.future(self.id)
-        qr = self._rpc.get_backup_qr(self.id)
-        new_account = self.manager.add_account()
-        new_account._rpc.get_backup(new_account.id, qr)
-        future()
-        return new_account
+        """Clone given account."""
+        with TemporaryDirectory() as tmp_dir:
+            tmp_path = Path(tmp_dir)
+            self.export_backup(tmp_path)
+            files = list(tmp_path.glob("*.tar"))
+            new_account = self.manager.add_account()
+            new_account.import_backup(files[0])
+            return new_account

    def start_io(self) -> None:
        """Start the account I/O."""
@@ -113,7 +112,10 @@ class Account:
    def bring_online(self):
        """Start I/O and wait until IMAP becomes IDLE."""
        self.start_io()
-        self.wait_for_event(EventType.IMAP_INBOX_IDLE)
+        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.
@@ -332,15 +334,24 @@ class Account:

    def wait_for_incoming_msg_event(self):
        """Wait for incoming message event and return it."""
-        return self.wait_for_event(EventType.INCOMING_MSG)
+        while True:
+            event = self.wait_for_event()
+            if event.kind == EventType.INCOMING_MSG:
+                return event

    def wait_for_msgs_changed_event(self):
        """Wait for messages changed event and return it."""
-        return self.wait_for_event(EventType.MSGS_CHANGED)
+        while True:
+            event = self.wait_for_event()
+            if event.kind == EventType.MSGS_CHANGED:
+                return event

    def wait_for_msgs_noticed_event(self):
        """Wait for messages noticed event and return it."""
-        return self.wait_for_event(EventType.MSGS_NOTICED)
+        while True:
+            event = self.wait_for_event()
+            if event.kind == EventType.MSGS_NOTICED:
+                return event

    def wait_for_incoming_msg(self):
        """Wait for incoming message and return it.
@@ -361,7 +372,10 @@ class Account:
                break

    def wait_for_reactions_changed(self):
-        return self.wait_for_event(EventType.REACTIONS_CHANGED)
+        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."""
--- a/deltachat-rpc-client/src/deltachat_rpc_client/pytestplugin.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/pytestplugin.py
@@ -4,7 +4,6 @@ import os
 import random
 from typing import AsyncGenerator, Optional

-import py
 import pytest

 from . import Account, AttrDict, Bot, Chat, Client, DeltaChat, EventType, Message
@@ -125,50 +124,3 @@ def rpc(tmp_path) -> AsyncGenerator:
@pytest.fixture
 def acfactory(rpc) -> AsyncGenerator:
    return ACFactory(DeltaChat(rpc))
-
-
-@pytest.fixture
-def data():
-    """Test data."""
-
-    class Data:
-        def __init__(self) -> None:
-            for path in reversed(py.path.local(__file__).parts()):
-                datadir = path.join("test-data")
-                if datadir.isdir():
-                    self.path = datadir
-                    return
-            raise Exception("Data path cannot be found")
-
-        def get_path(self, bn):
-            """return path of file or None if it doesn't exist."""
-            fn = os.path.join(self.path, *bn.split("/"))
-            assert os.path.exists(fn)
-            return fn
-
-        def read_path(self, bn, mode="r"):
-            fn = self.get_path(bn)
-            if fn is not None:
-                with open(fn, mode) as f:
-                    return f.read()
-            return None
-
-    return Data()
-
-
-@pytest.fixture
-def log():
-    """Log printer fixture."""
-
-    class Printer:
-        def section(self, msg: str) -> None:
-            print()
-            print("=" * 10, msg, "=" * 10)
-
-        def step(self, msg: str) -> None:
-            print("-" * 5, "step " + msg, "-" * 5)
-
-        def indent(self, msg: str) -> None:
-            print("  " + msg)
-
-    return Printer()
--- a/deltachat-rpc-client/tests/test_iroh_webxdc.py
+++ b/deltachat-rpc-client/tests/test_iroh_webxdc.py
@@ -175,11 +175,17 @@ def test_no_duplicate_messages(acfactory, path_to_webxdc):

    threading.Thread(target=thread_run, daemon=True).start()

-    event = ac2.wait_for_event(EventType.WEBXDC_REALTIME_DATA)
-    n = int(bytes(event.data).decode())
+    while 1:
+        event = ac2.wait_for_event()
+        if event.kind == EventType.WEBXDC_REALTIME_DATA:
+            n = int(bytes(event.data).decode())
+            break

-    event = ac2.wait_for_event(EventType.WEBXDC_REALTIME_DATA)
-    assert int(bytes(event.data).decode()) > n
+    while 1:
+        event = ac2.wait_for_event()
+        if event.kind == EventType.WEBXDC_REALTIME_DATA:
+            assert int(bytes(event.data).decode()) > n
+            break


 def test_no_reordering(acfactory, path_to_webxdc):
@@ -223,5 +229,8 @@ def test_advertisement_after_chatting(acfactory, path_to_webxdc):
    ac2_hello_msg_snapshot.chat.accept()

    ac2_webxdc_msg.send_webxdc_realtime_advertisement()
-    event = ac1.wait_for_event(EventType.WEBXDC_REALTIME_ADVERTISEMENT_RECEIVED)
-    assert event.msg_id == ac1_webxdc_msg.id
+    while 1:
+        event = ac1.wait_for_event()
+        if event.kind == EventType.WEBXDC_REALTIME_ADVERTISEMENT_RECEIVED:
+            assert event.msg_id == ac1_webxdc_msg.id
+            break
--- a/deltachat-rpc-client/tests/test_key_transfer.py
+++ b/deltachat-rpc-client/tests/test_key_transfer.py
@@ -21,7 +21,6 @@ def test_autocrypt_setup_message_key_transfer(acfactory):
    alice2.set_config("addr", alice1.get_config("addr"))
    alice2.set_config("mail_pw", alice1.get_config("mail_pw"))
    alice2.configure()
-    alice2.bring_online()

    setup_code = alice1.initiate_autocrypt_key_transfer()
    msg = wait_for_autocrypt_setup_message(alice2)
@@ -35,12 +34,10 @@ def test_autocrypt_setup_message_key_transfer(acfactory):

 def test_ac_setup_message_twice(acfactory):
    alice1 = acfactory.get_online_account()
-
    alice2 = acfactory.get_unconfigured_account()
    alice2.set_config("addr", alice1.get_config("addr"))
    alice2.set_config("mail_pw", alice1.get_config("mail_pw"))
    alice2.configure()
-    alice2.bring_online()

    # Send the first Autocrypt Setup Message and ignore it.
    _setup_code = alice1.initiate_autocrypt_key_transfer()
--- a/deltachat-rpc-client/tests/test_securejoin.py
+++ b/deltachat-rpc-client/tests/test_securejoin.py
@@ -76,11 +76,17 @@ def test_qr_securejoin(acfactory, protect):
    bob.secure_join(qr_code)

    # Alice deletes "vg-request".
-    alice.wait_for_event(EventType.IMAP_MESSAGE_DELETED)
+    while True:
+        event = alice.wait_for_event()
+        if event["kind"] == "ImapMessageDeleted":
+            break
    alice.wait_for_securejoin_inviter_success()
    # Bob deletes "vg-auth-required", Alice deletes "vg-request-with-auth".
    for ac in [alice, bob]:
-        ac.wait_for_event(EventType.IMAP_MESSAGE_DELETED)
+        while True:
+            event = ac.wait_for_event()
+            if event["kind"] == "ImapMessageDeleted":
+                break
    bob.wait_for_securejoin_joiner_success()

    # Test that Alice verified Bob's profile.
@@ -457,7 +463,6 @@ def test_qr_new_group_unblocked(acfactory):
    assert ac2_msg.chat.get_basic_snapshot().is_contact_request


-@pytest.mark.skip(reason="AEAP is disabled for now")
 def test_aeap_flow_verified(acfactory):
    """Test that a new address is added to a contact when it changes its address."""
    ac1, ac2 = acfactory.get_online_accounts(2)
--- a/deltachat-rpc-client/tests/test_something.py
+++ b/deltachat-rpc-client/tests/test_something.py
@@ -110,9 +110,12 @@ def test_account(acfactory) -> None:
    alice_chat_bob = alice_contact_bob.create_chat()
    alice_chat_bob.send_text("Hello!")

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

    message = bob.get_message_by_id(msg_id)
    snapshot = message.get_snapshot()
@@ -284,31 +287,6 @@ def test_message(acfactory) -> None:
    assert reactions == snapshot.reactions


-def test_selfavatar_sync(acfactory, data, log) -> None:
-    alice = acfactory.get_online_account()
-
-    log.section("Alice adds a second device")
-    alice2 = alice.clone()
-
-    log.section("Second device goes online")
-    alice2.start_io()
-
-    log.section("First device changes avatar")
-    image = data.get_path("image/avatar1000x1000.jpg")
-    alice.set_config("selfavatar", image)
-    avatar_config = alice.get_config("selfavatar")
-    avatar_hash = os.path.basename(avatar_config)
-    print("Info: avatar hash is ", avatar_hash)
-
-    log.section("First device receives avatar change")
-    alice2.wait_for_event(EventType.SELFAVATAR_CHANGED)
-    avatar_config2 = alice2.get_config("selfavatar")
-    avatar_hash2 = os.path.basename(avatar_config2)
-    print("Info: avatar hash on second device is ", avatar_hash2)
-    assert avatar_hash == avatar_hash2
-    assert avatar_config != avatar_config2
-
-
 def test_reaction_seen_on_another_dev(acfactory) -> None:
    alice, bob = acfactory.get_online_accounts(2)
    alice2 = alice.clone()
@@ -327,11 +305,18 @@ def test_reaction_seen_on_another_dev(acfactory) -> None:
    snapshot.chat.accept()
    message.send_reaction("😎")
    for a in [alice, alice2]:
-        a.wait_for_event(EventType.INCOMING_REACTION)
+        while True:
+            event = a.wait_for_event()
+            if event.kind == EventType.INCOMING_REACTION:
+                break

    alice2.clear_all_events()
    alice_chat_bob.mark_noticed()
-    chat_id = alice2.wait_for_event(EventType.MSGS_NOTICED).chat_id
+    while True:
+        event = alice2.wait_for_event()
+        if event.kind == EventType.MSGS_NOTICED:
+            chat_id = event.chat_id
+            break
    alice2_contact_bob = alice2.get_contact_by_addr(bob_addr)
    alice2_chat_bob = alice2_contact_bob.create_chat()
    assert chat_id == alice2_chat_bob.id
@@ -349,12 +334,16 @@ def test_is_bot(acfactory) -> None:
    alice.set_config("bot", "1")
    alice_chat_bob.send_text("Hello!")

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


 def test_bot(acfactory) -> None:
@@ -515,7 +504,10 @@ def test_mdn_doesnt_break_autocrypt(acfactory) -> None:

    # Alice reads Bob's message.
    message.mark_seen()
-    bob.wait_for_event(EventType.MSG_READ)
+    while True:
+        event = bob.wait_for_event()
+        if event.kind == EventType.MSG_READ:
+            break

    # Bob sends a message to Alice, it should also be encrypted.
    bob_chat_alice.send_text("Hi Alice!")
@@ -685,7 +677,10 @@ def test_markseen_contact_request(acfactory):
    assert message2.get_snapshot().state == MessageState.IN_FRESH

    message.mark_seen()
-    bob2.wait_for_event(EventType.MSGS_NOTICED)
+    while True:
+        event = bob2.wait_for_event()
+        if event.kind == EventType.MSGS_NOTICED:
+            break
    assert message2.get_snapshot().state == MessageState.IN_SEEN


@@ -733,8 +728,6 @@ def test_no_old_msg_is_fresh(acfactory):
    assert ac1.create_chat(ac2).get_fresh_message_count() == 1
    assert len(list(ac1.get_fresh_messages())) == 1

-    ac1.wait_for_event(EventType.IMAP_INBOX_IDLE)
-
    logging.info("Send a message from ac1_clone to ac2 and check that ac1 marks the first message as 'noticed'")
    ac1_clone_chat.send_text("Hi back")
    ev = ac1.wait_for_msgs_noticed_event()
--- a/deltachat-rpc-client/tests/test_webxdc.py
+++ b/deltachat-rpc-client/tests/test_webxdc.py
@@ -1,3 +1,6 @@
+from deltachat_rpc_client import EventType
+
+
 def test_webxdc(acfactory) -> None:
    alice, bob = acfactory.get_online_accounts(2)

@@ -6,9 +9,12 @@ def test_webxdc(acfactory) -> None:
    alice_chat_bob = alice_contact_bob.create_chat()
    alice_chat_bob.send_message(text="Let's play chess!", file="../test-data/webxdc/chess.xdc")

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

    webxdc_info = message.get_webxdc_info()
    assert webxdc_info == {
--- a/deltachat-rpc-server/Cargo.toml
+++ b/deltachat-rpc-server/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "deltachat-rpc-server"
-version = "1.157.3"
+version = "1.157.1"
 description = "DeltaChat JSON-RPC server"
 edition = "2021"
 readme = "README.md"
--- a/deltachat-rpc-server/npm-package/package.json
+++ b/deltachat-rpc-server/npm-package/package.json
@@ -15,5 +15,5 @@
  },
  "type": "module",
  "types": "index.d.ts",
-  "version": "1.157.3"
+  "version": "1.157.1"
 }
--- a/deny.toml
+++ b/deny.toml
@@ -31,7 +31,6 @@ skip = [
     { name = "event-listener", version = "2.5.3" },
     { name = "generator", version = "0.7.5" },
     { name = "getrandom", version = "0.2.12" },
-     { name = "heck", version = "0.4.1" },
     { name = "http", version = "0.2.12" },
     { name = "loom", version = "0.5.6" },
     { name = "netlink-packet-route", version = "0.17.1" },
@@ -46,11 +45,12 @@ skip = [
     { name = "regex-syntax", version = "0.6.29" },
     { name = "rtnetlink", version = "0.13.1" },
     { name = "security-framework", version = "2.11.1" },
-     { name = "strum_macros", version = "0.26.2" },
-     { name = "strum", version = "0.26.2" },
+     { name = "sync_wrapper", version = "0.1.2" },
     { name = "syn", version = "1.0.109" },
     { name = "thiserror-impl", version = "1.0.69" },
     { name = "thiserror", version = "1.0.69" },
+     { name = "tokio-tungstenite", version = "0.21.0" },
+     { name = "tungstenite", version = "0.21.0" },
     { name = "unicode-width", version = "0.1.11" },
     { name = "wasi", version = "0.11.0+wasi-snapshot-preview1" },
     { name = "windows" },
--- a/python/pyproject.toml
+++ b/python/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"

 [project]
 name = "deltachat"
-version = "1.157.3"
+version = "1.157.1"
 description = "Python bindings for the Delta Chat Core library using CFFI against the Rust-implemented libdeltachat"
 readme = "README.rst"
 requires-python = ">=3.8"
--- a/release-date.in
+++ b/release-date.in
@@ -1 +1 @@
-2025-03-19
+2025-03-13
--- a/src/blob.rs
+++ b/src/blob.rs
@@ -193,7 +193,6 @@ impl<'a> BlobObject<'a> {
    /// Note that this is NOT the user-visible filename,
    /// which is only stored in Param::Filename on the message.
    ///
-    #[allow(rustdoc::private_intra_doc_links)]
    /// [Params]: crate::param::Params
    pub fn as_name(&self) -> &str {
        &self.name
@@ -252,7 +251,6 @@ impl<'a> BlobObject<'a> {
        Ok(blob.as_name().to_string())
    }

-    /// Recode image to avatar size.
    pub async fn recode_to_avatar_size(&mut self, context: &Context) -> Result<()> {
        let (img_wh, max_bytes) =
            match MediaQuality::from_i32(context.get_config_int(Config::MediaQuality).await?)
--- a/src/chat.rs
+++ b/src/chat.rs
@@ -3029,10 +3029,10 @@ pub(crate) async fn create_send_msg_jobs(context: &Context, msg: &mut Message) -
    // disabled by default is fine.
    //
    // `from` must be the last addr, see `receive_imf_inner()` why.
-    recipients.retain(|x| x.to_lowercase() != lowercase_from);
-    if (context.get_config_bool(Config::BccSelf).await?
-        || msg.param.get_cmd() == SystemMessage::AutocryptSetupMessage)
-        && (context.get_config_delete_server_after().await? != Some(0) || !recipients.is_empty())
+    if context.get_config_bool(Config::BccSelf).await?
+        && !recipients
+            .iter()
+            .any(|x| x.to_lowercase() == lowercase_from)
    {
        recipients.push(from);
    }
--- a/src/chat/chat_tests.rs
+++ b/src/chat/chat_tests.rs
@@ -2964,24 +2964,15 @@ async fn test_sync_accept_before_first_msg() -> Result<()> {

    let ba_chat = bob.create_chat(alice0).await;
    let sent_msg = bob.send_text(ba_chat.id, "hi").await;
-    let rcvd_msg = alice0.recv_msg(&sent_msg).await;
-    let a0b_chat_id = rcvd_msg.chat_id;
-    let a0b_contact_id = rcvd_msg.from_id;
-    assert_eq!(
-        Chat::load_from_db(alice0, a0b_chat_id).await?.blocked,
-        Blocked::Request
-    );
+    let a0b_chat_id = alice0.recv_msg(&sent_msg).await.chat_id;
+    assert_eq!(alice0.get_chat(&bob).await.blocked, Blocked::Request);
    a0b_chat_id.accept(alice0).await?;
-    let a0b_contact = Contact::get_by_id(alice0, a0b_contact_id).await?;
+    let a0b_contact = alice0.add_or_lookup_contact(&bob).await;
    assert_eq!(a0b_contact.origin, Origin::CreateChat);
    assert_eq!(alice0.get_chat(&bob).await.blocked, Blocked::Not);

    sync(alice0, alice1).await;
-    let alice1_contacts = Contact::get_all(alice1, 0, None).await?;
-    assert_eq!(alice1_contacts.len(), 1);
-    let a1b_contact_id = alice1_contacts[0];
-    let a1b_contact = Contact::get_by_id(alice1, a1b_contact_id).await?;
-    assert_eq!(a1b_contact.get_addr(), "bob@example.net");
+    let a1b_contact = alice1.add_or_lookup_contact(&bob).await;
    assert_eq!(a1b_contact.origin, Origin::CreateChat);
    let a1b_chat = alice1.get_chat(&bob).await;
    assert_eq!(a1b_chat.blocked, Blocked::Not);
@@ -3004,22 +2995,22 @@ async fn test_sync_block_before_first_msg() -> Result<()> {

    let ba_chat = bob.create_chat(alice0).await;
    let sent_msg = bob.send_text(ba_chat.id, "hi").await;
-    let rcvd_msg = alice0.recv_msg(&sent_msg).await;
-    let a0b_chat_id = rcvd_msg.chat_id;
-    let a0b_contact_id = rcvd_msg.from_id;
+    let a0b_chat_id = alice0.recv_msg(&sent_msg).await.chat_id;
    assert_eq!(alice0.get_chat(&bob).await.blocked, Blocked::Request);
    a0b_chat_id.block(alice0).await?;
-    let a0b_contact = Contact::get_by_id(alice0, a0b_contact_id).await?;
+    let a0b_contact = alice0.add_or_lookup_contact(&bob).await;
    assert_eq!(a0b_contact.origin, Origin::IncomingUnknownFrom);
    assert_eq!(alice0.get_chat(&bob).await.blocked, Blocked::Yes);

    sync(alice0, alice1).await;
-    let alice1_contacts = Contact::get_all(alice1, 0, None).await?;
-    assert_eq!(alice1_contacts.len(), 0);
+    let a1b_contact = alice1.add_or_lookup_contact(&bob).await;
+    assert_eq!(a1b_contact.origin, Origin::Hidden);
+    assert!(ChatIdBlocked::lookup_by_contact(alice1, a1b_contact.id)
+        .await?
+        .is_none());

    let rcvd_msg = alice1.recv_msg(&sent_msg).await;
-    let a1b_contact_id = rcvd_msg.from_id;
-    let a1b_contact = Contact::get_by_id(alice1, a1b_contact_id).await?;
+    let a1b_contact = alice1.add_or_lookup_contact(&bob).await;
    assert_eq!(a1b_contact.origin, Origin::IncomingUnknownFrom);
    let a1b_chat = alice1.get_chat(&bob).await;
    assert_eq!(a1b_chat.blocked, Blocked::Yes);
--- a/src/configure.rs
+++ b/src/configure.rs
@@ -28,15 +28,13 @@ use crate::constants::NON_ALPHANUMERIC_WITHOUT_DOT;
 use crate::context::Context;
 use crate::imap::Imap;
 use crate::log::LogExt;
-pub use crate::login_param::EnteredLoginParam;
 use crate::login_param::{
    ConfiguredCertificateChecks, ConfiguredLoginParam, ConfiguredServerLoginParam,
-    ConnectionCandidate, EnteredCertificateChecks, ProxyConfig,
+    ConnectionCandidate, EnteredCertificateChecks, EnteredLoginParam,
 };
 use crate::message::Message;
 use crate::oauth2::get_oauth2_addr;
 use crate::provider::{Protocol, Socket, UsernamePattern};
-use crate::qr::set_account_from_qr;
 use crate::smtp::Smtp;
 use crate::sync::Sync::*;
 use crate::tools::time;
@@ -66,59 +64,8 @@ impl Context {
        self.sql.get_raw_config_bool("configured").await
    }

-    /// Configures this account with the currently provided parameters.
-    ///
-    /// Deprecated since 2025-02; use `add_transport_from_qr()`
-    /// or `add_transport()` instead.
+    /// Configures this account with the currently set parameters.
    pub async fn configure(&self) -> Result<()> {
-        let param = EnteredLoginParam::load(self).await?;
-
-        self.add_transport_inner(&param).await
-    }
-
-    /// Configures a new email account using the provided parameters
-    /// and adds it as a transport.
-    ///
-    /// If the email address is the same as an existing transport,
-    /// then this existing account will be reconfigured instead of a new one being added.
-    ///
-    /// This function stops and starts IO as needed.
-    ///
-    /// Usually it will be enough to only set `addr` and `imap.password`,
-    /// and all the other settings will be autoconfigured.
-    ///
-    /// During configuration, ConfigureProgress events are emitted;
-    /// they indicate a successful configuration as well as errors
-    /// and may be used to create a progress bar.
-    /// This function will return after configuration is finished.
-    ///
-    /// If configuration is successful,
-    /// the working server parameters will be saved
-    /// and used for connecting to the server.
-    /// The parameters entered by the user will be saved separately
-    /// so that they can be prefilled when the user opens the server-configuration screen again.
-    ///
-    /// See also:
-    /// - [Self::is_configured()] to check whether there is
-    ///   at least one working transport.
-    /// - [Self::add_transport_from_qr()] to add a transport
-    ///   from a server encoded in a QR code.
-    /// - [Self::list_transports()] to get a list of all configured transports.
-    /// - [Self::delete_transport()] to remove a transport.
-    pub async fn add_transport(&self, param: &EnteredLoginParam) -> Result<()> {
-        self.stop_io().await;
-        let result = self.add_transport_inner(param).await;
-        if result.is_err() {
-            if let Ok(true) = self.is_configured().await {
-                self.start_io().await;
-            }
-            return result;
-        }
-        self.start_io().await;
-        Ok(())
-    }
-
-    async fn add_transport_inner(&self, param: &EnteredLoginParam) -> Result<()> {
        ensure!(
            !self.scheduler.is_running().await,
            "cannot configure, already running"
@@ -127,63 +74,42 @@ impl Context {
            self.sql.is_open().await,
            "cannot configure, database not opened."
        );
-        let old_addr = self.get_config(Config::ConfiguredAddr).await?;
-        if self.is_configured().await? && !addr_cmp(&old_addr.unwrap_or_default(), &param.addr) {
-            bail!("Adding a new transport is not supported right now. Check back in a few months!");
-        }
        let cancel_channel = self.alloc_ongoing().await?;

        let res = self
-            .inner_configure(param)
+            .inner_configure()
            .race(cancel_channel.recv().map(|_| Err(format_err!("Cancelled"))))
            .await;

        self.free_ongoing().await;

        if let Err(err) = res.as_ref() {
-            // We are using Anyhow's .context() and to show the
-            // inner error, too, we need the {:#}:
-            let error_msg = stock_str::configuration_failed(self, &format!("{err:#}")).await;
-            progress!(self, 0, Some(error_msg));
+            progress!(
+                self,
+                0,
+                Some(
+                    stock_str::configuration_failed(
+                        self,
+                        // We are using Anyhow's .context() and to show the
+                        // inner error, too, we need the {:#}:
+                        &format!("{err:#}"),
+                    )
+                    .await
+                )
+            );
        } else {
-            param.save(self).await?;
            progress!(self, 1000);
        }

        res
    }

-    /// Adds a new email account as a transport
-    /// using the server encoded in the QR code.
-    /// See [Self::add_transport].
-    pub async fn add_transport_from_qr(&self, qr: &str) -> Result<()> {
-        set_account_from_qr(self, qr).await?;
-        self.configure().await?;
-
-        Ok(())
-    }
-
-    /// Returns the list of all email accounts that are used as a transport in the current profile.
-    /// Use [Self::add_transport()] to add or change a transport
-    /// and [Self::delete_transport()] to delete a transport.
-    pub async fn list_transports(&self) -> Result<Vec<EnteredLoginParam>> {
-        let param = EnteredLoginParam::load(self).await?;
-
-        Ok(vec![param])
-    }
-
-    /// Removes the transport with the specified email address
-    /// (i.e. [EnteredLoginParam::addr]).
-    #[expect(clippy::unused_async)]
-    pub async fn delete_transport(&self, _addr: &str) -> Result<()> {
-        bail!("Adding and removing additional transports is not supported yet. Check back in a few months!")
-    }
-
-    async fn inner_configure(&self, param: &EnteredLoginParam) -> Result<()> {
+    async fn inner_configure(&self) -> Result<()> {
        info!(self, "Configure ...");

+        let param = EnteredLoginParam::load(self).await?;
        let old_addr = self.get_config(Config::ConfiguredAddr).await?;
-        let configured_param = configure(self, param).await?;
+        let configured_param = configure(self, &param).await?;
        self.set_config_internal(Config::NotifyAboutWrongPw, Some("1"))
            .await?;
        on_configure_completed(self, configured_param, old_addr).await?;
@@ -259,7 +185,8 @@ async fn get_configured_param(
        param.smtp.password.clone()
    };

-    let proxy_enabled = ctx.get_config_bool(Config::ProxyEnabled).await?;
+    let proxy_config = param.proxy_config.clone();
+    let proxy_enabled = proxy_config.is_some();

    let mut addr = param.addr.clone();
    if param.oauth2 {
@@ -418,7 +345,7 @@ async fn get_configured_param(
            .collect(),
        smtp_user: param.smtp.user.clone(),
        smtp_password,
-        proxy_config: ProxyConfig::load(ctx).await?,
+        proxy_config: param.proxy_config.clone(),
        provider,
        certificate_checks: match param.certificate_checks {
            EnteredCertificateChecks::Automatic => ConfiguredCertificateChecks::Automatic,
--- a/src/imex/key_transfer.rs
+++ b/src/imex/key_transfer.rs
@@ -46,11 +46,11 @@ pub async fn initiate_key_transfer(context: &Context) -> Result<String> {
    msg.force_plaintext();
    msg.param.set_int(Param::SkipAutocrypt, 1);

+    chat::send_msg(context, chat_id, &mut msg).await?;
+
    // Enable BCC-self, because transferring a key
    // means we have a multi-device setup.
    context.set_config_bool(Config::BccSelf, true).await?;
-
-    chat::send_msg(context, chat_id, &mut msg).await?;
    Ok(setup_code)
 }

--- a/src/imex/transfer.rs
+++ b/src/imex/transfer.rs
@@ -45,7 +45,7 @@ use crate::message::Message;
 use crate::qr::Qr;
 use crate::stock_str::backup_transfer_msg_body;
 use crate::tools::{create_id, time, TempPathGuard};
-use crate::{e2ee, EventType};
+use crate::EventType;

 use super::{export_backup_stream, export_database, import_backup_stream, DBFILE_BACKUP_NAME};

@@ -109,11 +109,6 @@ impl BackupProvider {
            .parent()
            .context("Context dir not found")?;

-        // before we export, make sure the private key exists
-        e2ee::ensure_secret_key_exists(context)
-            .await
-            .context("Cannot create private key or private key not available")?;
-
        let dbfile = context_dir.join(DBFILE_BACKUP_NAME);
        if fs::metadata(&dbfile).await.is_ok() {
            fs::remove_file(&dbfile).await?;
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -52,7 +52,7 @@ pub(crate) mod events;
 pub use events::*;

 mod aheader;
-pub mod blob;
+mod blob;
 pub mod chat;
 pub mod chatlist;
 pub mod config;
@@ -68,7 +68,7 @@ mod imap;
 pub mod imex;
 pub mod key;
 pub mod location;
-pub mod login_param;
+mod login_param;
 pub mod message;
 mod mimefactory;
 pub mod mimeparser;
--- a/src/login_param.rs
+++ b/src/login_param.rs
@@ -4,7 +4,6 @@ use std::fmt;

 use anyhow::{format_err, Context as _, Result};
 use deltachat_contact_tools::EmailAddress;
-use num_traits::ToPrimitive as _;
 use serde::{Deserialize, Serialize};

 use crate::config::Config;
@@ -12,11 +11,9 @@ use crate::configure::server_params::{expand_param_vector, ServerParams};
 use crate::constants::{DC_LP_AUTH_FLAGS, DC_LP_AUTH_NORMAL, DC_LP_AUTH_OAUTH2};
 use crate::context::Context;
 use crate::net::load_connection_timestamp;
-pub use crate::net::proxy::ProxyConfig;
-pub use crate::provider::Socket;
-use crate::provider::{Protocol, Provider, UsernamePattern};
+use crate::net::proxy::ProxyConfig;
+use crate::provider::{Protocol, Provider, Socket, UsernamePattern};
 use crate::sql::Sql;
-use crate::tools::ToOption;

 /// User-entered setting for certificate checks.
 ///
@@ -47,7 +44,7 @@ pub enum EnteredCertificateChecks {
 #[derive(Copy, Clone, Debug, Display, FromPrimitive, ToPrimitive, PartialEq, Eq)]
 #[repr(u32)]
 #[strum(serialize_all = "snake_case")]
-pub(crate) enum ConfiguredCertificateChecks {
+pub enum ConfiguredCertificateChecks {
    /// Use configuration from the provider database.
    /// If there is no provider database setting for certificate checks,
    /// accept invalid certificates.
@@ -119,13 +116,15 @@ pub struct EnteredLoginParam {
    /// invalid hostnames
    pub certificate_checks: EnteredCertificateChecks,

-    /// If true, login via OAUTH2 (not recommended anymore)
+    /// Proxy configuration.
+    pub proxy_config: Option<ProxyConfig>,
+
    pub oauth2: bool,
 }

 impl EnteredLoginParam {
    /// Loads entered account settings.
-    pub(crate) async fn load(context: &Context) -> Result<Self> {
+    pub async fn load(context: &Context) -> Result<Self> {
        let addr = context
            .get_config(Config::Addr)
            .await?
@@ -197,6 +196,8 @@ impl EnteredLoginParam {
            .unwrap_or_default();
        let oauth2 = matches!(server_flags & DC_LP_AUTH_FLAGS, DC_LP_AUTH_OAUTH2);

+        let proxy_config = ProxyConfig::load(context).await?;
+
        Ok(EnteredLoginParam {
            addr,
            imap: EnteredServerLoginParam {
@@ -214,71 +215,10 @@ impl EnteredLoginParam {
                password: send_pw,
            },
            certificate_checks,
+            proxy_config,
            oauth2,
        })
    }
-
-    /// Saves entered account settings,
-    /// so that they can be prefilled if the user wants to configure the server again.
-    pub(crate) async fn save(&self, context: &Context) -> Result<()> {
-        context.set_config(Config::Addr, Some(&self.addr)).await?;
-
-        context
-            .set_config(Config::MailServer, self.imap.server.to_option())
-            .await?;
-        context
-            .set_config(Config::MailPort, self.imap.port.to_option().as_deref())
-            .await?;
-        context
-            .set_config(
-                Config::MailSecurity,
-                self.imap.security.to_i32().to_option().as_deref(),
-            )
-            .await?;
-        context
-            .set_config(Config::MailUser, self.imap.user.to_option())
-            .await?;
-        context
-            .set_config(Config::MailPw, self.imap.password.to_option())
-            .await?;
-
-        context
-            .set_config(Config::SendServer, self.smtp.server.to_option())
-            .await?;
-        context
-            .set_config(Config::SendPort, self.smtp.port.to_option().as_deref())
-            .await?;
-        context
-            .set_config(
-                Config::SendSecurity,
-                self.smtp.security.to_i32().to_option().as_deref(),
-            )
-            .await?;
-        context
-            .set_config(Config::SendUser, self.smtp.user.to_option())
-            .await?;
-        context
-            .set_config(Config::SendPw, self.smtp.password.to_option())
-            .await?;
-
-        context
-            .set_config(
-                Config::ImapCertificateChecks,
-                self.certificate_checks.to_i32().to_option().as_deref(),
-            )
-            .await?;
-
-        let server_flags = if self.oauth2 {
-            Some(DC_LP_AUTH_OAUTH2.to_string())
-        } else {
-            None
-        };
-        context
-            .set_config(Config::ServerFlags, server_flags.as_deref())
-            .await?;
-
-        Ok(())
-    }
 }

 impl fmt::Display for EnteredLoginParam {
@@ -379,7 +319,7 @@ impl TryFrom<Socket> for ConnectionSecurity {
 }

 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub(crate) struct ConfiguredServerLoginParam {
+pub struct ConfiguredServerLoginParam {
    pub connection: ConnectionCandidate,

    /// Username.
@@ -417,7 +357,7 @@ pub(crate) async fn prioritize_server_login_params(
 /// Login parameters saved to the database
 /// after successful configuration.
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct ConfiguredLoginParam {
+pub struct ConfiguredLoginParam {
    /// `From:` address that was used at the time of configuration.
    pub addr: String,

@@ -450,7 +390,6 @@ pub(crate) struct ConfiguredLoginParam {
    /// invalid hostnames
    pub certificate_checks: ConfiguredCertificateChecks,

-    /// If true, login via OAUTH2 (not recommended anymore)
    pub oauth2: bool,
 }

@@ -489,7 +428,7 @@ impl ConfiguredLoginParam {
    /// Load configured account settings from the database.
    ///
    /// Returns `None` if account is not configured.
-    pub(crate) async fn load(context: &Context) -> Result<Option<Self>> {
+    pub async fn load(context: &Context) -> Result<Option<Self>> {
        if !context.get_config_bool(Config::Configured).await? {
            return Ok(None);
        }
@@ -760,7 +699,7 @@ impl ConfiguredLoginParam {
    }

    /// Save this loginparam to the database.
-    pub(crate) async fn save_as_configured_params(&self, context: &Context) -> Result<()> {
+    pub async fn save_as_configured_params(&self, context: &Context) -> Result<()> {
        context.set_primary_self_addr(&self.addr).await?;

        context
@@ -837,7 +776,7 @@ impl ConfiguredLoginParam {
        Ok(())
    }

-    pub(crate) fn strict_tls(&self) -> bool {
+    pub fn strict_tls(&self) -> bool {
        let provider_strict_tls = self.provider.map(|provider| provider.opt.strict_tls);
        match self.certificate_checks {
            ConfiguredCertificateChecks::OldAutomatic => {
@@ -900,42 +839,6 @@ mod tests {
        Ok(())
    }

-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_save_entered_login_param() -> Result<()> {
-        let t = TestContext::new().await;
-        let param = EnteredLoginParam {
-            addr: "alice@example.org".to_string(),
-            imap: EnteredServerLoginParam {
-                server: "".to_string(),
-                port: 0,
-                security: Socket::Starttls,
-                user: "".to_string(),
-                password: "foobar".to_string(),
-            },
-            smtp: EnteredServerLoginParam {
-                server: "".to_string(),
-                port: 2947,
-                security: Socket::default(),
-                user: "".to_string(),
-                password: "".to_string(),
-            },
-            certificate_checks: Default::default(),
-            oauth2: false,
-        };
-        param.save(&t).await?;
-        assert_eq!(
-            t.get_config(Config::Addr).await?.unwrap(),
-            "alice@example.org"
-        );
-        assert_eq!(t.get_config(Config::MailPw).await?.unwrap(), "foobar");
-        assert_eq!(t.get_config(Config::SendPw).await?, None);
-        assert_eq!(t.get_config_int(Config::SendPort).await?, 2947);
-
-        assert_eq!(EnteredLoginParam::load(&t).await?, param);
-
-        Ok(())
-    }
-
    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
    async fn test_save_load_login_param() -> Result<()> {
        let t = TestContext::new().await;
--- a/src/mimefactory.rs
+++ b/src/mimefactory.rs
@@ -184,6 +184,9 @@ impl MimeFactory {
        let mut req_mdn = false;

        if chat.is_self_talk() {
+            if msg.param.get_cmd() == SystemMessage::AutocryptSetupMessage {
+                recipients.push(from_addr.to_string());
+            }
            to.push((from_displayname.to_string(), from_addr.to_string()));
        } else if chat.is_mailing_list() {
            let list_post = chat
@@ -604,7 +607,10 @@ impl MimeFactory {
                || to.len() + past_members.len() == self.member_timestamps.len()
        );
        if to.is_empty() {
-            to.push(hidden_recipients());
+            to.push(Address::new_group(
+                Some("hidden-recipients".to_string()),
+                Vec::new(),
+            ));
        }

        // Start with Internet Message Format headers in the order of the standard example
@@ -707,11 +713,12 @@ impl MimeFactory {

        if let Loaded::Message { chat, .. } = &self.loaded {
            if chat.typ == Chattype::Broadcast {
+                let encoded_chat_name = encode_words(&chat.name);
                headers.push((
                    "List-ID",
-                    mail_builder::headers::text::Text::new(format!(
-                        "{} <{}>",
-                        chat.name, chat.grpid
+                    mail_builder::headers::raw::Raw::new(format!(
+                        "{encoded_chat_name} <{}>",
+                        chat.grpid
                    ))
                    .into(),
                ));
@@ -881,23 +888,21 @@ impl MimeFactory {
            } else if header_name == "to" {
                protected_headers.push(header.clone());
                if is_encrypted {
-                    let mut to_without_names = to
-                        .clone()
-                        .into_iter()
-                        .filter_map(|header| match header {
-                            Address::Address(mb) => Some(Address::Address(EmailAddress {
-                                name: None,
-                                email: mb.email,
-                            })),
-                            _ => None,
-                        })
-                        .collect::<Vec<_>>();
-                    if to_without_names.is_empty() {
-                        to_without_names.push(hidden_recipients());
-                    }
                    unprotected_headers.push((
                        original_header_name,
-                        Address::new_list(to_without_names).into(),
+                        Address::new_list(
+                            to.clone()
+                                .into_iter()
+                                .filter_map(|header| match header {
+                                    Address::Address(mb) => Some(Address::Address(EmailAddress {
+                                        name: None,
+                                        email: mb.email,
+                                    })),
+                                    _ => None,
+                                })
+                                .collect::<Vec<_>>(),
+                        )
+                        .into(),
                    ));
                } else {
                    unprotected_headers.push(header.clone());
@@ -1628,10 +1633,6 @@ impl MimeFactory {
    }
 }

-fn hidden_recipients() -> Address<'static> {
-    Address::new_group(Some("hidden-recipients".to_string()), Vec::new())
-}
-
 async fn build_body_file(context: &Context, msg: &Message) -> Result<MimePart<'static>> {
    let file_name = msg.get_filename().context("msg has no file")?;
    let suffix = Path::new(&file_name)
@@ -1747,5 +1748,13 @@ fn render_rfc724_mid(rfc724_mid: &str) -> String {
    }
 }

+/* ******************************************************************************
+ * Encode/decode header words, RFC 2047
+ ******************************************************************************/
+
+fn encode_words(word: &str) -> String {
+    encoded_words::encode(word, None, encoded_words::EncodingFlag::Shortest, None)
+}
+
 #[cfg(test)]
 mod mimefactory_tests;
--- a/src/mimefactory/mimefactory_tests.rs
+++ b/src/mimefactory/mimefactory_tests.rs
@@ -898,23 +898,3 @@ async fn test_dont_remove_self() -> Result<()> {

    Ok(())
 }
-
-/// Regression test: mimefactory should never create an empty to header,
-/// also not if the Selftalk parameter is missing
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn test_no_empty_to_header() -> Result<()> {
-    let alice = &TestContext::new_alice().await;
-    let mut self_chat = alice.get_self_chat().await;
-    self_chat.param.remove(Param::Selftalk);
-    self_chat.update_param(alice).await?;
-
-    let payload = alice.send_text(self_chat.id, "Hi").await.payload;
-    assert!(
-        // It would be equally fine if the payload contained `To: alice@example.org` or similar,
-        // as long as it's a valid header
-        payload.contains("To: \"hidden-recipients\": ;"),
-        "Payload doesn't contain correct To: header: {payload}"
-    );
-
-    Ok(())
-}
--- a/src/mimeparser.rs
+++ b/src/mimeparser.rs
@@ -264,7 +264,7 @@ impl MimeMessage {
                    // messages are shown as unencrypted anyway.

                    timestamp_sent =
-                        Self::get_timestamp_sent(&part.headers, timestamp_sent, timestamp_rcvd);
+                        Self::get_timestamp_sent(&mail.headers, timestamp_sent, timestamp_rcvd);
                    MimeMessage::merge_headers(
                        context,
                        &mut headers,
@@ -345,13 +345,6 @@ impl MimeMessage {
                    }

                    decrypted_msg = Some(msg);
-
-                    timestamp_sent = Self::get_timestamp_sent(
-                        &decrypted_mail.headers,
-                        timestamp_sent,
-                        timestamp_rcvd,
-                    );
-
                    if let Some(protected_aheader_value) = decrypted_mail
                        .headers
                        .get_header_value(HeaderDef::Autocrypt)
@@ -423,27 +416,13 @@ impl MimeMessage {
            content
        });
        if let (Ok(mail), true) = (mail, encrypted) {
+            timestamp_sent =
+                Self::get_timestamp_sent(&mail.headers, timestamp_sent, timestamp_rcvd);
            if !signatures.is_empty() {
                // Remove unsigned opportunistically protected headers from messages considered
                // Autocrypt-encrypted / displayed with padlock.
                // For "Subject" see <https://github.com/deltachat/deltachat-core-rust/issues/1790>.
-                for h in [
-                    HeaderDef::Subject,
-                    HeaderDef::ChatGroupId,
-                    HeaderDef::ChatGroupName,
-                    HeaderDef::ChatGroupNameChanged,
-                    HeaderDef::ChatGroupNameTimestamp,
-                    HeaderDef::ChatGroupAvatar,
-                    HeaderDef::ChatGroupMemberRemoved,
-                    HeaderDef::ChatGroupMemberAdded,
-                    HeaderDef::ChatGroupMemberTimestamps,
-                    HeaderDef::ChatGroupPastMembers,
-                    HeaderDef::ChatDelete,
-                    HeaderDef::ChatEdit,
-                    HeaderDef::ChatUserAvatar,
-                ] {
-                    headers.remove(h.get_headername());
-                }
+                headers.retain(|k, _| !(k.starts_with("chat-") || k == "subject"));
            }

            // let known protected headers from the decrypted
--- a/src/mimeparser/mimeparser_tests.rs
+++ b/src/mimeparser/mimeparser_tests.rs
@@ -1418,6 +1418,25 @@ async fn test_x_microsoft_original_message_id_precedence() -> Result<()> {
    Ok(())
 }

+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn test_extra_imf_chat_header() -> Result<()> {
+    let mut tcm = TestContextManager::new();
+    let t = &tcm.alice().await;
+    let chat_id = t.get_self_chat().await.id;
+
+    chat::send_text_msg(t, chat_id, "hi!".to_string()).await?;
+    let sent_msg = t.pop_sent_msg().await;
+    let payload = sent_msg
+        .payload
+        .replace("Message-ID:", "Chat-Forty-Two: 42\r\nMessage-ID:");
+    let msg = MimeMessage::from_bytes(t, payload.as_bytes(), None)
+        .await
+        .unwrap();
+    assert!(msg.headers.contains_key("chat-version"));
+    assert!(!msg.headers.contains_key("chat-forty-two"));
+    Ok(())
+}
+
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_long_in_reply_to() -> Result<()> {
    let t = TestContext::new_alice().await;
@@ -1982,32 +2001,3 @@ async fn test_chat_edit_imf_header() -> Result<()> {

    Ok(())
 }
-
-/// Tests that timestamp of signed but not encrypted message is protected.
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn test_protected_date() -> Result<()> {
-    let mut tcm = TestContextManager::new();
-    let alice = &tcm.alice().await;
-    let bob = &tcm.bob().await;
-
-    alice.set_config(Config::SignUnencrypted, Some("1")).await?;
-
-    let alice_chat = alice.create_email_chat(bob).await;
-    let alice_msg_id = chat::send_text_msg(alice, alice_chat.id, "Hello!".to_string()).await?;
-    let alice_msg = Message::load_from_db(alice, alice_msg_id).await?;
-    assert_eq!(alice_msg.get_showpadlock(), false);
-
-    let mut sent_msg = alice.pop_sent_msg().await;
-    sent_msg.payload = sent_msg.payload.replacen(
-        "Date:",
-        "Date: Wed, 17 Mar 2021 14:30:53 +0100 (CET)\r\nX-Not-Date:",
-        1,
-    );
-    let bob_msg = bob.recv_msg(&sent_msg).await;
-    assert_eq!(alice_msg.get_text(), bob_msg.get_text());
-
-    // Timestamp that the sender has put into the message
-    // should always be displayed as is on the receiver.
-    assert_eq!(alice_msg.get_timestamp(), bob_msg.get_timestamp());
-    Ok(())
-}
--- a/src/net/proxy.rs
+++ b/src/net/proxy.rs
@@ -154,21 +154,18 @@ impl Socks5Config {
    }
 }

-/// Configuration for the proxy through which all traffic
-/// (except for iroh p2p connections)
-/// will be sent.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum ProxyConfig {
-    /// HTTP proxy.
+    // HTTP proxy.
    Http(HttpConfig),

-    /// HTTPS proxy.
+    // HTTPS proxy.
    Https(HttpConfig),

-    /// SOCKS5 proxy.
+    // SOCKS5 proxy.
    Socks5(Socks5Config),

-    /// Shadowsocks proxy.
+    // Shadowsocks proxy.
    Shadowsocks(ShadowsocksConfig),
 }

@@ -249,7 +246,7 @@ where

 impl ProxyConfig {
    /// Creates a new proxy configuration by parsing given proxy URL.
-    pub fn from_url(url: &str) -> Result<Self> {
+    pub(crate) fn from_url(url: &str) -> Result<Self> {
        let url = Url::parse(url).context("Cannot parse proxy URL")?;
        match url.scheme() {
            "http" => {
@@ -308,7 +305,7 @@ impl ProxyConfig {
    ///
    /// This function can be used to normalize proxy URL
    /// by parsing it and serializing back.
-    pub fn to_url(&self) -> String {
+    pub(crate) fn to_url(&self) -> String {
        match self {
            Self::Http(http_config) => http_config.to_url("http"),
            Self::Https(http_config) => http_config.to_url("https"),
@@ -394,7 +391,7 @@ impl ProxyConfig {

    /// If `load_dns_cache` is true, loads cached DNS resolution results.
    /// Use this only if the connection is going to be protected with TLS checks.
-    pub(crate) async fn connect(
+    pub async fn connect(
        &self,
        context: &Context,
        target_host: &str,
--- a/src/qr.rs
+++ b/src/qr.rs
@@ -695,7 +695,7 @@ struct CreateAccountErrorResponse {
 /// take a qr of the type DC_QR_ACCOUNT, parse it's parameters,
 /// download additional information from the contained url and set the parameters.
 /// on success, a configure::configure() should be able to log in to the account
-pub(crate) async fn set_account_from_qr(context: &Context, qr: &str) -> Result<()> {
+async fn set_account_from_qr(context: &Context, qr: &str) -> Result<()> {
    let url_str = qr
        .get(DCACCOUNT_SCHEME.len()..)
        .context("Invalid DCACCOUNT scheme")?;
--- a/src/receive_imf.rs
+++ b/src/receive_imf.rs
@@ -1495,9 +1495,73 @@ async fn add_parts(
        }
    }

-    if handle_edit_delete(context, mime_parser, from_id).await? {
+    if let Some(rfc724_mid) = mime_parser.get_header(HeaderDef::ChatEdit) {
        chat_id = DC_CHAT_ID_TRASH;
-        info!(context, "Message edits/deletes existing message (TRASH).");
+        if let Some((original_msg_id, _)) = rfc724_mid_exists(context, rfc724_mid).await? {
+            if let Some(mut original_msg) =
+                Message::load_from_db_optional(context, original_msg_id).await?
+            {
+                if original_msg.from_id == from_id {
+                    if let Some(part) = mime_parser.parts.first() {
+                        let edit_msg_showpadlock = part
+                            .param
+                            .get_bool(Param::GuaranteeE2ee)
+                            .unwrap_or_default();
+                        if edit_msg_showpadlock || !original_msg.get_showpadlock() {
+                            let new_text =
+                                part.msg.strip_prefix(EDITED_PREFIX).unwrap_or(&part.msg);
+                            chat::save_text_edit_to_db(context, &mut original_msg, new_text)
+                                .await?;
+                        } else {
+                            warn!(context, "Edit message: Not encrypted.");
+                        }
+                    }
+                } else {
+                    warn!(context, "Edit message: Bad sender.");
+                }
+            } else {
+                warn!(context, "Edit message: Database entry does not exist.");
+            }
+        } else {
+            warn!(
+                context,
+                "Edit message: rfc724_mid {rfc724_mid:?} not found."
+            );
+        }
+    } else if let Some(rfc724_mid_list) = mime_parser.get_header(HeaderDef::ChatDelete) {
+        chat_id = DC_CHAT_ID_TRASH;
+        if let Some(part) = mime_parser.parts.first() {
+            // See `message::delete_msgs_ex()`, unlike edit requests, DC doesn't send unencrypted
+            // deletion requests, so there's no need to support them.
+            if part.param.get_bool(Param::GuaranteeE2ee).unwrap_or(false) {
+                let mut modified_chat_ids = HashSet::new();
+                let mut msg_ids = Vec::new();
+
+                let rfc724_mid_vec: Vec<&str> = rfc724_mid_list.split_whitespace().collect();
+                for rfc724_mid in rfc724_mid_vec {
+                    if let Some((msg_id, _)) =
+                        message::rfc724_mid_exists(context, rfc724_mid).await?
+                    {
+                        if let Some(msg) = Message::load_from_db_optional(context, msg_id).await? {
+                            if msg.from_id == from_id {
+                                message::delete_msg_locally(context, &msg).await?;
+                                msg_ids.push(msg.id);
+                                modified_chat_ids.insert(msg.chat_id);
+                            } else {
+                                warn!(context, "Delete message: Bad sender.");
+                            }
+                        } else {
+                            warn!(context, "Delete message: Database entry does not exist.");
+                        }
+                    } else {
+                        warn!(context, "Delete message: {rfc724_mid:?} not found.");
+                    }
+                }
+                message::delete_msgs_locally_done(context, &msg_ids, modified_chat_ids).await?;
+            } else {
+                warn!(context, "Delete message: Not encrypted.");
+            }
+        }
    }

    let mut parts = mime_parser.parts.iter().peekable();
@@ -1766,89 +1830,6 @@ RETURNING id
    })
 }

-/// Checks for "Chat-Edit" and "Chat-Delete" headers,
-/// and edits/deletes existing messages accordingly.
-///
-/// Returns `true` if this message is an edit/deletion request.
-async fn handle_edit_delete(
-    context: &Context,
-    mime_parser: &MimeMessage,
-    from_id: ContactId,
-) -> Result<bool> {
-    if let Some(rfc724_mid) = mime_parser.get_header(HeaderDef::ChatEdit) {
-        if let Some((original_msg_id, _)) = rfc724_mid_exists(context, rfc724_mid).await? {
-            if let Some(mut original_msg) =
-                Message::load_from_db_optional(context, original_msg_id).await?
-            {
-                if original_msg.from_id == from_id {
-                    if let Some(part) = mime_parser.parts.first() {
-                        let edit_msg_showpadlock = part
-                            .param
-                            .get_bool(Param::GuaranteeE2ee)
-                            .unwrap_or_default();
-                        if edit_msg_showpadlock || !original_msg.get_showpadlock() {
-                            let new_text =
-                                part.msg.strip_prefix(EDITED_PREFIX).unwrap_or(&part.msg);
-                            chat::save_text_edit_to_db(context, &mut original_msg, new_text)
-                                .await?;
-                        } else {
-                            warn!(context, "Edit message: Not encrypted.");
-                        }
-                    }
-                } else {
-                    warn!(context, "Edit message: Bad sender.");
-                }
-            } else {
-                warn!(context, "Edit message: Database entry does not exist.");
-            }
-        } else {
-            warn!(
-                context,
-                "Edit message: rfc724_mid {rfc724_mid:?} not found."
-            );
-        }
-
-        Ok(true)
-    } else if let Some(rfc724_mid_list) = mime_parser.get_header(HeaderDef::ChatDelete) {
-        if let Some(part) = mime_parser.parts.first() {
-            // See `message::delete_msgs_ex()`, unlike edit requests, DC doesn't send unencrypted
-            // deletion requests, so there's no need to support them.
-            if part.param.get_bool(Param::GuaranteeE2ee).unwrap_or(false) {
-                let mut modified_chat_ids = HashSet::new();
-                let mut msg_ids = Vec::new();
-
-                let rfc724_mid_vec: Vec<&str> = rfc724_mid_list.split_whitespace().collect();
-                for rfc724_mid in rfc724_mid_vec {
-                    if let Some((msg_id, _)) =
-                        message::rfc724_mid_exists(context, rfc724_mid).await?
-                    {
-                        if let Some(msg) = Message::load_from_db_optional(context, msg_id).await? {
-                            if msg.from_id == from_id {
-                                message::delete_msg_locally(context, &msg).await?;
-                                msg_ids.push(msg.id);
-                                modified_chat_ids.insert(msg.chat_id);
-                            } else {
-                                warn!(context, "Delete message: Bad sender.");
-                            }
-                        } else {
-                            warn!(context, "Delete message: Database entry does not exist.");
-                        }
-                    } else {
-                        warn!(context, "Delete message: {rfc724_mid:?} not found.");
-                    }
-                }
-                message::delete_msgs_locally_done(context, &msg_ids, modified_chat_ids).await?;
-            } else {
-                warn!(context, "Delete message: Not encrypted.");
-            }
-        }
-
-        Ok(true)
-    } else {
-        Ok(false)
-    }
-}
-
 async fn tweak_sort_timestamp(
    context: &Context,
    mime_parser: &mut MimeMessage,
--- a/src/receive_imf/receive_imf_tests.rs
+++ b/src/receive_imf/receive_imf_tests.rs
@@ -2218,17 +2218,6 @@ async fn test_no_smtp_job_for_self_chat() -> Result<()> {
    let mut msg = Message::new_text("Happy birthday to me".to_string());
    chat::send_msg(bob, chat_id, &mut msg).await?;
    assert!(bob.pop_sent_msg_opt(Duration::ZERO).await.is_none());
-
-    bob.set_config_bool(Config::BccSelf, true).await?;
-    bob.set_config(Config::DeleteServerAfter, Some("1")).await?;
-    let mut msg = Message::new_text("Happy birthday to me".to_string());
-    chat::send_msg(bob, chat_id, &mut msg).await?;
-    assert!(bob.pop_sent_msg_opt(Duration::ZERO).await.is_none());
-
-    bob.set_config(Config::DeleteServerAfter, None).await?;
-    let mut msg = Message::new_text("Happy birthday to me".to_string());
-    chat::send_msg(bob, chat_id, &mut msg).await?;
-    assert!(bob.pop_sent_msg_opt(Duration::ZERO).await.is_some());
    Ok(())
 }

--- a/src/tools.rs
+++ b/src/tools.rs
@@ -603,36 +603,6 @@ where
    }
 }

-pub(crate) trait ToOption<T> {
-    fn to_option(self) -> Option<T>;
-}
-impl<'a> ToOption<&'a str> for &'a String {
-    fn to_option(self) -> Option<&'a str> {
-        if self.is_empty() {
-            None
-        } else {
-            Some(self)
-        }
-    }
-}
-impl ToOption<String> for u16 {
-    fn to_option(self) -> Option<String> {
-        if self == 0 {
-            None
-        } else {
-            Some(self.to_string())
-        }
-    }
-}
-impl ToOption<String> for Option<i32> {
-    fn to_option(self) -> Option<String> {
-        match self {
-            None | Some(0) => None,
-            Some(v) => Some(v.to_string()),
-        }
-    }
-}
-
 pub fn remove_subject_prefix(last_subject: &str) -> String {
    let subject_start = if last_subject.starts_with("Chat:") {
        0
@@ -1 +1 @@
 -03-19
 -03-13