fix fmt and add missing commas

and that is stdio. also mention the other (embedded into desktop code)
transport implementations and link to their code

.github/workflows/ci.yml

@@ -20,7 +20,7 @@ permissions: {}
 
 env:
   RUSTFLAGS: -Dwarnings
-  RUST_VERSION: 1.93.0
+  RUST_VERSION: 1.92.0
 
   # Minimum Supported Rust Version
   MSRV: 1.88.0
@@ -59,9 +59,9 @@ jobs:
         with:
           show-progress: false
           persist-credentials: false
-      - uses: EmbarkStudios/cargo-deny-action@3fd3802e88374d3fe9159b834c7714ec57d6c979
+      - uses: EmbarkStudios/cargo-deny-action@76cd80eb775d7bbbd2d80292136d74d39e1b4918
         with:
-          arguments: --workspace --all-features --locked
+          arguments: --all-features --workspace
           command: check
           command-arguments: "-Dwarnings"
 

CHANGELOG.md

@@ -1,195 +1,5 @@
 # Changelog
 
-## [2.42.0] - 2026-02-10
-
-### Fixes
-
-- Set `mvbox_move` to '0' explicitly for existing chatmail profiles.
-  It's needed to prevent device message about deprecated `mvbox_move` option from appearing in chatmail profiles.
-
-### Features / Changes
-
-- Do not scan not watched folders.
-
-### Miscellaneous Tasks
-
-- Update rPGP from 0.18.0 to 0.19.0.
-- cargo: Bump quick-xml from 0.38.4 to 0.39.0.
-
-### Tests
-
-- Remove test_dont_show_emails.
-
-### Other
-
-- Fix typo in CHANGELOG for marknoticed_all_chats.
-
-## [2.41.0] - 2026-02-06
-
-### Features / Changes
-
-- Do not require `ShowEmails` to be set to `All` for adding second relay.
-- Use different strings for audio and video calls.
-
-### Fixes
-
-- Don't set download state to Failure if message is available on another Session's transport ([#7684](https://github.com/chatmail/core/pull/7684)).
-- Make use of call stock strings.
-
-### Miscellaneous Tasks
-
-- cargo: Bump `time` from 0.3.37 to 0.3.47.
-
-## [2.40.0] - 2026-02-04
-
-### Features / Changes
-
-- Receive_imf: Log reasoning for chat assignment.
-- Use more fitting encryption info message.
-- Send Intended Recipient Fingerprint subpackets.
-- Trash messages with intended recipient fingerprints, but w/o our one included.
-- Do not collect email addresses from messages after configuration.
-- Add device message about legacy `mvbox_move`.
-- Never create IMAP folders.
-- Make summary for pre-messages look like summary for fully downloaded messages ([#7775](https://github.com/chatmail/core/pull/7775)).
-- Don't call `BlobObject::create_and_deduplicate()` when forwarding message to the same account.
-- Allow clients to specify whether a call has video initially or not ([#7740](https://github.com/chatmail/core/pull/7740)).
-- Do not load more than one own key from the keychain.
-
-### Fixes
-
-- Cross-account forwarding of a message which `has_html()` ([#7791](https://github.com/chatmail/core/pull/7791)).
-- Make self-contact a key-contact even if key isn't generated yet.
-- `apply_group_changes()`: Check whether From is key-contact.
-- Don't add SELF to unencrypted chat created from encrypted message ([#7661](https://github.com/chatmail/core/pull/7661)).
-- Don't upscale images and test that image resolution isn't changed unnecessarily ([#7769](https://github.com/chatmail/core/pull/7769)).
-- Restart i/o when there are new transports in a sync message ([#7640](https://github.com/chatmail/core/pull/7640)).
-- `add_or_lookup_key_contacts*()`: Advance fingerprint_iter on invalid address.
-- `receive_imf`: Look up key contact by intended recipient fingerprint ([#7661](https://github.com/chatmail/core/pull/7661)).
-- Remove `Config::DeleteToTrash` and `Config::ConfiguredTrashFolder`.
-
-### API-Changes
-
-- jsonrpc(python): Process events forever by default.
-
-### CI
-
-- Make scripts/deny.sh test the locked version of dependencies.
-
-### Refactor
-
-- Remove unneeded dbg! statements ([#7776](https://github.com/chatmail/core/pull/7776)).
-- Remove unused Context.is_inbox().
-- Rename lookup_key_contacts_by_address_list() to lookup_key_contacts_fallback_to_chat().
-- Mark `ProviderOptions` as `non_exhaustive`.
-
-### Miscellaneous Tasks
-
-- Update provider database.
-- cargo: Update `bytes` from 1.11.0 to 1.11.1.
-- cargo: Bump tokio from 1.48.0 to 1.49.0.
-- cargo: Bump tokio-util from 0.7.17 to 0.7.18.
-- cargo: Bump libc from 0.2.178 to 0.2.180.
-- cargo: Bump quote from 1.0.42 to 1.0.44.
-- cargo: Bump syn from 2.0.111 to 2.0.114.
-- cargo: Bump human-panic from 2.0.4 to 2.0.6.
-- cargo: Bump chrono from 0.4.42 to 0.4.43.
-- cargo: Bump data-encoding from 2.9.0 to 2.10.0.
-- cargo: Bump colorutils-rs from 0.7.5 to 0.7.6.
-- Update provider database.
-- cargo: Bump thiserror from 2.0.17 to 2.0.18.
-- deps: Bump EmbarkStudios/cargo-deny-action from 2.0.14 to 2.0.15.
-- Remove RUSTSEC-2026-0002 exception from deny.toml.
-- cargo: Bump tokio-stream from 0.1.17 to 0.1.18.
-- cargo: Bump toml from 0.9.10+spec-1.1.0 to 0.9.11+spec-1.1.0.
-- cargo: Bump serde_json from 1.0.148 to 1.0.149.
-- cargo: Bump uuid from 1.19.0 to 1.20.0.
-- cargo: Bump rustls-pki-types from 1.13.2 to 1.14.0.
-- cargo: Bump tracing-subscriber from 0.3.20 to 0.3.22.
-
-### Tests
-
-- 2nd device receives message via new primary transport.
-- Make `test_dont_move_sync_msgs` less flaky.
-- Encrypted incoming message goes to encrypted 1:1 chat even if references messages in ad-hoc group.
-- Message in blocked chat arrives as InSeen.
-- Set `mvbox_move` to 0 for test rust accounts.
-
-## [2.39.0] - 2026-01-23
-
-### CI
-
-- Update Rust to 1.93.0.
-
-### Documentation
-
-- RELEASE.md: Push preparation commit to the main branch before tagging.
-- RELEASE.md: Add section about dealing with failed releases.
-
-### Fixes
-
-- Forward message with file ([#7755](https://github.com/chatmail/core/pull/7755)).
-- Do not additionally reduce the resolution of images that fit into the resolution-limit and are larger than the file-size-limit ([#7760](https://github.com/chatmail/core/pull/7760)).
-
-### Miscellaneous Tasks
-
-- Merge v2.38.0 into main branch.
-- Cleanup deprecated functions/defines ([#7763](https://github.com/chatmail/core/pull/7763)).
-
-## [2.38.0] - 2026-01-22
-
-### API-Changes
-
-- [**breaking**] Jsonrpc: remove `contacts` from `FullChat`. To migrate load contacts on demand via `get_contacts_by_ids` using `FullChat.contactIds` ([#7282](https://github.com/chatmail/core/pull/7282)).
-- jsonrpc: Add run_until parameter for bots ([#7688](https://github.com/chatmail/core/pull/7688)).
-- rust, jsonrpc: Add `get_message_read_receipt_count` method ([#7732](https://github.com/chatmail/core/pull/7732)).
-- rust and jsonrpc: Marknoticed_all_chats method to mark all chats as noticed, including muted ones. ([#7709](https://github.com/chatmail/core/pull/7709)).
-- Public re-export of Connectivity ([#7737](https://github.com/chatmail/core/pull/7737)).
-
-### Documentation
-
-- Fix chat types.
-- Set_config_from_qr() configures context for "DCACCOUNT:" and "DCLOGIN:" QRs ([#7450](https://github.com/chatmail/core/pull/7450)).
-- Fix formatting of `indoc!` link.
-
-### Features / Changes
-
-- Pre-messages / next version of download on demand ([#7371](https://github.com/chatmail/core/pull/7371)).
-- Connectivity view: move quota up and combine with IMAP state. ([#7653](https://github.com/chatmail/core/pull/7653)).
-- Execute sync message before checking for primary transport update.
-- Disable partial search by contact address.
-- Don't put text into post-message ([#7714](https://github.com/chatmail/core/pull/7714)).
-- Don't scale up Origin of multiple and broadcast recipients when sending a message.
-- pgp: Use preferred hash algorithm for signing instead of hardcoded SHA256.
-- In teamprofiles, don't mark chat as read on outgoing message ([#7717](https://github.com/chatmail/core/pull/7717)).
-- Send and apply MDNs to self ([#7005](https://github.com/chatmail/core/pull/7005))
-
-### Fixes
-
-- Do not show contact address in message info ([#7695](https://github.com/chatmail/core/pull/7695)).
-- Take transport_id into account when marking messages with \Seen flags.
-- Send bcc-self messages to all own relays ([#7656](https://github.com/chatmail/core/pull/7656)).
-- Only emit TransportsModified if transports are really modified.
-- Logging errors in deltachat-rpc-server during startup ([#7707](https://github.com/chatmail/core/pull/7707)).
-- Use only lowercase letters for stats id ([#7700](https://github.com/chatmail/core/pull/7700)).
-- Hide incoming broadcasts in `DC_GCL_FOR_FORWARDING` ([#7726](https://github.com/chatmail/core/pull/7726)).
-- Do not resolve ICE server hostnames during IMAP loop.
-- More reliable parsing of `dclogin:` links with ip address as host ([#7734](https://github.com/chatmail/core/pull/7734)).
-- Don't remember old channel members in the database ([#7716](https://github.com/chatmail/core/pull/7716)).
-- Make it possible to leave and immediately delete a chat ([#7744](https://github.com/chatmail/core/pull/7744)).
-- Emit MsgsChanged instead of MsgsNoticed on self-MDN if chat still has fresh messages.
-- Prevent possible infinite loop with invalid `smtp` row ([#7746](https://github.com/chatmail/core/pull/7746)).
-- Sync broadcast subscribers list ([#7578](https://github.com/chatmail/core/pull/7578))
-
-### Refactor
-
-- Don't use `concat!` in sql statements ([#7720](https://github.com/chatmail/core/pull/7720)).
-
-### Tests
-
-- Port test_dont_move_sync_msgs to JSON-RPC ([#7676](https://github.com/chatmail/core/pull/7676)).
-- rpc-client: Replace remaining print()s with `logging` ([#6082](https://github.com/chatmail/core/pull/6082)).
-
 ## [2.37.0] - 2026-01-08
 
 ### API-Changes
@@ -7733,8 +7543,3 @@ https://github.com/chatmail/core/pulls?q=is%3Apr+is%3Aclosed
 [2.35.0]: https://github.com/chatmail/core/compare/v2.34.0..v2.35.0
 [2.36.0]: https://github.com/chatmail/core/compare/v2.35.0..v2.36.0
 [2.37.0]: https://github.com/chatmail/core/compare/v2.36.0..v2.37.0
-[2.38.0]: https://github.com/chatmail/core/compare/v2.37.0..v2.38.0
-[2.39.0]: https://github.com/chatmail/core/compare/v2.38.0..v2.39.0
-[2.40.0]: https://github.com/chatmail/core/compare/v2.39.0..v2.40.0
-[2.41.0]: https://github.com/chatmail/core/compare/v2.40.0..v2.41.0
-[2.42.0]: https://github.com/chatmail/core/compare/v2.41.0..v2.42.0

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "deltachat"
-version = "2.42.0"
+version = "2.37.0"
 edition = "2024"
 license = "MPL-2.0"
 rust-version = "1.88"
@@ -56,7 +56,7 @@ chrono = { workspace = true, features = ["alloc", "clock", "std"] }
 colorutils-rs = { version = "0.7.5", default-features = false }
 data-encoding = "2.9.0"
 escaper = "0.1"
-fast-socks5 = "1"
+fast-socks5 = "0.10"
 fd-lock = "4"
 futures-lite = { workspace = true }
 futures = { workspace = true }
@@ -78,10 +78,10 @@ num-derive = "0.4"
 num-traits = { workspace = true }
 parking_lot = "0.12.4"
 percent-encoding = "2.3"
-pgp = { version = "0.19.0", default-features = false }
+pgp = { version = "0.18.0", default-features = false }
 pin-project = "1"
 qrcodegen = "1.7.0"
-quick-xml = { version = "0.39", features = ["escape-html"] }
+quick-xml = { version = "0.38", features = ["escape-html"] }
 rand-old = { package = "rand", version = "0.8" }
 rand = { workspace = true }
 regex = { workspace = true }
@@ -182,7 +182,7 @@ harness = false
 anyhow = "1"
 async-channel = "2.5.0"
 base64 = "0.22"
-chrono = { version = "0.4.43", default-features = false }
+chrono = { version = "0.4.42", default-features = false }
 deltachat-contact-tools = { path = "deltachat-contact-tools" }
 deltachat-jsonrpc = { path = "deltachat-jsonrpc", default-features = false }
 deltachat = { path = ".", default-features = false }
@@ -202,7 +202,7 @@ serde_json = "1"
 tempfile = "3.24.0"
 thiserror = "2"
 tokio = "1"
-tokio-util = "0.7.18"
+tokio-util = "0.7.17"
 tracing-subscriber = "0.3"
 yerpc = "0.6.4"
 

RELEASE.md

@@ -1,4 +1,4 @@
-# Releasing a new version of chatmail core
+# Releasing a new version of DeltaChat core
 
 For example, to release version 1.116.0 of the core, do the following steps.
 
@@ -14,17 +14,8 @@ For example, to release version 1.116.0 of the core, do the following steps.
 5. Commit the changes as `chore(release): prepare for 1.116.0`.
    Optionally, use a separate branch like `prep-1.116.0` for this commit and open a PR for review.
 
-6. Push the commit to the `main` branch.
+6. Tag the release: `git tag --annotate v1.116.0`.
 
-7. Once the commit is on the `main` branch and passed CI, tag the release: `git tag --annotate v1.116.0`.
+7. Push the release tag: `git push origin v1.116.0`.
 
-8. Push the release tag: `git push origin v1.116.0`.
-
-9. Create a GitHub release: `gh release create v1.116.0 --notes ''`.
-
-## Dealing with failed releases
-
-Once you make a GitHub release,
-CI will try to build and publish [PyPI](https://pypi.org/) and [npm](https://www.npmjs.com/) packages.
-If this fails for some reason, do not modify the failed tag, do not delete it and do not force-push to the `main` branch.
-Fix the build process and tag a new release instead.
+8. Create a GitHub release: `gh release create v1.116.0 --notes ''`.

STYLE.md

@@ -21,7 +21,7 @@ text TEXT DEFAULT '' NOT NULL -- message text
 ```
 
 Do not use macros like [`concat!`](https://doc.rust-lang.org/std/macro.concat.html)
-or [`indoc!`](https://docs.rs/indoc).
+or [`indoc!](https://docs.rs/indoc).
 Do not escape newlines like this:
 ```
     sql.execute(

benches/decrypting.rs

@@ -58,7 +58,7 @@ async fn create_context() -> Context {
         .await
         .unwrap();
     let secret = key_from_asc(include_str!("../test-data/key/bob-secret.asc")).unwrap();
-    let public = secret.to_public_key();
+    let public = secret.signed_public_key();
     let key_pair = KeyPair { public, secret };
     store_self_keypair(&context, &key_pair)
         .await

deltachat-ffi/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "deltachat_ffi"
-version = "2.42.0"
+version = "2.37.0"
 description = "Deltachat FFI"
 edition = "2018"
 readme = "README.md"

deltachat-ffi/deltachat.h

@@ -894,7 +894,7 @@ int             dc_preconfigure_keypair        (dc_context_t* context, const cha
  *       the pseudo-chat DC_CHAT_ID_ARCHIVED_LINK is added if there are _any_ archived
  *       chats
  *     - the flag DC_GCL_FOR_FORWARDING sorts "Saved messages" to the top of the chatlist
- *       and hides the "Device chat", contact requests and incoming broadcasts.
+ *       and hides the "Device chat" and contact requests.
  *       typically used on forwarding, may be combined with DC_GCL_NO_SPECIALS
  *       to also hide the archive link.
  *     - if the flag DC_GCL_NO_SPECIALS is set, archive link is not added
@@ -1242,12 +1242,9 @@ uint32_t        dc_init_webxdc_integration    (dc_context_t* context, uint32_t c
  *     This needs to be a one-to-one chat.
  * @param place_call_info any data that other devices receive
  *     in #DC_EVENT_INCOMING_CALL.
- * @param has_video Whether the call has video initially.
- *     This allows the recipient's client to adjust incoming call UX.
- *     A call can be upgraded to include video later.
  * @return ID of the system message announcing the call.
  */
-uint32_t        dc_place_outgoing_call       (dc_context_t* context, uint32_t chat_id, const char* place_call_info, int has_video);
+uint32_t        dc_place_outgoing_call       (dc_context_t* context, uint32_t chat_id, const char* place_call_info);
 
 
 /**
@@ -1566,7 +1563,7 @@ dc_array_t*     dc_wait_next_msgs            (dc_context_t* context);
  * Mark all messages in a chat as _noticed_.
  * _Noticed_ messages are no longer _fresh_ and do not count as being unseen
  * but are still waiting for being marked as "seen" using dc_markseen_msgs()
- * (read receipts aren't sent for noticed messages).
+ * (IMAP/MDNs is not done for noticed messages).
  *
  * Calling this function usually results in the event #DC_EVENT_MSGS_NOTICED.
  * See also dc_markseen_msgs().
@@ -2223,6 +2220,10 @@ uint32_t        dc_lookup_contact_id_by_addr (dc_context_t* context, const char*
 uint32_t        dc_create_contact            (dc_context_t* context, const char* name, const char* addr);
 
 
+
+// Deprecated 2025-05-20, setting this flag is a no-op.
+#define         DC_GCL_DEPRECATED_VERIFIED_ONLY         0x01
+
 #define         DC_GCL_ADD_SELF              0x02
 #define         DC_GCL_ADDRESS               0x04
 
@@ -2295,6 +2296,17 @@ dc_array_t*     dc_import_vcard              (dc_context_t* context, const char*
 dc_array_t*     dc_get_contacts              (dc_context_t* context, uint32_t flags, const char* query);
 
 
+/**
+ * Get the number of blocked contacts.
+ *
+ * @deprecated Deprecated 2021-02-22, use dc_array_get_cnt() on dc_get_blocked_contacts() instead.
+ * @memberof dc_context_t
+ * @param context The context object.
+ * @return The number of blocked contacts.
+ */
+int             dc_get_blocked_cnt           (dc_context_t* context);
+
+
 /**
  * Get blocked contacts.
  *
@@ -2567,6 +2579,7 @@ void            dc_stop_ongoing_process      (dc_context_t* context);
 #define         DC_QR_FPR_MISMATCH           220 // id=contact
 #define         DC_QR_FPR_WITHOUT_ADDR       230 // test1=formatted fingerprint
 #define         DC_QR_ACCOUNT                250 // text1=domain
+#define         DC_QR_BACKUP                 251 // deprecated
 #define         DC_QR_BACKUP2                252
 #define         DC_QR_BACKUP_TOO_NEW         255
 #define         DC_QR_PROXY                  271 // text1=address (e.g. "127.0.0.1:9050")
@@ -4662,6 +4675,7 @@ uint32_t        dc_msg_get_info_contact_id    (const dc_msg_t* msg);
 #define         DC_INFO_LOCATION_ONLY              9
 #define         DC_INFO_EPHEMERAL_TIMER_CHANGED   10
 #define         DC_INFO_PROTECTION_ENABLED        11
+#define         DC_INFO_PROTECTION_DISABLED       12 // deprecated 2025-07
 #define         DC_INFO_INVALID_UNENCRYPTED_MAIL  13
 #define         DC_INFO_WEBXDC_INFO_MESSAGE       32
 #define         DC_INFO_CHAT_E2EE                 50
@@ -7008,16 +7022,61 @@ void dc_event_unref(dc_event_t* event);
 /// Used in summaries.
 #define DC_STR_FILE                       12
 
+/// "Group name changed from %1$s to %2$s."
+///
+/// Used in status messages for group name changes.
+/// - %1$s will be replaced by the old group name
+/// - %2$s will be replaced by the new group name
+///
+/// @deprecated 2022-09-10
+#define DC_STR_MSGGRPNAME                 15
+
+/// "Group image changed."
+///
+/// Used in status messages for group images changes.
+///
+/// @deprecated 2022-09-10
+#define DC_STR_MSGGRPIMGCHANGED           16
+
+/// "Member %1$s added."
+///
+/// Used in status messages for added members.
+/// - %1$s will be replaced by the name of the added member
+///
+/// @deprecated 2022-09-10
+#define DC_STR_MSGADDMEMBER               17
+
+/// "Member %1$s removed."
+///
+/// Used in status messages for removed members.
+/// - %1$s will be replaced by the name of the removed member
+///
+/// @deprecated 2022-09-10
+#define DC_STR_MSGDELMEMBER               18
+
+/// "Group left."
+///
+/// Used in status messages.
+///
+/// @deprecated 2022-09-10
+#define DC_STR_MSGGROUPLEFT               19
+
 /// "GIF"
 ///
 /// Used in summaries.
 #define DC_STR_GIF                        23
 
+/// @deprecated 2025-07, this string is no longer needed.
+#define DC_STR_ENCRYPTEDMSG               24
+
 /// "End-to-end encryption available."
 ///
-/// @deprecated 2026-01-23
+/// Used to build the string returned by dc_get_contact_encrinfo().
 #define DC_STR_E2E_AVAILABLE              25
 
+/// @deprecated Deprecated 2021-02-07, this string is no longer needed.
+#define DC_STR_ENCR_TRANSP                27
+
 /// "No encryption."
 ///
 /// Used to build the string returned by dc_get_contact_encrinfo().
@@ -7028,23 +7087,90 @@ void dc_event_unref(dc_event_t* event);
 /// Used to build the string returned by dc_get_contact_encrinfo().
 #define DC_STR_FINGERPRINTS               30
 
+/// "Message opened"
+///
+/// Used in subjects of outgoing read receipts.
+///
+/// @deprecated Deprecated 2024-07-26
+#define DC_STR_READRCPT                   31
+
+/// "The message '%1$s' you sent was displayed on the screen of the recipient."
+///
+/// Used as message text of outgoing read receipts.
+/// - %1$s will be replaced by the subject of the displayed message
+///
+/// @deprecated Deprecated 2024-06-23
+#define DC_STR_READRCPT_MAILBODY          32
+
+/// @deprecated Deprecated, this string is no longer needed.
+#define DC_STR_MSGGRPIMGDELETED           33
+
+/// "End-to-end encryption preferred."
+///
+/// Used to build the string returned by dc_get_contact_encrinfo().
+/// @deprecated 2025-06-05
+#define DC_STR_E2E_PREFERRED              34
+
 /// "%1$s verified"
 ///
 /// Used in status messages.
 /// - %1$s will be replaced by the name of the verified contact
 #define DC_STR_CONTACT_VERIFIED           35
 
+/// "Cannot establish guaranteed end-to-end encryption with %1$s."
+///
+/// Used in status messages.
+/// - %1$s will be replaced by the name of the contact that cannot be verified
+/// @deprecated 2025-06-05
+#define DC_STR_CONTACT_NOT_VERIFIED       36
+
+/// "Changed setup for %1$s."
+///
+/// Used in status messages.
+/// - %1$s will be replaced by the name of the contact with the changed setup
+/// @deprecated 2025-06-05
+#define DC_STR_CONTACT_SETUP_CHANGED      37
+
 /// "Archived chats"
 ///
 /// Used as the name for the corresponding chatlist entry.
 #define DC_STR_ARCHIVEDCHATS              40
 
+/// "Autocrypt Setup Message"
+///
+/// @deprecated 2025-04
+#define DC_STR_AC_SETUP_MSG_SUBJECT       42
+
+/// "This is the Autocrypt Setup Message, open it in a compatible client to use your setup"
+///
+/// @deprecated 2025-04
+#define DC_STR_AC_SETUP_MSG_BODY          43
+
 /// "Cannot login as %1$s."
 ///
 /// Used in error strings.
 /// - %1$s will be replaced by the failing login name
 #define DC_STR_CANNOT_LOGIN               60
 
+/// "%1$s by %2$s"
+///
+/// Used to concretize actions,
+/// - %1$s will be replaced by an action
+///   as #DC_STR_MSGADDMEMBER or #DC_STR_MSGGRPIMGCHANGED (full-stop removed, if any)
+/// - %2$s will be replaced by the name of the user taking that action
+///
+/// @deprecated 2022-09-10
+#define DC_STR_MSGACTIONBYUSER            62
+
+/// "%1$s by me"
+///
+/// Used to concretize actions.
+/// - %1$s will be replaced by an action
+///   as #DC_STR_MSGADDMEMBER or #DC_STR_MSGGRPIMGCHANGED (full-stop removed, if any)
+///
+/// @deprecated 2022-09-10
+#define DC_STR_MSGACTIONBYME              63
+
 /// "Location streaming enabled."
 ///
 /// Used in status messages.
@@ -7085,6 +7211,13 @@ void dc_event_unref(dc_event_t* event);
 /// Used as message text for the message added to the device chat after successful login.
 #define DC_STR_WELCOME_MESSAGE            71
 
+/// "Unknown sender for this chat. See 'info' for more details."
+///
+/// Use as message text if assigning the message to a chat is not totally correct.
+///
+/// @deprecated 2025-08-18
+#define DC_STR_UNKNOWN_SENDER_FOR_CHAT    72
+
 /// "Message from %1$s"
 ///
 /// Used in subjects of outgoing messages in one-to-one chats.
@@ -7098,6 +7231,53 @@ void dc_event_unref(dc_event_t* event);
 /// - %1$s will be replaced by the name of the contact the message cannot be sent to
 #define DC_STR_FAILED_SENDING_TO          74
 
+/// "Message deletion timer is disabled."
+///
+/// Used in status messages.
+///
+/// @deprecated 2022-09-10
+#define DC_STR_EPHEMERAL_DISABLED         75
+
+/// "Message deletion timer is set to %1$s s."
+///
+/// Used in status messages when the other constants
+/// (#DC_STR_EPHEMERAL_MINUTE, #DC_STR_EPHEMERAL_HOUR and so on) do not match the timer.
+/// - %1$s will be replaced by the number of seconds the timer is set to
+///
+/// @deprecated 2022-09-10
+#define DC_STR_EPHEMERAL_SECONDS          76
+
+/// "Message deletion timer is set to 1 minute."
+///
+/// Used in status messages.
+///
+/// @deprecated 2022-09-10
+#define DC_STR_EPHEMERAL_MINUTE           77
+
+/// "Message deletion timer is set to 1 hour."
+///
+/// Used in status messages.
+///
+/// @deprecated 2022-09-10
+#define DC_STR_EPHEMERAL_HOUR             78
+
+/// "Message deletion timer is set to 1 day."
+///
+/// Used in status messages.
+///
+/// @deprecated 2022-09-10
+#define DC_STR_EPHEMERAL_DAY              79
+
+/// "Message deletion timer is set to 1 week."
+///
+/// Used in status messages.
+///
+/// @deprecated 2022-09-10
+#define DC_STR_EPHEMERAL_WEEK             80
+
+/// @deprecated Deprecated 2021-01-30, DC_STR_EPHEMERAL_WEEKS is used instead.
+#define DC_STR_EPHEMERAL_FOUR_WEEKS       81
+
 /// "Error: %1$s"
 ///
 /// Used in error strings.
@@ -7131,6 +7311,42 @@ void dc_event_unref(dc_event_t* event);
 /// Used as device message text.
 #define DC_STR_SELF_DELETED_MSG_BODY      91
 
+/// "Message deletion timer is set to %1$s minutes."
+///
+/// Used in status messages.
+///
+/// `%1$s` will be replaced by the number of minutes (always >1) the timer is set to.
+///
+/// @deprecated Replaced by DC_STR_MSG_YOU_EPHEMERAL_TIMER_MINUTES and DC_STR_MSG_EPHEMERAL_TIMER_MINUTES_BY.
+#define DC_STR_EPHEMERAL_MINUTES          93
+
+/// "Message deletion timer is set to %1$s hours."
+///
+/// Used in status messages.
+///
+/// `%1$s` will be replaced by the number of hours (always >1) the timer is set to.
+///
+/// @deprecated Replaced by DC_STR_MSG_YOU_EPHEMERAL_TIMER_HOURS and DC_STR_MSG_EPHEMERAL_TIMER_HOURS_BY.
+#define DC_STR_EPHEMERAL_HOURS            94
+
+/// "Message deletion timer is set to %1$s days."
+///
+/// Used in status messages.
+///
+/// `%1$s` will be replaced by the number of days (always >1) the timer is set to.
+///
+/// @deprecated Replaced by DC_STR_MSG_YOU_EPHEMERAL_TIMER_DAYS and DC_STR_MSG_EPHEMERAL_TIMER_DAYS_BY.
+#define DC_STR_EPHEMERAL_DAYS             95
+
+/// "Message deletion timer is set to %1$s weeks."
+///
+/// Used in status messages.
+///
+/// `%1$s` will be replaced by the number of weeks (always >1) the timer is set to.
+///
+/// @deprecated Replaced by DC_STR_MSG_YOU_EPHEMERAL_TIMER_WEEKS and DC_STR_MSG_EPHEMERAL_TIMER_WEEKS_BY.
+#define DC_STR_EPHEMERAL_WEEKS            96
+
 /// "Forwarded"
 ///
 /// Used in message summary text for notifications and chatlist.
@@ -7143,6 +7359,9 @@ void dc_event_unref(dc_event_t* event);
 /// `%1$s` will be replaced by the percentage used
 #define DC_STR_QUOTA_EXCEEDING_MSG_BODY   98
 
+/// @deprecated Deprecated 2025-11-12, this string is no longer needed.
+#define DC_STR_PARTIAL_DOWNLOAD_MSG_BODY  99
+
 /// "Multi Device Synchronization"
 ///
 /// Used in subjects of outgoing sync messages.
@@ -7168,6 +7387,10 @@ void dc_event_unref(dc_event_t* event);
 /// Used as a headline in the connectivity view.
 #define DC_STR_OUTGOING_MESSAGES          104
 
+
+/// @deprecated Deprecated 2022-04-16, this string is no longer needed.
+#define DC_STR_ONE_MOMENT                 106
+
 /// "Connected"
 ///
 /// Used as status in the connectivity view.
@@ -7258,6 +7481,12 @@ void dc_event_unref(dc_event_t* event);
 /// Used as status in the connectivity view.
 #define DC_STR_NOT_CONNECTED              121
 
+/// "%1$s changed their address from %2$s to %3$s"
+///
+/// Used as an info message to chats with contacts that changed their address.
+/// @deprecated 2025-06-05
+#define DC_STR_AEAP_ADDR_CHANGED          122
+
 /// "You changed group name from \"%1$s\" to \"%2$s\"."
 ///
 /// `%1$s` will be replaced by the old group name.
@@ -7372,6 +7601,17 @@ void dc_event_unref(dc_event_t* event);
 /// Used in status messages.
 #define DC_STR_EPHEMERAL_TIMER_SECONDS_BY_OTHER 141
 
+/// "You set message deletion timer to 1 minute."
+///
+/// @deprecated 2025-11-14, this string is no longer needed
+#define DC_STR_EPHEMERAL_TIMER_1_MINUTE_BY_YOU 142
+
+/// "Message deletion timer is set to 1 minute by %1$s."
+///
+/// `%1$s` will be replaced by name of the contact.
+/// @deprecated 2025-11-14, this string is no longer needed
+#define DC_STR_EPHEMERAL_TIMER_1_MINUTE_BY_OTHER 143
+
 /// "You set message deletion timer to 1 hour."
 ///
 /// Used in status messages.
@@ -7541,9 +7781,26 @@ void dc_event_unref(dc_event_t* event);
 /// Used as info message.
 #define DC_STR_SECUREJOIN_WAIT 190
 
+/// "Could not yet establish guaranteed end-to-end encryption, but you may already send a message."
+///
+/// @deprecated 2025-03
+#define DC_STR_SECUREJOIN_WAIT_TIMEOUT 191
+
+/// "The contact must be online to proceed. This process will continue automatically in background."
+///
+/// Used as info message.
+/// @deprecated 2025-06-05
+#define DC_STR_SECUREJOIN_TAKES_LONGER 192
+
 /// "❤️ Seems you're enjoying Delta Chat!"… (donation request device message)
 #define DC_STR_DONATION_REQUEST 193
 
+/// "Outgoing call"
+#define DC_STR_OUTGOING_CALL 194
+
+/// "Incoming call"
+#define DC_STR_INCOMING_CALL 195
+
 /// "Declined call"
 #define DC_STR_DECLINED_CALL 196
 
@@ -7595,18 +7852,6 @@ void dc_event_unref(dc_event_t* event);
 /// Used as the first info messages in newly created classic email threads.
 #define DC_STR_CHAT_UNENCRYPTED_EXPLANATON 230
 
-/// "Outgoing audio call"
-#define DC_STR_OUTGOING_AUDIO_CALL 232
-
-/// "Outgoing video call"
-#define DC_STR_OUTGOING_VIDEO_CALL 233
-
-/// "Incoming audio call"
-#define DC_STR_INCOMING_AUDIO_CALL 234
-
-/// "Incoming video call"
-#define DC_STR_INCOMING_VIDEO_CALL 235
-
 /**
  * @}
  */

deltachat-ffi/src/lib.rs

@@ -1181,7 +1181,6 @@ pub unsafe extern "C" fn dc_place_outgoing_call(
     context: *mut dc_context_t,
     chat_id: u32,
     place_call_info: *const libc::c_char,
-    has_video: bool,
 ) -> u32 {
     if context.is_null() || chat_id == 0 {
         eprintln!("ignoring careless call to dc_place_outgoing_call()");
@@ -1191,7 +1190,7 @@ pub unsafe extern "C" fn dc_place_outgoing_call(
     let chat_id = ChatId::new(chat_id);
     let place_call_info = to_string_lossy(place_call_info);
 
-    block_on(ctx.place_outgoing_call(chat_id, place_call_info, has_video))
+    block_on(ctx.place_outgoing_call(chat_id, place_call_info))
         .context("Failed to place call")
         .log_err(ctx)
         .map(|msg_id| msg_id.to_u32())
@@ -2261,6 +2260,22 @@ pub unsafe extern "C" fn dc_get_contacts(
     })
 }
 
+#[no_mangle]
+pub unsafe extern "C" fn dc_get_blocked_cnt(context: *mut dc_context_t) -> libc::c_int {
+    if context.is_null() {
+        eprintln!("ignoring careless call to dc_get_blocked_cnt()");
+        return 0;
+    }
+    let ctx = &*context;
+
+    block_on(async move {
+        Contact::get_all_blocked(ctx)
+            .await
+            .unwrap_or_log_default(ctx, "failed to get blocked count")
+            .len() as libc::c_int
+    })
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn dc_get_blocked_contacts(
     context: *mut dc_context_t,

deltachat-jsonrpc/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "deltachat-jsonrpc"
-version = "2.42.0"
+version = "2.37.0"
 description = "DeltaChat JSON-RPC API"
 edition = "2021"
 license = "MPL-2.0"

deltachat-jsonrpc/README.md

@@ -16,6 +16,7 @@ We also include a JavaScript and TypeScript client for the JSON-RPC API. The sou
 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. 
 
 To use it locally, first install the dependencies and compile the TypeScript code to JavaScript:
+
 ```sh
 cd typescript
 npm install
@@ -24,11 +25,28 @@ npm run build
 
 The JavaScript client is [published on NPM](https://www.npmjs.com/package/@deltachat/jsonrpc-client).
 
+###### Usage
+
+```typescript
+import { startDeltaChat } from "@deltachat/stdio-rpc-server";
+import { C } from "@deltachat/jsonrpc-client";
+
+const dc = await startDeltaChat("deltachat-data");
+console.log(await dc.rpc.getSystemInfo());
+const accounts = await dc.rpc.getAllAccounts();
+console.log("accounts", accounts);
+dc.close();
+```
+
+##### Generate TypeScript/JavaScript documentation
+
 A script is included to build autogenerated documentation, which includes all RPC methods:
+
 ```sh
 cd typescript
 npm run docs
 ```
+
 Then open the [`typescript/docs`](typescript/docs) folder in a web browser.
 
 ## Development

deltachat-jsonrpc/src/api.rs

@@ -11,8 +11,8 @@ use deltachat::blob::BlobObject;
 use deltachat::calls::ice_servers;
 use deltachat::chat::{
     self, add_contact_to_chat, forward_msgs, forward_msgs_2ctx, get_chat_media, get_chat_msgs,
-    get_chat_msgs_ex, marknoticed_all_chats, marknoticed_chat, remove_contact_from_chat, Chat,
-    ChatId, ChatItem, MessageListOptions,
+    get_chat_msgs_ex, marknoticed_chat, remove_contact_from_chat, Chat, ChatId, ChatItem,
+    MessageListOptions,
 };
 use deltachat::chatlist::Chatlist;
 use deltachat::config::{get_all_ui_config_keys, Config};
@@ -23,8 +23,8 @@ use deltachat::ephemeral::Timer;
 use deltachat::imex;
 use deltachat::location;
 use deltachat::message::{
-    self, delete_msgs_ex, get_existing_msg_ids, get_msg_read_receipt_count, get_msg_read_receipts,
-    markseen_msgs, Message, MessageState, MsgId, Viewtype,
+    self, delete_msgs_ex, get_existing_msg_ids, get_msg_read_receipts, markseen_msgs, Message,
+    MessageState, MsgId, Viewtype,
 };
 use deltachat::peer_channels::{
     leave_webxdc_realtime, send_webxdc_realtime_advertisement, send_webxdc_realtime_data,
@@ -1164,24 +1164,10 @@ impl CommandApi {
         Ok(None)
     }
 
-    /// Mark all messages in all chats as _noticed_.
-    /// Skips messages from blocked contacts, but does not skip messages in muted chats.
-    ///
-    /// _Noticed_ messages are no longer _fresh_ and do not count as being unseen
-    /// but are still waiting for being marked as "seen" using markseen_msgs()
-    /// (read receipts aren't sent for noticed messages).
-    ///
-    /// Calling this function usually results in the event #DC_EVENT_MSGS_NOTICED.
-    /// See also markseen_msgs().
-    pub async fn marknoticed_all_chats(&self, account_id: u32) -> Result<()> {
-        let ctx = self.get_context(account_id).await?;
-        marknoticed_all_chats(&ctx).await
-    }
-
     ///  Mark all messages in a chat as _noticed_.
     ///  _Noticed_ messages are no longer _fresh_ and do not count as being unseen
     ///  but are still waiting for being marked as "seen" using markseen_msgs()
-    ///  (read receipts aren't sent for noticed messages).
+    ///  (IMAP/MDNs is not done for noticed messages).
     ///
     ///  Calling this function usually results in the event #DC_EVENT_MSGS_NOTICED.
     ///  See also markseen_msgs().
@@ -1448,18 +1434,6 @@ impl CommandApi {
         MessageInfo::from_msg_id(&ctx, MsgId::new(message_id)).await
     }
 
-    /// Returns count of read receipts on message.
-    ///
-    /// This view count is meant as a feedback measure for the channel owner only.
-    async fn get_message_read_receipt_count(
-        &self,
-        account_id: u32,
-        message_id: u32,
-    ) -> Result<usize> {
-        let ctx = self.get_context(account_id).await?;
-        get_msg_read_receipt_count(&ctx, MsgId::new(message_id)).await
-    }
-
     /// Returns contacts that sent read receipts and the time of reading.
     async fn get_message_read_receipts(
         &self,
@@ -2167,11 +2141,10 @@ impl CommandApi {
         account_id: u32,
         chat_id: u32,
         place_call_info: String,
-        has_video: bool,
     ) -> Result<u32> {
         let ctx = self.get_context(account_id).await?;
         let msg_id = ctx
-            .place_outgoing_call(ChatId::new(chat_id), place_call_info, has_video)
+            .place_outgoing_call(ChatId::new(chat_id), place_call_info)
             .await?;
         Ok(msg_id.to_u32())
     }

deltachat-jsonrpc/src/api/types/calls.rs

@@ -1,6 +1,6 @@
 use anyhow::{Context as _, Result};
 
-use deltachat::calls::{call_state, CallState};
+use deltachat::calls::{call_state, sdp_has_video, CallState};
 use deltachat::context::Context;
 use deltachat::message::MsgId;
 use serde::Serialize;
@@ -15,7 +15,7 @@ pub struct JsonrpcCallInfo {
     /// even if incoming call event was missed.
     pub sdp_offer: String,
 
-    /// True if the call is started as a video call.
+    /// True if SDP offer has a video.
     pub has_video: bool,
 
     /// Call state.
@@ -30,7 +30,7 @@ impl JsonrpcCallInfo {
             format!("Attempting to get call state of non-call message {msg_id}")
         })?;
         let sdp_offer = call_info.place_call_info.clone();
-        let has_video = call_info.has_video_initially();
+        let has_video = sdp_has_video(&sdp_offer).unwrap_or_default();
         let state = JsonrpcCallState::from_msg_id(context, msg_id).await?;
 
         Ok(JsonrpcCallInfo {

deltachat-jsonrpc/typescript/Readme.md

@@ -0,0 +1,206 @@
+# @deltachat/jsonrpc-client
+
+This package is a client for the jsonrpc server.
+
+> If you are looking for the functions in the documentation, they are under [`RawClient`](https://js.jsonrpc.delta.chat/classes/RawClient.html).
+
+### Important Terms
+
+- [chat mail core (formerly delta chat core)](https://github.com/deltachat/deltachat-core-rust/) is heart of all Delta Chat clients. Handels all the heavy lifting (email, encryption, ...) and provides an easy api for bots and clients (`getChatlist`, `getChat`, `getContact`, ...).
+- [jsonrpc](https://www.jsonrpc.org/specification) is a JSON based protocol
+  for applications to speak to each other by [remote procedure calls](https://en.wikipedia.org/wiki/Remote_procedure_call) (short RPC),
+  which basically means that the client can call methods on the server by sending a JSON messages.
+- [`deltachat-rpc-server`](https://github.com/deltachat/deltachat-core-rust/tree/main/deltachat-rpc-server) provides the jsonrpc api over stdio (stdin/stdout)
+- [`@deltachat/stdio-rpc-server`](https://www.npmjs.com/package/@deltachat/stdio-rpc-server) is an easy way to install `deltachat-rpc-server` from npm and use it from nodejs.
+
+#### Transport
+
+You need to connect this client to an instance of chatmail-core via a transport.
+
+For this you can use the `StdioTransport`, which you can use by importing `StdioDeltaChat`.
+
+You can also make your own transport, for example deltachat desktop uses a custom transport that sends the json messages over electron ipc.
+Just implement your transport based on the `Transport` interface - look at how the [stdio transport is implemented](https://github.com/deltachat/deltachat-core-rust/blob/7121675d226e69fd85d0194d4b9c4442e4dd8299/deltachat-jsonrpc/typescript/src/client.ts#L113) for an example, it's not hard.
+
+The other transports that exist (but note that those are not standalone, they list here only serves as reference on how to implement those.):
+
+- Electron IPC (from Delta Chat Desktop)
+  - [transport](https://github.com/deltachat/deltachat-desktop/blob/0a4fdb2065c7b14fa097769181afd05e3f552f54/packages/target-electron/runtime-electron/runtime.ts#L49-L123), [request handling](https://github.com/deltachat/deltachat-desktop/blob/0a4fdb2065c7b14fa097769181afd05e3f552f54/packages/target-electron/src/deltachat/controller.ts#L199-L201), [responses](https://github.com/deltachat/deltachat-desktop/blob/0a4fdb2065c7b14fa097769181afd05e3f552f54/packages/target-electron/src/deltachat/controller.ts#L93-L113)
+- Tauri IPC (from DC Desktop Tauri edition)
+  - [transport](https://github.com/deltachat/deltachat-desktop/blob/0a4fdb2065c7b14fa097769181afd05e3f552f54/packages/target-tauri/runtime-tauri/runtime.ts#L86-L118), backend: [request handling](https://github.com/deltachat/deltachat-desktop/blob/0a4fdb2065c7b14fa097769181afd05e3f552f54/packages/target-tauri/src-tauri/src/lib.rs#L85-L94), [responses](https://github.com/deltachat/deltachat-desktop/blob/0a4fdb2065c7b14fa097769181afd05e3f552f54/packages/target-tauri/src-tauri/src/state/deltachat.rs#L43-L95)
+- Authenticated Websocket (from DC Desktop Browser edition)
+  - [transport](https://github.com/deltachat/deltachat-desktop/blob/0a4fdb2065c7b14fa097769181afd05e3f552f54/packages/target-browser/runtime-browser/runtime.ts#L37-L80), backend: [authentication](https://github.com/deltachat/deltachat-desktop/blob/0a4fdb2065c7b14fa097769181afd05e3f552f54/packages/target-browser/src/index.ts#L258-L275), [web socket server](https://github.com/deltachat/deltachat-desktop/blob/0a4fdb2065c7b14fa097769181afd05e3f552f54/packages/target-browser/src/deltachat-rpc.ts#L93) (this also contains some unrelated code, it's easier than it looks at first glance)
+
+## Usage
+
+> The **minimum** nodejs version for `@deltachat/stdio-rpc-server` is `16`
+
+```
+npm i @deltachat/stdio-rpc-server @deltachat/jsonrpc-client
+```
+
+```js
+import { startDeltaChat } from "@deltachat/stdio-rpc-server";
+// Import constants you might need later
+import { C } from "@deltachat/jsonrpc-client";
+
+async function main() {
+  const dc = await startDeltaChat("deltachat-data");
+  console.log(await dc.rpc.getSystemInfo());
+  dc.close();
+}
+main();
+```
+
+For a more complete example refer to <https://github.com/deltachat-bot/echo/tree/master/nodejs_stdio_jsonrpc>.
+
+### Listening for events
+
+```ts
+dc.on("Info", (accountId, { msg }) =>
+  console.info(accountId, "[core:info]", msg),
+);
+// Or get an event emitter for only one account
+const emitter = dc.getContextEvents(accountId);
+emitter.on("IncomingMsg", async ({ chatId, msgId }) => {
+  const message = await dc.rpc.getMessage(accountId, msgId);
+  console.log("got message in chat " + chatId + " : ", message.text);
+});
+```
+
+### Getting Started
+
+This section describes how to handle the Delta Chat core library over the jsonrpc bindings.
+For general information about Delta Chat itself,
+see <https://delta.chat> and <https://github.com/deltachat>.
+
+Let's start.
+
+First of all, you have to start the deltachat-rpc-server process.
+
+```js
+import { startDeltaChat } from "@deltachat/stdio-rpc-server";
+const dc = await startDeltaChat("deltachat-data");
+```
+
+Then we have to create an Account (also called Context or profile) that is bound to a database.
+The database is a normal SQLite file with a "blob directory" beside it.
+But these details are handled by deltachat's account manager.
+So you just have to tell the account manager to create a new account:
+
+```js
+const accountId = await dc.rpc.addAccount();
+```
+
+After that, register event listeners so you can see what core is doing:
+Intenally `@deltachat/jsonrpc-client` implments a loop that waits for new events and then emits them to javascript land.
+
+```js
+dc.on("Info", (accountId, { msg }) =>
+  console.info(accountId, "[core:info]", msg),
+);
+```
+
+Now you can **configure the account:**
+
+```js
+// use some real test credentials here
+await dc.rpc.setConfig(accountId, "addr", "alice@example.org");
+await dc.rpc.setConfig(accountId, "mail_pw", "***");
+// you can also set multiple config options in one call
+await dc.rpc.batchSetConfig(accountId, {
+  addr: "alice@example.org",
+  mail_pw: "***",
+});
+
+// after setting the credentials attempt to login
+await dc.rpc.configure(accountId);
+```
+
+`configure()` returns a promise that is rejected on error (with await is is thrown).
+The configuration itself may take a while. You can monitor it's progress like this:
+
+```js
+dc.on("ConfigureProgress", (accountId, { progress, comment }) => {
+  console.log(accountId, "ConfigureProgress", progress, comment);
+});
+// make sure to register this event handler before calling `dc.rpc.configure()`
+```
+
+The configuration result is saved in the database.
+On subsequent starts it is not needed to call `dc.rpc.configure(accountId)`
+(you can check this using `dc.rpc.isConfigured(accountId)`).
+
+On a successfully configuration delta chat core automatically connects to the server, however subsequent starts you **need to do that manually** by calling `dc.rpc.startIo(accountId)` or `dc.rpc.startIoForAllAccounts()`.
+
+```js
+if (!(await dc.rpc.isConfigured(accountId))) {
+  // use some real test credentials here
+  await dc.rpc.batchSetConfig(accountId, {
+    addr: "alice@example.org",
+    mail_pw: "***",
+  });
+  await dc.rpc.configure(accountId);
+} else {
+  await dc.rpc.startIo(accountId);
+}
+```
+
+Now you can **send the first message:**
+
+```js
+const contactId = await dc.rpc.createContact(
+  accountId,
+  "bob@example.org",
+  null /* optional name */,
+);
+const chatId = await dc.rpc.createChatByContactId(accountId, contactId);
+
+await dc.rpc.miscSendTextMessage(
+  accountId,
+  chatId,
+  "Hi, here is my first message!",
+);
+```
+
+`dc.rpc.miscSendTextMessage()` returns immediately;
+the sending itself is done in the background.
+If you check the testing address (bob),
+you should receive a normal e-mail.
+Answer this e-mail in any e-mail program with "Got it!",
+and the IO you started above will **receive the message**.
+
+You can then **list all messages** of a chat as follows:
+
+```js
+let i = 0;
+for (const msgId of await exp.rpc.getMessageIds(120, 12, false, false)) {
+  i++;
+  console.log(`Message: ${i}`, (await dc.rpc.getMessage(120, msgId)).text);
+}
+```
+
+This will output the following two lines:
+
+```
+Message 1: Hi, here is my first message!
+Message 2: Got it!
+```
+
+<!-- TODO: ### Clean shutdown? - seems to be more advanced to call async functions on exit, also is this needed in this usecase? -->
+
+## Further information
+
+- `@deltachat/stdio-rpc-server`
+  - [package on npm](https://www.npmjs.com/package/@deltachat/stdio-rpc-server)
+  - [source code on github](https://github.com/deltachat/deltachat-core-rust/tree/main/deltachat-rpc-server/npm-package)
+- [use `@deltachat/stdio-rpc-server` on an usuported platform](https://github.com/deltachat/deltachat-core-rust/tree/main/deltachat-rpc-server/npm-package#how-to-use-on-an-unsupported-platform)
+- The issue-tracker for the core library is here: <https://github.com/deltachat/deltachat-core-rust/issues>
+
+If you need further assistance,
+please do not hesitate to contact us
+through the channels shown at https://delta.chat/en/contribute
+
+Please keep in mind, that your derived work
+must respect the Mozilla Public License 2.0 of deltachat-rpc-server
+and the respective licenses of the libraries deltachat-rpc-server links with.

deltachat-jsonrpc/typescript/package.json

@@ -54,5 +54,5 @@
   },
   "type": "module",
   "types": "dist/deltachat.d.ts",
-  "version": "2.42.0"
+  "version": "2.37.0"
 }

deltachat-jsonrpc/typescript/src/client.ts

@@ -5,14 +5,14 @@ import { RawClient } from "../generated/client.js";
 import { BaseTransport, Request } from "yerpc";
 import { TinyEmitter } from "@deltachat/tiny-emitter";
 
-type Events = { ALL: (accountId: number, event: EventType) => void } & {
+export type Events = { ALL: (accountId: number, event: EventType) => void } & {
   [Property in EventType["kind"]]: (
     accountId: number,
     event: Extract<EventType, { kind: Property }>,
   ) => void;
 };
 
-type ContextEvents = { ALL: (event: EventType) => void } & {
+export type ContextEvents = { ALL: (event: EventType) => void } & {
   [Property in EventType["kind"]]: (
     event: Extract<EventType, { kind: Property }>,
   ) => void;

deltachat-repl/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "deltachat-repl"
-version = "2.42.0"
+version = "2.37.0"
 license = "MPL-2.0"
 edition = "2021"
 repository = "https://github.com/chatmail/core"

deltachat-rpc-client/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "deltachat-rpc-client"
-version = "2.42.0"
+version = "2.37.0"
 license = "MPL-2.0"
 description = "Python client for Delta Chat core JSON-RPC interface"
 classifiers = [

deltachat-rpc-client/src/deltachat_rpc_client/_utils.py

@@ -44,13 +44,8 @@ class AttrDict(dict):
         super().__setattr__(attr, val)
 
 
-def _forever(_event: AttrDict) -> bool:
-    return False
-
-
 def run_client_cli(
     hooks: Optional[Iterable[Tuple[Callable, Union[type, "EventFilter"]]]] = None,
-    until: Callable[[AttrDict], bool] = _forever,
     argv: Optional[list] = None,
     **kwargs,
 ) -> None:
@@ -60,11 +55,10 @@ def run_client_cli(
     """
     from .client import Client
 
-    _run_cli(Client, until, hooks, argv, **kwargs)
+    _run_cli(Client, hooks, argv, **kwargs)
 
 
 def run_bot_cli(
-    until: Callable[[AttrDict], bool] = _forever,
     hooks: Optional[Iterable[Tuple[Callable, Union[type, "EventFilter"]]]] = None,
     argv: Optional[list] = None,
     **kwargs,
@@ -75,12 +69,11 @@ def run_bot_cli(
     """
     from .client import Bot
 
-    _run_cli(Bot, until, hooks, argv, **kwargs)
+    _run_cli(Bot, hooks, argv, **kwargs)
 
 
 def _run_cli(
     client_type: Type["Client"],
-    until: Callable[[AttrDict], bool] = _forever,
     hooks: Optional[Iterable[Tuple[Callable, Union[type, "EventFilter"]]]] = None,
     argv: Optional[list] = None,
     **kwargs,
@@ -118,7 +111,7 @@ def _run_cli(
                 kwargs={"email": args.email, "password": args.password},
             )
             configure_thread.start()
-        client.run_until(until)
+        client.run_forever()
 
 
 def extract_addr(text: str) -> str:

deltachat-rpc-client/src/deltachat_rpc_client/chat.py

@@ -303,7 +303,7 @@ class Chat:
             f.flush()
             self._rpc.send_msg(self.account.id, self.id, {"viewtype": ViewType.VCARD, "file": f.name})
 
-    def place_outgoing_call(self, place_call_info: str, has_video_initially: bool) -> Message:
+    def place_outgoing_call(self, place_call_info: str) -> Message:
         """Starts an outgoing call."""
-        msg_id = self._rpc.place_outgoing_call(self.account.id, self.id, place_call_info, has_video_initially)
+        msg_id = self._rpc.place_outgoing_call(self.account.id, self.id, place_call_info)
         return Message(self.account, msg_id)

deltachat-rpc-client/src/deltachat_rpc_client/client.py

@@ -14,7 +14,6 @@ from typing import (
 
 from ._utils import (
     AttrDict,
-    _forever,
     parse_system_add_remove,
     parse_system_image_changed,
     parse_system_title_changed,
@@ -92,28 +91,19 @@ class Client:
 
     def run_forever(self) -> None:
         """Process events forever."""
-        self.run_until(_forever)
+        self.run_until(lambda _: False)
 
     def run_until(self, func: Callable[[AttrDict], bool]) -> AttrDict:
-        """Start the event processing loop."""
+        """Process events until the given callable evaluates to True.
+
+        The callable should accept an AttrDict object representing the
+        last processed event. The event is returned when the callable
+        evaluates to True.
+        """
         self.logger.debug("Listening to incoming events...")
         if self.is_configured():
             self.account.start_io()
         self._process_messages()  # Process old messages.
-        return self._process_events(until_func=func)  # Loop over incoming events
-
-    def _process_events(
-        self,
-        until_func: Callable[[AttrDict], bool] = _forever,
-        until_event: EventType = False,
-    ) -> AttrDict:
-        """Process events until the given callable evaluates to True,
-        or until a certain event happens.
-
-        The until_func callable should accept an AttrDict object representing
-        the last processed event. The event is returned when the callable
-        evaluates to True.
-        """
         while True:
             event = self.account.wait_for_event()
             event["kind"] = EventType(event.kind)
@@ -122,13 +112,10 @@ class Client:
             if event.kind == EventType.INCOMING_MSG:
                 self._process_messages()
 
-            stop = until_func(event)
+            stop = func(event)
             if stop:
                 return event
 
-            if event.kind == until_event:
-                return event
-
     def _on_event(self, event: AttrDict, filter_type: Type[EventFilter] = RawEvent) -> None:
         for hook, evfilter in self._hooks.get(filter_type, []):
             if evfilter.filter(event):

deltachat-rpc-client/src/deltachat_rpc_client/message.py

@@ -44,14 +44,6 @@ class Message:
         read_receipts = self._rpc.get_message_read_receipts(self.account.id, self.id)
         return [AttrDict(read_receipt) for read_receipt in read_receipts]
 
-    def get_read_receipt_count(self) -> int:
-        """
-        Returns count of read receipts on message.
-
-        This view count is meant as a feedback measure for the channel owner only.
-        """
-        return self._rpc.get_message_read_receipt_count(self.account.id, self.id)
-
     def get_reactions(self) -> Optional[AttrDict]:
         """Get message reactions."""
         reactions = self._rpc.get_message_reactions(self.account.id, self.id)

deltachat-rpc-client/src/deltachat_rpc_client/pytestplugin.py

@@ -22,7 +22,7 @@ from .rpc import Rpc
 E2EE_INFO_MSGS = 1
 """
 The number of info messages added to new e2ee chats.
-Currently this is "Messages are end-to-end encrypted."
+Currently this is "End-to-end encryption available".
 """
 
 

deltachat-rpc-client/tests/test_calls.py

@@ -10,15 +10,15 @@ def test_calls(acfactory) -> None:
     alice_contact_bob = alice.create_contact(bob, "Bob")
     alice_chat_bob = alice_contact_bob.create_chat()
     bob.create_chat(alice)  # Accept the chat so incoming call causes a notification.
-    outgoing_call_message = alice_chat_bob.place_outgoing_call(place_call_info, has_video_initially=True)
+    outgoing_call_message = alice_chat_bob.place_outgoing_call(place_call_info)
     assert outgoing_call_message.get_call_info().state.kind == "Alerting"
 
     incoming_call_event = bob.wait_for_event(EventType.INCOMING_CALL)
     assert incoming_call_event.place_call_info == place_call_info
-    assert incoming_call_event.has_video
+    assert not incoming_call_event.has_video  # Cannot be parsed as SDP, so false by default
     incoming_call_message = Message(bob, incoming_call_event.msg_id)
     assert incoming_call_message.get_call_info().state.kind == "Alerting"
-    assert incoming_call_message.get_call_info().has_video
+    assert not incoming_call_message.get_call_info().has_video
 
     incoming_call_message.accept_incoming_call(accept_call_info)
     assert incoming_call_message.get_call_info().sdp_offer == place_call_info
@@ -41,38 +41,46 @@ def test_video_call(acfactory) -> None:
     #
     # `s=` cannot be empty according to RFC 3264,
     # so it is more clear as `s=-`.
+    place_call_info = """v=0\r
+o=alice 2890844526 2890844526 IN IP6 2001:db8::3\r
+s=-\r
+c=IN IP6 2001:db8::3\r
+t=0 0\r
+a=group:BUNDLE foo bar\r
+\r
+m=audio 10000 RTP/AVP 0 8 97\r
+b=AS:200\r
+a=mid:foo\r
+a=rtcp-mux\r
+a=rtpmap:0 PCMU/8000\r
+a=rtpmap:8 PCMA/8000\r
+a=rtpmap:97 iLBC/8000\r
+a=extmap:1 urn:ietf:params:rtp-hdrext:sdes:mid\r
+\r
+m=video 10002 RTP/AVP 31 32\r
+b=AS:1000\r
+a=mid:bar\r
+a=rtcp-mux\r
+a=rtpmap:31 H261/90000\r
+a=rtpmap:32 MPV/90000\r
+a=extmap:1 urn:ietf:params:rtp-hdrext:sdes:mid\r
+"""
 
     alice, bob = acfactory.get_online_accounts(2)
 
     bob.create_chat(alice)  # Accept the chat so incoming call causes a notification.
     alice_contact_bob = alice.create_contact(bob, "Bob")
     alice_chat_bob = alice_contact_bob.create_chat()
-    alice_chat_bob.place_outgoing_call("offer", has_video_initially=True)
+    alice_chat_bob.place_outgoing_call(place_call_info)
 
     incoming_call_event = bob.wait_for_event(EventType.INCOMING_CALL)
-    assert incoming_call_event.place_call_info == "offer"
+    assert incoming_call_event.place_call_info == place_call_info
     assert incoming_call_event.has_video
 
     incoming_call_message = Message(bob, incoming_call_event.msg_id)
     assert incoming_call_message.get_call_info().has_video
 
 
-def test_audio_call(acfactory) -> None:
-    alice, bob = acfactory.get_online_accounts(2)
-
-    bob.create_chat(alice)  # Accept the chat so incoming call causes a notification.
-    alice_contact_bob = alice.create_contact(bob, "Bob")
-    alice_chat_bob = alice_contact_bob.create_chat()
-    alice_chat_bob.place_outgoing_call("offer", has_video_initially=False)
-
-    incoming_call_event = bob.wait_for_event(EventType.INCOMING_CALL)
-    assert incoming_call_event.place_call_info == "offer"
-    assert not incoming_call_event.has_video
-
-    incoming_call_message = Message(bob, incoming_call_event.msg_id)
-    assert not incoming_call_message.get_call_info().has_video
-
-
 def test_ice_servers(acfactory) -> None:
     alice = acfactory.get_online_account()
 
@@ -84,7 +92,7 @@ def test_no_contact_request_call(acfactory) -> None:
     alice, bob = acfactory.get_online_accounts(2)
 
     alice_chat_bob = alice.create_chat(bob)
-    alice_chat_bob.place_outgoing_call("offer", has_video_initially=True)
+    alice_chat_bob.place_outgoing_call("offer")
     alice_chat_bob.send_text("Hello!")
 
     # Notification for "Hello!" message should arrive
@@ -111,7 +119,7 @@ def test_who_can_call_me_nobody(acfactory) -> None:
     bob.create_chat(alice)
 
     alice_chat_bob = alice.create_chat(bob)
-    alice_chat_bob.place_outgoing_call("offer", has_video_initially=True)
+    alice_chat_bob.place_outgoing_call("offer")
     alice_chat_bob.send_text("Hello!")
 
     # Notification for "Hello!" message should arrive
@@ -136,7 +144,7 @@ def test_who_can_call_me_everybody(acfactory) -> None:
     bob.set_config("who_can_call_me", "0")
 
     alice_chat_bob = alice.create_chat(bob)
-    alice_chat_bob.place_outgoing_call("offer", has_video_initially=True)
+    alice_chat_bob.place_outgoing_call("offer")
     incoming_call_event = bob.wait_for_event(EventType.INCOMING_CALL)
 
     incoming_call_message = Message(bob, incoming_call_event.msg_id)

deltachat-rpc-client/tests/test_folders.py

@@ -8,10 +8,8 @@ from imap_tools import AND, U
 from deltachat_rpc_client import Contact, EventType, Message
 
 
-def test_move_works(acfactory, direct_imap):
+def test_move_works(acfactory):
     ac1, ac2 = acfactory.get_online_accounts(2)
-    ac2_direct_imap = direct_imap(ac2)
-    ac2_direct_imap.create_folder("DeltaChat")
     ac2.set_config("mvbox_move", "1")
     ac2.bring_online()
 
@@ -26,6 +24,68 @@ def test_move_works(acfactory, direct_imap):
     assert msg.text == "message1"
 
 
+def test_move_avoids_loop(acfactory, direct_imap):
+    """Test that the message is only moved from INBOX to DeltaChat.
+
+    This is to avoid busy loop if moved message reappears in the Inbox
+    or some scanned folder later.
+    For example, this happens on servers that alias `INBOX.DeltaChat` to `DeltaChat` folder,
+    so the message moved to `DeltaChat` appears as a new message in the `INBOX.DeltaChat` folder.
+    We do not want to move this message from `INBOX.DeltaChat` to `DeltaChat` again.
+    """
+    ac1, ac2 = acfactory.get_online_accounts(2)
+    ac2.set_config("mvbox_move", "1")
+    ac2.set_config("delete_server_after", "0")
+    ac2.bring_online()
+
+    # Create INBOX.DeltaChat folder and make sure
+    # it is detected by full folder scan.
+    ac2_direct_imap = direct_imap(ac2)
+    ac2_direct_imap.create_folder("INBOX.DeltaChat")
+    ac2.stop_io()
+    ac2.start_io()
+
+    while True:
+        event = ac2.wait_for_event()
+        # Wait until the end of folder scan.
+        if event.kind == EventType.INFO and "Found folders:" in event.msg:
+            break
+
+    ac1_chat = acfactory.get_accepted_chat(ac1, ac2)
+    ac1_chat.send_text("Message 1")
+
+    # Message is moved to the DeltaChat folder and downloaded.
+    ac2_msg1 = ac2.wait_for_incoming_msg().get_snapshot()
+    assert ac2_msg1.text == "Message 1"
+
+    # Move the message to the INBOX.DeltaChat again.
+    # We assume that test server uses "." as the delimiter.
+    ac2_direct_imap.select_folder("DeltaChat")
+    ac2_direct_imap.conn.move(["*"], "INBOX.DeltaChat")
+
+    ac1_chat.send_text("Message 2")
+    ac2_msg2 = ac2.wait_for_incoming_msg().get_snapshot()
+    assert ac2_msg2.text == "Message 2"
+
+    # Stop and start I/O to trigger folder scan.
+    ac2.stop_io()
+    ac2.start_io()
+    while True:
+        event = ac2.wait_for_event()
+        # Wait until the end of folder scan.
+        if event.kind == EventType.INFO and "Found folders:" in event.msg:
+            break
+
+    # Check that Message 1 is still in the INBOX.DeltaChat folder
+    # and Message 2 is in the DeltaChat folder.
+    ac2_direct_imap.select_folder("INBOX")
+    assert len(ac2_direct_imap.get_all_messages()) == 0
+    ac2_direct_imap.select_folder("DeltaChat")
+    assert len(ac2_direct_imap.get_all_messages()) == 1
+    ac2_direct_imap.select_folder("INBOX.DeltaChat")
+    assert len(ac2_direct_imap.get_all_messages()) == 1
+
+
 def test_reactions_for_a_reordering_move(acfactory, direct_imap):
     """When a batch of messages is moved from Inbox to DeltaChat folder with a single MOVE command,
     their UIDs may be reordered (e.g. Gmail is known for that) which led to that messages were
@@ -37,8 +97,6 @@ def test_reactions_for_a_reordering_move(acfactory, direct_imap):
     addr, password = acfactory.get_credentials()
     ac2 = acfactory.get_unconfigured_account()
     ac2.add_or_update_transport({"addr": addr, "password": password})
-    ac2_direct_imap = direct_imap(ac2)
-    ac2_direct_imap.create_folder("DeltaChat")
     ac2.set_config("mvbox_move", "1")
     assert ac2.is_configured()
 
@@ -72,12 +130,174 @@ def test_reactions_for_a_reordering_move(acfactory, direct_imap):
     assert list(reactions.reactions_by_contact.values())[0] == [react_str]
 
 
-def test_move_works_on_self_sent(acfactory, direct_imap):
+def test_delete_deltachat_folder(acfactory, direct_imap):
+    """Test that DeltaChat folder is recreated if user deletes it manually."""
+    ac1 = acfactory.new_configured_account()
+    ac1.set_config("mvbox_move", "1")
+    ac1.bring_online()
+
+    ac1_direct_imap = direct_imap(ac1)
+    ac1_direct_imap.conn.folder.delete("DeltaChat")
+    assert "DeltaChat" not in ac1_direct_imap.list_folders()
+
+    # Wait until new folder is created and UIDVALIDITY is updated.
+    while True:
+        event = ac1.wait_for_event()
+        if event.kind == EventType.INFO and "transport 1: UID validity for folder DeltaChat changed from " in event.msg:
+            break
+
+    ac2 = acfactory.get_online_account()
+    ac2.create_chat(ac1).send_text("hello")
+    msg = ac1.wait_for_incoming_msg().get_snapshot()
+    assert msg.text == "hello"
+
+    assert "DeltaChat" in ac1_direct_imap.list_folders()
+
+
+def test_dont_show_emails(acfactory, direct_imap, log):
+    """Most mailboxes have a "Drafts" folder where constantly new emails appear but we don't actually want to show them.
+    So: If it's outgoing AND there is no Received header, then ignore the email.
+
+    If the draft email is sent out and received later (i.e. it's in "Inbox"), it must be shown.
+
+    Also, test that unknown emails in the Spam folder are not shown."""
+    ac1 = acfactory.new_configured_account()
+    ac1.stop_io()
+    ac1.set_config("show_emails", "2")
+
+    ac1.create_contact("alice@example.org").create_chat()
+
+    ac1_direct_imap = direct_imap(ac1)
+    ac1_direct_imap.create_folder("Drafts")
+    ac1_direct_imap.create_folder("Spam")
+    ac1_direct_imap.create_folder("Junk")
+
+    # Learn UID validity for all folders.
+    ac1.set_config("scan_all_folders_debounce_secs", "0")
+    ac1.start_io()
+    ac1.wait_for_event(EventType.IMAP_INBOX_IDLE)
+    ac1.stop_io()
+
+    ac1_direct_imap.append(
+        "Drafts",
+        """
+        From: ac1 <{}>
+        Subject: subj
+        To: alice@example.org
+        Message-ID: <aepiors@example.org>
+        Content-Type: text/plain; charset=utf-8
+
+        message in Drafts received later
+    """.format(
+            ac1.get_config("configured_addr"),
+        ),
+    )
+    ac1_direct_imap.append(
+        "Spam",
+        """
+        From: unknown.address@junk.org
+        Subject: subj
+        To: {}
+        Message-ID: <spam.message@junk.org>
+        Content-Type: text/plain; charset=utf-8
+
+        Unknown message in Spam
+    """.format(
+            ac1.get_config("configured_addr"),
+        ),
+    )
+    ac1_direct_imap.append(
+        "Spam",
+        """
+        From: unknown.address@junk.org, unkwnown.add@junk.org
+        Subject: subj
+        To: {}
+        Message-ID: <spam.message2@junk.org>
+        Content-Type: text/plain; charset=utf-8
+
+        Unknown & malformed message in Spam
+    """.format(
+            ac1.get_config("configured_addr"),
+        ),
+    )
+    ac1_direct_imap.append(
+        "Spam",
+        """
+        From: delta<address: inbox@nhroy.com>
+        Subject: subj
+        To: {}
+        Message-ID: <spam.message99@junk.org>
+        Content-Type: text/plain; charset=utf-8
+
+        Unknown & malformed message in Spam
+    """.format(
+            ac1.get_config("configured_addr"),
+        ),
+    )
+    ac1_direct_imap.append(
+        "Spam",
+        """
+        From: alice@example.org
+        Subject: subj
+        To: {}
+        Message-ID: <spam.message3@junk.org>
+        Content-Type: text/plain; charset=utf-8
+
+        Actually interesting message in Spam
+    """.format(
+            ac1.get_config("configured_addr"),
+        ),
+    )
+    ac1_direct_imap.append(
+        "Junk",
+        """
+        From: unknown.address@junk.org
+        Subject: subj
+        To: {}
+        Message-ID: <spam.message@junk.org>
+        Content-Type: text/plain; charset=utf-8
+
+        Unknown message in Junk
+    """.format(
+            ac1.get_config("configured_addr"),
+        ),
+    )
+
+    ac1.set_config("scan_all_folders_debounce_secs", "0")
+    log.section("All prepared, now let DC find the message")
+    ac1.start_io()
+
+    # Wait until each folder was scanned, this is necessary for this test to test what it should test:
+    ac1.wait_for_event(EventType.IMAP_INBOX_IDLE)
+
+    fresh_msgs = list(ac1.get_fresh_messages())
+    msg = fresh_msgs[0].get_snapshot()
+    chat_msgs = msg.chat.get_messages()
+    assert len(chat_msgs) == 1
+    assert msg.text == "subj – Actually interesting message in Spam"
+
+    assert not any("unknown.address" in c.get_full_snapshot().name for c in ac1.get_chatlist())
+    ac1_direct_imap.select_folder("Spam")
+    assert ac1_direct_imap.get_uid_by_message_id("spam.message@junk.org")
+
+    ac1.stop_io()
+    log.section("'Send out' the draft by moving it to Inbox, and wait for DC to display it this time")
+    ac1_direct_imap.select_folder("Drafts")
+    uid = ac1_direct_imap.get_uid_by_message_id("aepiors@example.org")
+    ac1_direct_imap.conn.move(uid, "Inbox")
+
+    ac1.start_io()
+    event = ac1.wait_for_event(EventType.MSGS_CHANGED)
+    msg2 = Message(ac1, event.msg_id).get_snapshot()
+
+    assert msg2.text == "subj – message in Drafts received later"
+    assert len(msg.chat.get_messages()) == 2
+
+
+def test_move_works_on_self_sent(acfactory):
     ac1, ac2 = acfactory.get_online_accounts(2)
 
-    # Create and enable movebox.
-    ac1_direct_imap = direct_imap(ac1)
-    ac1_direct_imap.create_folder("DeltaChat")
+    # Enable movebox and wait until it is created.
     ac1.set_config("mvbox_move", "1")
     ac1.set_config("bcc_self", "1")
     ac1.bring_online()
@@ -94,8 +314,6 @@ def test_move_works_on_self_sent(acfactory, direct_imap):
 def test_moved_markseen(acfactory, direct_imap):
     """Test that message already moved to DeltaChat folder is marked as seen."""
     ac1, ac2 = acfactory.get_online_accounts(2)
-    ac2_direct_imap = direct_imap(ac2)
-    ac2_direct_imap.create_folder("DeltaChat")
     ac2.set_config("mvbox_move", "1")
     ac2.set_config("delete_server_after", "0")
     ac2.set_config("sync_msgs", "0")  # Do not send a sync message when accepting a contact request.
@@ -138,8 +356,6 @@ def test_markseen_message_and_mdn(acfactory, direct_imap, mvbox_move):
     for ac in ac1, ac2:
         ac.set_config("delete_server_after", "0")
         if mvbox_move:
-            ac_direct_imap = direct_imap(ac)
-            ac_direct_imap.create_folder("DeltaChat")
             ac.set_config("mvbox_move", "1")
             ac.bring_online()
 
@@ -174,12 +390,120 @@ def test_markseen_message_and_mdn(acfactory, direct_imap, mvbox_move):
     assert len(list(ac2_direct_imap.conn.fetch(AND(seen=True), mark_seen=False))) == 1
 
 
+def test_mvbox_and_trash(acfactory, direct_imap, log):
+    log.section("ac1: start with mvbox")
+    ac1 = acfactory.get_online_account()
+    ac1.set_config("mvbox_move", "1")
+    ac1.bring_online()
+
+    log.section("ac2: start without a mvbox")
+    ac2 = acfactory.get_online_account()
+
+    log.section("ac1: create trash")
+    ac1_direct_imap = direct_imap(ac1)
+    ac1_direct_imap.create_folder("Trash")
+    ac1.set_config("scan_all_folders_debounce_secs", "0")
+    ac1.stop_io()
+    ac1.start_io()
+
+    log.section("ac1: send message and wait for ac2 to receive it")
+    acfactory.get_accepted_chat(ac1, ac2).send_text("message1")
+    assert ac2.wait_for_incoming_msg().get_snapshot().text == "message1"
+
+    assert ac1.get_config("configured_mvbox_folder") == "DeltaChat"
+    while ac1.get_config("configured_trash_folder") != "Trash":
+        ac1.wait_for_event(EventType.CONNECTIVITY_CHANGED)
+
+
+@pytest.mark.parametrize(
+    ("folder", "move", "expected_destination"),
+    [
+        (
+            "xyz",
+            False,
+            "xyz",
+        ),  # Test that emails aren't found in a random folder
+        (
+            "xyz",
+            True,
+            "xyz",
+        ),  # ...emails are found in a random folder and downloaded without moving
+        (
+            "Spam",
+            False,
+            "INBOX",
+        ),  # ...emails are moved from the spam folder to the Inbox
+    ],
+)
+# Testrun.org does not support the CREATE-SPECIAL-USE capability, which means that we can't create a folder with
+# the "\Junk" flag (see https://tools.ietf.org/html/rfc6154). So, we can't test spam folder detection by flag.
+def test_scan_folders(acfactory, log, direct_imap, folder, move, expected_destination):
+    """Delta Chat periodically scans all folders for new messages to make sure we don't miss any."""
+    variant = folder + "-" + str(move) + "-" + expected_destination
+    log.section("Testing variant " + variant)
+    ac1, ac2 = acfactory.get_online_accounts(2)
+    ac1.set_config("delete_server_after", "0")
+    if move:
+        ac1.set_config("mvbox_move", "1")
+        ac1.bring_online()
+
+    ac1.stop_io()
+    ac1_direct_imap = direct_imap(ac1)
+    ac1_direct_imap.create_folder(folder)
+
+    # Wait until each folder was selected once and we are IDLEing:
+    ac1.start_io()
+    ac1.bring_online()
+
+    ac1.stop_io()
+    assert folder in ac1_direct_imap.list_folders()
+
+    log.section("Send a message from ac2 to ac1 and manually move it to `folder`")
+    ac1_direct_imap.select_config_folder("inbox")
+    with ac1_direct_imap.idle() as idle1:
+        acfactory.get_accepted_chat(ac2, ac1).send_text("hello")
+        idle1.wait_for_new_message()
+    ac1_direct_imap.conn.move(["*"], folder)  # "*" means "biggest UID in mailbox"
+
+    log.section("start_io() and see if DeltaChat finds the message (" + variant + ")")
+    ac1.set_config("scan_all_folders_debounce_secs", "0")
+    ac1.start_io()
+    chat = ac1.create_chat(ac2)
+    n_msgs = 1  # "Messages are end-to-end encrypted."
+    if folder == "Spam":
+        msg = ac1.wait_for_incoming_msg().get_snapshot()
+        assert msg.text == "hello"
+        n_msgs += 1
+    else:
+        ac1.wait_for_event(EventType.IMAP_INBOX_IDLE)
+    assert len(chat.get_messages()) == n_msgs
+
+    # The message has reached its destination.
+    ac1_direct_imap.select_folder(expected_destination)
+    assert len(ac1_direct_imap.get_all_messages()) == 1
+    if folder != expected_destination:
+        ac1_direct_imap.select_folder(folder)
+        assert len(ac1_direct_imap.get_all_messages()) == 0
+
+
 def test_trash_multiple_messages(acfactory, direct_imap, log):
     ac1, ac2 = acfactory.get_online_accounts(2)
     ac2.stop_io()
 
+    # Create the Trash folder on IMAP server and configure deletion to it. There was a bug that if
+    # Trash wasn't configured initially, it can't be configured later, let's check this.
+    log.section("Creating trash folder")
+    ac2_direct_imap = direct_imap(ac2)
+    ac2_direct_imap.create_folder("Trash")
     ac2.set_config("delete_server_after", "0")
     ac2.set_config("sync_msgs", "0")
+    ac2.set_config("delete_to_trash", "1")
+
+    log.section("Check that Trash can be configured initially as well")
+    ac3 = ac2.clone()
+    ac3.bring_online()
+    assert ac3.get_config("configured_trash_folder")
+    ac3.stop_io()
 
     ac2.start_io()
     chat12 = acfactory.get_accepted_chat(ac1, ac2)
@@ -196,15 +520,17 @@ def test_trash_multiple_messages(acfactory, direct_imap, log):
         assert msg.text in texts
         if text != "second":
             to_delete.append(msg)
+    # ac2 has received some messages, this is impossible w/o the trash folder configured, let's
+    # check the configuration.
+    assert ac2.get_config("configured_trash_folder") == "Trash"
 
     log.section("ac2: deleting all messages except second")
     assert len(to_delete) == len(texts) - 1
     ac2.delete_messages(to_delete)
 
     log.section("ac2: test that only one message is left")
-    ac2_direct_imap = direct_imap(ac2)
     while 1:
-        ac2.wait_for_event(EventType.IMAP_MESSAGE_DELETED)
+        ac2.wait_for_event(EventType.IMAP_MESSAGE_MOVED)
         ac2_direct_imap.select_config_folder("inbox")
         nr_msgs = len(ac2_direct_imap.get_all_messages())
         assert nr_msgs > 0

deltachat-rpc-client/tests/test_multitransport.py

@@ -1,7 +1,6 @@
 import pytest
 
 from deltachat_rpc_client import EventType
-from deltachat_rpc_client.const import DownloadState
 from deltachat_rpc_client.rpc import JsonRpcError
 
 
@@ -38,8 +37,8 @@ def test_add_second_address(acfactory) -> None:
         with pytest.raises(JsonRpcError):
             account.set_config(option, "1")
 
-    # show_emails does not matter for multi-relay, can be set to anything
-    account.set_config("show_emails", "0")
+    with pytest.raises(JsonRpcError):
+        account.set_config("show_emails", "0")
 
 
 @pytest.mark.parametrize("key", ["mvbox_move", "only_fetch_mvbox"])
@@ -58,8 +57,8 @@ def test_no_second_transport_with_mvbox(acfactory, key) -> None:
         account.add_transport_from_qr(qr)
 
 
-def test_second_transport_without_classic_emails(acfactory) -> None:
-    """Test that second transport can be configured if classic emails are not fetched."""
+def test_no_second_transport_without_classic_emails(acfactory) -> None:
+    """Test that second transport cannot be configured if classic emails are not fetched."""
     account = acfactory.new_configured_account()
     assert len(account.list_transports()) == 1
 
@@ -68,7 +67,8 @@ def test_second_transport_without_classic_emails(acfactory) -> None:
     qr = acfactory.get_account_qr()
     account.set_config("show_emails", "0")
 
-    account.add_transport_from_qr(qr)
+    with pytest.raises(JsonRpcError):
+        account.add_transport_from_qr(qr)
 
 
 def test_change_address(acfactory) -> None:
@@ -120,33 +120,6 @@ def test_change_address(acfactory) -> None:
     assert sender_addr2 == new_alice_addr
 
 
-def test_download_on_demand(acfactory) -> None:
-    alice, bob = acfactory.get_online_accounts(2)
-    alice.set_config("download_limit", "1")
-
-    alice.stop_io()
-    qr = acfactory.get_account_qr()
-    alice.add_transport_from_qr(qr)
-    alice.start_io()
-
-    alice.create_chat(bob)
-    chat_bob_alice = bob.create_chat(alice)
-    chat_bob_alice.send_message(file="../test-data/image/screenshot.jpg")
-    msg = alice.wait_for_incoming_msg()
-    snapshot = msg.get_snapshot()
-    assert snapshot.download_state == DownloadState.AVAILABLE
-    chat_id = snapshot.chat_id
-    # Actually the message isn't available yet. Wait somehow for the post-message to arrive.
-    chat_bob_alice.send_message("Now you can download my previous message")
-    alice.wait_for_incoming_msg()
-    alice._rpc.download_full_message(alice.id, msg.id)
-    for dstate in [DownloadState.IN_PROGRESS, DownloadState.DONE]:
-        event = alice.wait_for_event(EventType.MSGS_CHANGED)
-        assert event.chat_id == chat_id
-        assert event.msg_id == msg.id
-        assert msg.get_snapshot().download_state == dstate
-
-
 @pytest.mark.parametrize("is_chatmail", ["0", "1"])
 def test_mvbox_move_first_transport(acfactory, is_chatmail) -> None:
     """Test that mvbox_move is disabled by default even for non-chatmail accounts.
@@ -236,7 +209,7 @@ def test_transport_synchronization(acfactory, log) -> None:
 
 def test_transport_sync_new_as_primary(acfactory, log) -> None:
     """Test synchronization of new transport as primary between devices."""
-    ac1, bob = acfactory.get_online_accounts(2)
+    ac1 = acfactory.get_online_account()
     ac1_clone = ac1.clone()
     ac1_clone.bring_online()
 
@@ -256,15 +229,6 @@ def test_transport_sync_new_as_primary(acfactory, log) -> None:
     ac1_clone.wait_for_event(EventType.TRANSPORTS_MODIFIED)
     assert ac1_clone.get_config("configured_addr") == transport2["addr"]
 
-    log.section("ac1_clone receives a message via the new primary transport")
-    ac1_chat = ac1.create_chat(bob)
-    ac1_chat.send_text("Hello!")
-    bob_chat_id = bob.wait_for_incoming_msg_event().chat_id
-    bob_chat = bob.get_chat_by_id(bob_chat_id)
-    bob_chat.accept()
-    bob_chat.send_text("hello back")
-    assert ac1_clone.wait_for_incoming_msg().get_snapshot().text == "hello back"
-
 
 def test_recognize_self_address(acfactory) -> None:
     alice, bob = acfactory.get_online_accounts(2)

deltachat-rpc-client/tests/test_something.py

@@ -5,7 +5,6 @@ import logging
 import os
 import socket
 import subprocess
-import time
 from unittest.mock import MagicMock
 
 import pytest
@@ -388,29 +387,22 @@ def test_dont_move_sync_msgs(acfactory, direct_imap):
     ac1.set_config("bcc_self", "1")
     ac1.set_config("fix_is_chatmail", "1")
     ac1.add_or_update_transport({"addr": addr, "password": password})
-    ac1.start_io()
+    ac1.bring_online()
     ac1_direct_imap = direct_imap(ac1)
 
-    # Sync messages may also be sent during configuration.
-    ac1.wait_for_event(EventType.MSG_DELIVERED)
     ac1_direct_imap.select_folder("Inbox")
-    while True:
-        if len(ac1_direct_imap.get_all_messages()) == 1:
-            break
-        time.sleep(1)
+    # Sync messages may also be sent during configuration.
+    inbox_msg_cnt = len(ac1_direct_imap.get_all_messages())
 
     ac1.set_config("displayname", "Alice")
     ac1.wait_for_event(EventType.MSG_DELIVERED)
     ac1.set_config("displayname", "Bob")
     ac1.wait_for_event(EventType.MSG_DELIVERED)
+    ac1_direct_imap.select_folder("Inbox")
+    assert len(ac1_direct_imap.get_all_messages()) == inbox_msg_cnt + 2
 
-    # Message may not be delivered to IMAP immediately
-    # after sending over SMTP,
-    # retry until they are delivered to IMAP.
-    while True:
-        if len(ac1_direct_imap.get_all_messages()) == 3:
-            break
-        time.sleep(1)
+    ac1_direct_imap.select_folder("DeltaChat")
+    assert len(ac1_direct_imap.get_all_messages()) == 0
 
 
 def test_reaction_seen_on_another_dev(acfactory) -> None:
@@ -919,47 +911,6 @@ def test_markseen_contact_request(acfactory):
     assert message2.get_snapshot().state == MessageState.IN_SEEN
 
 
-@pytest.mark.parametrize("team_profile", [True, False])
-def test_no_markseen_in_team_profile(team_profile, acfactory):
-    """
-    Test that seen status is synchronized iff `team_profile` isn't set.
-    """
-    alice, bob = acfactory.get_online_accounts(2)
-    if team_profile:
-        bob.set_config("team_profile", "1")
-
-    # Bob sets up a second device.
-    bob2 = bob.clone()
-    bob2.start_io()
-
-    alice_chat_bob = alice.create_chat(bob)
-    bob_chat_alice = bob.create_chat(alice)
-    bob2.create_chat(alice)
-    alice_chat_bob.send_text("Hello Bob!")
-
-    message = bob.wait_for_incoming_msg()
-    message2 = bob2.wait_for_incoming_msg()
-    assert message2.get_snapshot().state == MessageState.IN_FRESH
-
-    message.mark_seen()
-
-    # Send a message and wait until it arrives
-    # in order to wait until Bob2 gets the markseen message.
-    # This also tests that outgoing messages
-    # don't mark preceeding messages as seen in team profiles.
-    bob_chat_alice.send_text("Outgoing message")
-    while True:
-        outgoing = bob2.wait_for_msg(EventType.MSGS_CHANGED)
-        if outgoing.id != 0:
-            break
-    assert outgoing.get_snapshot().text == "Outgoing message"
-
-    if team_profile:
-        assert message2.get_snapshot().state == MessageState.IN_FRESH
-    else:
-        assert message2.get_snapshot().state == MessageState.IN_SEEN
-
-
 def test_read_receipt(acfactory):
     """
     Test sending a read receipt and ensure it is attributed to the correct contact.
@@ -979,9 +930,6 @@ def test_read_receipt(acfactory):
     assert len(read_receipts) == 1
     assert read_receipts[0].contact_id == alice_contact_bob.id
 
-    read_receipt_cnt = read_msg.get_read_receipt_count()
-    assert read_receipt_cnt == 1
-
 
 def test_get_http_response(acfactory):
     alice = acfactory.new_configured_account()
@@ -1185,30 +1133,6 @@ def test_leave_broadcast(acfactory, all_devices_online):
     check_account(bob2, bob2.create_contact(alice), inviter_side=False)
 
 
-def test_leave_and_delete_group(acfactory, log):
-    alice, bob = acfactory.get_online_accounts(2)
-
-    log.section("Alice creates a group")
-    alice_chat = alice.create_group("Group")
-    alice_chat.add_contact(bob)
-    assert len(alice_chat.get_contacts()) == 2  # Alice and Bob
-    alice_chat.send_text("hello")
-
-    log.section("Bob sees the group, and leaves and deletes it")
-    msg = bob.wait_for_incoming_msg().get_snapshot()
-    assert msg.text == "hello"
-    msg.chat.accept()
-
-    msg.chat.leave()
-    # Bob deletes the chat. This must not prevent the leave message from being sent.
-    msg.chat.delete()
-
-    log.section("Alice receives the delete message")
-    # After Bob left, only Alice will be left in the group:
-    while len(alice_chat.get_contacts()) != 1:
-        alice.wait_for_event(EventType.CHAT_MODIFIED)
-
-
 def test_immediate_autodelete(acfactory, direct_imap, log):
     ac1, ac2 = acfactory.get_online_accounts(2)
 

deltachat-rpc-server/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "deltachat-rpc-server"
-version = "2.42.0"
+version = "2.37.0"
 description = "DeltaChat JSON-RPC server"
 edition = "2021"
 readme = "README.md"

deltachat-rpc-server/npm-package/README.md

@@ -5,6 +5,8 @@ it does not use NAPI bindings but instead uses stdio executables
 to let you talk to core over jsonrpc over stdio.
 This simplifies cross-compilation and even reduces binary size (no CFFI layer and no NAPI layer).
 
+📚 Docs: <https://js.jsonrpc.delta.chat/>
+
 ## Usage
 
 > The **minimum** nodejs version for this package is `16`
@@ -18,20 +20,47 @@ import { startDeltaChat } from "@deltachat/stdio-rpc-server";
 import { C } from "@deltachat/jsonrpc-client";
 
 async function main() {
-    const dc = await startDeltaChat("deltachat-data");
-    console.log(await dc.rpc.getSystemInfo());
-    dc.close()
+  const dc = await startDeltaChat("deltachat-data");
+  console.log(await dc.rpc.getSystemInfo());
+  dc.close();
 }
-main()
+main();
 ```
 
-For a more complete example refer to https://github.com/deltachat-bot/echo/pull/69/files (TODO change link when pr is merged).
+For a more complete example refer to <https://github.com/deltachat-bot/echo/tree/master/nodejs_stdio_jsonrpc>.
 
 ## How to use on an unsupported platform
 
-<!-- todo instructions, will uses an env var for pointing to `deltachat-rpc-server` binary -->
+You need to have rust installed to compile deltachat core for your platform and cpu architecture.
+<https://rustup.rs/> is the recommended way to install rust.
+Also your system probably needs more than 4GB RAM to compile core, alternatively your could try to build the debug build, which might take less RAM to build.
 
-<!-- todo copy parts from https://github.com/deltachat/deltachat-desktop/blob/7045c6f549e4b9d5caa0709d5bd314bbd9fd53db/docs/UPDATE_CORE.md -->
+1. clone the core repo, right next to your project folder: `git clone git@github.com:deltachat/deltachat-core-rust.git`
+2. go into your core checkout and run `git pull` and `git checkout <version>` to point it to the correct version (needs to be the same version the `@deltachat/jsonrpc-client` package has)
+3. run `cargo build --release --package deltachat-rpc-server --bin deltachat-rpc-server`
+
+Then you have 2 options:
+
+### point to deltachat-rpc-server via direct path:
+
+```sh
+# start your app with the DELTA_CHAT_RPC_SERVER env var
+DELTA_CHAT_RPC_SERVER="../deltachat-core-rust/target/release/deltachat-rpc-server" node myapp.js
+```
+
+### install deltachat-rpc-server in your $PATH:
+
+```sh
+# use this to install to ~/.cargo/bin
+cargo install --release --package deltachat-rpc-server --bin deltachat-rpc-server
+# or manually move deltachat-core-rust/target/release/deltachat-rpc-server
+# to a location that is included in your $PATH Environment variable.
+```
+
+And make sure to enable the `takeVersionFromPATH` option:
+```js
+startDeltaChat("data-dir", { takeVersionFromPATH: true });
+```
 
 ## How does it work when you install it
 
@@ -46,7 +75,7 @@ references:
 When you import this package it searches for the rpc server in the following locations and order:
 
 1. `DELTA_CHAT_RPC_SERVER` environment variable
-2. use the PATH when `{takeVersionFromPATH: true}` is supplied in the options. 
+2. use the PATH when `{takeVersionFromPATH: true}` is supplied in the options.
 3. prebuilds in npm packages
 
 so by default it uses the prebuilds.

deltachat-rpc-server/npm-package/package.json

@@ -15,5 +15,5 @@
   },
   "type": "module",
   "types": "index.d.ts",
-  "version": "2.42.0"
+  "version": "2.37.0"
 }

deny.toml

@@ -17,6 +17,11 @@ ignore = [
     # It is a transitive dependency of iroh 0.35.0,
     # this should be fixed by upgrading to iroh 1.0 once it is released.
     "RUSTSEC-2025-0134",
+
+    # Old versions of "lru" are transitive dependencies of iroh 0.35.0.
+    # <https://rustsec.org/advisories/RUSTSEC-2026-0002>
+    # <https://github.com/chatmail/core/issues/7692>
+    "RUSTSEC-2026-0002",
 ]
 
 [bans]

python/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "deltachat"
-version = "2.42.0"
+version = "2.37.0"
 license = "MPL-2.0"
 description = "Python bindings for the Delta Chat Core library using CFFI against the Rust-implemented libdeltachat"
 readme = "README.rst"

python/tests/test_1_online.py

@@ -220,6 +220,21 @@ def test_webxdc_huge_update(acfactory, data, lp):
     assert update["payload"] == payload
 
 
+def test_enable_mvbox_move(acfactory, lp):
+    (ac1,) = acfactory.get_online_accounts(1)
+
+    lp.sec("ac2: start without mvbox thread")
+    ac2 = acfactory.new_online_configuring_account(mvbox_move=False)
+    acfactory.bring_accounts_online()
+
+    lp.sec("ac2: configuring mvbox")
+    ac2.set_config("mvbox_move", "1")
+
+    lp.sec("ac1: send message and wait for ac2 to receive it")
+    acfactory.get_accepted_chat(ac1, ac2).send_text("message1")
+    assert ac2._evtracker.wait_next_incoming_message().text == "message1"
+
+
 def test_forward_messages(acfactory, lp):
     ac1, ac2 = acfactory.get_online_accounts(2)
     chat = ac1.create_chat(ac2)
@@ -335,7 +350,7 @@ def test_long_group_name(acfactory, lp):
 
 
 def test_send_self_message(acfactory, lp):
-    ac1 = acfactory.new_online_configuring_account(bcc_self=True)
+    ac1 = acfactory.new_online_configuring_account(mvbox_move=True, bcc_self=True)
     acfactory.bring_accounts_online()
     lp.sec("ac1: create self chat")
     chat = ac1.get_self_contact().create_chat()
@@ -494,7 +509,7 @@ def test_reply_privately(acfactory):
 
 
 def test_mdn_asymmetric(acfactory, lp):
-    ac1 = acfactory.new_online_configuring_account()
+    ac1 = acfactory.new_online_configuring_account(mvbox_move=True)
     ac2 = acfactory.new_online_configuring_account()
     acfactory.bring_accounts_online()
 
@@ -523,14 +538,20 @@ def test_mdn_asymmetric(acfactory, lp):
     ac2.mark_seen_messages([msg])
 
     lp.sec("ac1: waiting for incoming activity")
+    # MDN should be moved even though MDNs are already disabled
+    ac1._evtracker.get_matching("DC_EVENT_IMAP_MESSAGE_MOVED")
+
     assert len(chat.get_messages()) == 1 + E2EE_INFO_MSGS
 
     # Wait for the message to be marked as seen on IMAP.
-    ac1._evtracker.get_info_contains("Marked messages [0-9]+ in folder INBOX as seen.")
+    ac1._evtracker.get_info_contains("Marked messages [0-9]+ in folder DeltaChat as seen.")
 
     # MDN is received even though MDNs are already disabled
     assert msg_out.is_out_mdn_received()
 
+    ac1.direct_imap.select_config_folder("mvbox")
+    assert len(list(ac1.direct_imap.conn.fetch(AND(seen=True)))) == 1
+
 
 def test_send_receive_encrypt(acfactory, lp):
     ac1, ac2 = acfactory.get_online_accounts(2)
@@ -932,6 +953,7 @@ def test_set_get_group_image(acfactory, data, lp):
 
 def test_connectivity(acfactory, lp):
     ac1, ac2 = acfactory.get_online_accounts(2)
+    ac1.set_config("scan_all_folders_debounce_secs", "0")
 
     ac1._evtracker.wait_for_connectivity(dc.const.DC_CONNECTIVITY_CONNECTED)
 

python/tests/test_3_offline.py

@@ -258,6 +258,9 @@ class TestOfflineChat:
         with pytest.raises(ValueError):
             ac1.set_stock_translation(dc.const.DC_STR_FILE, "xyz %1$s")
         ac1._evtracker.get_matching("DC_EVENT_WARNING")
+        with pytest.raises(ValueError):
+            ac1.set_stock_translation(dc.const.DC_STR_CONTACT_NOT_VERIFIED, "xyz %2$s")
+        ac1._evtracker.get_matching("DC_EVENT_WARNING")
         with pytest.raises(ValueError):
             ac1.set_stock_translation(500, "xyz %1$s")
         ac1._evtracker.get_matching("DC_EVENT_WARNING")

release-date.in

@@ -1 +1 @@
-2026-02-10
+2026-01-08

scripts/coredeps/install-rust.sh

@@ -7,7 +7,7 @@ set -euo pipefail
 #
 # Avoid using rustup here as it depends on reading /proc/self/exe and
 # has problems running under QEMU.
-RUST_VERSION=1.93.0
+RUST_VERSION=1.92.0
 
 ARCH="$(uname -m)"
 test -f "/lib/libc.musl-$ARCH.so.1" && LIBC=musl || LIBC=gnu

scripts/deny.sh

@@ -3,4 +3,4 @@
 # Update package cache without changing the lockfile.
 cargo update --dry-run
 
-cargo deny --workspace --all-features --locked check -D warnings
+cargo deny --workspace --all-features check -D warnings

scripts/update-provider-database.sh

@@ -6,11 +6,11 @@ set -euo pipefail
 export TZ=UTC
 
 # Provider database revision.
-REV=996c4bc82be5a7404f70b185ff062da33bfa98d9
+REV=d041136c19a48b493823b46d472f12b9ee94ae80
 
 CORE_ROOT="$PWD"
 TMP="$(mktemp -d)"
-git clone --filter=blob:none https://github.com/chatmail/provider-db.git "$TMP"
+git clone --filter=blob:none https://github.com/deltachat/provider-db.git "$TMP"
 cd "$TMP"
 git checkout "$REV"
 DATE=$(git show -s --format=%cs)

src/aheader.rs

@@ -110,9 +110,9 @@ impl FromStr for Aheader {
                 SignedPublicKey::from_base64(&raw).context("autocrypt key cannot be decoded")
             })
             .and_then(|key| {
-                key.verify_bindings()
+                key.verify()
                     .and(Ok(key))
-                    .context("Autocrypt key cannot be verified")
+                    .context("autocrypt key cannot be verified")
             })?;
 
         let prefer_encrypt = attributes

src/blob.rs

@@ -1,6 +1,6 @@
 //! # Blob directory management.
 
-use std::cmp::max;
+use core::cmp::max;
 use std::io::{Cursor, Seek};
 use std::iter::FusedIterator;
 use std::mem;
@@ -256,7 +256,7 @@ impl<'a> BlobObject<'a> {
 
     /// Recode image to avatar size.
     pub async fn recode_to_avatar_size(&mut self, context: &Context) -> Result<()> {
-        let (max_wh, max_bytes) =
+        let (img_wh, max_bytes) =
             match MediaQuality::from_i32(context.get_config_int(Config::MediaQuality).await?)
                 .unwrap_or_default()
             {
@@ -273,7 +273,7 @@ impl<'a> BlobObject<'a> {
         let is_avatar = true;
         self.check_or_recode_to_size(
             context, None, // The name of an avatar doesn't matter
-            viewtype, max_wh, max_bytes, is_avatar,
+            viewtype, img_wh, max_bytes, is_avatar,
         )?;
 
         Ok(())
@@ -294,7 +294,7 @@ impl<'a> BlobObject<'a> {
         name: Option<String>,
         viewtype: &mut Viewtype,
     ) -> Result<String> {
-        let (max_wh, max_bytes) =
+        let (img_wh, max_bytes) =
             match MediaQuality::from_i32(context.get_config_int(Config::MediaQuality).await?)
                 .unwrap_or_default()
             {
@@ -305,15 +305,13 @@ impl<'a> BlobObject<'a> {
                 MediaQuality::Worse => (constants::WORSE_IMAGE_SIZE, constants::WORSE_IMAGE_BYTES),
             };
         let is_avatar = false;
-        self.check_or_recode_to_size(context, name, viewtype, max_wh, max_bytes, is_avatar)
+        self.check_or_recode_to_size(context, name, viewtype, img_wh, max_bytes, is_avatar)
     }
 
-    /// Checks or recodes the image so that it fits into limits on width/height and/or byte size.
+    /// Checks or recodes the image so that it fits into limits on width/height and byte size.
     ///
-    /// If `!is_avatar`, then if `max_bytes` is exceeded, reduces the image to `max_wh` and proceeds
-    /// with the result (even if `max_bytes` is still exceeded).
-    ///
-    /// If `is_avatar`, the resolution will be reduced in a loop until the image fits `max_bytes`.
+    /// If `!is_avatar`, then if `max_bytes` is exceeded, reduces the image to `img_wh` and proceeds
+    /// with the result without rechecking.
     ///
     /// This modifies the blob object in-place.
     ///
@@ -326,7 +324,7 @@ impl<'a> BlobObject<'a> {
         context: &Context,
         name: Option<String>,
         viewtype: &mut Viewtype,
-        max_wh: u32,
+        mut img_wh: u32,
         max_bytes: usize,
         is_avatar: bool,
     ) -> Result<String> {
@@ -388,14 +386,7 @@ impl<'a> BlobObject<'a> {
                 _ => img,
             };
 
-            // max_wh is the maximum image width and height, i.e. the resolution-limit.
-            // target_wh target-resolution for resizing the image.
-            let exceeds_wh = img.width() > max_wh || img.height() > max_wh;
-            let mut target_wh = if exceeds_wh {
-                max_wh
-            } else {
-                max(img.width(), img.height())
-            };
+            let exceeds_wh = img.width() > img_wh || img.height() > img_wh;
             let exceeds_max_bytes = nr_bytes > max_bytes as u64;
 
             let jpeg_quality = 75;
@@ -434,6 +425,15 @@ impl<'a> BlobObject<'a> {
                         });
 
             if do_scale {
+                if !exceeds_wh {
+                    img_wh = max(img.width(), img.height());
+                    // PNGs and WebPs may be huge because of animation, which is lost by the `image`
+                    // crate when recoding, so don't scale them down.
+                    if matches!(fmt, ImageFormat::Jpeg) || !encoded.is_empty() {
+                        img_wh = img_wh * 2 / 3;
+                    }
+                }
+
                 loop {
                     if mem::take(&mut add_white_bg) {
                         self::add_white_bg(&mut img);
@@ -448,9 +448,9 @@ impl<'a> BlobObject<'a> {
                     // usually has less pixels by cropping, UI that needs to wait anyways,
                     // and also benefits from slightly better (5%) encoding of Triangle-filtered images.
                     let new_img = if is_avatar {
-                        img.resize(target_wh, target_wh, image::imageops::FilterType::Triangle)
+                        img.resize(img_wh, img_wh, image::imageops::FilterType::Triangle)
                     } else {
-                        img.thumbnail(target_wh, target_wh)
+                        img.thumbnail(img_wh, img_wh)
                     };
 
                     if encoded_img_exceeds_bytes(
@@ -461,19 +461,19 @@ impl<'a> BlobObject<'a> {
                         &mut encoded,
                     )? && is_avatar
                     {
-                        if target_wh < 20 {
+                        if img_wh < 20 {
                             return Err(format_err!(
                                 "Failed to scale image to below {max_bytes}B.",
                             ));
                         }
 
-                        target_wh = target_wh * 2 / 3;
+                        img_wh = img_wh * 2 / 3;
                     } else {
                         info!(
                             context,
                             "Final scaled-down image size: {}B ({}px).",
                             encoded.len(),
-                            target_wh
+                            img_wh
                         );
                         break;
                     }

src/blob/blob_tests.rs

@@ -798,56 +798,3 @@ async fn test_create_and_deduplicate_from_bytes() -> Result<()> {
 
     Ok(())
 }
-
-/// Tests that an image that already fits into the width limit,
-/// but not the bytes limit,
-/// is compressed without changing the resolution.
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn test_recode_without_downscaling() -> Result<()> {
-    let t = &TestContext::new().await;
-
-    let image = include_bytes!("../../test-data/image/screenshot120x120.jpg");
-    const { assert!(120 < constants::WORSE_AVATAR_SIZE) };
-
-    for is_avatar in [true, false] {
-        let mut blob =
-            BlobObject::create_and_deduplicate_from_bytes(t, image, "image.jpg").unwrap();
-        let image_path = blob.to_abs_path();
-        check_image_size(&image_path, 120, 120);
-
-        assert!(
-            fs::metadata(&image_path).await.unwrap().len() > constants::WORSE_AVATAR_BYTES as u64
-        );
-
-        // Repeat the check, because a second call to `check_or_recode_to_size()`
-        // is not supposed to change anything:
-        let mut imgs = vec![];
-        for _ in 0..2 {
-            let mut viewtype = Viewtype::Image;
-            let new_name = blob.check_or_recode_to_size(
-                t,
-                Some("image.jpg".to_string()),
-                &mut viewtype,
-                constants::WORSE_AVATAR_SIZE,
-                constants::WORSE_AVATAR_BYTES,
-                is_avatar,
-            )?;
-            let image_path = blob.to_abs_path();
-            assert_eq!(new_name, "image.jpg"); // The name shall not have changed
-            assert_eq!(viewtype, Viewtype::Image); // The viewtype shall not have changed
-            let img = check_image_size(&image_path, 120, 120); // The resolution shall not have changed
-            imgs.push(img);
-
-            let new_image_bytes = fs::metadata(&image_path).await.unwrap().len();
-            assert!(
-                new_image_bytes < constants::WORSE_AVATAR_BYTES as u64,
-                "The new image size, {new_image_bytes}, should be lower than {}, is_avatar={is_avatar}",
-                constants::WORSE_AVATAR_BYTES
-            );
-        }
-
-        assert_eq!(imgs[0], imgs[1]);
-    }
-
-    Ok(())
-}

src/calls.rs

@@ -15,12 +15,13 @@ use crate::message::{Message, MsgId, Viewtype};
 use crate::mimeparser::{MimeMessage, SystemMessage};
 use crate::net::dns::lookup_host_with_cache;
 use crate::param::Param;
-use crate::stock_str;
 use crate::tools::{normalize_text, time};
 use anyhow::{Context as _, Result, ensure};
 use deltachat_derive::{FromSql, ToSql};
 use num_traits::FromPrimitive;
+use sdp::SessionDescription;
 use serde::Serialize;
+use std::io::Cursor;
 use std::str::FromStr;
 use std::time::Duration;
 use tokio::task;
@@ -103,14 +104,10 @@ impl CallInfo {
         };
 
         if self.is_incoming() {
-            let incoming_call_str =
-                stock_str::incoming_call(context, self.has_video_initially()).await;
-            self.update_text(context, &format!("{incoming_call_str}\n{duration}"))
+            self.update_text(context, &format!("Incoming call\n{duration}"))
                 .await?;
         } else {
-            let outgoing_call_str =
-                stock_str::outgoing_call(context, self.has_video_initially()).await;
-            self.update_text(context, &format!("{outgoing_call_str}\n{duration}"))
+            self.update_text(context, &format!("Outgoing call\n{duration}"))
                 .await?;
         }
         Ok(())
@@ -129,14 +126,6 @@ impl CallInfo {
         self.msg.param.exists(CALL_ACCEPTED_TIMESTAMP)
     }
 
-    /// Returns true if the call is started as a video call.
-    pub fn has_video_initially(&self) -> bool {
-        self.msg
-            .param
-            .get_bool(Param::WebrtcHasVideoInitially)
-            .unwrap_or(false)
-    }
-
     /// Returns true if the call is missed
     /// because the caller canceled it
     /// explicitly before ringing stopped.
@@ -196,7 +185,6 @@ impl Context {
         &self,
         chat_id: ChatId,
         place_call_info: String,
-        has_video_initially: bool,
     ) -> Result<MsgId> {
         let chat = Chat::load_from_db(self, chat_id).await?;
         ensure!(
@@ -205,15 +193,12 @@ impl Context {
         );
         ensure!(!chat.is_self_talk(), "Cannot call self");
 
-        let outgoing_call_str = stock_str::outgoing_call(self, has_video_initially).await;
         let mut call = Message {
             viewtype: Viewtype::Call,
-            text: outgoing_call_str,
+            text: "Outgoing call".into(),
             ..Default::default()
         };
         call.param.set(Param::WebrtcRoom, &place_call_info);
-        call.param
-            .set_int(Param::WebrtcHasVideoInitially, has_video_initially.into());
         call.id = send_msg(self, chat_id, &mut call).await?;
 
         let wait = RINGING_SECONDS;
@@ -281,12 +266,10 @@ impl Context {
         if !call.is_accepted() {
             if call.is_incoming() {
                 call.mark_as_ended(self).await?;
-                let declined_call_str = stock_str::declined_call(self).await;
-                call.update_text(self, &declined_call_str).await?;
+                call.update_text(self, "Declined call").await?;
             } else {
                 call.mark_as_canceled(self).await?;
-                let canceled_call_str = stock_str::canceled_call(self).await;
-                call.update_text(self, &canceled_call_str).await?;
+                call.update_text(self, "Canceled call").await?;
             }
         } else {
             call.mark_as_ended(self).await?;
@@ -328,12 +311,10 @@ impl Context {
         if !call.is_accepted() && !call.is_ended() {
             if call.is_incoming() {
                 call.mark_as_canceled(&context).await?;
-                let missed_call_str = stock_str::missed_call(&context).await;
-                call.update_text(&context, &missed_call_str).await?;
+                call.update_text(&context, "Missed call").await?;
             } else {
                 call.mark_as_ended(&context).await?;
-                let canceled_call_str = stock_str::canceled_call(&context).await;
-                call.update_text(&context, &canceled_call_str).await?;
+                call.update_text(&context, "Canceled call").await?;
             }
             context.emit_msgs_changed(call.msg.chat_id, call_id);
             context.emit_event(EventType::CallEnded {
@@ -358,14 +339,18 @@ impl Context {
 
             if call.is_incoming() {
                 if call.is_stale() {
-                    let missed_call_str = stock_str::missed_call(self).await;
-                    call.update_text(self, &missed_call_str).await?;
+                    call.update_text(self, "Missed call").await?;
                     self.emit_incoming_msg(call.msg.chat_id, call_id); // notify missed call
                 } else {
-                    let incoming_call_str =
-                        stock_str::incoming_call(self, call.has_video_initially()).await;
-                    call.update_text(self, &incoming_call_str).await?;
+                    call.update_text(self, "Incoming call").await?;
                     self.emit_msgs_changed(call.msg.chat_id, call_id); // ringing calls are not additionally notified
+                    let has_video = match sdp_has_video(&call.place_call_info) {
+                        Ok(has_video) => has_video,
+                        Err(err) => {
+                            warn!(self, "Failed to determine if SDP offer has video: {err:#}.");
+                            false
+                        }
+                    };
                     let can_call_me = match who_can_call_me(self).await? {
                         WhoCanCallMe::Contacts => ChatIdBlocked::lookup_by_contact(self, from_id)
                             .await?
@@ -392,7 +377,7 @@ impl Context {
                             msg_id: call.msg.id,
                             chat_id: call.msg.chat_id,
                             place_call_info: call.place_call_info.to_string(),
-                            has_video: call.has_video_initially(),
+                            has_video,
                         });
                     }
                     let wait = call.remaining_ring_seconds();
@@ -404,9 +389,7 @@ impl Context {
                     ));
                 }
             } else {
-                let outgoing_call_str =
-                    stock_str::outgoing_call(self, call.has_video_initially()).await;
-                call.update_text(self, &outgoing_call_str).await?;
+                call.update_text(self, "Outgoing call").await?;
                 self.emit_msgs_changed(call.msg.chat_id, call_id);
             }
         } else {
@@ -456,23 +439,19 @@ impl Context {
                         if call.is_incoming() {
                             if from_id == ContactId::SELF {
                                 call.mark_as_ended(self).await?;
-                                let declined_call_str = stock_str::declined_call(self).await;
-                                call.update_text(self, &declined_call_str).await?;
+                                call.update_text(self, "Declined call").await?;
                             } else {
                                 call.mark_as_canceled(self).await?;
-                                let missed_call_str = stock_str::missed_call(self).await;
-                                call.update_text(self, &missed_call_str).await?;
+                                call.update_text(self, "Missed call").await?;
                             }
                         } else {
                             // outgoing
                             if from_id == ContactId::SELF {
                                 call.mark_as_canceled(self).await?;
-                                let canceled_call_str = stock_str::canceled_call(self).await;
-                                call.update_text(self, &canceled_call_str).await?;
+                                call.update_text(self, "Canceled call").await?;
                             } else {
                                 call.mark_as_ended(self).await?;
-                                let declined_call_str = stock_str::declined_call(self).await;
-                                call.update_text(self, &declined_call_str).await?;
+                                call.update_text(self, "Declined call").await?;
                             }
                         }
                     } else {
@@ -528,6 +507,19 @@ impl Context {
     }
 }
 
+/// Returns true if SDP offer has a video.
+pub fn sdp_has_video(sdp: &str) -> Result<bool> {
+    let mut cursor = Cursor::new(sdp);
+    let session_description =
+        SessionDescription::unmarshal(&mut cursor).context("Failed to parse SDP")?;
+    for media_description in &session_description.media_descriptions {
+        if media_description.media_name.media == "video" {
+            return Ok(true);
+        }
+    }
+    Ok(false)
+}
+
 /// State of the call for display in the message bubble.
 #[derive(Debug, PartialEq, Eq)]
 pub enum CallState {
@@ -625,7 +617,33 @@ struct IceServer {
     pub credential: Option<String>,
 }
 
-/// Creates ICE servers from a line received over IMAP METADATA.
+/// Creates JSON with ICE servers.
+async fn create_ice_servers(
+    context: &Context,
+    hostname: &str,
+    port: u16,
+    username: &str,
+    password: &str,
+) -> Result<String> {
+    // Do not use cache because there is no TLS.
+    let load_cache = false;
+    let urls: Vec<String> = lookup_host_with_cache(context, hostname, port, "", load_cache)
+        .await?
+        .into_iter()
+        .map(|addr| format!("turn:{addr}"))
+        .collect();
+
+    let ice_server = IceServer {
+        urls,
+        username: Some(username.to_string()),
+        credential: Some(password.to_string()),
+    };
+
+    let json = serde_json::to_string(&[ice_server])?;
+    Ok(json)
+}
+
+/// Creates JSON with ICE servers from a line received over IMAP METADATA.
 ///
 /// IMAP METADATA returns a line such as
 /// `example.com:3478:1758650868:8Dqkyyu11MVESBqjbIylmB06rv8=`
@@ -635,107 +653,20 @@ struct IceServer {
 /// while `8Dqkyyu11MVESBqjbIylmB06rv8=`
 /// is the password.
 pub(crate) async fn create_ice_servers_from_metadata(
+    context: &Context,
     metadata: &str,
-) -> Result<(i64, Vec<UnresolvedIceServer>)> {
+) -> Result<(i64, String)> {
     let (hostname, rest) = metadata.split_once(':').context("Missing hostname")?;
     let (port, rest) = rest.split_once(':').context("Missing port")?;
     let port = u16::from_str(port).context("Failed to parse the port")?;
     let (ts, password) = rest.split_once(':').context("Missing timestamp")?;
     let expiration_timestamp = i64::from_str(ts).context("Failed to parse the timestamp")?;
-    let ice_servers = vec![UnresolvedIceServer::Turn {
-        hostname: hostname.to_string(),
-        port,
-        username: ts.to_string(),
-        credential: password.to_string(),
-    }];
+    let ice_servers = create_ice_servers(context, hostname, port, ts, password).await?;
     Ok((expiration_timestamp, ice_servers))
 }
 
-/// STUN or TURN server with unresolved DNS name.
-#[derive(Debug, Clone)]
-pub(crate) enum UnresolvedIceServer {
-    /// STUN server.
-    Stun { hostname: String, port: u16 },
-
-    /// TURN server with the username and password.
-    Turn {
-        hostname: String,
-        port: u16,
-        username: String,
-        credential: String,
-    },
-}
-
-/// Resolves domain names of ICE servers.
-///
-/// On failure to resolve, logs the error
-/// and skips the server, but does not fail.
-pub(crate) async fn resolve_ice_servers(
-    context: &Context,
-    unresolved_ice_servers: Vec<UnresolvedIceServer>,
-) -> Result<String> {
-    let mut result: Vec<IceServer> = Vec::new();
-
-    // Do not use cache because there is no TLS.
-    let load_cache = false;
-
-    for unresolved_ice_server in unresolved_ice_servers {
-        match unresolved_ice_server {
-            UnresolvedIceServer::Stun { hostname, port } => {
-                match lookup_host_with_cache(context, &hostname, port, "", load_cache).await {
-                    Ok(addrs) => {
-                        let urls: Vec<String> = addrs
-                            .into_iter()
-                            .map(|addr| format!("stun:{addr}"))
-                            .collect();
-                        let stun_server = IceServer {
-                            urls,
-                            username: None,
-                            credential: None,
-                        };
-                        result.push(stun_server);
-                    }
-                    Err(err) => {
-                        warn!(
-                            context,
-                            "Failed to resolve STUN {hostname}:{port}: {err:#}."
-                        );
-                    }
-                }
-            }
-            UnresolvedIceServer::Turn {
-                hostname,
-                port,
-                username,
-                credential,
-            } => match lookup_host_with_cache(context, &hostname, port, "", load_cache).await {
-                Ok(addrs) => {
-                    let urls: Vec<String> = addrs
-                        .into_iter()
-                        .map(|addr| format!("turn:{addr}"))
-                        .collect();
-                    let turn_server = IceServer {
-                        urls,
-                        username: Some(username),
-                        credential: Some(credential),
-                    };
-                    result.push(turn_server);
-                }
-                Err(err) => {
-                    warn!(
-                        context,
-                        "Failed to resolve TURN {hostname}:{port}: {err:#}."
-                    );
-                }
-            },
-        }
-    }
-    let json = serde_json::to_string(&result)?;
-    Ok(json)
-}
-
 /// Creates JSON with ICE servers when no TURN servers are known.
-pub(crate) fn create_fallback_ice_servers() -> Vec<UnresolvedIceServer> {
+pub(crate) async fn create_fallback_ice_servers(context: &Context) -> Result<String> {
     // Do not use public STUN server from https://stunprotocol.org/.
     // It changes the hostname every year
     // (e.g. stunserver2025.stunprotocol.org
@@ -743,18 +674,36 @@ pub(crate) fn create_fallback_ice_servers() -> Vec<UnresolvedIceServer> {
     // because of bandwidth costs:
     // <https://github.com/jselbie/stunserver/issues/50>
 
-    vec![
-        UnresolvedIceServer::Stun {
-            hostname: "nine.testrun.org".to_string(),
-            port: STUN_PORT,
-        },
-        UnresolvedIceServer::Turn {
-            hostname: "turn.delta.chat".to_string(),
-            port: STUN_PORT,
-            username: "public".to_string(),
-            credential: "o4tR7yG4rG2slhXqRUf9zgmHz".to_string(),
-        },
-    ]
+    let hostname = "nine.testrun.org";
+    // Do not use cache because there is no TLS.
+    let load_cache = false;
+    let urls: Vec<String> = lookup_host_with_cache(context, hostname, STUN_PORT, "", load_cache)
+        .await?
+        .into_iter()
+        .map(|addr| format!("stun:{addr}"))
+        .collect();
+    let stun_server = IceServer {
+        urls,
+        username: None,
+        credential: None,
+    };
+
+    let hostname = "turn.delta.chat";
+    // Do not use cache because there is no TLS.
+    let load_cache = false;
+    let urls: Vec<String> = lookup_host_with_cache(context, hostname, STUN_PORT, "", load_cache)
+        .await?
+        .into_iter()
+        .map(|addr| format!("turn:{addr}"))
+        .collect();
+    let turn_server = IceServer {
+        urls,
+        username: Some("public".to_string()),
+        credential: Some("o4tR7yG4rG2slhXqRUf9zgmHz".to_string()),
+    };
+
+    let json = serde_json::to_string(&[stun_server, turn_server])?;
+    Ok(json)
 }
 
 /// Returns JSON with ICE servers.
@@ -768,8 +717,7 @@ pub(crate) fn create_fallback_ice_servers() -> Vec<UnresolvedIceServer> {
 /// <https://github.com/deltachat/deltachat-desktop/issues/5447>.
 pub async fn ice_servers(context: &Context) -> Result<String> {
     if let Some(ref metadata) = *context.metadata.read().await {
-        let ice_servers = resolve_ice_servers(context, metadata.ice_servers.clone()).await?;
-        Ok(ice_servers)
+        Ok(metadata.ice_servers.clone())
     } else {
         Ok("[]".to_string())
     }

src/calls/calls_tests.rs

@@ -25,6 +25,13 @@ async fn assert_text(t: &TestContext, call_id: MsgId, text: &str) -> Result<()>
 const PLACE_INFO: &str = "v=0\r\no=alice 2890844526 2890844526 IN IP4 host.anywhere.com\r\ns=-\r\nc=IN IP4 host.anywhere.com\r\nt=0 0\r\nm=audio 62986 RTP/AVP 0 4 18\r\na=rtpmap:0 PCMU/8000\r\na=rtpmap:4 G723/8000\r\na=rtpmap:18 G729/8000\r\na=inactive\r\n";
 const ACCEPT_INFO: &str = "v=0\r\no=bob 2890844730 2890844731 IN IP4 host.example.com\r\ns=\r\nc=IN IP4 host.example.com\r\nt=0 0\r\nm=audio 54344 RTP/AVP 0 4\r\na=rtpmap:0 PCMU/8000\r\na=rtpmap:4 G723/8000\r\na=inactive\r\n";
 
+/// Example from <https://datatracker.ietf.org/doc/rfc9143/>
+/// with `s= ` replaced with `s=-`.
+///
+/// `s=` cannot be empty according to RFC 3264,
+/// so it is more clear as `s=-`.
+const PLACE_INFO_VIDEO: &str = "v=0\r\no=alice 2890844526 2890844526 IN IP6 2001:db8::3\r\ns=-\r\nc=IN IP6 2001:db8::3\r\nt=0 0\r\na=group:BUNDLE foo bar\r\n\r\nm=audio 10000 RTP/AVP 0 8 97\r\nb=AS:200\r\na=mid:foo\r\na=rtcp-mux\r\na=rtpmap:0 PCMU/8000\r\na=rtpmap:8 PCMA/8000\r\na=rtpmap:97 iLBC/8000\r\na=extmap:1 urn:ietf:params:rtp-hdrext:sdes:mid\r\n\r\nm=video 10002 RTP/AVP 31 32\r\nb=AS:1000\r\na=mid:bar\r\na=rtcp-mux\r\na=rtpmap:31 H261/90000\r\na=rtpmap:32 MPV/90000\r\na=extmap:1 urn:ietf:params:rtp-hdrext:sdes:mid\r\n";
+
 async fn setup_call() -> Result<CallSetup> {
     let mut tcm = TestContextManager::new();
     let alice = tcm.alice().await;
@@ -45,7 +52,7 @@ async fn setup_call() -> Result<CallSetup> {
     bob2.create_chat(&alice).await;
 
     let test_msg_id = alice
-        .place_outgoing_call(alice_chat.id, PLACE_INFO.to_string(), true)
+        .place_outgoing_call(alice_chat.id, PLACE_INFO.to_string())
         .await?;
     let sent1 = alice.pop_sent_msg().await;
     assert_eq!(sent1.sender_msg_id, test_msg_id);
@@ -61,8 +68,7 @@ async fn setup_call() -> Result<CallSetup> {
         assert!(!info.is_incoming());
         assert!(!info.is_accepted());
         assert_eq!(info.place_call_info, PLACE_INFO);
-        assert_eq!(info.has_video_initially(), true);
-        assert_text(t, m.id, "Outgoing video call").await?;
+        assert_text(t, m.id, "Outgoing call").await?;
         assert_eq!(call_state(t, m.id).await?, CallState::Alerting);
     }
 
@@ -83,8 +89,7 @@ async fn setup_call() -> Result<CallSetup> {
         assert!(info.is_incoming());
         assert!(!info.is_accepted());
         assert_eq!(info.place_call_info, PLACE_INFO);
-        assert_eq!(info.has_video_initially(), true);
-        assert_text(t, m.id, "Incoming video call").await?;
+        assert_text(t, m.id, "Incoming call").await?;
         assert_eq!(call_state(t, m.id).await?, CallState::Alerting);
     }
 
@@ -115,7 +120,7 @@ async fn accept_call() -> Result<CallSetup> {
     // Bob accepts the incoming call
     bob.accept_incoming_call(bob_call.id, ACCEPT_INFO.to_string())
         .await?;
-    assert_text(&bob, bob_call.id, "Incoming video call").await?;
+    assert_text(&bob, bob_call.id, "Incoming call").await?;
     bob.evtracker
         .get_matching(|evt| matches!(evt, EventType::IncomingCallAccepted { .. }))
         .await;
@@ -129,7 +134,7 @@ async fn accept_call() -> Result<CallSetup> {
     assert_eq!(call_state(&bob, bob_call.id).await?, CallState::Active);
 
     bob2.recv_msg_trash(&sent2).await;
-    assert_text(&bob, bob_call.id, "Incoming video call").await?;
+    assert_text(&bob, bob_call.id, "Incoming call").await?;
     bob2.evtracker
         .get_matching(|evt| matches!(evt, EventType::IncomingCallAccepted { .. }))
         .await;
@@ -142,7 +147,7 @@ async fn accept_call() -> Result<CallSetup> {
 
     // Alice receives the acceptance message
     alice.recv_msg_trash(&sent2).await;
-    assert_text(&alice, alice_call.id, "Outgoing video call").await?;
+    assert_text(&alice, alice_call.id, "Outgoing call").await?;
     let ev = alice
         .evtracker
         .get_matching(|evt| matches!(evt, EventType::OutgoingCallAccepted { .. }))
@@ -164,7 +169,7 @@ async fn accept_call() -> Result<CallSetup> {
     assert_eq!(call_state(&alice, alice_call.id).await?, CallState::Active);
 
     alice2.recv_msg_trash(&sent2).await;
-    assert_text(&alice2, alice2_call.id, "Outgoing video call").await?;
+    assert_text(&alice2, alice2_call.id, "Outgoing call").await?;
     alice2
         .evtracker
         .get_matching(|evt| matches!(evt, EventType::OutgoingCallAccepted { .. }))
@@ -203,7 +208,7 @@ async fn test_accept_call_callee_ends() -> Result<()> {
 
     // Bob has accepted the call and also ends it
     bob.end_call(bob_call.id).await?;
-    assert_text(&bob, bob_call.id, "Incoming video call\n<1 minute").await?;
+    assert_text(&bob, bob_call.id, "Incoming call\n<1 minute").await?;
     bob.evtracker
         .get_matching(|evt| matches!(evt, EventType::CallEnded { .. }))
         .await;
@@ -214,7 +219,7 @@ async fn test_accept_call_callee_ends() -> Result<()> {
     ));
 
     bob2.recv_msg_trash(&sent3).await;
-    assert_text(&bob2, bob2_call.id, "Incoming video call\n<1 minute").await?;
+    assert_text(&bob2, bob2_call.id, "Incoming call\n<1 minute").await?;
     bob2.evtracker
         .get_matching(|evt| matches!(evt, EventType::CallEnded { .. }))
         .await;
@@ -225,7 +230,7 @@ async fn test_accept_call_callee_ends() -> Result<()> {
 
     // Alice receives the ending message
     alice.recv_msg_trash(&sent3).await;
-    assert_text(&alice, alice_call.id, "Outgoing video call\n<1 minute").await?;
+    assert_text(&alice, alice_call.id, "Outgoing call\n<1 minute").await?;
     alice
         .evtracker
         .get_matching(|evt| matches!(evt, EventType::CallEnded { .. }))
@@ -236,7 +241,7 @@ async fn test_accept_call_callee_ends() -> Result<()> {
     ));
 
     alice2.recv_msg_trash(&sent3).await;
-    assert_text(&alice2, alice2_call.id, "Outgoing video call\n<1 minute").await?;
+    assert_text(&alice2, alice2_call.id, "Outgoing call\n<1 minute").await?;
     alice2
         .evtracker
         .get_matching(|evt| matches!(evt, EventType::CallEnded { .. }))
@@ -266,7 +271,7 @@ async fn test_accept_call_caller_ends() -> Result<()> {
 
     // Bob has accepted the call but Alice ends it
     alice.end_call(alice_call.id).await?;
-    assert_text(&alice, alice_call.id, "Outgoing video call\n<1 minute").await?;
+    assert_text(&alice, alice_call.id, "Outgoing call\n<1 minute").await?;
     alice
         .evtracker
         .get_matching(|evt| matches!(evt, EventType::CallEnded { .. }))
@@ -278,7 +283,7 @@ async fn test_accept_call_caller_ends() -> Result<()> {
     ));
 
     alice2.recv_msg_trash(&sent3).await;
-    assert_text(&alice2, alice2_call.id, "Outgoing video call\n<1 minute").await?;
+    assert_text(&alice2, alice2_call.id, "Outgoing call\n<1 minute").await?;
     alice2
         .evtracker
         .get_matching(|evt| matches!(evt, EventType::CallEnded { .. }))
@@ -290,7 +295,7 @@ async fn test_accept_call_caller_ends() -> Result<()> {
 
     // Bob receives the ending message
     bob.recv_msg_trash(&sent3).await;
-    assert_text(&bob, bob_call.id, "Incoming video call\n<1 minute").await?;
+    assert_text(&bob, bob_call.id, "Incoming call\n<1 minute").await?;
     bob.evtracker
         .get_matching(|evt| matches!(evt, EventType::CallEnded { .. }))
         .await;
@@ -300,7 +305,7 @@ async fn test_accept_call_caller_ends() -> Result<()> {
     ));
 
     bob2.recv_msg_trash(&sent3).await;
-    assert_text(&bob2, bob2_call.id, "Incoming video call\n<1 minute").await?;
+    assert_text(&bob2, bob2_call.id, "Incoming call\n<1 minute").await?;
     bob2.evtracker
         .get_matching(|evt| matches!(evt, EventType::CallEnded { .. }))
         .await;
@@ -420,7 +425,7 @@ async fn test_caller_cancels_call() -> Result<()> {
     // Test that message summary says it is a missed call.
     let bob_call_msg = Message::load_from_db(&bob, bob_call.id).await?;
     let summary = bob_call_msg.get_summary(&bob, None).await?;
-    assert_eq!(summary.text, "🎥 Missed call");
+    assert_eq!(summary.text, "📞 Missed call");
 
     bob2.recv_msg_trash(&sent3).await;
     assert_text(&bob2, bob2_call.id, "Missed call").await?;
@@ -520,6 +525,13 @@ async fn test_update_call_text() -> Result<()> {
     Ok(())
 }
 
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn test_sdp_has_video() {
+    assert!(sdp_has_video("foobar").is_err());
+    assert_eq!(sdp_has_video(PLACE_INFO).unwrap(), false);
+    assert_eq!(sdp_has_video(PLACE_INFO_VIDEO).unwrap(), true);
+}
+
 /// Tests that calls are forwarded as text messages.
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_forward_call() -> Result<()> {
@@ -530,7 +542,7 @@ async fn test_forward_call() -> Result<()> {
 
     let alice_bob_chat = alice.create_chat(bob).await;
     let alice_msg_id = alice
-        .place_outgoing_call(alice_bob_chat.id, PLACE_INFO.to_string(), true)
+        .place_outgoing_call(alice_bob_chat.id, PLACE_INFO.to_string())
         .await
         .context("Failed to place a call")?;
     let alice_call = Message::load_from_db(alice, alice_msg_id).await?;

src/chat.rs

@@ -19,7 +19,6 @@ use strum_macros::EnumIter;
 
 use crate::blob::BlobObject;
 use crate::chatlist::Chatlist;
-use crate::chatlist_events;
 use crate::color::str_to_color;
 use crate::config::Config;
 use crate::constants::{
@@ -43,7 +42,7 @@ use crate::mimefactory::{MimeFactory, RenderedEmail};
 use crate::mimeparser::SystemMessage;
 use crate::param::{Param, Params};
 use crate::receive_imf::ReceivedMsg;
-use crate::smtp::{self, send_msg_to_smtp};
+use crate::smtp::send_msg_to_smtp;
 use crate::stock_str;
 use crate::sync::{self, Sync::*, SyncData};
 use crate::tools::{
@@ -52,6 +51,7 @@ use crate::tools::{
     gm2local_offset, normalize_text, smeared_time, time, truncate_msg_text,
 };
 use crate::webxdc::StatusUpdateSerial;
+use crate::{chatlist_events, imap};
 
 pub(crate) const PARAM_BROADCAST_SECRET: Param = Param::Arg3;
 
@@ -618,6 +618,7 @@ impl ChatId {
         );
 
         let chat = Chat::load_from_db(context, self).await?;
+        let delete_msgs_target = context.get_delete_msgs_target().await?;
         let sync_id = match sync {
             Nosync => None,
             Sync => chat.get_sync_id(context).await?,
@@ -627,11 +628,15 @@ impl ChatId {
             .sql
             .transaction(|transaction| {
                 transaction.execute(
-                    "UPDATE imap SET target='' WHERE rfc724_mid IN (SELECT rfc724_mid FROM msgs WHERE chat_id=? AND rfc724_mid!='')",
-                    (self,),
+                    "UPDATE imap SET target=? WHERE rfc724_mid IN (SELECT rfc724_mid FROM msgs WHERE chat_id=? AND rfc724_mid!='')",
+                    (&delete_msgs_target, self,),
                 )?;
                 transaction.execute(
-                    "UPDATE imap SET target='' WHERE rfc724_mid IN (SELECT pre_rfc724_mid FROM msgs WHERE chat_id=? AND pre_rfc724_mid!='')",
+                    "UPDATE imap SET target=? WHERE rfc724_mid IN (SELECT pre_rfc724_mid FROM msgs WHERE chat_id=? AND pre_rfc724_mid!='')",
+                    (&delete_msgs_target, self,),
+                )?;
+                transaction.execute(
+                    "DELETE FROM smtp WHERE msg_id IN (SELECT id FROM msgs WHERE chat_id=?)",
                     (self,),
                 )?;
                 transaction.execute(
@@ -1151,7 +1156,7 @@ SELECT id, rfc724_mid, pre_rfc724_mid, timestamp, ?, 1 FROM msgs WHERE chat_id=?
             return Ok(stock_str::encr_none(context).await);
         }
 
-        let mut ret = stock_str::messages_e2e_encrypted(context).await + "\n";
+        let mut ret = stock_str::e2e_available(context).await + "\n";
 
         for &contact_id in get_chat_contacts(context, self)
             .await?
@@ -1885,7 +1890,11 @@ impl Chat {
 
         let (msg_text, was_truncated) = truncate_msg_text(context, msg.text.clone()).await?;
         let new_mime_headers = if msg.has_html() {
-            msg.param.get(Param::SendHtml).map(|s| s.to_string())
+            if msg.param.exists(Param::Forwarded) {
+                msg.get_id().get_html(context).await?
+            } else {
+                msg.param.get(Param::SendHtml).map(|s| s.to_string())
+            }
         } else {
             None
         };
@@ -2126,11 +2135,10 @@ pub(crate) async fn sync(context: &Context, id: SyncId, action: SyncAction) -> R
 }
 
 /// Whether the chat is pinned or archived.
-#[derive(Debug, Copy, Eq, PartialEq, Clone, Serialize, Deserialize, EnumIter, Default)]
+#[derive(Debug, Copy, Eq, PartialEq, Clone, Serialize, Deserialize, EnumIter)]
 #[repr(i8)]
 pub enum ChatVisibility {
     /// Chat is neither archived nor pinned.
-    #[default]
     Normal = 0,
 
     /// Chat is archived.
@@ -2830,11 +2838,32 @@ pub(crate) async fn create_send_msg_jobs(context: &Context, msg: &mut Message) -
     let from = context.get_primary_self_addr().await?;
     let lowercase_from = from.to_lowercase();
 
+    // Send BCC to self if it is enabled.
+    //
+    // Previous versions of Delta Chat did not send BCC self
+    // if DeleteServerAfter was set to immediately delete messages
+    // from the server. This is not the case anymore
+    // because BCC-self messages are also used to detect
+    // that message was sent if SMTP server is slow to respond
+    // and connection is frequently lost
+    // before receiving status line. NB: This is not a problem for chatmail servers, so `BccSelf`
+    // 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
+    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())
     {
-        smtp::add_self_recipients(context, &mut recipients, needs_encryption).await?;
+        // Avoid sending unencrypted messages to all transports, chatmail relays won't accept
+        // them. Normally the user should have a non-chatmail primary transport to send unencrypted
+        // messages.
+        if needs_encryption {
+            for addr in context.get_secondary_self_addrs().await? {
+                recipients.push(addr);
+            }
+        }
+        recipients.push(from);
     }
 
     // Default Webxdc integrations are hidden messages and must not be sent out
@@ -3201,36 +3230,6 @@ pub async fn get_chat_msgs_ex(
     Ok(items)
 }
 
-/// Marks all unread messages in all chats as noticed.
-/// Ignores messages from blocked contacts, but does not ignore messages in muted chats.
-pub async fn marknoticed_all_chats(context: &Context) -> Result<()> {
-    // The sql statement here is similar to the one in get_fresh_msgs
-    let list = context
-        .sql
-        .query_map_vec(
-            "SELECT DISTINCT(c.id)
-                 FROM msgs m
-                 INNER JOIN chats c
-                        ON m.chat_id=c.id
-                 WHERE m.state=?
-                   AND m.hidden=0
-                   AND m.chat_id>9
-                   AND c.blocked=0;",
-            (MessageState::InFresh,),
-            |row| {
-                let msg_id: ChatId = row.get(0)?;
-                Ok(msg_id)
-            },
-        )
-        .await?;
-
-    for chat_id in list {
-        marknoticed_chat(context, chat_id).await?;
-    }
-
-    Ok(())
-}
-
 /// Marks all messages in the chat as noticed.
 /// If the given chat-id is the archive-link, marks all messages in all archived chats as noticed.
 pub async fn marknoticed_chat(context: &Context, chat_id: ChatId) -> Result<()> {
@@ -3292,7 +3291,7 @@ pub async fn marknoticed_chat(context: &Context, chat_id: ChatId) -> Result<()>
         let hidden_messages = context
             .sql
             .query_map_vec(
-                "SELECT id FROM msgs
+                "SELECT id, rfc724_mid FROM msgs
                     WHERE state=?
                       AND hidden=1
                       AND chat_id=?
@@ -3300,11 +3299,16 @@ pub async fn marknoticed_chat(context: &Context, chat_id: ChatId) -> Result<()>
                 (MessageState::InFresh, chat_id), // No need to check for InNoticed messages, because reactions are never InNoticed
                 |row| {
                     let msg_id: MsgId = row.get(0)?;
-                    Ok(msg_id)
+                    let rfc724_mid: String = row.get(1)?;
+                    Ok((msg_id, rfc724_mid))
                 },
             )
             .await?;
-        message::markseen_msgs(context, hidden_messages).await?;
+        for (msg_id, rfc724_mid) in &hidden_messages {
+            message::update_msg_state(context, *msg_id, MessageState::InSeen).await?;
+            imap::markseen_on_imap_table(context, rfc724_mid).await?;
+        }
+
         if noticed_msgs_count == 0 {
             return Ok(());
         }
@@ -3326,10 +3330,6 @@ pub(crate) async fn mark_old_messages_as_noticed(
     context: &Context,
     mut msgs: Vec<ReceivedMsg>,
 ) -> Result<()> {
-    if context.get_config_bool(Config::TeamProfile).await? {
-        return Ok(());
-    }
-
     msgs.retain(|m| m.state.is_outgoing());
     if msgs.is_empty() {
         return Ok(());
@@ -4112,7 +4112,7 @@ pub async fn remove_contact_from_chat(
         } else {
             let mut sync = Nosync;
 
-            if chat.is_promoted() && chat.typ != Chattype::OutBroadcast {
+            if chat.is_promoted() {
                 remove_from_chat_contacts_table(context, chat_id, contact_id).await?;
             } else {
                 remove_from_chat_contacts_table_without_trace(context, chat_id, contact_id).await?;
@@ -4362,30 +4362,20 @@ pub async fn forward_msgs_2ctx(
         msg.param = Params::new();
 
         if msg.get_viewtype() != Viewtype::Sticker {
-            let forwarded_msg_id = match ctx_src.blobdir == ctx_dst.blobdir {
-                true => src_msg_id,
-                false => MsgId::new_unset(),
-            };
             msg.param
-                .set_int(Param::Forwarded, forwarded_msg_id.to_u32() as i32);
+                .set_int(Param::Forwarded, src_msg_id.to_u32() as i32);
         }
 
         if msg.get_viewtype() == Viewtype::Call {
             msg.viewtype = Viewtype::Text;
         }
-        msg.text += &msg.additional_text;
+
+        if msg.download_state != DownloadState::Done {
+            msg.text += &msg.additional_text;
+        }
 
         let param = &mut param;
-
-        // When forwarding between different accounts, blob files must be physically copied
-        // because each account has its own blob directory.
-        if ctx_src.blobdir == ctx_dst.blobdir {
-            msg.param.steal(param, Param::File);
-        } else if let Some(src_path) = param.get_file_path(ctx_src)? {
-            let new_blob = BlobObject::create_and_deduplicate(ctx_dst, &src_path, &src_path)
-                .context("Failed to copy blob file to destination account")?;
-            msg.param.set(Param::File, new_blob.as_name());
-        }
+        msg.param.steal(param, Param::File);
         msg.param.steal(param, Param::Filename);
         msg.param.steal(param, Param::Width);
         msg.param.steal(param, Param::Height);
@@ -4394,9 +4384,6 @@ pub async fn forward_msgs_2ctx(
         msg.param.steal(param, Param::ProtectQuote);
         msg.param.steal(param, Param::Quote);
         msg.param.steal(param, Param::Summary1);
-        if msg.has_html() {
-            msg.set_html(src_msg_id.get_html(ctx_src).await?);
-        }
         msg.in_reply_to = None;
 
         // do not leak data as group names; a default subject is generated by mimefactory
@@ -4466,7 +4453,9 @@ pub(crate) async fn save_copy_in_self_talk(
     msg.param.remove(Param::PostMessageFileBytes);
     msg.param.remove(Param::PostMessageViewtype);
 
-    msg.text += &msg.additional_text;
+    if msg.download_state != DownloadState::Done {
+        msg.text += &msg.additional_text;
+    }
 
     if !msg.original_msg_id.is_unset() {
         bail!("message already saved.");

src/chat/chat_tests.rs

@@ -1,7 +1,6 @@
 use std::sync::Arc;
 
 use super::*;
-use crate::Event;
 use crate::chatlist::get_archived_cnt;
 use crate::constants::{DC_GCL_ARCHIVED_ONLY, DC_GCL_NO_SPECIALS};
 use crate::ephemeral::Timer;
@@ -1241,96 +1240,6 @@ async fn test_unarchive_if_muted() -> Result<()> {
     Ok(())
 }
 
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn test_marknoticed_all_chats() -> Result<()> {
-    let mut tcm = TestContextManager::new();
-    let alice = &tcm.alice().await;
-    let bob = &tcm.bob().await;
-
-    tcm.section("alice: create chats & promote them by sending a message");
-
-    let alice_chat_normal = alice
-        .create_group_with_members("Chat (normal)", &[alice, bob])
-        .await;
-    send_text_msg(alice, alice_chat_normal, "Hi".to_string()).await?;
-
-    let alice_chat_muted = alice
-        .create_group_with_members("Chat (muted)", &[alice, bob])
-        .await;
-    send_text_msg(alice, alice_chat_muted, "Hi".to_string()).await?;
-    set_muted(&alice.ctx, alice_chat_muted, MuteDuration::Forever).await?;
-
-    let alice_chat_archived_and_muted = alice
-        .create_group_with_members("Chat (archived and muted)", &[alice, bob])
-        .await;
-    send_text_msg(alice, alice_chat_archived_and_muted, "Hi".to_string()).await?;
-    set_muted(
-        &alice.ctx,
-        alice_chat_archived_and_muted,
-        MuteDuration::Forever,
-    )
-    .await?;
-    alice_chat_archived_and_muted
-        .set_visibility(&alice.ctx, ChatVisibility::Archived)
-        .await?;
-
-    tcm.section("bob: receive messages, accept all chats and send a reply to each messsage");
-
-    while let Some(sent_msg) = alice.pop_sent_msg_opt(Duration::default()).await {
-        let bob_message = bob.recv_msg(&sent_msg).await;
-        let bob_chat_id = bob_message.chat_id;
-        bob_chat_id.accept(bob).await?;
-        send_text_msg(bob, bob_chat_id, "reply".to_string()).await?;
-    }
-
-    tcm.section("alice: receive replies from bob");
-    while let Some(sent_msg) = bob.pop_sent_msg_opt(Duration::default()).await {
-        alice.recv_msg(&sent_msg).await;
-    }
-    // ensure chats have unread messages
-    assert_eq!(alice_chat_normal.get_fresh_msg_cnt(alice).await?, 1);
-    assert_eq!(alice_chat_muted.get_fresh_msg_cnt(alice).await?, 1);
-    assert_eq!(
-        alice_chat_archived_and_muted
-            .get_fresh_msg_cnt(alice)
-            .await?,
-        1
-    );
-
-    tcm.section("alice: mark as read");
-    alice.evtracker.clear_events();
-    marknoticed_all_chats(alice).await?;
-    tcm.section("alice: check that chats are no longer unread and that chatlist update events were received");
-    assert_eq!(alice_chat_normal.get_fresh_msg_cnt(alice).await?, 0);
-    assert_eq!(alice_chat_muted.get_fresh_msg_cnt(alice).await?, 0);
-    assert_eq!(
-        alice_chat_archived_and_muted
-            .get_fresh_msg_cnt(alice)
-            .await?,
-        0
-    );
-
-    let emitted_events = alice.evtracker.take_events();
-    for event in &[
-        EventType::ChatlistItemChanged {
-            chat_id: Some(alice_chat_normal),
-        },
-        EventType::ChatlistItemChanged {
-            chat_id: Some(alice_chat_muted),
-        },
-        EventType::ChatlistItemChanged {
-            chat_id: Some(alice_chat_archived_and_muted),
-        },
-        EventType::ChatlistItemChanged {
-            chat_id: Some(DC_CHAT_ID_ARCHIVED_LINK),
-        },
-    ] {
-        assert!(emitted_events.iter().any(|Event { typ, .. }| typ == event));
-    }
-
-    Ok(())
-}
-
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_archive_fresh_msgs() -> Result<()> {
     let t = TestContext::new_alice().await;
@@ -3435,11 +3344,6 @@ async fn test_remove_member_from_broadcast() -> Result<()> {
     let alice_bob_contact_id = alice.add_or_lookup_contact_id(bob).await;
     remove_contact_from_chat(alice, alice_chat_id, alice_bob_contact_id).await?;
 
-    // Alice must not remember old members,
-    // because we would like to remember the minimum information possible
-    let past_contacts = get_past_chat_contacts(alice, alice_chat_id).await?;
-    assert_eq!(past_contacts.len(), 0);
-
     let remove_msg = alice.pop_sent_msg().await;
     let rcvd = bob.recv_msg(&remove_msg).await;
     assert_eq!(rcvd.text, "Member Me removed by alice@example.org.");
@@ -3816,13 +3720,13 @@ async fn test_chat_get_encryption_info() -> Result<()> {
     let chat_id = create_group(alice, "Group").await?;
     assert_eq!(
         chat_id.get_encryption_info(alice).await?,
-        "Messages are end-to-end encrypted."
+        "End-to-end encryption available"
     );
 
     add_contact_to_chat(alice, chat_id, contact_bob).await?;
     assert_eq!(
         chat_id.get_encryption_info(alice).await?,
-        "Messages are end-to-end encrypted.\n\
+        "End-to-end encryption available\n\
          \n\
          bob@example.net\n\
          CCCB 5AA9 F6E1 141C 9431\n\
@@ -3832,7 +3736,7 @@ async fn test_chat_get_encryption_info() -> Result<()> {
     add_contact_to_chat(alice, chat_id, contact_fiona).await?;
     assert_eq!(
         chat_id.get_encryption_info(alice).await?,
-        "Messages are end-to-end encrypted.\n\
+        "End-to-end encryption available\n\
          \n\
          fiona@example.net\n\
          C8BA 50BF 4AC1 2FAF 38D7\n\
@@ -3846,13 +3750,13 @@ async fn test_chat_get_encryption_info() -> Result<()> {
     let email_chat = alice.create_email_chat(bob).await;
     assert_eq!(
         email_chat.id.get_encryption_info(alice).await?,
-        "No encryption."
+        "No encryption"
     );
 
     alice.sql.execute("DELETE FROM public_keys", ()).await?;
     assert_eq!(
         chat_id.get_encryption_info(alice).await?,
-        "Messages are end-to-end encrypted.\n\
+        "End-to-end encryption available\n\
          \n\
          fiona@example.net\n\
          (key missing)\n\
@@ -5491,97 +5395,6 @@ async fn test_forward_msgs_2ctx() -> Result<()> {
     Ok(())
 }
 
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn test_forward_msgs_2ctx_with_file() -> Result<()> {
-    let mut tcm = TestContextManager::new();
-    let alice = &tcm.alice().await;
-    let bob = &tcm.bob().await;
-
-    // First, establish a chat between Alice and Bob to have the chat IDs
-    let alice_chat = alice.create_chat(bob).await;
-    let alice_initial = alice.send_text(alice_chat.id, "hi").await;
-    let bob_alice_msg = bob.recv_msg(&alice_initial).await;
-    let bob_chat_id = bob_alice_msg.chat_id;
-    bob_chat_id.accept(bob).await?;
-
-    // Alice sends a message with an attached file to her self-chat
-    let alice_self_chat = alice.get_self_chat().await;
-    let file_bytes = b"test file content";
-    let file = alice.get_blobdir().join("test.txt");
-    tokio::fs::write(&file, file_bytes).await?;
-
-    let mut msg = Message::new(Viewtype::File);
-    msg.set_file_and_deduplicate(alice, &file, Some("test.txt"), Some("text/plain"))?;
-    msg.set_text("Here's a file".to_string());
-
-    alice.send_msg(alice_self_chat.id, &mut msg).await;
-    let alice_self_msg = alice.get_last_msg().await;
-
-    // Verify the file exists in Alice's blobdir
-    assert_eq!(alice_self_msg.viewtype, Viewtype::File);
-    let alice_original_file_path = alice_self_msg.get_file(alice).unwrap();
-    let alice_original_content = tokio::fs::read(&alice_original_file_path).await?;
-    assert_eq!(alice_original_content, file_bytes);
-
-    // Alice forwards the message to Bob using forward_msgs_2ctx
-    forward_msgs_2ctx(alice, &[alice_self_msg.id], bob, bob_chat_id).await?;
-
-    // Bob should have the forwarded message with the file in his database
-    let bob_msg = bob.get_last_msg().await;
-    assert_eq!(bob_msg.viewtype, Viewtype::File);
-    assert!(bob_msg.is_forwarded());
-    assert_eq!(bob_msg.text, "Here's a file");
-    assert_eq!(bob_msg.from_id, ContactId::SELF);
-
-    // Verify Bob has the file in his blobdir with correct content
-    let bob_file_path = bob_msg.get_file(bob).unwrap();
-    let bob_file_content = tokio::fs::read(&bob_file_path).await?;
-    assert_eq!(bob_file_content, file_bytes);
-
-    Ok(())
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn test_forward_msgs_2ctx_missing_blob() -> Result<()> {
-    let mut tcm = TestContextManager::new();
-    let alice = &tcm.alice().await;
-    let bob = &tcm.bob().await;
-
-    let alice_chat = alice.create_chat(bob).await;
-    let alice_initial = alice.send_text(alice_chat.id, "hi").await;
-    let bob_alice_msg = bob.recv_msg(&alice_initial).await;
-    let bob_chat_id = bob_alice_msg.chat_id;
-    bob_chat_id.accept(bob).await?;
-    // Alice sends a file to her self-chat
-    let alice_self_chat = alice.get_self_chat().await;
-    let file_bytes = b"test content";
-    let file = alice.get_blobdir().join("test.txt");
-    tokio::fs::write(&file, file_bytes).await?;
-
-    let mut msg = Message::new(Viewtype::File);
-    msg.set_file_and_deduplicate(alice, &file, Some("test.txt"), Some("text/plain"))?;
-    msg.set_text("File message".to_string());
-
-    alice.send_msg(alice_self_chat.id, &mut msg).await;
-    let alice_self_msg = alice.get_last_msg().await;
-
-    // Delete the blob file from Alice's blobdir to simulate a missing file
-    let alice_file_path = alice_self_msg.get_file(alice).unwrap();
-    tokio::fs::remove_file(&alice_file_path).await?;
-
-    // Alice tries to forward the message - this should fail with an error
-    let result = forward_msgs_2ctx(alice, &[alice_self_msg.id], bob, bob_chat_id).await;
-    assert!(result.is_err());
-    assert!(
-        result
-            .unwrap_err()
-            .to_string()
-            .contains("Failed to copy blob file")
-    );
-
-    Ok(())
-}
-
 /// Tests that in multi-device setup
 /// second device learns the key of a contact
 /// via Autocrypt-Gossip in 1:1 chats.

src/chatlist.rs

@@ -76,7 +76,7 @@ impl Chatlist {
     ///   the pseudo-chat DC_CHAT_ID_ARCHIVED_LINK is added if there are *any* archived
     ///   chats
     /// - the flag DC_GCL_FOR_FORWARDING sorts "Saved messages" to the top of the chatlist
-    ///   and hides the device-chat, contact requests and incoming broadcasts.
+    ///   and hides the device-chat and contact requests
     ///   typically used on forwarding, may be combined with DC_GCL_NO_SPECIALS
     /// - if the flag DC_GCL_NO_SPECIALS is set, archive link is not added
     ///   to the list (may be used eg. for selecting chats on forwarding, the flag is
@@ -224,9 +224,8 @@ impl Chatlist {
                 let process_rows = |rows: rusqlite::AndThenRows<_>| {
                     rows.filter_map(|row: std::result::Result<(_, _, Params, _), _>| match row {
                         Ok((chat_id, typ, param, msg_id)) => {
-                            if typ == Chattype::InBroadcast
-                                || (typ == Chattype::Mailinglist
-                                    && param.get(Param::ListPost).is_none_or_empty())
+                            if typ == Chattype::Mailinglist
+                                && param.get(Param::ListPost).is_none_or_empty()
                             {
                                 None
                             } else {
@@ -598,41 +597,6 @@ mod tests {
         assert_eq!(chats.len(), 1);
     }
 
-    /// Test that DC_CHAT_TYPE_IN_BROADCAST are hidden
-    /// and DC_CHAT_TYPE_OUT_BROADCAST are shown in chatlist for forwarding.
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_broadcast_visiblity_on_forward() -> Result<()> {
-        let mut tcm = TestContextManager::new();
-        let alice = &tcm.alice().await;
-        let bob = &tcm.bob().await;
-
-        let alice_broadcast_a_id = create_broadcast(alice, "Channel Alice".to_string()).await?;
-        let qr = get_securejoin_qr(alice, Some(alice_broadcast_a_id))
-            .await
-            .unwrap();
-        let bob_broadcast_a_id = tcm.exec_securejoin_qr(bob, alice, &qr).await;
-        let bob_broadcast_b_id = create_broadcast(bob, "Channel Bob".to_string()).await?;
-
-        let chats = Chatlist::try_load(bob, DC_GCL_FOR_FORWARDING, None, None)
-            .await
-            .unwrap();
-
-        assert!(
-            !chats
-                .iter()
-                .any(|(chat_id, _)| chat_id == &bob_broadcast_a_id),
-            "alice broadcast is not shown in bobs forwarding chatlist"
-        );
-        assert!(
-            chats
-                .iter()
-                .any(|(chat_id, _)| chat_id == &bob_broadcast_b_id),
-            "bobs own broadcast is shown in his forwarding chatlist"
-        );
-
-        Ok(())
-    }
-
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_search_special_chat_names() {
         let t = TestContext::new_alice().await;

src/config.rs

@@ -175,6 +175,11 @@ pub enum Config {
     #[strum(props(default = "0"))] // also change MediaQuality.default() on changes
     MediaQuality,
 
+    /// If set to "1", then existing messages are considered to be already fetched.
+    /// This flag is reset after successful configuration.
+    #[strum(props(default = "1"))]
+    FetchedExistingMsgs,
+
     /// Timer in seconds after which the message is deleted from the
     /// server.
     ///
@@ -194,6 +199,10 @@ pub enum Config {
     #[strum(props(default = "0"))]
     DeleteDeviceAfter,
 
+    /// Move messages to the Trash folder instead of marking them "\Deleted". Overrides
+    /// `ProviderOptions::delete_to_trash`.
+    DeleteToTrash,
+
     /// The primary email address.
     ConfiguredAddr,
 
@@ -271,6 +280,9 @@ pub enum Config {
     /// Configured folder for chat messages.
     ConfiguredMvboxFolder,
 
+    /// Configured "Trash" folder.
+    ConfiguredTrashFolder,
+
     /// Unix timestamp of the last successful configuration.
     ConfiguredTimestamp,
 
@@ -328,6 +340,10 @@ pub enum Config {
     /// Timestamp of the last `CantDecryptOutgoingMsgs` notification.
     LastCantDecryptOutgoingMsgs,
 
+    /// To how many seconds to debounce scan_all_folders. Used mainly in tests, to disable debouncing completely.
+    #[strum(props(default = "60"))]
+    ScanAllFoldersDebounceSecs,
+
     /// Whether to avoid using IMAP IDLE even if the server supports it.
     ///
     /// This is a developer option for testing "fake idle".
@@ -591,7 +607,8 @@ impl Context {
             .get_config(key)
             .await?
             .and_then(|s| s.parse::<i32>().ok())
-            .is_some_and(|x| x != 0))
+            .map(|x| x != 0)
+            .unwrap_or_default())
     }
 
     /// Returns true if movebox ("DeltaChat" folder) should be watched.
@@ -684,6 +701,7 @@ impl Context {
             | Config::MdnsEnabled
             | Config::MvboxMove
             | Config::OnlyFetchMvbox
+            | Config::DeleteToTrash
             | Config::Configured
             | Config::Bot
             | Config::NotifyAboutWrongPw
@@ -707,7 +725,12 @@ impl Context {
         Self::check_config(key, value)?;
 
         let n_transports = self.count_transports().await?;
-        if n_transports > 1 && matches!(key, Config::MvboxMove | Config::OnlyFetchMvbox) {
+        if n_transports > 1
+            && matches!(
+                key,
+                Config::MvboxMove | Config::OnlyFetchMvbox | Config::ShowEmails
+            )
+        {
             bail!("Cannot reconfigure {key} when multiple transports are configured");
         }
 

src/configure.rs

@@ -23,7 +23,7 @@ use percent_encoding::utf8_percent_encode;
 use server_params::{ServerParams, expand_param_vector};
 use tokio::task;
 
-use crate::config::Config;
+use crate::config::{self, Config};
 use crate::constants::NON_ALPHANUMERIC_WITHOUT_DOT;
 use crate::context::Context;
 use crate::imap::Imap;
@@ -124,6 +124,10 @@ impl Context {
     }
 
     pub(crate) async fn add_transport_inner(&self, param: &mut EnteredLoginParam) -> Result<()> {
+        ensure!(
+            !self.scheduler.is_running().await,
+            "cannot configure, already running"
+        );
         ensure!(
             self.sql.is_open().await,
             "cannot configure, database not opened."
@@ -282,6 +286,11 @@ impl Context {
                     "To use additional relays, disable the legacy option \"Settings / Advanced / Move automatically to DeltaChat Folder\"."
                 );
             }
+            if self.get_config(Config::ShowEmails).await?.as_deref() != Some("2") {
+                bail!(
+                    "To use additional relays, set the legacy option \"Settings / Advanced / Show Classic Emails\" to \"All\"."
+                );
+            }
 
             if self
                 .sql
@@ -622,6 +631,8 @@ async fn configure(ctx: &Context, param: &EnteredLoginParam) -> Result<Option<&'
 
     progress!(ctx, 920);
 
+    ctx.set_config_internal(Config::FetchedExistingMsgs, config::from_bool(false))
+        .await?;
     ctx.scheduler.interrupt_inbox().await;
 
     progress!(ctx, 940);

src/contact.rs

@@ -1299,6 +1299,18 @@ WHERE addr=?
         Ok(())
     }
 
+    /// Returns number of blocked contacts.
+    pub async fn get_blocked_cnt(context: &Context) -> Result<usize> {
+        let count = context
+            .sql
+            .count(
+                "SELECT COUNT(*) FROM contacts WHERE id>? AND blocked!=0",
+                (ContactId::LAST_SPECIAL,),
+            )
+            .await?;
+        Ok(count)
+    }
+
     /// Get blocked contacts.
     pub async fn get_all_blocked(context: &Context) -> Result<Vec<ContactId>> {
         Contact::update_blocked_mailinglist_contacts(context)
@@ -1342,13 +1354,13 @@ WHERE addr=?
         let fingerprint_other = fingerprint_other.to_string();
 
         let stock_message = if contact.public_key(context).await?.is_some() {
-            stock_str::messages_e2e_encrypted(context).await
+            stock_str::e2e_available(context).await
         } else {
             stock_str::encr_none(context).await
         };
 
         let finger_prints = stock_str::finger_prints(context).await;
-        let mut ret = format!("{stock_message}\n{finger_prints}:");
+        let mut ret = format!("{stock_message}.\n{finger_prints}:");
 
         let fingerprint_self = load_self_public_key(context)
             .await?
@@ -1454,7 +1466,7 @@ WHERE addr=?
     /// Returns true if the contact is a key-contact.
     /// Otherwise it is an addresss-contact.
     pub fn is_key_contact(&self) -> bool {
-        self.fingerprint.is_some() || self.id == ContactId::SELF
+        self.fingerprint.is_some()
     }
 
     /// Returns OpenPGP fingerprint of a contact.

src/contact/contact_tests.rs

@@ -823,7 +823,7 @@ async fn test_contact_get_encrinfo() -> Result<()> {
 
     let address_contact_bob_id = alice.add_or_lookup_address_contact_id(bob).await;
     let encrinfo = Contact::get_encrinfo(alice, address_contact_bob_id).await?;
-    assert_eq!(encrinfo, "No encryption.");
+    assert_eq!(encrinfo, "No encryption");
 
     let contact = Contact::get_by_id(alice, address_contact_bob_id).await?;
     assert!(!contact.e2ee_avail(alice).await?);
@@ -832,7 +832,7 @@ async fn test_contact_get_encrinfo() -> Result<()> {
     let encrinfo = Contact::get_encrinfo(alice, contact_bob_id).await?;
     assert_eq!(
         encrinfo,
-        "Messages are end-to-end encrypted.
+        "End-to-end encryption available.
 Fingerprints:
 
 Me (alice@example.org):

src/context.rs

@@ -8,7 +8,7 @@ use std::sync::atomic::AtomicBool;
 use std::sync::{Arc, OnceLock, Weak};
 use std::time::Duration;
 
-use anyhow::{Result, bail, ensure};
+use anyhow::{Context as _, Result, bail, ensure};
 use async_channel::{self as channel, Receiver, Sender};
 use ratelimit::Ratelimit;
 use tokio::sync::{Mutex, Notify, RwLock};
@@ -36,8 +36,6 @@ use crate::tools::{self, duration_to_str, time, time_elapsed};
 use crate::transport::ConfiguredLoginParam;
 use crate::{chatlist_events, stats};
 
-pub use crate::scheduler::connectivity::Connectivity;
-
 /// Builder for the [`Context`].
 ///
 /// Many arguments to the [`Context`] are kind of optional and only needed to handle
@@ -880,6 +878,10 @@ impl Context {
             .get_config(Config::ConfiguredMvboxFolder)
             .await?
             .unwrap_or_else(|| "<unset>".to_string());
+        let configured_trash_folder = self
+            .get_config(Config::ConfiguredTrashFolder)
+            .await?
+            .unwrap_or_else(|| "<unset>".to_string());
 
         let mut res = get_info();
 
@@ -942,6 +944,12 @@ impl Context {
         }
 
         res.insert("secondary_addrs", secondary_addrs);
+        res.insert(
+            "fetched_existing_msgs",
+            self.get_config_bool(Config::FetchedExistingMsgs)
+                .await?
+                .to_string(),
+        );
         res.insert(
             "show_emails",
             self.get_config_int(Config::ShowEmails).await?.to_string(),
@@ -964,6 +972,7 @@ impl Context {
         );
         res.insert("configured_inbox_folder", configured_inbox_folder);
         res.insert("configured_mvbox_folder", configured_mvbox_folder);
+        res.insert("configured_trash_folder", configured_trash_folder);
         res.insert("mdns_enabled", mdns_enabled.to_string());
         res.insert("bcc_self", bcc_self.to_string());
         res.insert("sync_msgs", sync_msgs.to_string());
@@ -987,6 +996,12 @@ impl Context {
                 .await?
                 .to_string(),
         );
+        res.insert(
+            "delete_to_trash",
+            self.get_config(Config::DeleteToTrash)
+                .await?
+                .unwrap_or_else(|| "<unset>".to_string()),
+        );
         res.insert(
             "last_housekeeping",
             self.get_config_int(Config::LastHousekeeping)
@@ -999,6 +1014,12 @@ impl Context {
                 .await?
                 .to_string(),
         );
+        res.insert(
+            "scan_all_folders_debounce_secs",
+            self.get_config_int(Config::ScanAllFoldersDebounceSecs)
+                .await?
+                .to_string(),
+        );
         res.insert(
             "quota_exceeding",
             self.get_config_int(Config::QuotaExceeding)
@@ -1099,19 +1120,21 @@ impl Context {
         let list = self
             .sql
             .query_map_vec(
-                "SELECT m.id
-FROM msgs m
-LEFT JOIN contacts ct
-    ON m.from_id=ct.id
-LEFT JOIN chats c
-    ON m.chat_id=c.id
-WHERE m.state=?
-AND m.hidden=0
-AND m.chat_id>9
-AND ct.blocked=0
-AND c.blocked=0
-AND NOT(c.muted_until=-1 OR c.muted_until>?)
-ORDER BY m.timestamp DESC,m.id DESC",
+                concat!(
+                    "SELECT m.id",
+                    " FROM msgs m",
+                    " LEFT JOIN contacts ct",
+                    "        ON m.from_id=ct.id",
+                    " LEFT JOIN chats c",
+                    "        ON m.chat_id=c.id",
+                    " WHERE m.state=?",
+                    "   AND m.hidden=0",
+                    "   AND m.chat_id>9",
+                    "   AND ct.blocked=0",
+                    "   AND c.blocked=0",
+                    "   AND NOT(c.muted_until=-1 OR c.muted_until>?)",
+                    " ORDER BY m.timestamp DESC,m.id DESC;"
+                ),
                 (MessageState::InFresh, time()),
                 |row| {
                     let msg_id: MsgId = row.get(0)?;
@@ -1263,12 +1286,45 @@ ORDER BY m.timestamp DESC,m.id DESC",
         Ok(list)
     }
 
+    /// Returns true if given folder name is the name of the inbox.
+    pub async fn is_inbox(&self, folder_name: &str) -> Result<bool> {
+        let inbox = self.get_config(Config::ConfiguredInboxFolder).await?;
+        Ok(inbox.as_deref() == Some(folder_name))
+    }
+
     /// Returns true if given folder name is the name of the "DeltaChat" folder.
     pub async fn is_mvbox(&self, folder_name: &str) -> Result<bool> {
         let mvbox = self.get_config(Config::ConfiguredMvboxFolder).await?;
         Ok(mvbox.as_deref() == Some(folder_name))
     }
 
+    /// Returns true if given folder name is the name of the trash folder.
+    pub async fn is_trash(&self, folder_name: &str) -> Result<bool> {
+        let trash = self.get_config(Config::ConfiguredTrashFolder).await?;
+        Ok(trash.as_deref() == Some(folder_name))
+    }
+
+    pub(crate) async fn should_delete_to_trash(&self) -> Result<bool> {
+        if let Some(v) = self.get_config_bool_opt(Config::DeleteToTrash).await? {
+            return Ok(v);
+        }
+        if let Some(provider) = self.get_configured_provider().await? {
+            return Ok(provider.opt.delete_to_trash);
+        }
+        Ok(false)
+    }
+
+    /// Returns `target` for deleted messages as per `imap` table. Empty string means "delete w/o
+    /// moving to trash".
+    pub(crate) async fn get_delete_msgs_target(&self) -> Result<String> {
+        if !self.should_delete_to_trash().await? {
+            return Ok("".into());
+        }
+        self.get_config(Config::ConfiguredTrashFolder)
+            .await?
+            .context("No configured trash folder")
+    }
+
     pub(crate) fn derive_blobdir(dbfile: &Path) -> PathBuf {
         let mut blob_fname = OsString::new();
         blob_fname.push(dbfile.file_name().unwrap_or_default());

src/download.rs

@@ -99,8 +99,7 @@ impl MsgId {
         Ok(())
     }
 
-    /// Updates the message download state. Returns `Ok` if the message doesn't exist anymore or has
-    /// the download state up to date.
+    /// Updates the message download state. Returns `Ok` if the message doesn't exist anymore.
     pub(crate) async fn update_download_state(
         self,
         context: &Context,
@@ -109,7 +108,7 @@ impl MsgId {
         if context
             .sql
             .execute(
-                "UPDATE msgs SET download_state=? WHERE id=? AND download_state<>?1",
+                "UPDATE msgs SET download_state=? WHERE id=?;",
                 (download_state, self),
             )
             .await?
@@ -136,46 +135,42 @@ impl Message {
     }
 }
 
-/// Actually downloads a message partially downloaded before if the message is available on the
-/// session transport, in which case returns `Some`. If the message is available on another
-/// transport, returns `None`.
+/// Actually download a message partially downloaded before.
 ///
 /// Most messages are downloaded automatically on fetch instead.
 pub(crate) async fn download_msg(
     context: &Context,
     rfc724_mid: String,
     session: &mut Session,
-) -> Result<Option<()>> {
+) -> Result<()> {
     let transport_id = session.transport_id();
     let row = context
         .sql
         .query_row_optional(
-            "SELECT uid, folder, transport_id FROM imap
-             WHERE rfc724_mid=? AND target!=''
-             ORDER BY transport_id=? DESC LIMIT 1",
+            "SELECT uid, folder FROM imap
+             WHERE rfc724_mid=?
+             AND transport_id=?
+             AND target!=''",
             (&rfc724_mid, transport_id),
             |row| {
                 let server_uid: u32 = row.get(0)?;
                 let server_folder: String = row.get(1)?;
-                let msg_transport_id: u32 = row.get(2)?;
-                Ok((server_uid, server_folder, msg_transport_id))
+                Ok((server_uid, server_folder))
             },
         )
         .await?;
 
-    let Some((server_uid, server_folder, msg_transport_id)) = row else {
+    let Some((server_uid, server_folder)) = row else {
         // No IMAP record found, we don't know the UID and folder.
         return Err(anyhow!(
             "IMAP location for {rfc724_mid:?} post-message is unknown"
         ));
     };
-    if msg_transport_id != transport_id {
-        return Ok(None);
-    }
+
     session
         .fetch_single_msg(context, &server_folder, server_uid, rfc724_mid)
         .await?;
-    Ok(Some(()))
+    Ok(())
 }
 
 impl Session {
@@ -194,7 +189,10 @@ impl Session {
             bail!("Attempt to fetch UID 0");
         }
 
-        let folder_exists = self.select_with_uidvalidity(context, folder).await?;
+        let create = false;
+        let folder_exists = self
+            .select_with_uidvalidity(context, folder, create)
+            .await?;
         ensure!(folder_exists, "No folder {folder}");
 
         // we are connected, and the folder is selected
@@ -277,7 +275,7 @@ pub(crate) async fn download_msgs(context: &Context, session: &mut Session) -> R
 
     for rfc724_mid in &rfc724_mids {
         let res = download_msg(context, rfc724_mid.clone(), session).await;
-        if let Ok(Some(())) = res {
+        if res.is_ok() {
             delete_from_downloads(context, rfc724_mid).await?;
             delete_from_available_post_msgs(context, rfc724_mid).await?;
         }
@@ -332,7 +330,7 @@ pub(crate) async fn download_known_post_messages_without_pre_message(
             // The message may be in the wrong order,
             // but at least we have it at all.
             let res = download_msg(context, rfc724_mid.clone(), session).await;
-            if let Ok(Some(())) = res {
+            if res.is_ok() {
                 delete_from_available_post_msgs(context, rfc724_mid).await?;
             }
             if let Err(err) = res {

src/ephemeral.rs

@@ -665,19 +665,25 @@ pub(crate) async fn delete_expired_imap_messages(context: &Context) -> Result<()
                 now - max(delete_server_after, MIN_DELETE_SERVER_AFTER),
             ),
         };
+    let target = context.get_delete_msgs_target().await?;
 
     context
         .sql
         .execute(
             "UPDATE imap
-             SET target=''
+             SET target=?
              WHERE rfc724_mid IN (
                SELECT rfc724_mid FROM msgs
                WHERE ((download_state = 0 AND timestamp < ?) OR
                       (download_state != 0 AND timestamp < ?) OR
                       (ephemeral_timestamp != 0 AND ephemeral_timestamp <= ?))
              )",
-            (threshold_timestamp, threshold_timestamp_extended, now),
+            (
+                &target,
+                threshold_timestamp,
+                threshold_timestamp_extended,
+                now,
+            ),
         )
         .await?;
 

src/events.rs

@@ -71,7 +71,7 @@ impl EventEmitter {
     /// [`try_recv`]: Self::try_recv
     pub async fn recv(&self) -> Option<Event> {
         let mut lock = self.0.lock().await;
-        match lock.recv_direct().await {
+        match lock.recv().await {
             Err(async_broadcast::RecvError::Overflowed(n)) => Some(Event {
                 id: 0,
                 typ: EventType::EventChannelOverflow { n },

src/headerdef.rs

@@ -91,7 +91,6 @@ pub enum HeaderDef {
     ChatDispositionNotificationTo,
     ChatWebrtcRoom,
     ChatWebrtcAccepted,
-    ChatWebrtcHasVideoInitially,
 
     /// This message deletes the messages listed in the value by rfc724_mid.
     ChatDelete,

src/html.rs

@@ -254,20 +254,13 @@ fn mimepart_to_data_url(mail: &mailparse::ParsedMail<'_>) -> Result<String> {
 
 impl MsgId {
     /// Get HTML by database message id.
-    /// Returns `Some` at least if `Message.has_html()` is true.
-    /// NB: we do not save raw mime unconditionally in the database to save space.
+    /// This requires `mime_headers` field to be set for the message;
+    /// this is the case at least when `Message.has_html()` returns true
+    /// (we do not save raw mime unconditionally in the database to save space).
     /// The corresponding ffi-function is `dc_get_msg_html()`.
     pub async fn get_html(self, context: &Context) -> Result<Option<String>> {
-        // If there are many concurrent db readers, going to the queue earlier makes sense.
-        let (param, rawmime) = tokio::join!(
-            self.get_param(context),
-            message::get_mime_headers(context, self)
-        );
-        if let Some(html) = param?.get(SendHtml) {
-            return Ok(Some(html.to_string()));
-        }
+        let rawmime = message::get_mime_headers(context, self).await?;
 
-        let rawmime = rawmime?;
         if !rawmime.is_empty() {
             match HtmlMsgParser::from_bytes(context, &rawmime).await {
                 Err(err) => {
@@ -286,9 +279,9 @@ impl MsgId {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::chat::{self, Chat, forward_msgs, save_msgs};
+    use crate::chat;
+    use crate::chat::{forward_msgs, save_msgs};
     use crate::config::Config;
-    use crate::constants;
     use crate::contact::ContactId;
     use crate::message::{MessengerMessage, Viewtype};
     use crate::receive_imf::receive_imf;
@@ -447,7 +440,7 @@ test some special html-characters as &lt; &gt; and &amp; but also &quot; and &#x
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_html_forwarding() -> Result<()> {
+    async fn test_html_forwarding() {
         // alice receives a non-delta html-message
         let mut tcm = TestContextManager::new();
         let alice = &tcm.alice().await;
@@ -466,57 +459,31 @@ test some special html-characters as &lt; &gt; and &amp; but also &quot; and &#x
         assert!(html.contains("this is <b>html</b>"));
 
         // alice: create chat with bob and forward received html-message there
-        let chat_alice = alice.create_chat_with_contact("", "bob@example.net").await;
-        forward_msgs(alice, &[msg.get_id()], chat_alice.get_id())
+        let chat = alice.create_chat_with_contact("", "bob@example.net").await;
+        forward_msgs(alice, &[msg.get_id()], chat.get_id())
             .await
             .unwrap();
-        async fn check_sender(ctx: &TestContext, chat: &Chat) {
-            let msg = ctx.get_last_msg_in(chat.get_id()).await;
-            assert_eq!(msg.get_from_id(), ContactId::SELF);
-            assert_eq!(msg.is_dc_message, MessengerMessage::Yes);
-            assert!(msg.is_forwarded());
-            assert!(msg.get_text().contains("this is plain"));
-            assert!(msg.has_html());
-            let html = msg.get_id().get_html(ctx).await.unwrap().unwrap();
-            assert!(html.contains("this is <b>html</b>"));
-        }
-        check_sender(alice, &chat_alice).await;
+        let msg = alice.get_last_msg_in(chat.get_id()).await;
+        assert_eq!(msg.get_from_id(), ContactId::SELF);
+        assert_eq!(msg.is_dc_message, MessengerMessage::Yes);
+        assert!(msg.is_forwarded());
+        assert!(msg.get_text().contains("this is plain"));
+        assert!(msg.has_html());
+        let html = msg.get_id().get_html(alice).await.unwrap().unwrap();
+        assert!(html.contains("this is <b>html</b>"));
 
         // bob: check that bob also got the html-part of the forwarded message
         let bob = &tcm.bob().await;
-        let chat_bob = bob.create_chat_with_contact("", "alice@example.org").await;
-        async fn check_receiver(ctx: &TestContext, chat: &Chat, sender: &TestContext) {
-            let msg = ctx.recv_msg(&sender.pop_sent_msg().await).await;
-            assert_eq!(chat.id, msg.chat_id);
-            assert_ne!(msg.get_from_id(), ContactId::SELF);
-            assert_eq!(msg.is_dc_message, MessengerMessage::Yes);
-            assert!(msg.is_forwarded());
-            assert!(msg.get_text().contains("this is plain"));
-            assert!(msg.has_html());
-            let html = msg.get_id().get_html(ctx).await.unwrap().unwrap();
-            assert!(html.contains("this is <b>html</b>"));
-        }
-        check_receiver(bob, &chat_bob, alice).await;
-
-        // Let's say that the alice and bob profiles are on the same device,
-        // so alice can forward the message to herself via bob profile!
-        chat::forward_msgs_2ctx(alice, &[msg.get_id()], bob, chat_bob.get_id()).await?;
-        check_sender(bob, &chat_bob).await;
-        check_receiver(alice, &chat_alice, bob).await;
-
-        // Check cross-profile forwarding of long outgoing messages.
-        let line = "this text with 42 chars is just repeated.\n";
-        let long_txt = line.repeat(constants::DC_DESIRED_TEXT_LEN / line.len() + 2);
-        let mut msg = Message::new_text(long_txt);
-        alice.send_msg(chat_alice.id, &mut msg).await;
-        let msg = alice.get_last_msg_in(chat_alice.id).await;
+        let chat = bob.create_chat_with_contact("", "alice@example.org").await;
+        let msg = bob.recv_msg(&alice.pop_sent_msg().await).await;
+        assert_eq!(chat.id, msg.chat_id);
+        assert_ne!(msg.get_from_id(), ContactId::SELF);
+        assert_eq!(msg.is_dc_message, MessengerMessage::Yes);
+        assert!(msg.is_forwarded());
+        assert!(msg.get_text().contains("this is plain"));
         assert!(msg.has_html());
-        let html = msg.id.get_html(alice).await?.unwrap();
-        chat::forward_msgs_2ctx(alice, &[msg.get_id()], bob, chat_bob.get_id()).await?;
-        let msg = bob.get_last_msg_in(chat_bob.id).await;
-        assert!(msg.has_html());
-        assert_eq!(msg.id.get_html(bob).await?.unwrap(), html);
-        Ok(())
+        let html = msg.get_id().get_html(bob).await.unwrap().unwrap();
+        assert!(html.contains("this is <b>html</b>"));
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]

src/imap.rs

@@ -16,20 +16,19 @@ use std::{
 use anyhow::{Context as _, Result, bail, ensure, format_err};
 use async_channel::{self, Receiver, Sender};
 use async_imap::types::{Fetch, Flag, Name, NameAttribute, UnsolicitedResponse};
+use deltachat_contact_tools::ContactAddress;
 use futures::{FutureExt as _, TryStreamExt};
 use futures_lite::FutureExt;
 use num_traits::FromPrimitive;
 use ratelimit::Ratelimit;
 use url::Url;
 
-use crate::calls::{
-    UnresolvedIceServer, create_fallback_ice_servers, create_ice_servers_from_metadata,
-};
+use crate::calls::{create_fallback_ice_servers, create_ice_servers_from_metadata};
 use crate::chat::{self, ChatId, ChatIdBlocked, add_device_msg};
 use crate::chatlist_events;
 use crate::config::Config;
 use crate::constants::{self, Blocked, DC_VERSION_STR, ShowEmails};
-use crate::contact::ContactId;
+use crate::contact::{Contact, ContactId, Modifier, Origin};
 use crate::context::Context;
 use crate::events::EventType;
 use crate::headerdef::{HeaderDef, HeaderDefMap};
@@ -53,10 +52,12 @@ use crate::transport::{
 pub(crate) mod capabilities;
 mod client;
 mod idle;
+pub mod scan_folders;
 pub mod select_folder;
 pub(crate) mod session;
 
 use client::{Client, determine_capabilities};
+use mailparse::SingleInfo;
 use session::Session;
 
 pub(crate) const GENERATED_PREFIX: &str = "GEN_";
@@ -133,15 +134,16 @@ pub(crate) struct ServerMetadata {
 
     pub iroh_relay: Option<Url>,
 
-    /// ICE servers for WebRTC calls.
-    pub ice_servers: Vec<UnresolvedIceServer>,
+    /// JSON with ICE servers for WebRTC calls
+    /// and the expiration timestamp.
+    ///
+    /// If JSON is about to expire, new TURN credentials
+    /// should be fetched from the server
+    /// to be ready for WebRTC calls.
+    pub ice_servers: String,
 
     /// Timestamp when ICE servers are considered
     /// expired and should be updated.
-    ///
-    /// If ICE servers are about to expire, new TURN credentials
-    /// should be fetched from the server
-    /// to be ready for WebRTC calls.
     pub ice_servers_expiration_timestamp: i64,
 }
 
@@ -182,7 +184,7 @@ impl FolderMeaning {
             FolderMeaning::Spam => None,
             FolderMeaning::Inbox => Some(Config::ConfiguredInboxFolder),
             FolderMeaning::Mvbox => Some(Config::ConfiguredMvboxFolder),
-            FolderMeaning::Trash => None,
+            FolderMeaning::Trash => Some(Config::ConfiguredTrashFolder),
             FolderMeaning::Virtual => None,
         }
     }
@@ -498,7 +500,13 @@ impl Imap {
             .get_raw_config_int(constants::DC_FOLDERS_CONFIGURED_KEY)
             .await?;
         if folders_configured.unwrap_or_default() < constants::DC_FOLDERS_CONFIGURED_VERSION {
-            self.configure_folders(context, &mut session).await?;
+            let is_chatmail = match context.get_config_bool(Config::FixIsChatmail).await? {
+                false => session.is_chatmail(),
+                true => context.get_config_bool(Config::IsChatmail).await?,
+            };
+            let create_mvbox = !is_chatmail || context.get_config_bool(Config::MvboxMove).await?;
+            self.configure_folders(context, &mut session, create_mvbox)
+                .await?;
         }
 
         Ok(session)
@@ -556,8 +564,9 @@ impl Imap {
             return Ok(false);
         }
 
+        let create = false;
         let folder_exists = session
-            .select_with_uidvalidity(context, folder)
+            .select_with_uidvalidity(context, folder, create)
             .await
             .with_context(|| format!("Failed to select folder {folder:?}"))?;
         if !folder_exists {
@@ -610,6 +619,7 @@ impl Imap {
         let mut download_later: Vec<String> = Vec::new();
         let mut uid_message_ids = BTreeMap::new();
         let mut largest_uid_skipped = None;
+        let delete_target = context.get_delete_msgs_target().await?;
 
         let download_limit: Option<u32> = context
             .get_config_parsed(Config::DownloadLimit)
@@ -659,7 +669,7 @@ impl Imap {
 
             let _target;
             let target = if delete {
-                ""
+                &delete_target
             } else {
                 _target = target_folder(context, folder, folder_meaning, &headers).await?;
                 &_target
@@ -826,6 +836,27 @@ impl Imap {
 
         Ok((read_cnt, fetch_more))
     }
+
+    /// Read the recipients from old emails sent by the user and add them as contacts.
+    /// This way, we can already offer them some email addresses they can write to.
+    ///
+    /// Then, Fetch the last messages DC_FETCH_EXISTING_MSGS_COUNT emails from the server
+    /// and show them in the chat list.
+    pub(crate) async fn fetch_existing_msgs(
+        &mut self,
+        context: &Context,
+        session: &mut Session,
+    ) -> Result<()> {
+        add_all_recipients_as_contacts(context, session, Config::ConfiguredMvboxFolder)
+            .await
+            .context("failed to get recipients from the movebox")?;
+        add_all_recipients_as_contacts(context, session, Config::ConfiguredInboxFolder)
+            .await
+            .context("failed to get recipients from the inbox")?;
+
+        info!(context, "Done fetching existing messages.");
+        Ok(())
+    }
 }
 
 impl Session {
@@ -864,7 +895,10 @@ impl Session {
         // Collect pairs of UID and Message-ID.
         let mut msgs = BTreeMap::new();
 
-        let folder_exists = self.select_with_uidvalidity(context, folder).await?;
+        let create = false;
+        let folder_exists = self
+            .select_with_uidvalidity(context, folder, create)
+            .await?;
         let transport_id = self.transport_id();
         if folder_exists {
             let mut list = self
@@ -986,6 +1020,17 @@ impl Session {
                     return Ok(());
                 }
                 Err(err) => {
+                    if context.should_delete_to_trash().await? {
+                        error!(
+                            context,
+                            "Cannot move messages {} to {}, no fallback to COPY/DELETE because \
+                            delete_to_trash is set. Error: {:#}",
+                            set,
+                            target,
+                            err,
+                        );
+                        return Err(err.into());
+                    }
                     warn!(
                         context,
                         "Cannot move messages, fallback to COPY/DELETE {} to {}: {}",
@@ -999,11 +1044,19 @@ impl Session {
 
         // Server does not support MOVE or MOVE failed.
         // Copy messages to the destination folder if needed and mark records for deletion.
-        info!(
-            context,
-            "Server does not support MOVE, fallback to COPY/DELETE {} to {}", set, target
-        );
-        self.uid_copy(&set, &target).await?;
+        let copy = !context.is_trash(target).await?;
+        if copy {
+            info!(
+                context,
+                "Server does not support MOVE, fallback to COPY/DELETE {} to {}", set, target
+            );
+            self.uid_copy(&set, &target).await?;
+        } else {
+            error!(
+                context,
+                "Server does not support MOVE, fallback to DELETE {} to {}", set, target,
+            );
+        }
         context
             .sql
             .transaction(|transaction| {
@@ -1015,9 +1068,11 @@ impl Session {
             })
             .await
             .context("Cannot plan deletion of messages")?;
-        context.emit_event(EventType::ImapMessageMoved(format!(
-            "IMAP messages {set} copied to {target}"
-        )));
+        if copy {
+            context.emit_event(EventType::ImapMessageMoved(format!(
+                "IMAP messages {set} copied to {target}"
+            )));
+        }
         Ok(())
     }
 
@@ -1049,7 +1104,10 @@ impl Session {
             // MOVE/DELETE operations. This does not result in multiple SELECT commands
             // being sent because `select_folder()` does nothing if the folder is already
             // selected.
-            let folder_exists = self.select_with_uidvalidity(context, folder).await?;
+            let create = false;
+            let folder_exists = self
+                .select_with_uidvalidity(context, folder, create)
+                .await?;
             ensure!(folder_exists, "No folder {folder}");
 
             // Empty target folder name means messages should be deleted.
@@ -1081,6 +1139,7 @@ impl Session {
     /// Stores pending `\Seen` flags for messages in `imap_markseen` table.
     pub(crate) async fn store_seen_flags_on_imap(&mut self, context: &Context) -> Result<()> {
         if context.get_config_bool(Config::TeamProfile).await? {
+            info!(context, "Team profile, skipping seen flag synchronization.");
             return Ok(());
         }
 
@@ -1104,7 +1163,8 @@ impl Session {
             .await?;
 
         for (folder, rowid_set, uid_set) in UidGrouper::from(rows) {
-            let folder_exists = match self.select_with_uidvalidity(context, &folder).await {
+            let create = false;
+            let folder_exists = match self.select_with_uidvalidity(context, &folder, create).await {
                 Err(err) => {
                     warn!(
                         context,
@@ -1155,11 +1215,13 @@ impl Session {
         }
 
         if context.get_config_bool(Config::TeamProfile).await? {
+            info!(context, "Team profile, skipping seen flag synchronization.");
             return Ok(());
         }
 
+        let create = false;
         let folder_exists = self
-            .select_with_uidvalidity(context, folder)
+            .select_with_uidvalidity(context, folder, create)
             .await
             .context("Failed to select folder")?;
         if !folder_exists {
@@ -1251,6 +1313,41 @@ impl Session {
         Ok(())
     }
 
+    /// Gets the from, to and bcc addresses from all existing outgoing emails.
+    pub async fn get_all_recipients(&mut self, context: &Context) -> Result<Vec<SingleInfo>> {
+        let mut uids: Vec<_> = self
+            .uid_search(get_imap_self_sent_search_command(context).await?)
+            .await?
+            .into_iter()
+            .collect();
+        uids.sort_unstable();
+
+        let mut result = Vec::new();
+        for (_, uid_set) in build_sequence_sets(&uids)? {
+            let mut list = self
+                .uid_fetch(uid_set, "(UID BODY.PEEK[HEADER.FIELDS (FROM TO CC BCC)])")
+                .await
+                .context("IMAP Could not fetch")?;
+
+            while let Some(msg) = list.try_next().await? {
+                match get_fetch_headers(&msg) {
+                    Ok(headers) => {
+                        if let Some(from) = mimeparser::get_from(&headers)
+                            && context.is_self_addr(&from.addr).await?
+                        {
+                            result.extend(mimeparser::get_recipients(&headers));
+                        }
+                    }
+                    Err(err) => {
+                        warn!(context, "{}", err);
+                        continue;
+                    }
+                };
+            }
+        }
+        Ok(result)
+    }
+
     /// Fetches a list of messages by server UID.
     ///
     /// Sends pairs of UID and info about each downloaded message to the provided channel.
@@ -1455,7 +1552,7 @@ impl Session {
                     if m.entry == "/shared/vendor/deltachat/turn"
                         && let Some(value) = m.value
                     {
-                        match create_ice_servers_from_metadata(&value).await {
+                        match create_ice_servers_from_metadata(context, &value).await {
                             Ok((parsed_timestamp, parsed_ice_servers)) => {
                                 old_metadata.ice_servers_expiration_timestamp = parsed_timestamp;
                                 old_metadata.ice_servers = parsed_ice_servers;
@@ -1472,7 +1569,7 @@ impl Session {
                 info!(context, "Will use fallback ICE servers.");
                 // Set expiration timestamp 7 days in the future so we don't request it again.
                 old_metadata.ice_servers_expiration_timestamp = time() + 3600 * 24 * 7;
-                old_metadata.ice_servers = create_fallback_ice_servers();
+                old_metadata.ice_servers = create_fallback_ice_servers(context).await?;
             }
             return Ok(());
         }
@@ -1519,7 +1616,7 @@ impl Session {
                 }
                 "/shared/vendor/deltachat/turn" => {
                     if let Some(value) = m.value {
-                        match create_ice_servers_from_metadata(&value).await {
+                        match create_ice_servers_from_metadata(context, &value).await {
                             Ok((parsed_timestamp, parsed_ice_servers)) => {
                                 ice_servers_expiration_timestamp = parsed_timestamp;
                                 ice_servers = Some(parsed_ice_servers);
@@ -1538,7 +1635,7 @@ impl Session {
         } else {
             // Set expiration timestamp 7 days in the future so we don't request it again.
             ice_servers_expiration_timestamp = time() + 3600 * 24 * 7;
-            create_fallback_ice_servers()
+            create_fallback_ice_servers(context).await?
         };
 
         *lock = Some(ServerMetadata {
@@ -1670,16 +1767,17 @@ impl Session {
 
     /// Attempts to configure mvbox.
     ///
-    /// Tries to find any folder examining `folders` in the order they go.
-    /// This method does not use LIST command to ensure that
+    /// Tries to find any folder examining `folders` in the order they go. If none is found, tries
+    /// to create any folder in the same order. This method does not use LIST command to ensure that
     /// configuration works even if mailbox lookup is forbidden via Access Control List (see
     /// <https://datatracker.ietf.org/doc/html/rfc4314>).
     ///
-    /// Returns first found folder name.
+    /// Returns first found or created folder name.
     async fn configure_mvbox<'a>(
         &mut self,
         context: &Context,
         folders: &[&'a str],
+        create_mvbox: bool,
     ) -> Result<Option<&'a str>> {
         // Close currently selected folder if needed.
         // We are going to select folders using low-level EXAMINE operations below.
@@ -1696,12 +1794,34 @@ impl Session {
                 self.close().await?;
                 // Before moving emails to the mvbox we need to remember its UIDVALIDITY, otherwise
                 // emails moved before that wouldn't be fetched but considered "old" instead.
-                let folder_exists = self.select_with_uidvalidity(context, folder).await?;
+                let create = false;
+                let folder_exists = self
+                    .select_with_uidvalidity(context, folder, create)
+                    .await?;
                 ensure!(folder_exists, "No MVBOX folder {:?}??", &folder);
                 return Ok(Some(folder));
             }
         }
 
+        if !create_mvbox {
+            return Ok(None);
+        }
+        // Some servers require namespace-style folder names like "INBOX.DeltaChat", so we try all
+        // the variants here.
+        for folder in folders {
+            match self
+                .select_with_uidvalidity(context, folder, create_mvbox)
+                .await
+            {
+                Ok(_) => {
+                    info!(context, "MVBOX-folder {} created.", folder);
+                    return Ok(Some(folder));
+                }
+                Err(err) => {
+                    warn!(context, "Cannot create MVBOX-folder {:?}: {}", folder, err);
+                }
+            }
+        }
         Ok(None)
     }
 }
@@ -1711,6 +1831,7 @@ impl Imap {
         &mut self,
         context: &Context,
         session: &mut Session,
+        create_mvbox: bool,
     ) -> Result<()> {
         let mut folders = session
             .list(Some(""), Some("*"))
@@ -1751,7 +1872,7 @@ impl Imap {
 
         let fallback_folder = format!("INBOX{delimiter}DeltaChat");
         let mvbox_folder = session
-            .configure_mvbox(context, &["DeltaChat", &fallback_folder])
+            .configure_mvbox(context, &["DeltaChat", &fallback_folder], create_mvbox)
             .await
             .context("failed to configure mvbox")?;
 
@@ -2152,10 +2273,11 @@ pub(crate) async fn prefetch_should_download(
     let accepted_contact = origin.is_known();
     let is_reply_to_chat_message = get_prefetch_parent_message(context, headers)
         .await?
-        .is_some_and(|parent| match parent.is_dc_message {
+        .map(|parent| match parent.is_dc_message {
             MessengerMessage::No => false,
             MessengerMessage::Yes | MessengerMessage::Reply => true,
-        });
+        })
+        .unwrap_or_default();
 
     let show_emails =
         ShowEmails::from_i32(context.get_config_int(Config::ShowEmails).await?).unwrap_or_default();
@@ -2346,6 +2468,18 @@ async fn get_modseq(context: &Context, transport_id: u32, folder: &str) -> Resul
         .unwrap_or(0))
 }
 
+/// Compute the imap search expression for all self-sent mails (for all self addresses)
+pub(crate) async fn get_imap_self_sent_search_command(context: &Context) -> Result<String> {
+    // See https://www.rfc-editor.org/rfc/rfc3501#section-6.4.4 for syntax of SEARCH and OR
+    let mut search_command = format!("FROM \"{}\"", context.get_primary_self_addr().await?);
+
+    for item in context.get_secondary_self_addrs().await? {
+        search_command = format!("OR ({search_command}) (FROM \"{item}\")");
+    }
+
+    Ok(search_command)
+}
+
 /// Whether to ignore fetching messages from a folder.
 ///
 /// This caters for the [`Config::OnlyFetchMvbox`] setting which means mails from folders
@@ -2418,23 +2552,65 @@ impl std::fmt::Display for UidRange {
         }
     }
 }
-
-pub(crate) async fn get_watched_folder_configs(context: &Context) -> Result<Vec<Config>> {
-    let mut res = vec![Config::ConfiguredInboxFolder];
-    if context.should_watch_mvbox().await? {
-        res.push(Config::ConfiguredMvboxFolder);
+async fn add_all_recipients_as_contacts(
+    context: &Context,
+    session: &mut Session,
+    folder: Config,
+) -> Result<()> {
+    let mailbox = if let Some(m) = context.get_config(folder).await? {
+        m
+    } else {
+        info!(
+            context,
+            "Folder {} is not configured, skipping fetching contacts from it.", folder
+        );
+        return Ok(());
+    };
+    let create = false;
+    let folder_exists = session
+        .select_with_uidvalidity(context, &mailbox, create)
+        .await
+        .with_context(|| format!("could not select {mailbox}"))?;
+    if !folder_exists {
+        return Ok(());
     }
-    Ok(res)
-}
 
-pub(crate) async fn get_watched_folders(context: &Context) -> Result<Vec<String>> {
-    let mut res = Vec::new();
-    for folder_config in get_watched_folder_configs(context).await? {
-        if let Some(folder) = context.get_config(folder_config).await? {
-            res.push(folder);
+    let recipients = session
+        .get_all_recipients(context)
+        .await
+        .context("could not get recipients")?;
+
+    let mut any_modified = false;
+    for recipient in recipients {
+        let recipient_addr = match ContactAddress::new(&recipient.addr) {
+            Err(err) => {
+                warn!(
+                    context,
+                    "Could not add contact for recipient with address {:?}: {:#}",
+                    recipient.addr,
+                    err
+                );
+                continue;
+            }
+            Ok(recipient_addr) => recipient_addr,
+        };
+
+        let (_, modified) = Contact::add_or_lookup(
+            context,
+            &recipient.display_name.unwrap_or_default(),
+            &recipient_addr,
+            Origin::OutgoingTo,
+        )
+        .await?;
+        if modified != Modifier::None {
+            any_modified = true;
         }
     }
-    Ok(res)
+    if any_modified {
+        context.emit_event(EventType::ContactsChanged(None));
+    }
+
+    Ok(())
 }
 
 #[cfg(test)]

src/imap/idle.rs

@@ -27,7 +27,9 @@ impl Session {
         idle_interrupt_receiver: Receiver<()>,
         folder: &str,
     ) -> Result<Self> {
-        self.select_with_uidvalidity(context, folder).await?;
+        let create = true;
+        self.select_with_uidvalidity(context, folder, create)
+            .await?;
 
         if self.drain_unsolicited_responses(context)? {
             self.new_mail = true;

src/imap/imap_tests.rs

@@ -1,6 +1,6 @@
 use super::*;
-use crate::contact::Contact;
 use crate::test_utils::TestContext;
+use crate::transport::add_pseudo_transport;
 
 #[test]
 fn test_get_folder_meaning_by_name() {
@@ -264,6 +264,31 @@ async fn test_target_folder_setupmsg() -> Result<()> {
     Ok(())
 }
 
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn test_get_imap_search_command() -> Result<()> {
+    let t = TestContext::new_alice().await;
+    assert_eq!(
+        get_imap_self_sent_search_command(&t.ctx).await?,
+        r#"FROM "alice@example.org""#
+    );
+
+    add_pseudo_transport(&t, "alice@another.com").await?;
+    t.ctx.set_primary_self_addr("alice@another.com").await?;
+    assert_eq!(
+        get_imap_self_sent_search_command(&t.ctx).await?,
+        r#"OR (FROM "alice@another.com") (FROM "alice@example.org")"#
+    );
+
+    add_pseudo_transport(&t, "alice@third.com").await?;
+    t.ctx.set_primary_self_addr("alice@third.com").await?;
+    assert_eq!(
+        get_imap_self_sent_search_command(&t.ctx).await?,
+        r#"OR (OR (FROM "alice@third.com") (FROM "alice@another.com")) (FROM "alice@example.org")"#
+    );
+
+    Ok(())
+}
+
 #[test]
 fn test_uid_grouper() {
     // Input: sequence of (rowid: i64, uid: u32, target: String)

src/imap/scan_folders.rs

@@ -0,0 +1,119 @@
+use std::collections::BTreeMap;
+
+use anyhow::{Context as _, Result};
+
+use super::{get_folder_meaning_by_attrs, get_folder_meaning_by_name};
+use crate::config::Config;
+use crate::imap::{Imap, session::Session};
+use crate::log::LogExt;
+use crate::tools::{self, time_elapsed};
+use crate::{context::Context, imap::FolderMeaning};
+
+impl Imap {
+    /// Returns true if folders were scanned, false if scanning was postponed.
+    pub(crate) async fn scan_folders(
+        &mut self,
+        context: &Context,
+        session: &mut Session,
+    ) -> Result<bool> {
+        // First of all, debounce to once per minute:
+        {
+            let mut last_scan = session.last_full_folder_scan.lock().await;
+            if let Some(last_scan) = *last_scan {
+                let elapsed_secs = time_elapsed(&last_scan).as_secs();
+                let debounce_secs = context
+                    .get_config_u64(Config::ScanAllFoldersDebounceSecs)
+                    .await?;
+
+                if elapsed_secs < debounce_secs {
+                    return Ok(false);
+                }
+            }
+
+            // Update the timestamp before scanning the folders
+            // to avoid holding the lock for too long.
+            // This means next scan is delayed even if
+            // the current one fails.
+            last_scan.replace(tools::Time::now());
+        }
+        info!(context, "Starting full folder scan");
+
+        let folders = session.list_folders().await?;
+        let watched_folders = get_watched_folders(context).await?;
+
+        let mut folder_configs = BTreeMap::new();
+        let mut folder_names = Vec::new();
+
+        for folder in folders {
+            let folder_meaning = get_folder_meaning_by_attrs(folder.attributes());
+            if folder_meaning == FolderMeaning::Virtual {
+                // Gmail has virtual folders that should be skipped. For example,
+                // emails appear in the inbox and under "All Mail" as soon as it is
+                // received. The code used to wrongly conclude that the email had
+                // already been moved and left it in the inbox.
+                continue;
+            }
+            folder_names.push(folder.name().to_string());
+            let folder_name_meaning = get_folder_meaning_by_name(folder.name());
+
+            if let Some(config) = folder_meaning.to_config() {
+                // Always takes precedence
+                folder_configs.insert(config, folder.name().to_string());
+            } else if let Some(config) = folder_name_meaning.to_config() {
+                // only set if none has been already set
+                folder_configs
+                    .entry(config)
+                    .or_insert_with(|| folder.name().to_string());
+            }
+
+            let folder_meaning = match folder_meaning {
+                FolderMeaning::Unknown => folder_name_meaning,
+                _ => folder_meaning,
+            };
+
+            // Don't scan folders that are watched anyway
+            if !watched_folders.contains(&folder.name().to_string())
+                && folder_meaning != FolderMeaning::Trash
+                && folder_meaning != FolderMeaning::Unknown
+            {
+                self.fetch_move_delete(context, session, folder.name(), folder_meaning)
+                    .await
+                    .context("Can't fetch new msgs in scanned folder")
+                    .log_err(context)
+                    .ok();
+            }
+        }
+
+        // Set config for the Trash folder. Or reset if the folder was deleted.
+        let conf = Config::ConfiguredTrashFolder;
+        let val = folder_configs.get(&conf).map(|s| s.as_str());
+        let interrupt = val.is_some() && context.get_config(conf).await?.is_none();
+        context.set_config_internal(conf, val).await?;
+        if interrupt {
+            // `Imap::fetch_move_delete()`, particularly message deletion, is possible now for other
+            // folders (NB: we are in the Inbox loop).
+            context.scheduler.interrupt_oboxes().await;
+        }
+
+        info!(context, "Found folders: {folder_names:?}.");
+        Ok(true)
+    }
+}
+
+pub(crate) async fn get_watched_folder_configs(context: &Context) -> Result<Vec<Config>> {
+    let mut res = vec![Config::ConfiguredInboxFolder];
+    if context.should_watch_mvbox().await? {
+        res.push(Config::ConfiguredMvboxFolder);
+    }
+    Ok(res)
+}
+
+pub(crate) async fn get_watched_folders(context: &Context) -> Result<Vec<String>> {
+    let mut res = Vec::new();
+    for folder_config in get_watched_folder_configs(context).await? {
+        if let Some(folder) = context.get_config(folder_config).await? {
+            res.push(folder);
+        }
+    }
+    Ok(res)
+}

src/imap/select_folder.rs

@@ -89,6 +89,33 @@ impl ImapSession {
         }
     }
 
+    /// Selects a folder. Tries to create it once and select again if the folder does not exist.
+    pub(super) async fn select_or_create_folder(
+        &mut self,
+        context: &Context,
+        folder: &str,
+    ) -> anyhow::Result<NewlySelected> {
+        match self.select_folder(context, folder).await {
+            Ok(newly_selected) => Ok(newly_selected),
+            Err(err) => match err {
+                Error::NoFolder(..) => {
+                    info!(context, "Failed to select folder {folder:?} because it does not exist, trying to create it.");
+                    let create_res = self.create(folder).await;
+                    if let Err(ref err) = create_res {
+                        info!(context, "Couldn't select folder, then create() failed: {err:#}.");
+                        // Need to recheck, could have been created in parallel.
+                    }
+                    let select_res = self.select_folder(context, folder).await.with_context(|| format!("failed to select newely created folder {folder}"));
+                    if select_res.is_err() {
+                        create_res?;
+                    }
+                    select_res
+                }
+                _ => Err(err).with_context(|| format!("failed to select folder {folder} with error other than NO, not trying to create it")),
+            },
+        }
+    }
+
     /// Selects a folder optionally creating it and takes care of UIDVALIDITY changes. Returns false
     /// iff `folder` doesn't exist.
     ///
@@ -102,16 +129,23 @@ impl ImapSession {
         &mut self,
         context: &Context,
         folder: &str,
+        create: bool,
     ) -> anyhow::Result<bool> {
-        let newly_selected = match self.select_folder(context, folder).await {
-            Ok(newly_selected) => newly_selected,
-            Err(err) => match err {
-                Error::NoFolder(..) => return Ok(false),
-                _ => {
-                    return Err(err)
-                        .with_context(|| format!("Failed to select folder {folder:?}"))?;
-                }
-            },
+        let newly_selected = if create {
+            self.select_or_create_folder(context, folder)
+                .await
+                .with_context(|| format!("Failed to select or create folder {folder:?}"))?
+        } else {
+            match self.select_folder(context, folder).await {
+                Ok(newly_selected) => newly_selected,
+                Err(err) => match err {
+                    Error::NoFolder(..) => return Ok(false),
+                    _ => {
+                        return Err(err)
+                            .with_context(|| format!("Failed to select folder {folder:?}"))?;
+                    }
+                },
+            }
         };
         let transport_id = self.transport_id();
 

src/imap/session.rs

@@ -5,9 +5,11 @@ use anyhow::{Context as _, Result};
 use async_imap::Session as ImapSession;
 use async_imap::types::Mailbox;
 use futures::TryStreamExt;
+use tokio::sync::Mutex;
 
 use crate::imap::capabilities::Capabilities;
 use crate::net::session::SessionStream;
+use crate::tools;
 
 /// Prefetch:
 /// - Message-ID to check if we already have the message.
@@ -44,6 +46,8 @@ pub(crate) struct Session {
 
     pub selected_folder_needs_expunge: bool,
 
+    pub(crate) last_full_folder_scan: Mutex<Option<tools::Time>>,
+
     /// True if currently selected folder has new messages.
     ///
     /// Should be false if no folder is currently selected.
@@ -80,6 +84,7 @@ impl Session {
             selected_folder: None,
             selected_mailbox: None,
             selected_folder_needs_expunge: false,
+            last_full_folder_scan: Mutex::new(None),
             new_mail: false,
             resync_request_sender,
         }

src/imex.rs

@@ -19,7 +19,7 @@ use crate::config::Config;
 use crate::context::Context;
 use crate::e2ee;
 use crate::events::EventType;
-use crate::key::{self, DcKey, SignedPublicKey, SignedSecretKey};
+use crate::key::{self, DcKey, DcSecretKey, SignedPublicKey, SignedSecretKey};
 use crate::log::{LogExt, warn};
 use crate::pgp;
 use crate::qr::DCBACKUP_VERSION;
@@ -142,7 +142,7 @@ pub async fn has_backup(_context: &Context, dir_name: &Path) -> Result<String> {
 
 async fn set_self_key(context: &Context, armored: &str) -> Result<()> {
     let private_key = SignedSecretKey::from_asc(armored)?;
-    let public_key = private_key.to_public_key();
+    let public_key = private_key.split_public_key()?;
 
     let keypair = pgp::KeyPair {
         public: public_key,
@@ -153,7 +153,7 @@ async fn set_self_key(context: &Context, armored: &str) -> Result<()> {
     info!(
         context,
         "stored self key: {:?}",
-        keypair.secret.public_key().legacy_key_id()
+        keypair.secret.public_key().key_id()
     );
     Ok(())
 }

src/key.rs

@@ -10,7 +10,7 @@ use deltachat_contact_tools::EmailAddress;
 use pgp::composed::Deserializable;
 pub use pgp::composed::{SignedPublicKey, SignedSecretKey};
 use pgp::ser::Serialize;
-use pgp::types::{KeyDetails, KeyId};
+use pgp::types::{KeyDetails, KeyId, Password};
 use tokio::runtime::Handle;
 
 use crate::context::Context;
@@ -156,14 +156,24 @@ pub(crate) async fn load_self_public_key(context: &Context) -> Result<SignedPubl
 }
 
 /// Returns our own public keyring.
-///
-/// No keys are generated and at most one key is returned.
 pub(crate) async fn load_self_public_keyring(context: &Context) -> Result<Vec<SignedPublicKey>> {
-    if let Some(public_key) = load_self_public_key_opt(context).await? {
-        Ok(vec![public_key])
-    } else {
-        Ok(vec![])
-    }
+    let keys = context
+        .sql
+        .query_map_vec(
+            r#"SELECT public_key
+               FROM keypairs
+               ORDER BY id=(SELECT value FROM config WHERE keyname='key_id') DESC"#,
+            (),
+            |row| {
+                let public_key_bytes: Vec<u8> = row.get(0)?;
+                Ok(public_key_bytes)
+            },
+        )
+        .await?
+        .into_iter()
+        .filter_map(|bytes| SignedPublicKey::from_slice(&bytes).log_err(context).ok())
+        .collect();
+    Ok(keys)
 }
 
 /// Returns own public key fingerprint in (not human-readable) hex representation.
@@ -264,7 +274,7 @@ impl DcKey for SignedPublicKey {
     }
 
     fn key_id(&self) -> KeyId {
-        KeyDetails::legacy_key_id(self)
+        KeyDetails::key_id(self)
     }
 }
 
@@ -291,7 +301,30 @@ impl DcKey for SignedSecretKey {
     }
 
     fn key_id(&self) -> KeyId {
-        KeyDetails::legacy_key_id(&**self)
+        KeyDetails::key_id(&**self)
+    }
+}
+
+/// Deltachat extension trait for secret keys.
+///
+/// Provides some convenience wrappers only applicable to [SignedSecretKey].
+pub(crate) trait DcSecretKey {
+    /// Create a public key from a private one.
+    fn split_public_key(&self) -> Result<SignedPublicKey>;
+}
+
+impl DcSecretKey for SignedSecretKey {
+    fn split_public_key(&self) -> Result<SignedPublicKey> {
+        self.verify()?;
+        let unsigned_pubkey = self.public_key();
+        let mut rng = rand_old::thread_rng();
+        let signed_pubkey = unsigned_pubkey.sign(
+            &mut rng,
+            &self.primary_key,
+            self.primary_key.public_key(),
+            &Password::empty(),
+        )?;
+        Ok(signed_pubkey)
     }
 }
 
@@ -403,7 +436,7 @@ pub(crate) async fn store_self_keypair(context: &Context, keypair: &KeyPair) ->
 /// Use import/export APIs instead.
 pub async fn preconfigure_keypair(context: &Context, secret_data: &str) -> Result<()> {
     let secret = SignedSecretKey::from_asc(secret_data)?;
-    let public = secret.to_public_key();
+    let public = secret.split_public_key()?;
     let keypair = KeyPair { public, secret };
     store_self_keypair(context, &keypair).await?;
     Ok(())
@@ -679,6 +712,12 @@ i8pcjGO+IZffvyZJVRWfVooBJmWWbPB1pueo3tx8w3+fcuzpxz+RLFKaPyqXO+dD
         assert_eq!(res0.unwrap(), res1.unwrap());
     }
 
+    #[test]
+    fn test_split_key() {
+        let pubkey = KEYPAIR.secret.split_public_key().unwrap();
+        assert_eq!(pubkey.primary_key, KEYPAIR.public.primary_key);
+    }
+
     /// Tests that setting a default key second time is not allowed.
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_save_self_key_twice() {

src/lib.rs

@@ -14,8 +14,7 @@
     clippy::unused_async,
     clippy::explicit_iter_loop,
     clippy::explicit_into_iter_loop,
-    clippy::cloned_instead_of_copied,
-    clippy::manual_is_variant_and
+    clippy::cloned_instead_of_copied
 )]
 #![cfg_attr(not(test), forbid(clippy::indexing_slicing))]
 #![cfg_attr(not(test), forbid(clippy::string_slice))]

src/message.rs

@@ -87,10 +87,12 @@ impl MsgId {
         let result = context
             .sql
             .query_row_optional(
-                "SELECT m.state, mdns.msg_id
-                  FROM msgs m LEFT JOIN msgs_mdns mdns ON mdns.msg_id=m.id
-                  WHERE id=?
-                  LIMIT 1",
+                concat!(
+                    "SELECT m.state, mdns.msg_id",
+                    " FROM msgs m LEFT JOIN msgs_mdns mdns ON mdns.msg_id=m.id",
+                    " WHERE id=?",
+                    " LIMIT 1",
+                ),
                 (self,),
                 |row| {
                     let state: MessageState = row.get(0)?;
@@ -452,7 +454,6 @@ pub struct Message {
     pub(crate) is_dc_message: MessengerMessage,
     pub(crate) original_msg_id: MsgId,
     pub(crate) mime_modified: bool,
-    pub(crate) chat_visibility: ChatVisibility,
     pub(crate) chat_blocked: Blocked,
     pub(crate) location_id: u32,
     pub(crate) error: Option<String>,
@@ -500,39 +501,40 @@ impl Message {
         let mut msg = context
             .sql
             .query_row_optional(
-                "SELECT
-                    m.id AS id,
-                    rfc724_mid AS rfc724mid,
-                    pre_rfc724_mid AS pre_rfc724mid,
-                    m.mime_in_reply_to AS mime_in_reply_to,
-                    m.chat_id AS chat_id,
-                    m.from_id AS from_id,
-                    m.to_id AS to_id,
-                    m.timestamp AS timestamp,
-                    m.timestamp_sent AS timestamp_sent,
-                    m.timestamp_rcvd AS timestamp_rcvd,
-                    m.ephemeral_timer AS ephemeral_timer,
-                    m.ephemeral_timestamp AS ephemeral_timestamp,
-                    m.type AS type,
-                    m.state AS state,
-                    mdns.msg_id AS mdn_msg_id,
-                    m.download_state AS download_state,
-                    m.error AS error,
-                    m.msgrmsg AS msgrmsg,
-                    m.starred AS original_msg_id,
-                    m.mime_modified AS mime_modified,
-                    m.txt AS txt,
-                    m.subject AS subject,
-                    m.param AS param,
-                    m.hidden AS hidden,
-                    m.location_id AS location,
-                    c.archived AS visibility,
-                    c.blocked AS blocked
-                 FROM msgs m
-                 LEFT JOIN chats c ON c.id=m.chat_id
-                 LEFT JOIN msgs_mdns mdns ON mdns.msg_id=m.id
-                 WHERE m.id=? AND chat_id!=3
-                 LIMIT 1",
+                concat!(
+                    "SELECT",
+                    "    m.id AS id,",
+                    "    rfc724_mid AS rfc724mid,",
+                    "    pre_rfc724_mid AS pre_rfc724mid,",
+                    "    m.mime_in_reply_to AS mime_in_reply_to,",
+                    "    m.chat_id AS chat_id,",
+                    "    m.from_id AS from_id,",
+                    "    m.to_id AS to_id,",
+                    "    m.timestamp AS timestamp,",
+                    "    m.timestamp_sent AS timestamp_sent,",
+                    "    m.timestamp_rcvd AS timestamp_rcvd,",
+                    "    m.ephemeral_timer AS ephemeral_timer,",
+                    "    m.ephemeral_timestamp AS ephemeral_timestamp,",
+                    "    m.type AS type,",
+                    "    m.state AS state,",
+                    "    mdns.msg_id AS mdn_msg_id,",
+                    "    m.download_state AS download_state,",
+                    "    m.error AS error,",
+                    "    m.msgrmsg AS msgrmsg,",
+                    "    m.starred AS original_msg_id,",
+                    "    m.mime_modified AS mime_modified,",
+                    "    m.txt AS txt,",
+                    "    m.subject AS subject,",
+                    "    m.param AS param,",
+                    "    m.hidden AS hidden,",
+                    "    m.location_id AS location,",
+                    "    c.blocked AS blocked",
+                    " FROM msgs m",
+                    " LEFT JOIN chats c ON c.id=m.chat_id",
+                    " LEFT JOIN msgs_mdns mdns ON mdns.msg_id=m.id",
+                    " WHERE m.id=? AND chat_id!=3",
+                    " LIMIT 1",
+                ),
                 (id,),
                 |row| {
                     let state: MessageState = row.get("state")?;
@@ -585,7 +587,6 @@ impl Message {
                         param: row.get::<_, String>("param")?.parse().unwrap_or_default(),
                         hidden: row.get("hidden")?,
                         location_id: row.get("location")?,
-                        chat_visibility: row.get::<_, Option<_>>("visibility")?.unwrap_or_default(),
                         chat_blocked: row
                             .get::<_, Option<Blocked>>("blocked")?
                             .unwrap_or_default(),
@@ -980,7 +981,7 @@ impl Message {
 
     /// Returns true if the message is a forwarded message.
     pub fn is_forwarded(&self) -> bool {
-        self.param.get_int(Param::Forwarded).is_some()
+        0 != self.param.get_int(Param::Forwarded).unwrap_or_default()
     }
 
     /// Returns true if the message is edited.
@@ -1506,16 +1507,6 @@ pub async fn get_msg_read_receipts(
         .await
 }
 
-/// Returns count of read receipts on message.
-///
-/// This view count is meant as a feedback measure for the channel owner only.
-pub async fn get_msg_read_receipt_count(context: &Context, msg_id: MsgId) -> Result<usize> {
-    context
-        .sql
-        .count("SELECT COUNT(*) FROM msgs_mdns WHERE msg_id=?", (msg_id,))
-        .await
-}
-
 pub(crate) fn guess_msgtype_from_suffix(msg: &Message) -> Option<(Viewtype, &'static str)> {
     msg.param
         .get(Param::Filename)
@@ -1762,11 +1753,12 @@ pub async fn delete_msgs_ex(
         modified_chat_ids.insert(msg.chat_id);
         deleted_rfc724_mid.push(msg.rfc724_mid.clone());
 
+        let target = context.get_delete_msgs_target().await?;
         let update_db = |trans: &mut rusqlite::Transaction| {
-            let mut stmt = trans.prepare("UPDATE imap SET target='' WHERE rfc724_mid=?")?;
-            stmt.execute((&msg.rfc724_mid,))?;
+            let mut stmt = trans.prepare("UPDATE imap SET target=? WHERE rfc724_mid=?")?;
+            stmt.execute((&target, &msg.rfc724_mid))?;
             if !msg.pre_rfc724_mid.is_empty() {
-                stmt.execute((&msg.pre_rfc724_mid,))?;
+                stmt.execute((&target, &msg.pre_rfc724_mid))?;
             }
             trans.execute("DELETE FROM smtp WHERE msg_id=?", (msg_id,))?;
             trans.execute(
@@ -1849,7 +1841,6 @@ pub async fn markseen_msgs(context: &Context, msg_ids: Vec<MsgId>) -> Result<()>
                     m.param AS param,
                     m.from_id AS from_id,
                     m.rfc724_mid AS rfc724_mid,
-                    m.hidden AS hidden,
                     c.archived AS archived,
                     c.blocked AS blocked
                  FROM msgs m LEFT JOIN chats c ON c.id=m.chat_id
@@ -1861,7 +1852,6 @@ pub async fn markseen_msgs(context: &Context, msg_ids: Vec<MsgId>) -> Result<()>
                     let param: Params = row.get::<_, String>("param")?.parse().unwrap_or_default();
                     let from_id: ContactId = row.get("from_id")?;
                     let rfc724_mid: String = row.get("rfc724_mid")?;
-                    let hidden: bool = row.get("hidden")?;
                     let visibility: ChatVisibility = row.get("archived")?;
                     let blocked: Option<Blocked> = row.get("blocked")?;
                     let ephemeral_timer: EphemeralTimer = row.get("ephemeral_timer")?;
@@ -1873,7 +1863,6 @@ pub async fn markseen_msgs(context: &Context, msg_ids: Vec<MsgId>) -> Result<()>
                             param,
                             from_id,
                             rfc724_mid,
-                            hidden,
                             visibility,
                             blocked.unwrap_or_default(),
                         ),
@@ -1906,7 +1895,6 @@ pub async fn markseen_msgs(context: &Context, msg_ids: Vec<MsgId>) -> Result<()>
             curr_param,
             curr_from_id,
             curr_rfc724_mid,
-            curr_hidden,
             curr_visibility,
             curr_blocked,
         ),
@@ -1919,9 +1907,8 @@ pub async fn markseen_msgs(context: &Context, msg_ids: Vec<MsgId>) -> Result<()>
 
             markseen_on_imap_table(context, &curr_rfc724_mid).await?;
 
-            // Read receipts for system messages are never sent to contacts.
-            // These messages have no place to display received read receipt
-            // anyway. And since their text is locally generated,
+            // Read receipts for system messages are never sent. These messages have no place to
+            // display received read receipt anyway.  And since their text is locally generated,
             // quoting them is dangerous as it may contain contact names. E.g., for original message
             // "Group left by me", a read receipt will quote "Group left by <name>", and the name can
             // be a display name stored in address book rather than the name sent in the From field by
@@ -1929,35 +1916,25 @@ pub async fn markseen_msgs(context: &Context, msg_ids: Vec<MsgId>) -> Result<()>
             //
             // We also don't send read receipts for contact requests.
             // Read receipts will not be sent even after accepting the chat.
-            let to_id = if curr_blocked == Blocked::Not
+            if curr_blocked == Blocked::Not
                 && curr_param.get_bool(Param::WantsMdn).unwrap_or_default()
                 && curr_param.get_cmd() == SystemMessage::Unknown
                 && context.should_send_mdns().await?
             {
-                Some(curr_from_id)
-            } else if context.get_config_bool(Config::BccSelf).await? {
-                Some(ContactId::SELF)
-            } else {
-                None
-            };
-            if let Some(to_id) = to_id {
                 context
                     .sql
                     .execute(
                         "INSERT INTO smtp_mdns (msg_id, from_id, rfc724_mid) VALUES(?, ?, ?)",
-                        (id, to_id, curr_rfc724_mid),
+                        (id, curr_from_id, curr_rfc724_mid),
                     )
                     .await
                     .context("failed to insert into smtp_mdns")?;
                 context.scheduler.interrupt_smtp().await;
             }
-            if !curr_hidden {
-                updated_chat_ids.insert(curr_chat_id);
-            }
+            updated_chat_ids.insert(curr_chat_id);
         }
-        archived_chats_maybe_noticed |= curr_state == MessageState::InFresh
-            && !curr_hidden
-            && curr_visibility == ChatVisibility::Archived;
+        archived_chats_maybe_noticed |=
+            curr_state == MessageState::InFresh && curr_visibility == ChatVisibility::Archived;
     }
 
     for updated_chat_id in updated_chat_ids {

src/mimefactory.rs

@@ -106,7 +106,6 @@ pub struct MimeFactory {
     /// addresses and OpenPGP keys
     /// to use for encryption.
     ///
-    /// If `Some`, encrypt to self also.
     /// `None` if the message is not encrypted.
     encryption_pubkeys: Option<Vec<(String, SignedPublicKey)>>,
 
@@ -235,6 +234,7 @@ impl MimeFactory {
             encryption_pubkeys = if msg.param.get_bool(Param::ForcePlaintext).unwrap_or(false) {
                 None
             } else {
+                // Encrypt, but only to self.
                 Some(Vec::new())
             };
         } else if chat.is_mailing_list() {
@@ -247,37 +247,6 @@ impl MimeFactory {
 
             // Do not encrypt messages to mailing lists.
             encryption_pubkeys = None;
-        } else if let Some(fp) = must_have_only_one_recipient(&msg, &chat) {
-            let fp = fp?;
-            // In a broadcast channel, only send member-added/removed messages
-            // to the affected member
-            let (authname, addr) = context
-                .sql
-                .query_row(
-                    "SELECT authname, addr FROM contacts WHERE fingerprint=?",
-                    (fp,),
-                    |row| {
-                        let authname: String = row.get(0)?;
-                        let addr: String = row.get(1)?;
-                        Ok((authname, addr))
-                    },
-                )
-                .await?;
-
-            let public_key_bytes: Vec<_> = context
-                .sql
-                .query_get_value(
-                    "SELECT public_key FROM public_keys WHERE fingerprint=?",
-                    (fp,),
-                )
-                .await?
-                .context("Can't send member addition/removal: missing key")?;
-
-            recipients.push(addr.clone());
-            to.push((authname, addr.clone()));
-
-            let public_key = SignedPublicKey::from_slice(&public_key_bytes)?;
-            encryption_pubkeys = Some(vec![(addr, public_key)]);
         } else {
             let email_to_remove = if msg.param.get_cmd() == SystemMessage::MemberRemovedFromGroup {
                 msg.param.get(Param::Arg)
@@ -337,6 +306,13 @@ impl MimeFactory {
                         for row in rows {
                             let (authname, addr, fingerprint, id, add_timestamp, remove_timestamp, public_key_bytes_opt) = row?;
 
+                            // In a broadcast channel, only send member-added/removed messages
+                            // to the affected member:
+                            if let Some(fp) = must_have_only_one_recipient(&msg, &chat)
+                                && fp? != fingerprint {
+                                    continue;
+                                }
+
                             let public_key_opt = if let Some(public_key_bytes) = &public_key_bytes_opt {
                                 Some(SignedPublicKey::from_slice(public_key_bytes)?)
                             } else {
@@ -450,16 +426,8 @@ impl MimeFactory {
                     },
                 )
                 .await?;
-            let recipient_ids: Vec<_> = recipient_ids
-                .into_iter()
-                .filter(|id| *id != ContactId::SELF)
-                .collect();
-            if recipient_ids.len() == 1
-                && msg.param.get_cmd() != SystemMessage::MemberRemovedFromGroup
-                && chat.typ != Chattype::OutBroadcast
-            {
-                ContactId::scaleup_origin(context, &recipient_ids, Origin::OutgoingTo).await?;
-            }
+            let recipient_ids: Vec<_> = recipient_ids.into_iter().collect();
+            ContactId::scaleup_origin(context, &recipient_ids, Origin::OutgoingTo).await?;
 
             if !msg.is_system_message()
                 && msg.param.get_int(Param::Reaction).unwrap_or_default() == 0
@@ -563,9 +531,7 @@ impl MimeFactory {
         let timestamp = create_smeared_timestamp(context);
 
         let addr = contact.get_addr().to_string();
-        let encryption_pubkeys = if from_id == ContactId::SELF {
-            Some(Vec::new())
-        } else if contact.is_key_contact() {
+        let encryption_pubkeys = if contact.is_key_contact() {
             if let Some(key) = contact.public_key(context).await? {
                 Some(vec![(addr.clone(), key)])
             } else {
@@ -1840,12 +1806,6 @@ impl MimeFactory {
                 mail_builder::headers::raw::Raw::new(b_encode(answer)).into(),
             ));
         }
-        if let Some(has_video) = msg.param.get(Param::WebrtcHasVideoInitially) {
-            headers.push((
-                "Chat-Webrtc-Has-Video-Initially",
-                mail_builder::headers::raw::Raw::new(b_encode(has_video)).into(),
-            ))
-        }
 
         if msg.viewtype == Viewtype::Voice
             || msg.viewtype == Viewtype::Audio
@@ -1940,19 +1900,15 @@ impl MimeFactory {
 
         let mut parts = Vec::new();
 
+        // add HTML-part, this is needed only if a HTML-message from a non-delta-client is forwarded;
+        // for simplificity and to avoid conversion errors, we're generating the HTML-part from the original message.
         if msg.has_html() {
-            let html = if let Some(html) = msg.param.get(Param::SendHtml) {
-                Some(html.to_string())
-            } else if let Some(orig_msg_id) = msg.param.get_int(Param::Forwarded)
-                && orig_msg_id != 0
-            {
-                // Legacy forwarded messages may not have `Param::SendHtml` set. Let's hope the
-                // original message exists.
+            let html = if let Some(orig_msg_id) = msg.param.get_int(Param::Forwarded) {
                 MsgId::new(orig_msg_id.try_into()?)
                     .get_html(context)
                     .await?
             } else {
-                None
+                msg.param.get(Param::SendHtml).map(|s| s.to_string())
             };
             if let Some(html) = html {
                 main_part = MimePart::new(

src/mimeparser.rs

@@ -89,12 +89,11 @@ pub(crate) struct MimeMessage {
     pub decrypting_failed: bool,
 
     /// Valid signature fingerprint if a message is an
-    /// Autocrypt encrypted and signed message and corresponding intended recipient fingerprints
-    /// (<https://www.rfc-editor.org/rfc/rfc9580.html#name-intended-recipient-fingerpr>) if any.
+    /// Autocrypt encrypted and signed message.
     ///
     /// If a message is not encrypted or the signature is not valid,
     /// this is `None`.
-    pub signature: Option<(Fingerprint, HashSet<Fingerprint>)>,
+    pub signature: Option<Fingerprint>,
 
     /// The addresses for which there was a gossip header
     /// and their respective gossiped keys.
@@ -496,7 +495,8 @@ impl MimeMessage {
                 // We don't decompress messages compressed multiple times.
                 None
             }
-            Some(pgp::composed::Message::Signed { reader, .. }) => reader.signature(0),
+            Some(pgp::composed::Message::SignedOnePass { reader, .. }) => reader.signature(),
+            Some(pgp::composed::Message::Signed { reader, .. }) => Some(reader.signature()),
             Some(pgp::composed::Message::Encrypted { .. }) => {
                 // The message is already decrypted once.
                 None
@@ -529,16 +529,12 @@ impl MimeMessage {
         let mut signatures = if let Some(ref decrypted_msg) = decrypted_msg {
             crate::pgp::valid_signature_fingerprints(decrypted_msg, &public_keyring)
         } else {
-            HashMap::new()
+            HashSet::new()
         };
 
         let mail = mail.as_ref().map(|mail| {
             let (content, signatures_detached) = validate_detached_signature(mail, &public_keyring)
                 .unwrap_or((mail, Default::default()));
-            let signatures_detached = signatures_detached
-                .into_iter()
-                .map(|fp| (fp, Vec::new()))
-                .collect::<HashMap<_, _>>();
             signatures.extend(signatures_detached);
             content
         });
@@ -644,10 +640,6 @@ impl MimeMessage {
             };
         }
 
-        let signature = signatures
-            .into_iter()
-            .last()
-            .map(|(fp, recipient_fps)| (fp, recipient_fps.into_iter().collect::<HashSet<_>>()));
         let mut parser = MimeMessage {
             parts: Vec::new(),
             headers,
@@ -663,7 +655,7 @@ impl MimeMessage {
             decrypting_failed: mail.is_err(),
 
             // only non-empty if it was a valid autocrypt message
-            signature,
+            signature: signatures.into_iter().last(),
             autocrypt_fingerprint,
             gossiped_keys,
             is_forwarded: false,
@@ -800,9 +792,6 @@ impl MimeMessage {
         let accepted = self
             .get_header(HeaderDef::ChatWebrtcAccepted)
             .map(|s| s.to_string());
-        let has_video = self
-            .get_header(HeaderDef::ChatWebrtcHasVideoInitially)
-            .map(|s| s.to_string());
         if let Some(part) = self.parts.first_mut() {
             if let Some(room) = room {
                 if content == "call" {
@@ -812,9 +801,6 @@ impl MimeMessage {
             } else if let Some(accepted) = accepted {
                 part.param.set(Param::WebrtcAccepted, accepted);
             }
-            if let Some(has_video) = has_video {
-                part.param.set(Param::WebrtcHasVideoInitially, has_video);
-            }
         }
     }
 
@@ -1635,7 +1621,7 @@ impl MimeMessage {
             }
             Ok(key) => key,
         };
-        if let Err(err) = key.verify_bindings() {
+        if let Err(err) = key.verify() {
             warn!(context, "Attached PGP key verification failed: {err:#}.");
             return Ok(false);
         }
@@ -2173,9 +2159,9 @@ pub(crate) struct Report {
     ///
     /// It MUST be present if the original message has a Message-ID according to RFC 8098.
     /// In case we can't find it (shouldn't happen), this is None.
-    pub original_message_id: Option<String>,
+    original_message_id: Option<String>,
     /// Additional-Message-IDs
-    pub additional_message_ids: Vec<String>,
+    additional_message_ids: Vec<String>,
 }
 
 /// Delivery Status Notification (RFC 3464, RFC 6533)
@@ -2482,23 +2468,31 @@ async fn handle_mdn(
     timestamp_sent: i64,
 ) -> Result<()> {
     if from_id == ContactId::SELF {
-        // MDNs to self are handled in receive_imf_inner().
+        warn!(
+            context,
+            "Ignoring MDN sent to self, this is a bug on the sender device."
+        );
+
+        // This is not an error on our side,
+        // we successfully ignored an invalid MDN and return `Ok`.
         return Ok(());
     }
 
     let Some((msg_id, chat_id, has_mdns, is_dup)) = context
         .sql
         .query_row_optional(
-            "SELECT
-                m.id AS msg_id,
-                c.id AS chat_id,
-                mdns.contact_id AS mdn_contact
-             FROM msgs m 
-             LEFT JOIN chats c ON m.chat_id=c.id
-             LEFT JOIN msgs_mdns mdns ON mdns.msg_id=m.id
-             WHERE rfc724_mid=? AND from_id=1
-             ORDER BY msg_id DESC, mdn_contact=? DESC
-             LIMIT 1",
+            concat!(
+                "SELECT",
+                "    m.id AS msg_id,",
+                "    c.id AS chat_id,",
+                "    mdns.contact_id AS mdn_contact",
+                " FROM msgs m ",
+                " LEFT JOIN chats c ON m.chat_id=c.id",
+                " LEFT JOIN msgs_mdns mdns ON mdns.msg_id=m.id",
+                " WHERE rfc724_mid=? AND from_id=1",
+                " ORDER BY msg_id DESC, mdn_contact=? DESC",
+                " LIMIT 1",
+            ),
             (&rfc724_mid, from_id),
             |row| {
                 let msg_id: MsgId = row.get("msg_id")?;

src/mimeparser/mimeparser_tests.rs

@@ -1,13 +1,11 @@
 use mailparse::ParsedMail;
 use std::mem;
-use std::time::Duration;
 
 use super::*;
 use crate::{
     chat,
     chatlist::Chatlist,
     constants::{self, Blocked, DC_DESIRED_TEXT_LEN, DC_ELLIPSIS},
-    key,
     message::{MessageState, MessengerMessage},
     receive_imf::receive_imf,
     test_utils::{TestContext, TestContextManager},
@@ -1422,40 +1420,6 @@ async fn test_extra_imf_headers() -> Result<()> {
     Ok(())
 }
 
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn test_intended_recipient_fingerprint() -> Result<()> {
-    let mut tcm = TestContextManager::new();
-    let t = &tcm.alice().await;
-    let t_fp = key::load_self_public_key(t).await?.dc_fingerprint();
-    t.set_config_bool(Config::BccSelf, false).await.unwrap();
-    let members = [tcm.bob().await, tcm.fiona().await];
-    let chat_id = chat::create_group(t, "").await?;
-
-    chat::send_text_msg(t, chat_id, "hi!".to_string()).await?;
-    assert!(t.pop_sent_msg_opt(Duration::ZERO).await.is_none());
-
-    for (i, member) in members.iter().enumerate() {
-        let contact = t.add_or_lookup_contact(member).await;
-        chat::add_contact_to_chat(t, chat_id, contact.id).await?;
-        let sent_msg = t.pop_sent_msg().await;
-        let (fp, recipient_fps) = t.parse_msg(&sent_msg).await.signature.unwrap();
-        assert_eq!(fp, t_fp);
-        // `mimefactory` encrypts to self unconditionally.
-        assert_eq!(recipient_fps.len(), 1 + i + 1);
-        assert!(recipient_fps.contains(&t_fp));
-        assert!(recipient_fps.contains(&contact.fingerprint().unwrap()));
-    }
-
-    t.set_config_bool(Config::BccSelf, true).await.unwrap();
-    chat::send_text_msg(t, chat_id, "hi!".to_string()).await?;
-    let sent_msg = t.pop_sent_msg().await;
-    let (fp, recipient_fps) = t.parse_msg(&sent_msg).await.signature.unwrap();
-    assert_eq!(fp, t_fp);
-    assert_eq!(recipient_fps.len(), 1 + members.len());
-    assert!(recipient_fps.contains(&t_fp));
-    Ok(())
-}
-
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_long_in_reply_to() -> Result<()> {
     let t = TestContext::new_alice().await;

src/param.rs

@@ -148,9 +148,6 @@ pub enum Param {
     /// For Messages
     WebrtcAccepted = b'7',
 
-    /// For Messages
-    WebrtcHasVideoInitially = b'z',
-
     /// For Messages: space-separated list of messaged IDs of forwarded copies.
     ///
     /// This is used when a [crate::message::Message] is in the

src/pgp.rs

@@ -1,24 +1,23 @@
 //! OpenPGP helper module using [rPGP facilities](https://github.com/rpgp/rpgp).
 
-use std::collections::{BTreeMap, HashMap, HashSet};
+use std::collections::{BTreeMap, HashSet};
 use std::io::{BufRead, Cursor};
 
 use anyhow::{Context as _, Result, bail};
+use chrono::SubsecRound;
 use deltachat_contact_tools::EmailAddress;
 use pgp::armor::BlockType;
 use pgp::composed::{
-    ArmorOptions, DecryptionOptions, Deserializable, DetachedSignature, EncryptionCaps,
-    KeyType as PgpKeyType, Message, MessageBuilder, SecretKeyParamsBuilder, SignedPublicKey,
-    SignedPublicSubKey, SignedSecretKey, SubkeyParamsBuilder, SubpacketConfig, TheRing,
+    ArmorOptions, DecryptionOptions, Deserializable, DetachedSignature, KeyType as PgpKeyType,
+    Message, MessageBuilder, SecretKeyParamsBuilder, SignedPublicKey, SignedPublicSubKey,
+    SignedSecretKey, SubkeyParamsBuilder, TheRing,
 };
 use pgp::crypto::aead::{AeadAlgorithm, ChunkSize};
 use pgp::crypto::ecc_curve::ECCCurve;
 use pgp::crypto::hash::HashAlgorithm;
 use pgp::crypto::sym::SymmetricKeyAlgorithm;
 use pgp::packet::{SignatureConfig, SignatureType, Subpacket, SubpacketData};
-use pgp::types::{
-    CompressionAlgorithm, KeyDetails, KeyVersion, Password, SigningKey as _, StringToKey,
-};
+use pgp::types::{CompressionAlgorithm, KeyDetails, Password, PublicKeyTrait, StringToKey};
 use rand_old::{Rng as _, thread_rng};
 use tokio::runtime::Handle;
 
@@ -32,6 +31,9 @@ pub(crate) const HEADER_SETUPCODE: &str = "passphrase-begin";
 /// Preferred symmetric encryption algorithm.
 const SYMMETRIC_KEY_ALGORITHM: SymmetricKeyAlgorithm = SymmetricKeyAlgorithm::AES128;
 
+/// Preferred cryptographic hash.
+const HASH_ALGORITHM: HashAlgorithm = HashAlgorithm::Sha256;
+
 /// Split data from PGP Armored Data as defined in <https://tools.ietf.org/html/rfc4880#section-6.2>.
 ///
 /// Returns (type, headers, base64 encoded body).
@@ -81,7 +83,9 @@ impl KeyPair {
     ///
     /// Public key is split off the secret key.
     pub fn new(secret: SignedSecretKey) -> Result<Self> {
-        let public = secret.to_public_key();
+        use crate::key::DcSecretKey;
+
+        let public = secret.split_public_key()?;
         Ok(Self { public, secret })
     }
 }
@@ -119,7 +123,7 @@ pub(crate) fn create_keypair(addr: EmailAddress) -> Result<KeyPair> {
         .subkey(
             SubkeyParamsBuilder::default()
                 .key_type(encryption_key_type)
-                .can_encrypt(EncryptionCaps::All)
+                .can_encrypt(true)
                 .passphrase(None)
                 .build()
                 .context("failed to build subkey parameters")?,
@@ -130,16 +134,18 @@ pub(crate) fn create_keypair(addr: EmailAddress) -> Result<KeyPair> {
     let mut rng = thread_rng();
     let secret_key = key_params
         .generate(&mut rng)
-        .context("Failed to generate the key")?;
+        .context("failed to generate the key")?
+        .sign(&mut rng, &Password::empty())
+        .context("failed to sign secret key")?;
     secret_key
-        .verify_bindings()
-        .context("Invalid secret key generated")?;
+        .verify()
+        .context("invalid secret key generated")?;
 
     let key_pair = KeyPair::new(secret_key)?;
     key_pair
         .public
-        .verify_bindings()
-        .context("Invalid public key generated")?;
+        .verify()
+        .context("invalid public key generated")?;
     Ok(key_pair)
 }
 
@@ -151,7 +157,7 @@ pub(crate) fn create_keypair(addr: EmailAddress) -> Result<KeyPair> {
 fn select_pk_for_encryption(key: &SignedPublicKey) -> Option<&SignedPublicSubKey> {
     key.public_subkeys
         .iter()
-        .find(|subkey| subkey.algorithm().can_encrypt())
+        .find(|subkey| subkey.is_encryption_key())
 }
 
 /// Version of SEIPD packet to use.
@@ -185,36 +191,6 @@ pub async fn pk_encrypt(
             let pkeys = public_keys_for_encryption
                 .iter()
                 .filter_map(select_pk_for_encryption);
-            let subpkts = {
-                let mut hashed = Vec::with_capacity(1 + public_keys_for_encryption.len() + 1);
-                hashed.push(Subpacket::critical(SubpacketData::SignatureCreationTime(
-                    pgp::types::Timestamp::now(),
-                ))?);
-                // Test "elena" uses old Delta Chat.
-                let skip = private_key_for_signing.dc_fingerprint().hex()
-                    == "B86586B6DEF437D674BFAFC02A6B2EBC633B9E82";
-                for key in &public_keys_for_encryption {
-                    if skip {
-                        break;
-                    }
-                    let data = SubpacketData::IntendedRecipientFingerprint(key.fingerprint());
-                    let subpkt = match private_key_for_signing.version() < KeyVersion::V6 {
-                        true => Subpacket::regular(data)?,
-                        false => Subpacket::critical(data)?,
-                    };
-                    hashed.push(subpkt);
-                }
-                hashed.push(Subpacket::regular(SubpacketData::IssuerFingerprint(
-                    private_key_for_signing.fingerprint(),
-                ))?);
-                let mut unhashed = vec![];
-                if private_key_for_signing.version() <= KeyVersion::V4 {
-                    unhashed.push(Subpacket::regular(SubpacketData::IssuerKeyId(
-                        private_key_for_signing.legacy_key_id(),
-                    ))?);
-                }
-                SubpacketConfig::UserDefined { hashed, unhashed }
-            };
 
             let msg = MessageBuilder::from_bytes("", plain);
             let encoded_msg = match seipd_version {
@@ -229,13 +205,7 @@ pub async fn pk_encrypt(
                         }
                     }
 
-                    let hash_algorithm = private_key_for_signing.hash_alg();
-                    msg.sign_with_subpackets(
-                        &*private_key_for_signing,
-                        Password::empty(),
-                        hash_algorithm,
-                        subpkts,
-                    );
+                    msg.sign(&*private_key_for_signing, Password::empty(), HASH_ALGORITHM);
                     if compress {
                         msg.compression(CompressionAlgorithm::ZLIB);
                     }
@@ -258,13 +228,7 @@ pub async fn pk_encrypt(
                         }
                     }
 
-                    let hash_algorithm = private_key_for_signing.hash_alg();
-                    msg.sign_with_subpackets(
-                        &*private_key_for_signing,
-                        Password::empty(),
-                        hash_algorithm,
-                        subpkts,
-                    );
+                    msg.sign(&*private_key_for_signing, Password::empty(), HASH_ALGORITHM);
                     if compress {
                         msg.compression(CompressionAlgorithm::ZLIB);
                     }
@@ -296,17 +260,12 @@ pub fn pk_calc_signature(
             private_key_for_signing.fingerprint(),
         ))?,
         Subpacket::critical(SubpacketData::SignatureCreationTime(
-            pgp::types::Timestamp::now(),
+            chrono::Utc::now().trunc_subsecs(0),
         ))?,
     ];
-    config.unhashed_subpackets = vec![];
-    if private_key_for_signing.version() <= KeyVersion::V4 {
-        config
-            .unhashed_subpackets
-            .push(Subpacket::regular(SubpacketData::IssuerKeyId(
-                private_key_for_signing.legacy_key_id(),
-            ))?);
-    }
+    config.unhashed_subpackets = vec![Subpacket::regular(SubpacketData::Issuer(
+        private_key_for_signing.key_id(),
+    ))?];
 
     let signature = config.sign(
         &private_key_for_signing.primary_key,
@@ -410,28 +369,19 @@ fn check_symmetric_encryption(msg: &Message<'_>) -> std::result::Result<(), &'st
 
 /// Returns fingerprints
 /// of all keys from the `public_keys_for_validation` keyring that
-/// have valid signatures in `msg` and corresponding intended recipient fingerprints
-/// (<https://www.rfc-editor.org/rfc/rfc9580.html#name-intended-recipient-fingerpr>) if any.
+/// have valid signatures there.
 ///
-/// If the message is wrongly signed, returns an empty map.
+/// If the message is wrongly signed, HashSet will be empty.
 pub fn valid_signature_fingerprints(
     msg: &pgp::composed::Message,
     public_keys_for_validation: &[SignedPublicKey],
-) -> HashMap<Fingerprint, Vec<Fingerprint>> {
-    let mut ret_signature_fingerprints = HashMap::new();
+) -> HashSet<Fingerprint> {
+    let mut ret_signature_fingerprints: HashSet<Fingerprint> = Default::default();
     if msg.is_signed() {
         for pkey in public_keys_for_validation {
-            if let Ok(signature) = msg.verify(&pkey.primary_key) {
+            if msg.verify(&pkey.primary_key).is_ok() {
                 let fp = pkey.dc_fingerprint();
-                let mut recipient_fps = Vec::new();
-                if let Some(cfg) = signature.config() {
-                    for subpkt in &cfg.hashed_subpackets {
-                        if let SubpacketData::IntendedRecipientFingerprint(fp) = &subpkt.data {
-                            recipient_fps.push(fp.clone().into());
-                        }
-                    }
-                }
-                ret_signature_fingerprints.insert(fp, recipient_fps);
+                ret_signature_fingerprints.insert(fp);
             }
         }
     }
@@ -503,8 +453,7 @@ pub async fn symm_encrypt_message(
         );
         msg.encrypt_with_password(&mut rng, s2k, &shared_secret)?;
 
-        let hash_algorithm = private_key_for_signing.hash_alg();
-        msg.sign(&*private_key_for_signing, Password::empty(), hash_algorithm);
+        msg.sign(&*private_key_for_signing, Password::empty(), HASH_ALGORITHM);
         if compress {
             msg.compression(CompressionAlgorithm::ZLIB);
         }
@@ -546,14 +495,13 @@ mod tests {
     use pgp::composed::Esk;
     use pgp::packet::PublicKeyEncryptedSessionKey;
 
-    #[expect(clippy::type_complexity)]
     fn pk_decrypt_and_validate<'a>(
         ctext: &'a [u8],
         private_keys_for_decryption: &'a [SignedSecretKey],
         public_keys_for_validation: &[SignedPublicKey],
     ) -> Result<(
         pgp::composed::Message<'static>,
-        HashMap<Fingerprint, Vec<Fingerprint>>,
+        HashSet<Fingerprint>,
         Vec<u8>,
     )> {
         let mut msg = decrypt(ctext.to_vec(), private_keys_for_decryption, &[])?;
@@ -661,7 +609,7 @@ mod tests {
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_decrypt_signed() {
+    async fn test_decrypt_singed() {
         // Check decrypting as Alice
         let decrypt_keyring = vec![KEYS.alice_secret.clone()];
         let sig_check_keyring = vec![KEYS.alice_public.clone()];
@@ -673,9 +621,6 @@ mod tests {
         .unwrap();
         assert_eq!(content, CLEARTEXT);
         assert_eq!(valid_signatures.len(), 1);
-        for recipient_fps in valid_signatures.values() {
-            assert_eq!(recipient_fps.len(), 2);
-        }
 
         // Check decrypting as Bob
         let decrypt_keyring = vec![KEYS.bob_secret.clone()];
@@ -688,9 +633,6 @@ mod tests {
         .unwrap();
         assert_eq!(content, CLEARTEXT);
         assert_eq!(valid_signatures.len(), 1);
-        for recipient_fps in valid_signatures.values() {
-            assert_eq!(recipient_fps.len(), 2);
-        }
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]

src/provider.rs

@@ -145,7 +145,6 @@ pub struct Provider {
 
 /// Provider options with good defaults.
 #[derive(Debug, PartialEq, Eq)]
-#[non_exhaustive]
 pub struct ProviderOptions {
     /// True if provider is known to use use proper,
     /// not self-signed certificates.
@@ -153,6 +152,9 @@ pub struct ProviderOptions {
 
     /// Maximum number of recipients the provider allows to send a single email to.
     pub max_smtp_rcpt_to: Option<u16>,
+
+    /// Move messages to the Trash folder instead of marking them "\Deleted".
+    pub delete_to_trash: bool,
 }
 
 impl ProviderOptions {
@@ -160,6 +162,7 @@ impl ProviderOptions {
         Self {
             strict_tls: true,
             max_smtp_rcpt_to: None,
+            delete_to_trash: false,
         }
     }
 }

src/provider/data.rs

@@ -505,10 +505,16 @@ static P_FIVE_CHAT: Provider = Provider {
     overview_page: "https://providers.delta.chat/five-chat",
     server: &[],
     opt: ProviderOptions::new(),
-    config_defaults: Some(&[ConfigDefault {
-        key: Config::BccSelf,
-        value: "1",
-    }]),
+    config_defaults: Some(&[
+        ConfigDefault {
+            key: Config::BccSelf,
+            value: "1",
+        },
+        ConfigDefault {
+            key: Config::MvboxMove,
+            value: "0",
+        },
+    ]),
     oauth2_authorizer: None,
 };
 
@@ -558,7 +564,7 @@ static P_FREENET_DE: Provider = Provider {
 static P_GMAIL: Provider = Provider {
     id: "gmail",
     status: Status::Preparation,
-    before_login_hint: "For Gmail accounts, you need to have \"2-Step Verification\" enabled and create an app-password. Gmail limits how many messages you can send per day.",
+    before_login_hint: "For Gmail accounts, you need to have \"2-Step Verification\" enabled and create an app-password.",
     after_login_hint: "",
     overview_page: "https://providers.delta.chat/gmail",
     server: &[
@@ -577,7 +583,10 @@ static P_GMAIL: Provider = Provider {
             username_pattern: Email,
         },
     ],
-    opt: ProviderOptions::new(),
+    opt: ProviderOptions {
+        delete_to_trash: true,
+        ..ProviderOptions::new()
+    },
     config_defaults: None,
     oauth2_authorizer: None,
 };
@@ -1071,6 +1080,10 @@ static P_NAUTA_CU: Provider = Provider {
             key: Config::DeleteServerAfter,
             value: "1",
         },
+        ConfigDefault {
+            key: Config::MvboxMove,
+            value: "0",
+        },
         ConfigDefault {
             key: Config::MediaQuality,
             value: "1",
@@ -1159,7 +1172,10 @@ static P_NINE_TESTRUN_ORG: Provider = Provider {
         },
     ],
     opt: ProviderOptions::new(),
-    config_defaults: None,
+    config_defaults: Some(&[ConfigDefault {
+        key: Config::MvboxMove,
+        value: "0",
+    }]),
     oauth2_authorizer: None,
 };
 
@@ -1600,10 +1616,16 @@ static P_TESTRUN: Provider = Provider {
         },
     ],
     opt: ProviderOptions::new(),
-    config_defaults: Some(&[ConfigDefault {
-        key: Config::BccSelf,
-        value: "1",
-    }]),
+    config_defaults: Some(&[
+        ConfigDefault {
+            key: Config::BccSelf,
+            value: "1",
+        },
+        ConfigDefault {
+            key: Config::MvboxMove,
+            value: "0",
+        },
+    ]),
     oauth2_authorizer: None,
 };
 
@@ -1944,7 +1966,10 @@ static P_YGGMAIL: Provider = Provider {
         },
     ],
     opt: ProviderOptions::new(),
-    config_defaults: None,
+    config_defaults: Some(&[ConfigDefault {
+        key: Config::MvboxMove,
+        value: "0",
+    }]),
     oauth2_authorizer: None,
 };
 
@@ -2622,4 +2647,4 @@ pub(crate) static PROVIDER_IDS: LazyLock<HashMap<&'static str, &'static Provider
     });
 
 pub static _PROVIDER_UPDATED: LazyLock<chrono::NaiveDate> =
-    LazyLock::new(|| chrono::NaiveDate::from_ymd_opt(2026, 1, 28).unwrap());
+    LazyLock::new(|| chrono::NaiveDate::from_ymd_opt(2025, 9, 10).unwrap());

src/qr/dclogin_scheme.rs

@@ -59,12 +59,14 @@ pub enum LoginOptions {
 /// scheme: `dclogin://user@host/?p=password&v=1[&options]`
 /// read more about the scheme at <https://github.com/deltachat/interface/blob/master/uri-schemes.md#DCLOGIN>
 pub(super) fn decode_login(qr: &str) -> Result<Qr> {
-    let qr = qr.replacen("://", ":", 1);
+    let url = url::Url::parse(qr).with_context(|| format!("Malformed url: {qr:?}"))?;
 
-    let url = url::Url::parse(&qr).with_context(|| format!("Malformed url: {qr:?}"))?;
-    let payload = qr
+    let url_without_scheme = qr
         .get(DCLOGIN_SCHEME.len()..)
         .context("invalid DCLOGIN payload E1")?;
+    let payload = url_without_scheme
+        .strip_prefix("//")
+        .unwrap_or(url_without_scheme);
 
     let addr = payload
         .split(['?', '/'])
@@ -363,32 +365,4 @@ mod test {
         }
         Ok(())
     }
-
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_decode_dclogin_ipv4() -> anyhow::Result<()> {
-        let result = decode_login("dclogin://test@[127.0.0.1]?p=1234&v=1")?;
-        if let Qr::Login { address, options } = result {
-            assert_eq!(address, "test@[127.0.0.1]".to_owned());
-            assert_eq!(options, login_options_just_pw!("1234".to_owned()));
-        } else {
-            unreachable!("wrong type");
-        }
-        Ok(())
-    }
-
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_decode_dclogin_ipv6() -> anyhow::Result<()> {
-        let result =
-            decode_login("dclogin://test@[2001:0db8:85a3:0000:0000:8a2e:0370:7334]?p=1234&v=1")?;
-        if let Qr::Login { address, options } = result {
-            assert_eq!(
-                address,
-                "test@[2001:0db8:85a3:0000:0000:8a2e:0370:7334]".to_owned()
-            );
-            assert_eq!(options, login_options_just_pw!("1234".to_owned()));
-        } else {
-            unreachable!("wrong type");
-        }
-        Ok(())
-    }
 }

src/quota.rs

@@ -9,7 +9,7 @@ use async_imap::types::{Quota, QuotaResource};
 use crate::chat::add_device_msg_with_importance;
 use crate::config::Config;
 use crate::context::Context;
-use crate::imap::get_watched_folders;
+use crate::imap::scan_folders::get_watched_folders;
 use crate::imap::session::Session as ImapSession;
 use crate::log::warn;
 use crate::message::Message;

src/reaction.rs

@@ -747,23 +747,13 @@ Content-Disposition: reaction\n\
             alice_reaction_msg.id.get_state(&alice).await?,
             MessageState::InSeen
         );
-        // Reactions don't request MDNs, but an MDN to self is sent.
+        // Reactions don't request MDNs.
         assert_eq!(
             alice
                 .sql
                 .count("SELECT COUNT(*) FROM smtp_mdns", ())
                 .await?,
-            1
-        );
-        assert_eq!(
-            alice
-                .sql
-                .count(
-                    "SELECT COUNT(*) FROM smtp_mdns WHERE from_id=?",
-                    (ContactId::SELF,)
-                )
-                .await?,
-            1
+            0
         );
 
         // Alice reacts to own message.

src/receive_imf.rs

@@ -1,6 +1,5 @@
 //! Internet Message Format reception pipeline.
 
-use std::cmp;
 use std::collections::{BTreeMap, BTreeSet, HashSet};
 use std::iter;
 use std::sync::LazyLock;
@@ -15,7 +14,7 @@ use mailparse::SingleInfo;
 use num_traits::FromPrimitive;
 use regex::Regex;
 
-use crate::chat::{self, Chat, ChatId, ChatIdBlocked, ChatVisibility, save_broadcast_secret};
+use crate::chat::{self, Chat, ChatId, ChatIdBlocked, save_broadcast_secret};
 use crate::config::Config;
 use crate::constants::{self, Blocked, Chattype, DC_CHAT_ID_TRASH, EDITED_PREFIX, ShowEmails};
 use crate::contact::{self, Contact, ContactId, Origin, mark_contact_id_as_verified};
@@ -27,9 +26,7 @@ use crate::events::EventType;
 use crate::headerdef::{HeaderDef, HeaderDefMap};
 use crate::imap::{GENERATED_PREFIX, markseen_on_imap_table};
 use crate::key::{DcKey, Fingerprint};
-use crate::key::{
-    load_self_public_key, load_self_public_key_opt, self_fingerprint, self_fingerprint_opt,
-};
+use crate::key::{self_fingerprint, self_fingerprint_opt};
 use crate::log::{LogExt as _, warn};
 use crate::message::{
     self, Message, MessageState, MessengerMessage, MsgId, Viewtype, rfc724_mid_exists,
@@ -198,7 +195,7 @@ async fn insert_tombstone(context: &Context, rfc724_mid: &str) -> Result<MsgId>
 async fn get_to_and_past_contact_ids(
     context: &Context,
     mime_parser: &MimeMessage,
-    chat_assignment: &mut ChatAssignment,
+    chat_assignment: &ChatAssignment,
     parent_message: &Option<Message>,
     incoming_origin: Origin,
 ) -> Result<(Vec<Option<ContactId>>, Vec<Option<ContactId>>)> {
@@ -284,7 +281,7 @@ async fn get_to_and_past_contact_ids(
             .await?;
 
             if let Some(chat_id) = chat_id {
-                past_ids = lookup_key_contacts_fallback_to_chat(
+                past_ids = lookup_key_contacts_by_address_list(
                     context,
                     &mime_parser.past_members,
                     past_member_fingerprints,
@@ -317,7 +314,7 @@ async fn get_to_and_past_contact_ids(
                     Origin::Hidden,
                 )
                 .await?;
-                past_ids = lookup_key_contacts_fallback_to_chat(
+                past_ids = lookup_key_contacts_by_address_list(
                     context,
                     &mime_parser.past_members,
                     past_member_fingerprints,
@@ -387,58 +384,54 @@ async fn get_to_and_past_contact_ids(
                 // mapped it to a key contact.
                 // This is an encrypted 1:1 chat.
                 to_ids = pgp_to_ids
-            } else {
-                let ids = if mime_parser.was_encrypted() {
-                    let mut recipient_fps = mime_parser
-                        .signature
-                        .as_ref()
-                        .map(|(_, recipient_fps)| recipient_fps.iter().cloned().collect::<Vec<_>>())
-                        .unwrap_or_default();
-                    // If there are extra recipient fingerprints, it may be a non-chat "implicit
-                    // Bcc" message. Fall back to in-chat lookup if so.
-                    if !recipient_fps.is_empty() && recipient_fps.len() <= 2 {
-                        let self_fp = load_self_public_key(context).await?.dc_fingerprint();
-                        recipient_fps.retain(|fp| *fp != self_fp);
-                        if recipient_fps.is_empty() {
-                            vec![Some(ContactId::SELF)]
-                        } else {
-                            add_or_lookup_key_contacts(
-                                context,
-                                &mime_parser.recipients,
-                                &mime_parser.gossiped_keys,
-                                &recipient_fps,
-                                Origin::Hidden,
-                            )
-                            .await?
-                        }
-                    } else {
-                        lookup_key_contacts_fallback_to_chat(
+            } else if let Some(chat_id) = chat_id {
+                to_ids = match mime_parser.was_encrypted() {
+                    true => {
+                        lookup_key_contacts_by_address_list(
                             context,
                             &mime_parser.recipients,
                             to_member_fingerprints,
-                            chat_id,
+                            Some(chat_id),
                         )
                         .await?
                     }
-                } else {
-                    vec![]
+                    false => {
+                        add_or_lookup_contacts_by_address_list(
+                            context,
+                            &mime_parser.recipients,
+                            if !mime_parser.incoming {
+                                Origin::OutgoingTo
+                            } else if incoming_origin.is_known() {
+                                Origin::IncomingTo
+                            } else {
+                                Origin::IncomingUnknownTo
+                            },
+                        )
+                        .await?
+                    }
+                }
+            } else {
+                let ids = match mime_parser.was_encrypted() {
+                    true => {
+                        lookup_key_contacts_by_address_list(
+                            context,
+                            &mime_parser.recipients,
+                            to_member_fingerprints,
+                            None,
+                        )
+                        .await?
+                    }
+                    false => vec![],
                 };
                 if mime_parser.was_encrypted() && !ids.contains(&None)
                 // Prefer creating PGP chats if there are any key-contacts. At least this prevents
-                // from replying unencrypted. Otherwise downgrade to a non-replyable ad-hoc group.
+                // from replying unencrypted.
                 || ids
                     .iter()
                     .any(|&c| c.is_some() && c != Some(ContactId::SELF))
                 {
                     to_ids = ids;
                 } else {
-                    if mime_parser.was_encrypted() {
-                        warn!(
-                            context,
-                            "No key-contact looked up. Downgrading to AdHocGroup."
-                        );
-                        *chat_assignment = ChatAssignment::AdHocGroup;
-                    }
                     to_ids = add_or_lookup_contacts_by_address_list(
                         context,
                         &mime_parser.recipients,
@@ -494,18 +487,6 @@ pub(crate) async fn receive_imf_inner(
         );
     }
 
-    let trash = || async {
-        let msg_ids = vec![insert_tombstone(context, rfc724_mid).await?];
-        Ok(Some(ReceivedMsg {
-            chat_id: DC_CHAT_ID_TRASH,
-            state: MessageState::Undefined,
-            hidden: false,
-            sort_timestamp: 0,
-            msg_ids,
-            needs_delete_job: false,
-        }))
-    };
-
     let mut mime_parser = match MimeMessage::from_bytes(context, imf_raw).await {
         Err(err) => {
             warn!(context, "receive_imf: can't parse MIME: {err:#}.");
@@ -513,7 +494,17 @@ pub(crate) async fn receive_imf_inner(
                 // We don't have an rfc724_mid, there's no point in adding a trash entry
                 return Ok(None);
             }
-            return trash().await;
+
+            let msg_ids = vec![insert_tombstone(context, rfc724_mid).await?];
+
+            return Ok(Some(ReceivedMsg {
+                chat_id: DC_CHAT_ID_TRASH,
+                state: MessageState::Undefined,
+                hidden: false,
+                sort_timestamp: 0,
+                msg_ids,
+                needs_delete_job: false,
+            }));
         }
         Ok(mime_parser) => mime_parser,
     };
@@ -521,18 +512,6 @@ pub(crate) async fn receive_imf_inner(
     let rfc724_mid_orig = &mime_parser
         .get_rfc724_mid()
         .unwrap_or(rfc724_mid.to_string());
-
-    if let Some((_, recipient_fps)) = &mime_parser.signature
-        && !recipient_fps.is_empty()
-        && let Some(self_pubkey) = load_self_public_key_opt(context).await?
-        && !recipient_fps.contains(&self_pubkey.dc_fingerprint())
-    {
-        warn!(
-            context,
-            "Message {rfc724_mid_orig:?} is not intended for us (TRASH)."
-        );
-        return trash().await;
-    }
     info!(
         context,
         "Receiving message {rfc724_mid_orig:?}, seen={seen}...",
@@ -616,7 +595,7 @@ pub(crate) async fn receive_imf_inner(
     // For example, GitHub sends messages from `notifications@github.com`,
     // but uses display name of the user whose action generated the notification
     // as the display name.
-    let fingerprint = mime_parser.signature.as_ref().map(|(fp, _)| fp);
+    let fingerprint = mime_parser.signature.as_ref();
     let (from_id, _from_id_blocked, incoming_origin) = match from_field_to_contact_id(
         context,
         &mime_parser.from,
@@ -654,12 +633,14 @@ pub(crate) async fn receive_imf_inner(
     .await?
     .filter(|p| Some(p.id) != replace_msg_id);
 
-    let mut chat_assignment =
+    let chat_assignment =
         decide_chat_assignment(context, &mime_parser, &parent_message, rfc724_mid, from_id).await?;
+    info!(context, "Chat assignment is {chat_assignment:?}.");
+
     let (to_ids, past_ids) = get_to_and_past_contact_ids(
         context,
         &mime_parser,
-        &mut chat_assignment,
+        &chat_assignment,
         &parent_message,
         incoming_origin,
     )
@@ -952,7 +933,7 @@ UPDATE config SET value=? WHERE keyname='configured_addr' AND value!=?1
 
     if !received_msg.msg_ids.is_empty() {
         let target = if received_msg.needs_delete_job || delete_server_after == Some(0) {
-            Some("".to_string())
+            Some(context.get_delete_msgs_target().await?)
         } else {
             None
         };
@@ -979,74 +960,6 @@ UPDATE config SET value=? WHERE keyname='configured_addr' AND value!=?1
             // This is a Delta Chat MDN. Mark as read.
             markseen_on_imap_table(context, rfc724_mid_orig).await?;
         }
-        if !mime_parser.incoming && !context.get_config_bool(Config::TeamProfile).await? {
-            let mut updated_chats = BTreeMap::new();
-            let mut archived_chats_maybe_noticed = false;
-            for report in &mime_parser.mdn_reports {
-                for msg_rfc724_mid in report
-                    .original_message_id
-                    .iter()
-                    .chain(&report.additional_message_ids)
-                {
-                    let Some(msg_id) = rfc724_mid_exists(context, msg_rfc724_mid).await? else {
-                        continue;
-                    };
-                    let Some(msg) = Message::load_from_db_optional(context, msg_id).await? else {
-                        continue;
-                    };
-                    if msg.state < MessageState::InFresh || msg.state >= MessageState::InSeen {
-                        continue;
-                    }
-                    if !mime_parser.was_encrypted() && msg.get_showpadlock() {
-                        warn!(context, "MDN: Not encrypted. Ignoring.");
-                        continue;
-                    }
-                    message::update_msg_state(context, msg_id, MessageState::InSeen).await?;
-                    if let Err(e) = msg_id.start_ephemeral_timer(context).await {
-                        error!(context, "start_ephemeral_timer for {msg_id}: {e:#}.");
-                    }
-                    if !mime_parser.has_chat_version() {
-                        continue;
-                    }
-                    archived_chats_maybe_noticed |= msg.state < MessageState::InNoticed
-                        && msg.chat_visibility == ChatVisibility::Archived;
-                    updated_chats
-                        .entry(msg.chat_id)
-                        .and_modify(|ts| *ts = cmp::max(*ts, msg.timestamp_sort))
-                        .or_insert(msg.timestamp_sort);
-                }
-            }
-            for (chat_id, timestamp_sort) in updated_chats {
-                context
-                    .sql
-                    .execute(
-                        "
-UPDATE msgs SET state=? WHERE
-    state=? AND
-    hidden=0 AND
-    chat_id=? AND
-    timestamp<?",
-                        (
-                            MessageState::InNoticed,
-                            MessageState::InFresh,
-                            chat_id,
-                            timestamp_sort,
-                        ),
-                    )
-                    .await
-                    .context("UPDATE msgs.state")?;
-                if chat_id.get_fresh_msg_cnt(context).await? == 0 {
-                    // Removes all notifications for the chat in UIs.
-                    context.emit_event(EventType::MsgsNoticed(chat_id));
-                } else {
-                    context.emit_msgs_changed_without_msg_id(chat_id);
-                }
-                chatlist_events::emit_chatlist_item_changed(context, chat_id);
-            }
-            if archived_chats_maybe_noticed {
-                context.on_archived_chats_maybe_noticed();
-            }
-        }
     }
 
     if mime_parser.is_call() {
@@ -1331,34 +1244,17 @@ async fn decide_chat_assignment(
     if from_id != ContactId::SELF && !has_self_addr {
         num_recipients += 1;
     }
-    let mut can_be_11_chat_log = String::new();
-    let mut l = |cond: bool, s: String| {
-        can_be_11_chat_log += &s;
-        cond
-    };
-    let can_be_11_chat = l(
-        num_recipients <= 1,
-        format!("num_recipients={num_recipients}."),
-    ) && (l(from_id != ContactId::SELF, format!(" from_id={from_id}."))
-        || !(l(
-            mime_parser.recipients.is_empty(),
-            format!(" Raw recipients len={}.", mime_parser.recipients.len()),
-        ) || l(has_self_addr, format!(" has_self_addr={has_self_addr}.")))
-        || l(
-            mime_parser.was_encrypted(),
-            format!(" was_encrypted={}.", mime_parser.was_encrypted()),
-        ));
+    let can_be_11_chat = num_recipients <= 1
+        && (from_id != ContactId::SELF
+            || !(mime_parser.recipients.is_empty() || has_self_addr)
+            || mime_parser.was_encrypted());
 
-    let chat_assignment_log;
     let chat_assignment = if should_trash {
-        chat_assignment_log = "".to_string();
         ChatAssignment::Trash
     } else if mime_parser.get_mailinglist_header().is_some() {
-        chat_assignment_log = "Mailing list header found.".to_string();
         ChatAssignment::MailingListOrBroadcast
     } else if let Some(grpid) = mime_parser.get_chat_group_id() {
         if mime_parser.was_encrypted() {
-            chat_assignment_log = "Encrypted group message.".to_string();
             ChatAssignment::GroupChat {
                 grpid: grpid.to_string(),
             }
@@ -1367,13 +1263,11 @@ async fn decide_chat_assignment(
                 lookup_chat_by_reply(context, mime_parser, parent).await?
             {
                 // Try to assign to a chat based on In-Reply-To/References.
-                chat_assignment_log = "Unencrypted group reply.".to_string();
                 ChatAssignment::ExistingChat {
                     chat_id,
                     chat_id_blocked,
                 }
             } else {
-                chat_assignment_log = "Unencrypted group reply.".to_string();
                 ChatAssignment::AdHocGroup
             }
         } else {
@@ -1384,7 +1278,6 @@ async fn decide_chat_assignment(
             // even if it had only two members.
             //
             // Group ID is ignored, however.
-            chat_assignment_log = "Unencrypted group message, no parent.".to_string();
             ChatAssignment::AdHocGroup
         }
     } else if let Some(parent) = &parent_message {
@@ -1392,38 +1285,24 @@ async fn decide_chat_assignment(
             lookup_chat_by_reply(context, mime_parser, parent).await?
         {
             // Try to assign to a chat based on In-Reply-To/References.
-            chat_assignment_log = "Reply w/o grpid.".to_string();
             ChatAssignment::ExistingChat {
                 chat_id,
                 chat_id_blocked,
             }
         } else if mime_parser.get_header(HeaderDef::ChatGroupName).is_some() {
-            chat_assignment_log = "Reply with Chat-Group-Name.".to_string();
             ChatAssignment::AdHocGroup
         } else if can_be_11_chat {
-            chat_assignment_log = format!("Non-group reply. {can_be_11_chat_log}");
             ChatAssignment::OneOneChat
         } else {
-            chat_assignment_log = format!("Non-group reply. {can_be_11_chat_log}");
             ChatAssignment::AdHocGroup
         }
     } else if mime_parser.get_header(HeaderDef::ChatGroupName).is_some() {
-        chat_assignment_log = "Message with Chat-Group-Name, no parent.".to_string();
         ChatAssignment::AdHocGroup
     } else if can_be_11_chat {
-        chat_assignment_log = format!("Non-group message, no parent. {can_be_11_chat_log}");
         ChatAssignment::OneOneChat
     } else {
-        chat_assignment_log = format!("Non-group message, no parent. {can_be_11_chat_log}");
         ChatAssignment::AdHocGroup
     };
-
-    if !chat_assignment_log.is_empty() {
-        info!(
-            context,
-            "{chat_assignment_log} Chat assignment = {chat_assignment:?}."
-        );
-    }
     Ok(chat_assignment)
 }
 
@@ -1817,6 +1696,8 @@ async fn add_parts(
     }
 
     let is_location_kml = mime_parser.location_kml.is_some();
+    let is_mdn = !mime_parser.mdn_reports.is_empty();
+
     let mut group_changes = match chat.typ {
         _ if chat.id.is_special() => GroupChangesInfo::default(),
         Chattype::Single => GroupChangesInfo::default(),
@@ -1852,10 +1733,7 @@ async fn add_parts(
 
     let state = if !mime_parser.incoming {
         MessageState::OutDelivered
-    } else if seen
-        || !mime_parser.mdn_reports.is_empty()
-        || chat_id_blocked == Blocked::Yes
-        || group_changes.silent
+    } else if seen || is_mdn || chat_id_blocked == Blocked::Yes || group_changes.silent
     // No check for `hidden` because only reactions are such and they should be `InFresh`.
     {
         MessageState::InSeen
@@ -2373,13 +2251,19 @@ RETURNING id
         }
     }
 
+    // Normally outgoing MDNs sent by us never appear in mailboxes, but Gmail saves all
+    // outgoing messages, including MDNs, to the Sent folder. If we detect such saved MDN,
+    // delete it.
+    let needs_delete_job =
+        !mime_parser.incoming && is_mdn && is_dc_message == MessengerMessage::Yes;
+
     Ok(ReceivedMsg {
         chat_id,
         state,
         hidden,
         sort_timestamp,
         msg_ids: created_db_entries,
-        needs_delete_job: false,
+        needs_delete_job,
     })
 }
 
@@ -2718,9 +2602,6 @@ async fn lookup_or_create_adhoc_group(
     let to_ids: Vec<ContactId> = to_ids.iter().filter_map(|x| *x).collect();
     let mut contact_ids = BTreeSet::<ContactId>::from_iter(to_ids.iter().copied());
     contact_ids.insert(from_id);
-    if mime_parser.was_encrypted() {
-        contact_ids.remove(&ContactId::SELF);
-    }
     let trans_fn = |t: &mut rusqlite::Transaction| {
         t.pragma_update(None, "query_only", "0")?;
         t.execute(
@@ -3028,8 +2909,6 @@ async fn apply_group_changes(
     to_ids: &[Option<ContactId>],
     past_ids: &[Option<ContactId>],
 ) -> Result<GroupChangesInfo> {
-    let from_is_key_contact = Contact::get_by_id(context, from_id).await?.is_key_contact();
-    ensure!(from_is_key_contact || chat.grpid.is_empty());
     let to_ids_flat: Vec<ContactId> = to_ids.iter().filter_map(|x| *x).collect();
     ensure!(chat.typ == Chattype::Group);
     ensure!(!chat.id.is_special());
@@ -3111,10 +2990,7 @@ async fn apply_group_changes(
         )
         .await?;
 
-        // Avoid insertion of `from_id` into a group with inappropriate encryption state.
-        if from_is_key_contact != chat.grpid.is_empty()
-            && chat.member_list_is_stale(context).await?
-        {
+        if chat.member_list_is_stale(context).await? {
             info!(context, "Member list is stale.");
             let mut new_members: HashSet<ContactId> =
                 HashSet::from_iter(to_ids_flat.iter().copied());
@@ -3122,9 +2998,7 @@ async fn apply_group_changes(
             if !from_id.is_special() {
                 new_members.insert(from_id);
             }
-            if mime_parser.was_encrypted() && chat.grpid.is_empty() {
-                new_members.remove(&ContactId::SELF);
-            }
+
             context
                 .sql
                 .transaction(|transaction| {
@@ -3174,7 +3048,7 @@ async fn apply_group_changes(
             if self_added {
                 new_members = HashSet::from_iter(to_ids_flat.iter().copied());
                 new_members.insert(ContactId::SELF);
-                if !from_id.is_special() && from_is_key_contact != chat.grpid.is_empty() {
+                if !from_id.is_special() {
                     new_members.insert(from_id);
                 }
             } else {
@@ -3198,10 +3072,6 @@ async fn apply_group_changes(
                 new_members.remove(&removed_id);
             }
 
-            if mime_parser.was_encrypted() && chat.grpid.is_empty() {
-                new_members.remove(&ContactId::SELF);
-            }
-
             if new_members != chat_contacts {
                 chat::update_chat_contacts_table(
                     context,
@@ -3843,15 +3713,11 @@ async fn create_adhoc_group(
     to_ids: &[ContactId],
     grpname: &str,
 ) -> Result<Option<(ChatId, Blocked)>> {
-    let mut member_ids: Vec<ContactId> = to_ids
-        .iter()
-        .copied()
-        .filter(|&id| id != ContactId::SELF)
-        .collect();
-    if from_id != ContactId::SELF && !member_ids.contains(&from_id) {
+    let mut member_ids: Vec<ContactId> = to_ids.to_vec();
+    if !member_ids.contains(&(from_id)) {
         member_ids.push(from_id);
     }
-    if !mime_parser.was_encrypted() {
+    if !member_ids.contains(&(ContactId::SELF)) {
         member_ids.push(ContactId::SELF);
     }
 
@@ -3940,7 +3806,7 @@ async fn has_verified_encryption(
     let signed_with_verified_key = mimeparser
         .signature
         .as_ref()
-        .is_some_and(|(signature, _)| *signature == fingerprint);
+        .is_some_and(|signature| *signature == fingerprint);
     if signed_with_verified_key {
         Ok(Verified)
     } else {
@@ -4068,13 +3934,12 @@ async fn add_or_lookup_key_contacts(
     let mut contact_ids = Vec::new();
     let mut fingerprint_iter = fingerprints.iter();
     for info in address_list {
-        let fp = fingerprint_iter.next();
         let addr = &info.addr;
         if !may_be_valid_addr(addr) {
             contact_ids.push(None);
             continue;
         }
-        let fingerprint: String = if let Some(fp) = fp {
+        let fingerprint: String = if let Some(fp) = fingerprint_iter.next() {
             // Iterator has not ran out of fingerprints yet.
             fp.hex()
         } else if let Some(key) = gossiped_keys.get(addr) {
@@ -4225,7 +4090,7 @@ async fn lookup_key_contact_by_fingerprint(
     }
 }
 
-/// Adds or looks up key-contacts by fingerprints or by email addresses in the given chat.
+/// Looks up key-contacts by email addresses.
 ///
 /// `fingerprints` may be empty.
 /// This is used as a fallback when email addresses are available,
@@ -4240,7 +4105,7 @@ async fn lookup_key_contact_by_fingerprint(
 /// is the same as the number of addresses in the header
 /// and it is possible to find corresponding
 /// `Chat-Group-Member-Timestamps` items.
-async fn lookup_key_contacts_fallback_to_chat(
+async fn lookup_key_contacts_by_address_list(
     context: &Context,
     address_list: &[SingleInfo],
     fingerprints: &[Fingerprint],
@@ -4249,14 +4114,13 @@ async fn lookup_key_contacts_fallback_to_chat(
     let mut contact_ids = Vec::new();
     let mut fingerprint_iter = fingerprints.iter();
     for info in address_list {
-        let fp = fingerprint_iter.next();
         let addr = &info.addr;
         if !may_be_valid_addr(addr) {
             contact_ids.push(None);
             continue;
         }
 
-        if let Some(fp) = fp {
+        if let Some(fp) = fingerprint_iter.next() {
             // Iterator has not ran out of fingerprints yet.
             let display_name = info.display_name.as_deref();
             let fingerprint: String = fp.hex();

src/receive_imf/receive_imf_tests.rs

@@ -4,9 +4,8 @@ use tokio::fs;
 
 use super::*;
 use crate::chat::{
-    CantSendReason, ChatItem, ChatVisibility, add_contact_to_chat, add_to_chat_contacts_table,
-    create_group, get_chat_contacts, get_chat_msgs, is_contact_in_chat, remove_contact_from_chat,
-    send_text_msg,
+    ChatItem, ChatVisibility, add_contact_to_chat, add_to_chat_contacts_table, create_group,
+    get_chat_contacts, get_chat_msgs, is_contact_in_chat, remove_contact_from_chat, send_text_msg,
 };
 use crate::chatlist::Chatlist;
 use crate::constants::DC_GCL_FOR_FORWARDING;
@@ -3284,8 +3283,7 @@ async fn test_blocked_contact_creates_group() -> Result<()> {
 
     let sent = bob.send_text(group_id, "Heyho, I'm a spammer!").await;
     let rcvd = alice.recv_msg(&sent).await;
-    // Alice blocked Bob, so she shouldn't be notified.
-    assert_eq!(rcvd.state, MessageState::InSeen);
+    // Alice blocked Bob, so she shouldn't get the message
     assert_eq!(rcvd.chat_blocked, Blocked::Yes);
 
     // Fiona didn't block Bob, though, so she gets the message
@@ -3880,29 +3878,6 @@ async fn test_group_contacts_goto_bottom() -> Result<()> {
     let contacts = Contact::get_all(bob, 0, None).await?;
     assert_eq!(contacts.len(), 2);
     assert_eq!(contacts[0], bob_fiona_id);
-
-    send_text_msg(
-        bob,
-        bob_chat_id,
-        "Hi Alice, stay down in my contact list".to_string(),
-    )
-    .await?;
-    bob.pop_sent_msg().await;
-    let contacts = Contact::get_all(bob, 0, None).await?;
-    assert_eq!(contacts[0], bob_fiona_id);
-
-    remove_contact_from_chat(bob, bob_chat_id, bob_fiona_id).await?;
-    bob.pop_sent_msg().await;
-    let contacts = Contact::get_all(bob, 0, None).await?;
-    // Fiona is still the 0th contact. This makes sense, maybe Bob is going to remove Alice from the
-    // chat too, so no need to make Alice a more "important" contact yet.
-    assert_eq!(contacts[0], bob_fiona_id);
-
-    send_text_msg(bob, bob_chat_id, "Alice, jump up!".to_string()).await?;
-    bob.pop_sent_msg().await;
-    let contacts = Contact::get_all(bob, 0, None).await?;
-    let bob_alice_id = bob.add_or_lookup_contact_id(alice).await;
-    assert_eq!(contacts[0], bob_alice_id);
     Ok(())
 }
 
@@ -5108,100 +5083,6 @@ async fn test_dont_verify_by_verified_by_unknown() -> Result<()> {
     Ok(())
 }
 
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn test_recv_outgoing_msg_before_securejoin() -> Result<()> {
-    let mut tcm = TestContextManager::new();
-    let bob = &tcm.bob().await;
-    let a0 = &tcm.elena().await;
-    let a1 = &tcm.elena().await;
-
-    tcm.execute_securejoin(bob, a0).await;
-    let chat_id_a0_bob = a0.create_chat_id(bob).await;
-    let sent_msg = a0.send_text(chat_id_a0_bob, "Hi").await;
-    bob.recv_msg(&sent_msg).await;
-    let msg_a1 = a1.recv_msg(&sent_msg).await;
-    assert!(msg_a1.get_showpadlock());
-    let chat_a1 = Chat::load_from_db(a1, msg_a1.chat_id).await?;
-    assert_eq!(chat_a1.typ, Chattype::Group);
-    assert!(!chat_a1.is_encrypted(a1).await?);
-    assert_eq!(
-        chat::get_chat_contacts(a1, chat_a1.id).await?,
-        [a1.add_or_lookup_address_contact_id(bob).await]
-    );
-    assert_eq!(
-        chat_a1.why_cant_send(a1).await?,
-        Some(CantSendReason::NotAMember)
-    );
-
-    let sent_msg = a0.send_text(chat_id_a0_bob, "Hi again").await;
-    bob.recv_msg(&sent_msg).await;
-    let msg_a1 = a1.recv_msg(&sent_msg).await;
-    assert!(msg_a1.get_showpadlock());
-    assert_eq!(msg_a1.chat_id, chat_a1.id);
-    let chat_a1 = Chat::load_from_db(a1, msg_a1.chat_id).await?;
-    assert_eq!(
-        chat_a1.why_cant_send(a1).await?,
-        Some(CantSendReason::NotAMember)
-    );
-
-    let msg_a1 = tcm.send_recv(bob, a1, "Hi back").await;
-    assert!(msg_a1.get_showpadlock());
-    let chat_a1 = Chat::load_from_db(a1, msg_a1.chat_id).await?;
-    assert_eq!(chat_a1.typ, Chattype::Single);
-    assert!(chat_a1.is_encrypted(a1).await?);
-    // Weird, but fine, anyway the bigger problem is the conversation split into two chats.
-    assert_eq!(
-        chat_a1.why_cant_send(a1).await?,
-        Some(CantSendReason::ContactRequest)
-    );
-
-    let a0 = &tcm.alice().await;
-    let a1 = &tcm.alice().await;
-    tcm.execute_securejoin(bob, a0).await;
-    let chat_id_a0_bob = a0.create_chat_id(bob).await;
-    let sent_msg = a0.send_text(chat_id_a0_bob, "Hi").await;
-    bob.recv_msg(&sent_msg).await;
-    let msg_a1 = a1.recv_msg(&sent_msg).await;
-    assert!(msg_a1.get_showpadlock());
-    let chat_a1 = Chat::load_from_db(a1, msg_a1.chat_id).await?;
-    assert_eq!(chat_a1.typ, Chattype::Single);
-    assert!(chat_a1.is_encrypted(a1).await?);
-    assert_eq!(
-        chat::get_chat_contacts(a1, chat_a1.id).await?,
-        [a1.add_or_lookup_contact_id(bob).await]
-    );
-    assert!(chat_a1.can_send(a1).await?);
-    Ok(())
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn test_recv_outgoing_msg_before_having_key_and_after() -> Result<()> {
-    let mut tcm = TestContextManager::new();
-    let a0 = &tcm.elena().await;
-    let a1 = &tcm.elena().await;
-    let bob = &tcm.bob().await;
-
-    tcm.execute_securejoin(bob, a0).await;
-    let chat_id_a0_bob = a0.create_chat_id(bob).await;
-    let sent_msg = a0.send_text(chat_id_a0_bob, "Hi").await;
-    let msg_a1 = a1.recv_msg(&sent_msg).await;
-    assert!(msg_a1.get_showpadlock());
-    let chat_a1 = Chat::load_from_db(a1, msg_a1.chat_id).await?;
-    assert_eq!(chat_a1.typ, Chattype::Group);
-    assert!(!chat_a1.is_encrypted(a1).await?);
-
-    // Device a1 somehow learns Bob's key and creates the corresponding chat. However, this doesn't
-    // help because we only look up key contacts by address in a particular chat and the new chat
-    // isn't referenced by the received message. This is fixed by sending and receiving Intended
-    // Recipient Fingerprint subpackets which elena doesn't send.
-    a1.create_chat_id(bob).await;
-    let sent_msg = a0.send_text(chat_id_a0_bob, "Hi again").await;
-    let msg_a1 = a1.recv_msg(&sent_msg).await;
-    assert!(msg_a1.get_showpadlock());
-    assert_eq!(msg_a1.chat_id, chat_a1.id);
-    Ok(())
-}
-
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_sanitize_filename_in_received() -> Result<()> {
     let alice = &TestContext::new_alice().await;
@@ -5461,14 +5342,16 @@ async fn test_encrypted_adhoc_group_message() -> Result<()> {
     assert_eq!(chat.is_encrypted(bob).await?, false);
 
     let contact_ids = get_chat_contacts(bob, chat.id).await?;
-    assert_eq!(contact_ids.len(), 2);
-    assert!(!chat.is_self_in_chat(bob).await?);
+    assert_eq!(contact_ids.len(), 3);
+    assert!(chat.is_self_in_chat(bob).await?);
 
     // Since the group is unencrypted, all contacts have
     // to be address-contacts.
     for contact_id in contact_ids {
         let contact = Contact::get_by_id(bob, contact_id).await?;
-        assert_eq!(contact.is_key_contact(), false);
+        if contact_id != ContactId::SELF {
+            assert_eq!(contact.is_key_contact(), false);
+        }
     }
 
     // `from_id` of the message corresponds to key-contact of Alice

src/scheduler.rs

@@ -11,7 +11,7 @@ use tokio_util::sync::CancellationToken;
 use tokio_util::task::TaskTracker;
 
 pub(crate) use self::connectivity::ConnectivityStore;
-use crate::config::Config;
+use crate::config::{self, Config};
 use crate::contact::{ContactId, RecentlySeenLoop};
 use crate::context::Context;
 use crate::download::{download_known_post_messages_without_pre_message, download_msgs};
@@ -256,6 +256,14 @@ impl SchedulerState {
         }
     }
 
+    /// Interrupt optional boxes (mvbox currently) loops.
+    pub(crate) async fn interrupt_oboxes(&self) {
+        let inner = self.inner.read().await;
+        if let InnerSchedulerState::Started(ref scheduler) = *inner {
+            scheduler.interrupt_oboxes();
+        }
+    }
+
     pub(crate) async fn interrupt_smtp(&self) {
         let inner = self.inner.read().await;
         if let InnerSchedulerState::Started(ref scheduler) = *inner {
@@ -469,6 +477,29 @@ async fn inbox_fetch_idle(ctx: &Context, imap: &mut Imap, mut session: Session)
     };
 
     maybe_send_stats(ctx).await.log_err(ctx).ok();
+    match ctx.get_config_bool(Config::FetchedExistingMsgs).await {
+        Ok(fetched_existing_msgs) => {
+            if !fetched_existing_msgs {
+                // Consider it done even if we fail.
+                //
+                // This operation is not critical enough to retry,
+                // especially if the error is persistent.
+                if let Err(err) = ctx
+                    .set_config_internal(Config::FetchedExistingMsgs, config::from_bool(true))
+                    .await
+                {
+                    warn!(ctx, "Can't set Config::FetchedExistingMsgs: {:#}", err);
+                }
+
+                if let Err(err) = imap.fetch_existing_msgs(ctx, &mut session).await {
+                    warn!(ctx, "Failed to fetch existing messages: {:#}", err);
+                }
+            }
+        }
+        Err(err) => {
+            warn!(ctx, "Can't get Config::FetchedExistingMsgs: {:#}", err);
+        }
+    }
 
     session
         .update_metadata(ctx)
@@ -511,24 +542,65 @@ async fn fetch_idle(
             .context("store_seen_flags_on_imap")?;
     }
 
-    // Fetch the watched folder.
-    connection
-        .fetch_move_delete(ctx, &mut session, &watch_folder, folder_meaning)
-        .await
-        .context("fetch_move_delete")?;
+    if !ctx.should_delete_to_trash().await?
+        || ctx
+            .get_config(Config::ConfiguredTrashFolder)
+            .await?
+            .is_some()
+    {
+        // Fetch the watched folder.
+        connection
+            .fetch_move_delete(ctx, &mut session, &watch_folder, folder_meaning)
+            .await
+            .context("fetch_move_delete")?;
 
-    // Mark expired messages for deletion. Marked messages will be deleted from the server
-    // on the next iteration of `fetch_move_delete`. `delete_expired_imap_messages` is not
-    // called right before `fetch_move_delete` because it is not well optimized and would
-    // otherwise slow down message fetching.
-    delete_expired_imap_messages(ctx)
-        .await
-        .context("delete_expired_imap_messages")?;
+        // Mark expired messages for deletion. Marked messages will be deleted from the server
+        // on the next iteration of `fetch_move_delete`. `delete_expired_imap_messages` is not
+        // called right before `fetch_move_delete` because it is not well optimized and would
+        // otherwise slow down message fetching.
+        delete_expired_imap_messages(ctx)
+            .await
+            .context("delete_expired_imap_messages")?;
 
-    download_known_post_messages_without_pre_message(ctx, &mut session).await?;
-    download_msgs(ctx, &mut session)
-        .await
-        .context("download_msgs")?;
+        download_known_post_messages_without_pre_message(ctx, &mut session).await?;
+        download_msgs(ctx, &mut session)
+            .await
+            .context("download_msgs")?;
+    } else if folder_config == Config::ConfiguredInboxFolder {
+        session.last_full_folder_scan.lock().await.take();
+    }
+
+    // Scan additional folders only after finishing fetching the watched folder.
+    //
+    // On iOS the application has strictly limited time to work in background, so we may not
+    // be able to scan all folders before time is up if there are many of them.
+    if folder_config == Config::ConfiguredInboxFolder {
+        // Only scan on the Inbox thread in order to prevent parallel scans, which might lead to duplicate messages
+        match connection
+            .scan_folders(ctx, &mut session)
+            .await
+            .context("scan_folders")
+        {
+            Err(err) => {
+                // Don't reconnect, if there is a problem with the connection we will realize this when IDLEing
+                // but maybe just one folder can't be selected or something
+                warn!(ctx, "{:#}", err);
+            }
+            Ok(true) => {
+                // Fetch the watched folder again in case scanning other folder moved messages
+                // there.
+                //
+                // In most cases this will select the watched folder and return because there are
+                // no new messages. We want to select the watched folder anyway before going IDLE
+                // there, so this does not take additional protocol round-trip.
+                connection
+                    .fetch_move_delete(ctx, &mut session, &watch_folder, folder_meaning)
+                    .await
+                    .context("fetch_move_delete after scan_folders")?;
+            }
+            Ok(false) => {}
+        }
+    }
 
     // Synchronize Seen flags.
     session
@@ -853,6 +925,12 @@ impl Scheduler {
         }
     }
 
+    fn interrupt_oboxes(&self) {
+        for b in &self.oboxes {
+            b.conn_state.interrupt();
+        }
+    }
+
     fn interrupt_smtp(&self) {
         self.smtp.interrupt();
     }

src/scheduler/connectivity.rs

@@ -6,7 +6,7 @@ use anyhow::Result;
 use humansize::{BINARY, format_size};
 
 use crate::events::EventType;
-use crate::imap::{FolderMeaning, get_watched_folder_configs};
+use crate::imap::{FolderMeaning, scan_folders::get_watched_folder_configs};
 use crate::quota::{QUOTA_ERROR_THRESHOLD_PERCENTAGE, QUOTA_WARN_THRESHOLD_PERCENTAGE};
 use crate::stock_str;
 use crate::{context::Context, log::LogExt};

src/securejoin.rs

@@ -784,7 +784,7 @@ fn encrypted_and_signed(
     mimeparser: &MimeMessage,
     expected_fingerprint: &Fingerprint,
 ) -> bool {
-    if let Some((signature, _)) = mimeparser.signature.as_ref() {
+    if let Some(signature) = mimeparser.signature.as_ref() {
         if signature == expected_fingerprint {
             true
         } else {

src/smtp.rs

@@ -13,7 +13,7 @@ use crate::config::Config;
 use crate::contact::{Contact, ContactId};
 use crate::context::Context;
 use crate::events::EventType;
-use crate::log::{LogExt, warn};
+use crate::log::warn;
 use crate::message::Message;
 use crate::message::{self, MsgId};
 use crate::mimefactory::MimeFactory;
@@ -184,9 +184,6 @@ pub(crate) async fn smtp_send(
     smtp: &mut Smtp,
     msg_id: Option<MsgId>,
 ) -> SendResult {
-    if recipients.is_empty() {
-        return SendResult::Success;
-    }
     if std::env::var(crate::DCC_MIME_DEBUG).is_ok() {
         info!(context, "SMTP-sending out mime message:\n{message}");
     }
@@ -377,15 +374,15 @@ pub(crate) async fn send_msg_to_smtp(
         return Ok(());
     };
     if retries > 6 {
+        if let Some(mut msg) = Message::load_from_db_optional(context, msg_id).await? {
+            message::set_msg_failed(context, &mut msg, "Number of retries exceeded the limit.")
+                .await?;
+        }
         context
             .sql
             .execute("DELETE FROM smtp WHERE id=?", (rowid,))
             .await
             .context("Failed to remove message with exceeded retry limit from smtp table")?;
-        if let Some(mut msg) = Message::load_from_db_optional(context, msg_id).await? {
-            message::set_msg_failed(context, &mut msg, "Number of retries exceeded the limit.")
-                .await?;
-        }
         return Ok(());
     }
     info!(
@@ -573,32 +570,17 @@ async fn send_mdn_rfc724_mid(
         additional_rfc724_mids.clone(),
     )
     .await?;
-    let encrypted = mimefactory.will_be_encrypted();
     let rendered_msg = mimefactory.render(context).await?;
     let body = rendered_msg.message;
 
-    let mut recipients = Vec::new();
-    if contact_id != ContactId::SELF {
-        recipients.push(contact.get_addr().to_string());
-    }
-    if context.get_config_bool(Config::BccSelf).await? {
-        add_self_recipients(context, &mut recipients, encrypted).await?;
-    }
-    let recipients: Vec<_> = recipients
-        .into_iter()
-        .filter_map(|addr| {
-            async_smtp::EmailAddress::new(addr.clone())
-                .with_context(|| format!("Invalid recipient: {addr}"))
-                .log_err(context)
-                .ok()
-        })
-        .collect();
+    let addr = contact.get_addr();
+    let recipient = async_smtp::EmailAddress::new(addr.to_string())
+        .map_err(|err| format_err!("invalid recipient: {addr} {err:?}"))?;
+    let recipients = vec![recipient];
 
     match smtp_send(context, &recipients, &body, smtp, None).await {
         SendResult::Success => {
-            if !recipients.is_empty() {
-                info!(context, "Successfully sent MDN for {rfc724_mid}.");
-            }
+            info!(context, "Successfully sent MDN for {rfc724_mid}.");
             context
                 .sql
                 .transaction(|transaction| {
@@ -685,34 +667,3 @@ async fn send_mdn(context: &Context, smtp: &mut Smtp) -> Result<bool> {
         }
     }
 }
-
-/// Adds self-addresses to `recipients` as necessary.
-/// This doesn't check `Config::BccSelf`, it should be checked by the caller if needed.
-pub(crate) async fn add_self_recipients(
-    context: &Context,
-    recipients: &mut Vec<String>,
-    encrypted: bool,
-) -> Result<()> {
-    // Previous versions of Delta Chat did not send BCC self
-    // if DeleteServerAfter was set to immediately delete messages
-    // from the server. This is not the case anymore
-    // because BCC-self messages are also used to detect
-    // that message was sent if SMTP server is slow to respond
-    // and connection is frequently lost
-    // before receiving status line. NB: This is not a problem for chatmail servers, so `BccSelf`
-    // disabled by default is fine.
-    if context.get_config_delete_server_after().await? != Some(0) || !recipients.is_empty() {
-        // Avoid sending unencrypted messages to all transports, chatmail relays won't accept
-        // them. Normally the user should have a non-chatmail primary transport to send unencrypted
-        // messages.
-        if encrypted {
-            for addr in context.get_secondary_self_addrs().await? {
-                recipients.push(addr);
-            }
-        }
-        // `from` must be the last addr, see `receive_imf_inner()` why.
-        let from = context.get_primary_self_addr().await?;
-        recipients.push(from);
-    }
-    Ok(())
-}

src/sql.rs

@@ -9,7 +9,6 @@ use rusqlite::{Connection, OpenFlags, Row, config::DbConfig, types::ValueRef};
 use tokio::sync::RwLock;
 
 use crate::blob::BlobObject;
-use crate::chat::add_device_msg;
 use crate::config::Config;
 use crate::constants::DC_CHAT_ID_TRASH;
 use crate::context::Context;
@@ -18,13 +17,11 @@ use crate::ephemeral::start_ephemeral_timers;
 use crate::imex::BLOBS_BACKUP_NAME;
 use crate::location::delete_orphaned_poi_locations;
 use crate::log::{LogExt, warn};
-use crate::message::Message;
 use crate::message::MsgId;
 use crate::net::dns::prune_dns_cache;
 use crate::net::http::http_cache_cleanup;
 use crate::net::prune_connection_history;
 use crate::param::{Param, Params};
-use crate::stock_str;
 use crate::tools::{SystemTime, Time, delete_file, time, time_elapsed};
 
 /// Extension to [`rusqlite::ToSql`] trait
@@ -868,12 +865,6 @@ pub async fn housekeeping(context: &Context) -> Result<()> {
         );
     }
 
-    maybe_add_mvbox_move_deprecation_message(context)
-        .await
-        .context("maybe_add_mvbox_move_deprecation_message")
-        .log_err(context)
-        .ok();
-
     if let Err(err) = incremental_vacuum(context).await {
         warn!(context, "Failed to run incremental vacuum: {err:#}.");
     }
@@ -933,18 +924,6 @@ pub async fn housekeeping(context: &Context) -> Result<()> {
     Ok(())
 }
 
-/// Adds device message about `mvbox_move` config deprecation
-/// if the user has it enabled.
-async fn maybe_add_mvbox_move_deprecation_message(context: &Context) -> Result<()> {
-    if !context.get_config_bool(Config::OnlyFetchMvbox).await?
-        && context.get_config_bool(Config::MvboxMove).await?
-    {
-        let mut msg = Message::new_text(stock_str::mvbox_move_deprecation(context).await);
-        add_device_msg(context, Some("mvbox_move_deprecation"), Some(&mut msg)).await?;
-    }
-    Ok(())
-}
-
 /// Get the value of a column `idx` of the `row` as `Vec<u8>`.
 pub fn row_get_vec(row: &Row, idx: usize) -> rusqlite::Result<Vec<u8>> {
     row.get(idx).or_else(|err| match row.get_ref(idx)? {

src/sql/migrations.rs

@@ -1525,39 +1525,6 @@ ALTER TABLE contacts ADD COLUMN name_normalized TEXT;
         .await?;
     }
 
-    // Copy of migration 144, but inserts a value for `mvbox_move`
-    // if it does not exist, because no value is treated as `1`.
-    inc_and_check(&mut migration_version, 146)?;
-    if dbversion < migration_version {
-        sql.execute_migration_transaction(
-            |transaction| {
-                let is_chatmail = transaction
-                    .query_row(
-                        "SELECT value FROM config WHERE keyname='is_chatmail'",
-                        (),
-                        |row| {
-                            let value: String = row.get(0)?;
-                            Ok(value)
-                        },
-                    )
-                    .optional()?
-                    .as_deref()
-                    == Some("1");
-
-                if is_chatmail {
-                    transaction.execute_batch(
-                        "DELETE FROM config WHERE keyname='only_fetch_mvbox';
-                         DELETE FROM config WHERE keyname='show_emails';
-                         INSERT OR REPLACE INTO config (keyname, value) VALUES ('mvbox_move', '0')",
-                    )?;
-                }
-                Ok(())
-            },
-            migration_version,
-        )
-        .await?;
-    }
-
     let new_version = sql
         .get_raw_config_int(VERSION_CFG)
         .await?

src/sql/migrations/migrations_tests.rs

@@ -96,6 +96,9 @@ async fn test_key_contacts_migration_email1() -> Result<()> {
     assert_eq!(email_bob.fingerprint(), None);
     assert_eq!(email_bob.get_verifier_id(&t).await?, None);
 
+    let bob_chat_contacts = chat::get_chat_contacts(&t, ChatId::new(10)).await?;
+    dbg!(&bob_chat_contacts);
+
     Ok(())
 }
 
@@ -134,6 +137,9 @@ async fn test_key_contacts_migration_email2() -> Result<()> {
     assert_eq!(email_bob.fingerprint(), None);
     assert_eq!(email_bob.get_verifier_id(&t).await?, None);
 
+    let bob_chat_contacts = chat::get_chat_contacts(&t, ChatId::new(10)).await?;
+    dbg!(&bob_chat_contacts);
+
     Ok(())
 }
 
@@ -170,6 +176,7 @@ async fn test_key_contacts_migration_verified() -> Result<()> {
     let pgp_bob_id = bob_chat_contacts[0];
 
     let pgp_bob = Contact::get_by_id(&t, pgp_bob_id).await?;
+    dbg!(&pgp_bob);
     assert_eq!(pgp_bob.origin, Origin::OutgoingTo);
     assert_eq!(pgp_bob.e2ee_avail(&t).await?, true);
     assert_eq!(

src/stats.rs

@@ -8,8 +8,7 @@ use std::collections::{BTreeMap, BTreeSet};
 use anyhow::{Context as _, Result};
 use deltachat_derive::FromSql;
 use num_traits::ToPrimitive;
-use pgp::types::KeyDetails as _;
-use rand::distr::SampleString as _;
+use pgp::types::PublicKeyTrait;
 use rusqlite::OptionalExtension;
 use serde::Serialize;
 
@@ -22,7 +21,7 @@ use crate::key::load_self_public_keyring;
 use crate::log::LogExt;
 use crate::message::{Message, Viewtype};
 use crate::securejoin::QrInvite;
-use crate::tools::time;
+use crate::tools::{create_id, time};
 
 pub(crate) const STATISTICS_BOT_EMAIL: &str = "self_reporting@testrun.org";
 const STATISTICS_BOT_VCARD: &str = include_str!("../assets/statistics-bot.vcf");
@@ -33,7 +32,7 @@ const MESSAGE_STATS_UPDATE_INTERVAL_SECONDS: i64 = 4 * 60; // 4 minutes (less th
 #[derive(Serialize)]
 struct Statistics {
     core_version: String,
-    key_create_timestamps: Vec<u32>,
+    key_create_timestamps: Vec<i64>,
     stats_id: String,
     is_chatmail: bool,
     contact_stats: Vec<ContactStat>,
@@ -345,10 +344,10 @@ async fn get_stats(context: &Context) -> Result<String> {
         .get_config_u32(Config::StatsLastOldContactId)
         .await?;
 
-    let key_create_timestamps: Vec<u32> = load_self_public_keyring(context)
+    let key_create_timestamps: Vec<i64> = load_self_public_keyring(context)
         .await?
         .iter()
-        .map(|k| k.created_at().as_secs())
+        .map(|k| k.created_at().timestamp())
         .collect();
 
     let sending_enabled_timestamps =
@@ -391,9 +390,7 @@ pub(crate) async fn stats_id(context: &Context) -> Result<String> {
     Ok(match context.get_config(Config::StatsId).await? {
         Some(id) => id,
         None => {
-            let id = rand::distr::Alphabetic
-                .sample_string(&mut rand::rng(), 25)
-                .to_lowercase();
+            let id = create_id();
             context
                 .set_config_internal(Config::StatsId, Some(&id))
                 .await?;

src/stock_str.rs

@@ -63,7 +63,10 @@ pub enum StockMessage {
     #[strum(props(fallback = "GIF"))]
     Gif = 23,
 
-    #[strum(props(fallback = "No encryption."))]
+    #[strum(props(fallback = "End-to-end encryption available"))]
+    E2eAvailable = 25,
+
+    #[strum(props(fallback = "No encryption"))]
     EncrNone = 28,
 
     #[strum(props(fallback = "Fingerprints"))]
@@ -369,6 +372,12 @@ Help keeping us to keep Delta Chat independent and make it more awesome in the f
 https://delta.chat/donate"))]
     DonationRequest = 193,
 
+    #[strum(props(fallback = "Outgoing call"))]
+    OutgoingCall = 194,
+
+    #[strum(props(fallback = "Incoming call"))]
+    IncomingCall = 195,
+
     #[strum(props(fallback = "Declined call"))]
     DeclinedCall = 196,
 
@@ -406,23 +415,6 @@ https://delta.chat/donate"))]
 
     #[strum(props(fallback = "Messages in this chat use classic email and are not encrypted."))]
     ChatUnencryptedExplanation = 230,
-
-    #[strum(props(
-        fallback = "You are using the legacy option \"Settings → Advanced → Move automatically to DeltaChat Folder\".\n\nThis option will be removed in a few weeks and you should disable it already today.\n\nIf having chat messages mixed into your inbox is a problem, see https://delta.chat/legacy-move"
-    ))]
-    MvboxMoveDeprecation = 231,
-
-    #[strum(props(fallback = "Outgoing audio call"))]
-    OutgoingAudioCall = 232,
-
-    #[strum(props(fallback = "Outgoing video call"))]
-    OutgoingVideoCall = 233,
-
-    #[strum(props(fallback = "Incoming audio call"))]
-    IncomingAudioCall = 234,
-
-    #[strum(props(fallback = "Incoming video call"))]
-    IncomingVideoCall = 235,
 }
 
 impl StockMessage {
@@ -715,6 +707,11 @@ pub(crate) async fn gif(context: &Context) -> String {
     translated(context, StockMessage::Gif).await
 }
 
+/// Stock string: `End-to-end encryption available.`.
+pub(crate) async fn e2e_available(context: &Context) -> String {
+    translated(context, StockMessage::E2eAvailable).await
+}
+
 /// Stock string: `No encryption.`.
 pub(crate) async fn encr_none(context: &Context) -> String {
     translated(context, StockMessage::EncrNone).await
@@ -768,30 +765,14 @@ pub(crate) async fn donation_request(context: &Context) -> String {
     translated(context, StockMessage::DonationRequest).await
 }
 
-/// Stock string: `Outgoing video call` or `Outgoing audio call`.
-pub(crate) async fn outgoing_call(context: &Context, has_video: bool) -> String {
-    translated(
-        context,
-        if has_video {
-            StockMessage::OutgoingVideoCall
-        } else {
-            StockMessage::OutgoingAudioCall
-        },
-    )
-    .await
+/// Stock string: `Outgoing call`.
+pub(crate) async fn outgoing_call(context: &Context) -> String {
+    translated(context, StockMessage::OutgoingCall).await
 }
 
-/// Stock string: `Incoming video call` or `Incoming audio call`.
-pub(crate) async fn incoming_call(context: &Context, has_video: bool) -> String {
-    translated(
-        context,
-        if has_video {
-            StockMessage::IncomingVideoCall
-        } else {
-            StockMessage::IncomingAudioCall
-        },
-    )
-    .await
+/// Stock string: `Incoming call`.
+pub(crate) async fn incoming_call(context: &Context) -> String {
+    translated(context, StockMessage::IncomingCall).await
 }
 
 /// Stock string: `Declined call`.
@@ -1250,11 +1231,6 @@ pub(crate) async fn chat_unencrypted_explanation(context: &Context) -> String {
     translated(context, StockMessage::ChatUnencryptedExplanation).await
 }
 
-/// Stock string: `You are using the legacy option "Move automatically to DeltaChat Folder`…
-pub(crate) async fn mvbox_move_deprecation(context: &Context) -> String {
-    translated(context, StockMessage::MvboxMoveDeprecation).await
-}
-
 impl Viewtype {
     /// returns Localized name for message viewtype
     pub async fn to_locale_string(&self, context: &Context) -> String {

src/summary.rs

@@ -4,9 +4,6 @@ use std::borrow::Cow;
 use std::fmt;
 use std::str;
 
-use anyhow::Result;
-use num_traits::FromPrimitive;
-
 use crate::calls::{CallState, call_state};
 use crate::chat::Chat;
 use crate::constants::Chattype;
@@ -18,6 +15,7 @@ use crate::param::Param;
 use crate::stock_str;
 use crate::stock_str::msg_reacted;
 use crate::tools::truncate;
+use anyhow::Result;
 
 /// Prefix displayed before message and separated by ":" in the chatlist.
 #[derive(Debug)]
@@ -169,15 +167,7 @@ impl Message {
     /// Returns a summary text without "Forwarded:" prefix.
     async fn get_summary_text_without_prefix(&self, context: &Context) -> String {
         let (emoji, type_name, type_file, append_text);
-        let viewtype = match self
-            .param
-            .get_i64(Param::PostMessageViewtype)
-            .and_then(Viewtype::from_i64)
-        {
-            Some(vt) => vt,
-            None => self.viewtype,
-        };
-        match viewtype {
+        match self.viewtype {
             Viewtype::Image => {
                 emoji = Some("📷");
                 type_name = Some(stock_str::image(context).await);
@@ -221,44 +211,33 @@ impl Message {
                 append_text = true
             }
             Viewtype::Webxdc => {
+                emoji = None;
                 type_name = None;
-                if self.viewtype == Viewtype::Webxdc {
-                    emoji = None;
-                    type_file = Some(
-                        self.get_webxdc_info(context)
-                            .await
-                            .map(|info| info.name)
-                            .unwrap_or_else(|_| "ErrWebxdcName".to_string()),
-                    );
-                } else {
-                    emoji = Some("📱");
-                    type_file = Some(viewtype.to_locale_string(context).await);
-                }
+                type_file = Some(
+                    self.get_webxdc_info(context)
+                        .await
+                        .map(|info| info.name)
+                        .unwrap_or_else(|_| "ErrWebxdcName".to_string()),
+                );
                 append_text = true;
             }
             Viewtype::Vcard => {
                 emoji = Some("👤");
                 type_name = None;
-                if self.viewtype == Viewtype::Vcard {
-                    type_file = self.param.get(Param::Summary1).map(|s| s.to_string());
-                } else {
-                    type_file = None;
-                }
+                type_file = self.param.get(Param::Summary1).map(|s| s.to_string());
                 append_text = true;
             }
             Viewtype::Call => {
-                let call_info = context.load_call_by_id(self.id).await.unwrap_or(None);
-                let has_video = call_info.is_some_and(|c| c.has_video_initially());
                 let call_state = call_state(context, self.id)
                     .await
                     .unwrap_or(CallState::Alerting);
-                emoji = Some(if has_video { "🎥" } else { "📞" });
+                emoji = Some("📞");
                 type_name = Some(match call_state {
                     CallState::Alerting | CallState::Active | CallState::Completed { .. } => {
                         if self.from_id == ContactId::SELF {
-                            stock_str::outgoing_call(context, has_video).await
+                            stock_str::outgoing_call(context).await
                         } else {
-                            stock_str::incoming_call(context, has_video).await
+                            stock_str::incoming_call(context).await
                         }
                     }
                     CallState::Missed => stock_str::missed_call(context).await,
@@ -282,7 +261,7 @@ impl Message {
             }
         };
 
-        let text = self.text.clone();
+        let text = self.text.clone() + &self.additional_text;
 
         let summary = if let Some(type_file) = type_file {
             if append_text && !text.is_empty() {
@@ -314,13 +293,6 @@ impl Message {
     }
 }
 
-#[cfg(test)]
-/// Asserts that the summary text with and w/o prefix is `expected`.
-pub async fn assert_summary_texts(msg: &Message, ctx: &Context, expected: &str) {
-    assert_eq!(msg.get_summary_text(ctx).await, expected);
-    assert_eq!(msg.get_summary_text_without_prefix(ctx).await, expected);
-}
-
 #[cfg(test)]
 mod tests {
     use std::path::PathBuf;
@@ -330,6 +302,11 @@ mod tests {
     use crate::param::Param;
     use crate::test_utils::TestContext;
 
+    async fn assert_summary_texts(msg: &Message, ctx: &Context, expected: &str) {
+        assert_eq!(msg.get_summary_text(ctx).await, expected);
+        assert_eq!(msg.get_summary_text_without_prefix(ctx).await, expected);
+    }
+
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_get_summary_text() {
         let d = TestContext::new_alice().await;

src/test_utils.rs

@@ -32,7 +32,7 @@ use crate::contact::{
 };
 use crate::context::Context;
 use crate::events::{Event, EventEmitter, EventType, Events};
-use crate::key::{self, DcKey, self_fingerprint};
+use crate::key::{self, DcKey, DcSecretKey, self_fingerprint};
 use crate::log::warn;
 use crate::login_param::EnteredLoginParam;
 use crate::message::{Message, MessageState, MsgId, update_msg_state};
@@ -44,7 +44,7 @@ use crate::stock_str::StockStrings;
 use crate::tools::time;
 
 /// The number of info messages added to new e2ee chats.
-/// Currently this is "Messages are end-to-end encrypted.", string `ChatProtectionEnabled`.
+/// Currently this is "End-to-end encryption available", string `E2eAvailable`.
 pub const E2EE_INFO_MSGS: usize = 1;
 
 #[allow(non_upper_case_globals)]
@@ -117,8 +117,6 @@ impl TestContextManager {
             .await
     }
 
-    /// Returns new elena's "device".
-    /// Elena doesn't send Intended Recipient Fingerprint subpackets to simulate old Delta Chat.
     pub async fn elena(&mut self) -> TestContext {
         TestContext::builder()
             .configure_elena()
@@ -567,7 +565,6 @@ impl TestContext {
             .unwrap();
         ctx.set_config(Config::BccSelf, Some("1")).await.unwrap();
         ctx.set_config(Config::SyncMsgs, Some("0")).await.unwrap();
-        ctx.set_config(Config::MvboxMove, Some("0")).await.unwrap();
 
         Self {
             ctx,
@@ -1355,7 +1352,7 @@ impl SentMessage<'_> {
 pub fn alice_keypair() -> KeyPair {
     let secret =
         key::SignedSecretKey::from_asc(include_str!("../test-data/key/alice-secret.asc")).unwrap();
-    let public = secret.to_public_key();
+    let public = secret.split_public_key().unwrap();
     KeyPair { public, secret }
 }
 
@@ -1365,7 +1362,7 @@ pub fn alice_keypair() -> KeyPair {
 pub fn bob_keypair() -> KeyPair {
     let secret =
         key::SignedSecretKey::from_asc(include_str!("../test-data/key/bob-secret.asc")).unwrap();
-    let public = secret.to_public_key();
+    let public = secret.split_public_key().unwrap();
     KeyPair { public, secret }
 }
 
@@ -1376,7 +1373,7 @@ pub fn charlie_keypair() -> KeyPair {
     let secret =
         key::SignedSecretKey::from_asc(include_str!("../test-data/key/charlie-secret.asc"))
             .unwrap();
-    let public = secret.to_public_key();
+    let public = secret.split_public_key().unwrap();
     KeyPair { public, secret }
 }
 
@@ -1386,7 +1383,7 @@ pub fn charlie_keypair() -> KeyPair {
 pub fn dom_keypair() -> KeyPair {
     let secret =
         key::SignedSecretKey::from_asc(include_str!("../test-data/key/dom-secret.asc")).unwrap();
-    let public = secret.to_public_key();
+    let public = secret.split_public_key().unwrap();
     KeyPair { public, secret }
 }
 
@@ -1396,7 +1393,7 @@ pub fn dom_keypair() -> KeyPair {
 pub fn elena_keypair() -> KeyPair {
     let secret =
         key::SignedSecretKey::from_asc(include_str!("../test-data/key/elena-secret.asc")).unwrap();
-    let public = secret.to_public_key();
+    let public = secret.split_public_key().unwrap();
     KeyPair { public, secret }
 }
 
@@ -1406,7 +1403,7 @@ pub fn elena_keypair() -> KeyPair {
 pub fn fiona_keypair() -> KeyPair {
     let secret =
         key::SignedSecretKey::from_asc(include_str!("../test-data/key/fiona-secret.asc")).unwrap();
-    let public = secret.to_public_key();
+    let public = secret.split_public_key().unwrap();
     KeyPair { public, secret }
 }
 
@@ -1495,15 +1492,6 @@ impl EventTracker {
     pub fn clear_events(&self) {
         while let Ok(_ev) = self.try_recv() {}
     }
-
-    /// Takes all items from event queue and returns them.
-    pub fn take_events(&self) -> Vec<Event> {
-        let mut events = Vec::new();
-        while let Ok(event) = self.try_recv() {
-            events.push(event);
-        }
-        events
-    }
 }
 
 /// Gets a specific message from a chat and asserts that the chat has a specific length.

src/tests/pre_messages/receiving.rs

@@ -10,7 +10,6 @@ use crate::message::{Message, MessageState, Viewtype, delete_msgs, markseen_msgs
 use crate::mimeparser::MimeMessage;
 use crate::param::Param;
 use crate::reaction::{get_msg_reactions, send_reaction};
-use crate::summary::assert_summary_texts;
 use crate::test_utils::TestContextManager;
 use crate::tests::pre_messages::util::{
     send_large_file_message, send_large_image_message, send_large_webxdc_message,
@@ -77,39 +76,6 @@ async fn test_receive_pre_message() -> Result<()> {
     assert_eq!(msg.get_filebytes(bob).await?, Some(1_000_000));
     assert_eq!(msg.get_post_message_viewtype(), Some(Viewtype::File));
     assert_eq!(msg.get_filename(), Some("test.bin".to_owned()));
-    assert_summary_texts(&msg, bob, "📎 test.bin – test").await;
-
-    // Some viewtypes are displayed unwell currently, still test them.
-
-    let (pre_message, ..) = send_large_webxdc_message(alice, alice_group_id).await?;
-    let msg = bob.recv_msg(&pre_message).await;
-    assert_eq!(msg.download_state, DownloadState::Available);
-    assert_summary_texts(
-        &msg,
-        bob,
-        &format!("📱 {} – test", Viewtype::Webxdc.to_locale_string(bob).await),
-    )
-    .await;
-
-    let (pre_message, ..) = send_large_file_message(
-        alice,
-        alice_group_id,
-        Viewtype::Vcard,
-        format!(
-            "BEGIN:VCARD\r\n\
-             VERSION:4.0\r\n\
-             EMAIL:alice@example.org\r\n\
-             FN:Alice\r\n\
-             NOTE:{}\r\n\
-             END:VCARD\r\n",
-            String::from_utf8(vec![97u8; 1_000_000])?,
-        )
-        .as_bytes(),
-    )
-    .await?;
-    let msg = bob.recv_msg(&pre_message).await;
-    assert_eq!(msg.download_state, DownloadState::Available);
-    assert_summary_texts(&msg, bob, "👤 test").await;
 
     Ok(())
 }

src/tests/pre_messages/util.rs

@@ -17,10 +17,10 @@ pub async fn send_large_file_message<'a>(
     content: &[u8],
 ) -> Result<(SentMessage<'a>, SentMessage<'a>, MsgId)> {
     let mut msg = Message::new(view_type);
-    let file_name = match view_type {
-        Viewtype::Webxdc => "test.xdc",
-        Viewtype::Vcard => "test.vcf",
-        _ => "test.bin",
+    let file_name = if view_type == Viewtype::Webxdc {
+        "test.xdc"
+    } else {
+        "test.bin"
     };
     msg.set_file_from_bytes(sender, file_name, content, None)?;
     msg.set_text("test".to_owned());

src/transport.rs

@@ -9,7 +9,6 @@
 //! and configured list of connection candidates.
 
 use std::fmt;
-use std::pin::Pin;
 
 use anyhow::{Context as _, Result, bail, format_err};
 use deltachat_contact_tools::{EmailAddress, addr_normalize};
@@ -761,18 +760,11 @@ pub(crate) async fn sync_transports(
         .await?;
 
     if modified {
-        tokio::task::spawn(restart_io_if_running_boxed(context.clone()));
         context.emit_event(EventType::TransportsModified);
     }
     Ok(())
 }
 
-/// Same as `context.restart_io_if_running()`, but `Box::pin`ed and with a `+ Send` bound,
-/// so that it can be called recursively.
-fn restart_io_if_running_boxed(context: Context) -> Pin<Box<dyn Future<Output = ()> + Send>> {
-    Box::pin(async move { context.restart_io_if_running().await })
-}
-
 /// Adds transport entry to the `transports` table with empty configuration.
 pub(crate) async fn add_pseudo_transport(context: &Context, addr: &str) -> Result<()> {
     context.sql