fmt

.github/workflows/ci.yml

@@ -24,7 +24,7 @@ jobs:
     name: Lint Rust
     runs-on: ubuntu-latest
     env:
-      RUSTUP_TOOLCHAIN: 1.83.0
+      RUSTUP_TOOLCHAIN: 1.82.0
     steps:
       - uses: actions/checkout@v4
         with:
@@ -37,10 +37,8 @@ jobs:
         run: cargo fmt --all -- --check
       - name: Run clippy
         run: scripts/clippy.sh
-      - name: Check with all features
+      - name: Check
         run: cargo check --workspace --all-targets --all-features
-      - name: Check with only default features
-        run: cargo check --all-targets
 
   npm_constants:
     name: Check if node constants are up to date
@@ -97,11 +95,11 @@ jobs:
       matrix:
         include:
           - os: ubuntu-latest
-            rust: 1.83.0
+            rust: 1.82.0
           - os: windows-latest
-            rust: 1.83.0
+            rust: 1.82.0
           - os: macos-latest
-            rust: 1.83.0
+            rust: 1.82.0
 
           # Minimum Supported Rust Version = 1.77.0
           - os: ubuntu-latest

.github/workflows/nix.yml

@@ -1,104 +0,0 @@
-name: Test Nix flake
-
-on:
-  pull_request:
-    paths:
-      - flake.nix
-      - flake.lock
-  push:
-    paths:
-      - flake.nix
-      - flake.lock
-    branches:
-      - main
-
-jobs:
-  format:
-    name: check flake formatting
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          show-progress: false
-      - uses: DeterminateSystems/nix-installer-action@main
-      - uses: DeterminateSystems/magic-nix-cache-action@main
-      - run: nix fmt
-
-      # Check that formatting does not change anything.
-      - run: git diff --exit-code
-
-  build:
-    name: nix build
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        installable:
-          # Ensure `nix develop` will work.
-          - devShells.x86_64-linux.default
-
-          - deltachat-python
-          - deltachat-repl
-          - deltachat-repl-aarch64-linux
-          - deltachat-repl-arm64-v8a-android
-          - deltachat-repl-armeabi-v7a-android
-          - deltachat-repl-armv6l-linux
-          - deltachat-repl-armv7l-linux
-          - deltachat-repl-i686-linux
-          - deltachat-repl-win32
-          - deltachat-repl-win64
-          - deltachat-repl-x86_64-linux
-          - deltachat-rpc-client
-          - deltachat-rpc-server
-          - deltachat-rpc-server-aarch64-linux
-          - deltachat-rpc-server-aarch64-linux-wheel
-          - deltachat-rpc-server-arm64-v8a-android
-          - deltachat-rpc-server-armeabi-v7a-android
-          - deltachat-rpc-server-armv6l-linux
-          - deltachat-rpc-server-armv6l-linux-wheel
-          - deltachat-rpc-server-armv7l-linux
-          - deltachat-rpc-server-armv7l-linux-wheel
-          - deltachat-rpc-server-i686-linux
-          - deltachat-rpc-server-i686-linux-wheel
-          - deltachat-rpc-server-source
-          - deltachat-rpc-server-win32
-          - deltachat-rpc-server-win32-wheel
-          - deltachat-rpc-server-win64
-          - deltachat-rpc-server-win64-wheel
-          - deltachat-rpc-server-x86_64-linux
-          - deltachat-rpc-server-x86_64-linux-wheel
-          - docs
-          - libdeltachat
-          - python-docs
-
-          # Fails to build
-          #- deltachat-repl-x86_64-android
-          #- deltachat-repl-x86-android
-          #- deltachat-rpc-server-x86_64-android
-          #- deltachat-rpc-server-x86-android
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          show-progress: false
-      - uses: DeterminateSystems/nix-installer-action@main
-      - uses: DeterminateSystems/magic-nix-cache-action@main
-      - run: nix build .#${{ matrix.installable }}
-
-  build-macos:
-    name: nix build on macOS
-    runs-on: macos-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        installable:
-          - deltachat-rpc-server-aarch64-darwin
-
-          # Fails to bulid
-          # - deltachat-rpc-server-x86_64-darwin
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          show-progress: false
-      - uses: DeterminateSystems/nix-installer-action@main
-      - uses: DeterminateSystems/magic-nix-cache-action@main
-      - run: nix build .#${{ matrix.installable }}

CHANGELOG.md

@@ -1,218 +1,5 @@
 # Changelog
 
-## [1.151.5] - 2024-12-05
-
-### API-Changes
-
-- [**breaking**] Remove dc_all_work_done().
-
-### Fixes
-
-- Store plaintext in mime_headers of truncated sent messages ([#6273](https://github.com/deltachat/deltachat-core-rust/pull/6273)).
-- cargo: Update rPGP to 0.14.2.
-
-### Documentation
-
-- Document `push` module.
-- Remove mention of non-existent `nightly` feature.
-
-### Tests
-
-- Fix panic in `receive_emails` benchmark ([#6306](https://github.com/deltachat/deltachat-core-rust/pull/6306)).
-
-## [1.151.4] - 2024-12-03
-
-### Features / Changes
-
-- Encrypt notification tokens.
-
-### Fixes
-
-- Replace connectivity state "Connected" with "Preparing".
-
-### Miscellaneous Tasks
-
-- Beta clippy suggestions ([#6271](https://github.com/deltachat/deltachat-core-rust/pull/6271)).
-
-### Tests
-
-- Fix `cargo check` for `receive_emails` benchmark.
-
-### CI
-
-- Also run cargo check without all-features.
-
-## [1.151.3] - 2024-12-02
-
-### API-Changes
-
-- Remove experimental `request_internet_access` option from webxdc's `manifest.toml`.
-- Add getWebxdcHref to json api ([#6281](https://github.com/deltachat/deltachat-core-rust/pull/6281)).
-
-### CI
-
-- Update Rust to 1.83.0.
-
-### Documentation
-
-- Update dc_msg_get_info_type() and dc_get_securejoin_qr() ([#6269](https://github.com/deltachat/deltachat-core-rust/pull/6269)).
-- Fix references to iroh-related headers in peer_channels docs.
-- Improve CFFI docs, link to corresponding JSON-RPC docs.
-
-### Features / Changes
-
-- Allow the user to replace maps integration ([#5678](https://github.com/deltachat/deltachat-core-rust/pull/5678)).
-- Mark saved messages chat as protected.
-
-### Fixes
-
-- Close iroh endpoint when I/O is stopped.
-- Do not add protection messages to Saved Messages chat.
-- Mark Saved Messages chat as protected if it exists.
-- Sync chat action even if sync message arrives before first one from contact ([#6259](https://github.com/deltachat/deltachat-core-rust/pull/6259)).
-
-### Refactor
-
-- Remove some .unwrap() calls.
-- Create_status_update_record: Remove double check of info_msg_id.
-- Use Option::or_else() to dedup emitting IncomingWebxdcNotify.
-
-## [1.151.2] - 2024-11-26
-
-### API-Changes
-
-- Deprecate webxdc `descr` parameter ([#6255](https://github.com/deltachat/deltachat-core-rust/pull/6255)).
-
-### Features / Changes
-
-- AEAP: Check that the old peerstate verified key fingerprint hasn't changed when removing it.
-- Add `AccountsChanged` and `AccountsItemChanged` events ([#6118](https://github.com/deltachat/deltachat-core-rust/pull/6118)).
-- Do not use format=flowed in outgoing messages ([#6256](https://github.com/deltachat/deltachat-core-rust/pull/6256)).
-- Add webxdc limits api.
-- Add href to IncomingWebxdcNotify event ([#6266](https://github.com/deltachat/deltachat-core-rust/pull/6266)).
-
-### Fixes
-
-- Revert treating some transient SMTP errors as permanent.
-
-### Refactor
-
-- Create_status_update_record: Get rid of `notify` var.
-
-### Tests
-
-- Check that IncomingMsg isn't emitted for reactions.
-
-## [1.151.1] - 2024-11-24
-
-### Build system
-
-- nix: Fix deltachat-rpc-server-source installable.
-
-### CI
-
-- Test building nix targets to avoid regressions.
-
-## [1.151.0] - 2024-11-23
-
-### Features / Changes
-
-- Trim whitespace from scanned QR codes.
-- Use privacy-preserving webxdc addresses ([#6237](https://github.com/deltachat/deltachat-core-rust/pull/6237)).
-- Webxdc notify ([#6230](https://github.com/deltachat/deltachat-core-rust/pull/6230)).
-- `update.href` api ([#6248](https://github.com/deltachat/deltachat-core-rust/pull/6248)).
-
-### Fixes
-
-- Never notify SELF ([#6251](https://github.com/deltachat/deltachat-core-rust/pull/6251)).
-
-### Build system
-
-- Use underscores in deltachat-rpc-server source package filename.
-- Remove imap_tools from dependencies ([#6238](https://github.com/deltachat/deltachat-core-rust/pull/6238)).
-- cargo: Update Rustls from 0.23.14 to 0.23.18.
-- deps: Bump curve25519-dalek from 3.2.0 to 4.1.3 in /fuzz.
-
-### Documentation
-
-- Move style guide into a separate document.
-- Clarify DC_EVENT_INCOMING_WEBXDC_NOTIFY documentation ([#6249](https://github.com/deltachat/deltachat-core-rust/pull/6249)).
-
-### Tests
-
-- After AEAP, 1:1 chat isn't available for sending, but unprotected groups are ([#6222](https://github.com/deltachat/deltachat-core-rust/pull/6222)).
-
-## [1.150.0] - 2024-11-21
-
-### API-Changes
-
-- Correct `DC_CERTCK_ACCEPT_*` values and docs ([#6176](https://github.com/deltachat/deltachat-core-rust/pull/6176)).
-
-### Features / Changes
-
-- Use Rustls for connections with strict TLS ([#6186](https://github.com/deltachat/deltachat-core-rust/pull/6186)).
-- Experimental header protection for Autocrypt.
-- Tune down io-not-started info in connectivity-html.
-- Clear config cache in start_io() ([#6228](https://github.com/deltachat/deltachat-core-rust/pull/6228)).
-- Line-before-quote may be up to 120 character long instead of 80.
-- Use i.delta.chat in qr codes ([#6223](https://github.com/deltachat/deltachat-core-rust/pull/6223)).
-
-### Fixes
-
-- Prevent accidental wrong-password-notifications ([#6122](https://github.com/deltachat/deltachat-core-rust/pull/6122)).
-- Remove footers from "Show Full Message...".
-- `send_msg_to_smtp`: Return Ok if `smtp` row is deleted in parallel.
-- Only add "member added/removed" messages if they actually do that ([#5992](https://github.com/deltachat/deltachat-core-rust/pull/5992)).
-- Do not fail to load chatlist summary if the message got removed.
-- deltachat-jsonrpc: Do not fail `get_chatlist_items_by_entries` if the message got deleted.
-- deltachat-jsonrpc: Do not fail `get_draft` if draft is deleted.
-- `markseen_msgs`: Limit not yet downloaded messages state to `InNoticed` ([#2970](https://github.com/deltachat/deltachat-core-rust/pull/2970)).
-- Update state of message when fully downloading it.
-- Dont overwrite equal drafts ([#6212](https://github.com/deltachat/deltachat-core-rust/pull/6212)).
-
-### Build system
-
-- Silence RUSTSEC-2024-0384.
-- cargo: Update rPGP from 0.13.2 to 0.14.0.
-- cargo: Update futures-concurrency from 7.6.1 to 7.6.2.
-- Update flake.nix ([#6200](https://github.com/deltachat/deltachat-core-rust/pull/6200))
-
-### CI
-
-- Ensure flake is formatted.
-
-### Documentation
-
-- Scanned proxies are added and normalized.
-
-### Refactor
-
-- Fix nightly clippy warnings.
-- Remove slicing from `is_file_in_use`.
-- Remove unnecessary `allow(clippy::indexing_slicing)`.
-- Don't use slicing in `remove_nonstandard_footer`.
-- Do not use slicing in `qr` module.
-- Eliminate indexing in `compute_mailinglist_name`.
-- Remove unused `allow(clippy::indexing_slicing)`.
-- Remove indexing/slicing from `remove_message_footer`.
-- Remove indexing/slicing from `squash_attachment_parts`.
-- Remove unused allow(clippy::indexing_slicing) for heuristically_parse_ndn.
-- Remove indexing/slicing from `parse_message_ids`.
-- Remove slicing from `remove_bottom_quote`.
-- Get rid of slicing in `remove_top_quote`.
-- Remove unused allow(clippy::indexing_slicing) from 'truncate'.
-- Forbid clippy::indexing_slicing.
-- Forbid clippy::string_slice.
-- Delete chat in a transaction.
-- Fix typo in `context.rs`.
-
-### Tests
-
-- Remove all calls to print() from deltachat-rpc-client tests.
-- Reply to protected group from MUA.
-- Mark not downloaded message as seen ([#2970](https://github.com/deltachat/deltachat-core-rust/pull/2970)).
-- Mark `receive_imf()` as only for tests and "internals" feature ([#6235](https://github.com/deltachat/deltachat-core-rust/pull/6235)).
-
 ## [1.149.0] - 2024-11-05
 
 ### Build system
@@ -449,7 +236,7 @@ This reverts commit 6f22ce2722b51773d7fbb0d89e4764f963cafd91..
 - Reset quota on configured address change ([#5908](https://github.com/deltachat/deltachat-core-rust/pull/5908)).
 - Do not emit progress 1000 when configuration is cancelled.
 - Assume file extensions are 32 chars max and don't contain whitespace ([#5338](https://github.com/deltachat/deltachat-core-rust/pull/5338)).
-- Re-add tokens.foreign_id column ([#6038](https://github.com/deltachat/deltachat-core-rust/pull/6038)).
+- Readd tokens.foreign_id column ([#6038](https://github.com/deltachat/deltachat-core-rust/pull/6038)).
 
 ### Miscellaneous Tasks
 
@@ -1040,7 +827,7 @@ This reverts commit 6f22ce2722b51773d7fbb0d89e4764f963cafd91..
 
 ### Tests
 
-- deltachat-rpc-client: re-enable `log_cli`.
+- deltachat-rpc-client: reenable `log_cli`.
 
 ## [1.140.0] - 2024-06-04
 
@@ -1977,7 +1764,7 @@ This reverts commit 6f22ce2722b51773d7fbb0d89e4764f963cafd91..
   - Mark 1:1 chat as verified for Bob early. 1:1 chat with Alice is verified as soon as Alice's key is verified rather than at the end of the protocol.
 - Put Message-ID into hidden headers and take it from there on receiver ([#4798](https://github.com/deltachat/deltachat-core-rust/pull/4798)). This works around servers which generate their own Message-ID and overwrite the one generated by Delta Chat.
 - deltachat-repl: Enable INFO logging by default and add timestamps.
-- Add `ConfigSynced` (`DC_EVENT_CONFIG_SYNCED`) event which is emitted when configuration is changed via synchronization message or synchronization message for configuration is sent. UI may refresh elements based on the configuration key which is a part of the event.
+- Add `ConfigSynced` (`DC_EVENT_CONFIG_SYNCED`) event which is emitted when configuration is changed via synchronization message or synchronization message for configuration is sent. UI may refresh elments based on the configuration key which is a part of the event.
 - Sync contact creation/rename across devices ([#5163](https://github.com/deltachat/deltachat-core-rust/pull/5163)).
 - Encrypt MDNs ([#5175](https://github.com/deltachat/deltachat-core-rust/pull/5175)).
 - Only try to configure non-strict TLS checks if explicitly set ([#5181](https://github.com/deltachat/deltachat-core-rust/pull/5181)).
@@ -5442,10 +5229,3 @@ https://github.com/deltachat/deltachat-core-rust/pulls?q=is%3Apr+is%3Aclosed
 [1.148.6]: https://github.com/deltachat/deltachat-core-rust/compare/v1.148.5..v1.148.6
 [1.148.7]: https://github.com/deltachat/deltachat-core-rust/compare/v1.148.6..v1.148.7
 [1.149.0]: https://github.com/deltachat/deltachat-core-rust/compare/v1.148.7..v1.149.0
-[1.150.0]: https://github.com/deltachat/deltachat-core-rust/compare/v1.149.0..v1.150.0
-[1.151.0]: https://github.com/deltachat/deltachat-core-rust/compare/v1.150.0..v1.151.0
-[1.151.1]: https://github.com/deltachat/deltachat-core-rust/compare/v1.151.0..v1.151.1
-[1.151.2]: https://github.com/deltachat/deltachat-core-rust/compare/v1.151.1..v1.151.2
-[1.151.3]: https://github.com/deltachat/deltachat-core-rust/compare/v1.151.2..v1.151.3
-[1.151.4]: https://github.com/deltachat/deltachat-core-rust/compare/v1.151.3..v1.151.4
-[1.151.5]: https://github.com/deltachat/deltachat-core-rust/compare/v1.151.4..v1.151.5

CONTRIBUTING.md

@@ -1,6 +1,6 @@
-# Contributing to Delta Chat
+# Contributing guidelines
 
-## Bug reports
+## Reporting bugs
 
 If you found a bug, [report it on GitHub](https://github.com/deltachat/deltachat-core-rust/issues).
 If the bug you found is specific to
@@ -9,114 +9,178 @@ If the bug you found is specific to
 [Desktop](https://github.com/deltachat/deltachat-desktop/issues),
 report it to the corresponding repository.
 
-## Feature proposals
+## Proposing features
 
 If you have a feature request, create a new topic on the [forum](https://support.delta.chat/).
 
-## Code contributions
+## Contributing code
 
-If you want to contribute a code, follow this guide.
+If you want to contribute a code, [open a Pull Request](https://github.com/deltachat/deltachat-core-rust/pulls).
 
-1. **Select an issue to work on.**
-
-   If you have an write access to the repository, assign the issue to yourself.
-   Otherwise state in the comment that you are going to work on the issue
-   to avoid duplicate work.
-
-   If the issue does not exist yet, create it first.
-
-2. **Write the code.**
-
-   Follow the [coding conventions](STYLE.md) when writing the code.
-
-3. **Commit the code.**
-
-   If you have write access to the repository,
-   push a branch named `<username>/<feature>`
-   so it is clear who is responsible for the branch,
-   and open a PR proposing to merge the change.
-   Otherwise fork the repository and create a branch in your fork.
-
-   Commit messages follow the [Conventional Commits] notation.
-   We use [git-cliff] to generate the changelog from commit messages before the release.
-
-   With **`git cliff --unreleased`**, you can check how the changelog entry for your commit will look.
-
-   The following prefix types are used:
-   - `feat`: Features, e.g. "feat: Pause IO for BackupProvider". If you are unsure what's the category of your commit, you can often just use `feat`.
-   - `fix`: Bug fixes, e.g. "fix: delete `smtp` rows when message sending is cancelled"
-   - `api`: API changes, e.g. "api(rust): add `get_msg_read_receipts(context, msg_id)`"
-   - `refactor`: Refactorings, e.g. "refactor: iterate over `msg_ids` without `.iter()`"
-   - `perf`: Performance improvements, e.g. "perf: improve SQLite performance with `PRAGMA synchronous=normal`"
-   - `test`: Test changes and improvements to the testing framework.
-   - `build`: Build system and tool configuration changes, e.g. "build(git-cliff): put "ci" commits into "CI" section of changelog"
-   - `ci`: CI configuration changes, e.g. "ci: limit artifact retention time for `libdeltachat.a` to 1 day"
-   - `docs`: Documentation changes, e.g. "docs: add contributing guidelines"
-   - `chore`: miscellaneous tasks, e.g. "chore: add `.DS_Store` to `.gitignore`"
-
-   Release preparation commits are marked as "chore(release): prepare for X.Y.Z"
-   as described in [releasing guide](RELEASE.md).
-
-   Use a `!` to mark breaking changes, e.g. "api!: Remove `dc_chat_can_send`".
-
-   Alternatively, breaking changes can go into the commit description, e.g.:
-
-   ```
-   fix: Fix race condition and db corruption when a message was received during backup
-
-   BREAKING CHANGE: You have to call `dc_stop_io()`/`dc_start_io()` before/after `dc_imex(DC_IMEX_EXPORT_BACKUP)`
-   ```
-
-4. [**Open a Pull Request**](https://github.com/deltachat/deltachat-core-rust/pulls).
-
-   Refer to the corresponding issue.
-
-   If you intend to squash merge the PR from the web interface,
-   make sure the PR title follows the conventional commits notation
-   as it will end up being a commit title.
-   Otherwise make sure each commit title follows the conventional commit notation.
-
-5. **Make sure all CI checks succeed.**
-
-   CI runs the tests and checks code formatting.
-
-   While it is running, self-review your PR to make sure all the changes you expect are there
-   and there are no accidentally committed unrelated changes and files.
-
-   Push the necessary fixup commits or force-push to your branch if needed.
-
-6. **Ask for review.**
-
-   Use built-in GitHub feature to request a review from suggested reviewers.
-
-   If you do not have write access to the repository, ask for review in the comments.
-
-7. **Merge the PR.**
-
-   Once a PR has an approval and passes CI, it can be merged.
-
-   PRs from a branch created in the main repository,
-   i.e. authored by those who have write access, are merged by their authors.
-
-   This is to ensure that PRs are merged as intended by the author,
-   e.g. as a squash merge, by rebasing from the web interface or manually from the command line.
-
-   If you have multiple changes in one PR, do a rebase merge.
-   Otherwise, you should usually do a squash merge.
-
-   If PR author does not have write access to the repository,
-   maintainers who reviewed the PR can merge it.
-
-   If you do not have access to the repository and created a PR from a fork,
-   ask the maintainers to merge the PR and say how it should be merged.
-
-## Other ways to contribute
-
-For other ways to contribute, refer to the [website](https://delta.chat/en/contribute).
+If you have write access to the repository,
+push a branch named `<username>/<feature>`
+so it is clear who is responsible for the branch,
+and open a PR proposing to merge the change.
+Otherwise fork the repository and create a branch in your fork.
 
 You can find the list of good first issues
 and a link to this guide
 on the contributing page: <https://github.com/deltachat/deltachat-core-rust/contribute>
 
+### Coding conventions
+
+We format the code using `rustfmt`. Run `cargo fmt` prior to committing the code.
+Run `scripts/clippy.sh` to check the code for common mistakes with [Clippy].
+
+### SQL
+
+Multi-line SQL statements should be formatted using string literals,
+for example
+```
+    sql.execute(
+        "CREATE TABLE messages (
+id INTEGER PRIMARY KEY AUTOINCREMENT,
+text TEXT DEFAULT '' NOT NULL -- message text
+) STRICT",
+    )
+    .await?;
+```
+
+Do not use macros like [`concat!`](https://doc.rust-lang.org/std/macro.concat.html)
+or [`indoc!](https://docs.rs/indoc).
+Do not escape newlines like this:
+```
+    sql.execute(
+        "CREATE TABLE messages ( \
+id INTEGER PRIMARY KEY AUTOINCREMENT, \
+text TEXT DEFAULT '' NOT NULL \
+) STRICT",
+    )
+    .await?;
+```
+Escaping newlines
+is prone to errors like this if space before backslash is missing:
+```
+"SELECT foo\
+ FROM bar"
+```
+Literal above results in `SELECT fooFROM bar` string.
+This style also does not allow using `--` comments.
+
+---
+
+Declare new SQL tables with [`STRICT`](https://sqlite.org/stricttables.html) keyword
+to make SQLite check column types.
+
+Declare primary keys with [`AUTOINCREMENT`](https://www.sqlite.org/autoinc.html) keyword.
+This avoids reuse of the row IDs and can avoid dangerous bugs
+like forwarding wrong message because the message was deleted
+and another message took its row ID.
+
+Declare all new columns as `NOT NULL`
+and set the `DEFAULT` value if it is optional so the column can be skipped in `INSERT` statements.
+Dealing with `NULL` values both in SQL and in Rust is tricky and we try to avoid it.
+If column is already declared without `NOT NULL`, use `IFNULL` function to provide default value when selecting it.
+Use `HAVING COUNT(*) > 0` clause
+to [prevent aggregate functions such as `MIN` and `MAX` from returning `NULL`](https://stackoverflow.com/questions/66527856/aggregate-functions-max-etc-return-null-instead-of-no-rows).
+
+Don't delete unused columns too early, but maybe after several months/releases, unused columns are
+still used by older versions, so deleting them breaks downgrading the core or importing a backup in
+an older version. Also don't change the column type, consider adding a new column with another name
+instead. Finally, never change column semantics, this is especially dangerous because the `STRICT`
+keyword doesn't help here.
+
+### Commit messages
+
+Commit messages follow the [Conventional Commits] notation.
+We use [git-cliff] to generate the changelog from commit messages before the release.
+
+With **`git cliff --unreleased`**, you can check how the changelog entry for your commit will look.
+
+The following prefix types are used:
+- `feat`: Features, e.g. "feat: Pause IO for BackupProvider". If you are unsure what's the category of your commit, you can often just use `feat`.
+- `fix`: Bug fixes, e.g. "fix: delete `smtp` rows when message sending is cancelled"
+- `api`: API changes, e.g. "api(rust): add `get_msg_read_receipts(context, msg_id)`"
+- `refactor`: Refactorings, e.g. "refactor: iterate over `msg_ids` without `.iter()`"
+- `perf`: Performance improvements, e.g. "perf: improve SQLite performance with `PRAGMA synchronous=normal`"
+- `test`: Test changes and improvements to the testing framework.
+- `build`: Build system and tool configuration changes, e.g. "build(git-cliff): put "ci" commits into "CI" section of changelog"
+- `ci`: CI configuration changes, e.g. "ci: limit artifact retention time for `libdeltachat.a` to 1 day"
+- `docs`: Documentation changes, e.g. "docs: add contributing guidelines"
+- `chore`: miscellaneous tasks, e.g. "chore: add `.DS_Store` to `.gitignore`"
+
+Release preparation commits are marked as "chore(release): prepare for vX.Y.Z".
+
+If you intend to squash merge the PR from the web interface,
+make sure the PR title follows the conventional commits notation
+as it will end up being a commit title.
+Otherwise make sure each commit title follows the conventional commit notation.
+
+#### Breaking Changes
+
+Use a `!` to mark breaking changes, e.g. "api!: Remove `dc_chat_can_send`".
+
+Alternatively, breaking changes can go into the commit description, e.g.:
+
+```
+fix: Fix race condition and db corruption when a message was received during backup
+
+BREAKING CHANGE: You have to call `dc_stop_io()`/`dc_start_io()` before/after `dc_imex(DC_IMEX_EXPORT_BACKUP)`
+```
+
+#### Multiple Changes in one PR
+
+If you have multiple changes in one PR, create multiple conventional commits, and then do a rebase merge. Otherwise, you should usually do a squash merge.
+
+[Clippy]: https://doc.rust-lang.org/clippy/
 [Conventional Commits]: https://www.conventionalcommits.org/
 [git-cliff]: https://git-cliff.org/
+
+### Errors
+
+Delta Chat core mostly uses [`anyhow`](https://docs.rs/anyhow/) errors.
+When using [`Context`](https://docs.rs/anyhow/latest/anyhow/trait.Context.html),
+capitalize it but do not add a full stop as the contexts will be separated by `:`.
+For example:
+```
+.with_context(|| format!("Unable to trash message {msg_id}"))
+```
+
+All errors should be handled in one of these ways:
+- With `if let Err() =` (incl. logging them into `warn!()`/`err!()`).
+- With `.log_err().ok()`.
+- Bubbled up with `?`.
+
+`backtrace` feature is enabled for `anyhow` crate
+and `debug = 1` option is set in the test profile.
+This allows to run `RUST_BACKTRACE=1 cargo test`
+and get a backtrace with line numbers in resultified tests
+which return `anyhow::Result`.
+
+### Logging
+
+For logging, use `info!`, `warn!` and `error!` macros.
+Log messages should be capitalized and have a full stop in the end. For example:
+```
+info!(context, "Ignoring addition of {added_addr:?} to {chat_id}.");
+```
+
+Format anyhow errors with `{:#}` to print all the contexts like this:
+```
+error!(context, "Failed to set selfavatar timestamp: {err:#}.");
+```
+
+### Reviewing
+
+Once a PR has an approval and passes CI, it can be merged.
+
+PRs from a branch created in the main repository, i.e. authored by those who have write access, are merged by their authors.
+This is to ensure that PRs are merged as intended by the author,
+e.g. as a squash merge, by rebasing from the web interface or manually from the command line.
+
+If you do not have access to the repository and created a PR from a fork,
+ask the maintainers to merge the PR and say how it should be merged.
+
+## Other ways to contribute
+
+For other ways to contribute, refer to the [website](https://delta.chat/en/contribute).

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "deltachat"
-version = "1.151.5"
+version = "1.149.0"
 edition = "2021"
 license = "MPL-2.0"
 rust-version = "1.77"
@@ -43,7 +43,7 @@ async-broadcast = "0.7.1"
 async-channel = { workspace = true }
 async-imap = { version = "0.10.2", default-features = false, features = ["runtime-tokio", "compress"] }
 async-native-tls = { version = "0.5", default-features = false, features = ["runtime-tokio"] }
-async-smtp = { version = "0.10", default-features = false, features = ["runtime-tokio"] }
+async-smtp = { version = "0.9", default-features = false, features = ["runtime-tokio"] }
 async_zip = { version = "0.0.17", default-features = false, features = ["deflate", "tokio-fs"] }
 base64 = { workspace = true }
 brotli = { version = "7", default-features=false, features = ["std"] }
@@ -62,10 +62,10 @@ http-body-util = "0.1.2"
 humansize = "2"
 hyper = "1"
 hyper-util = "0.1.10"
-image = { version = "0.25.5", default-features=false, features = ["gif", "jpeg", "ico", "png", "pnm", "webp", "bmp"] }
+image = { version = "0.25.4", default-features=false, features = ["gif", "jpeg", "ico", "png", "pnm", "webp", "bmp"] }
 iroh-gossip = { version = "0.28.1", default-features = false, features = ["net"] }
 iroh-net = { version = "0.28.1", default-features = false }
-kamadak-exif = "0.6.1"
+kamadak-exif = "0.6.0"
 lettre_email = { git = "https://github.com/deltachat/lettre", branch = "master" }
 libc = { workspace = true }
 mailparse = "0.15"
@@ -76,7 +76,7 @@ num-traits = { workspace = true }
 once_cell = { workspace = true }
 parking_lot = "0.12"
 percent-encoding = "2.3"
-pgp = { version = "0.14.2", default-features = false }
+pgp = { version = "0.13.2", default-features = false }
 pin-project = "1"
 qrcodegen = "1.7.0"
 quick-xml = "0.37"
@@ -86,13 +86,12 @@ regex = { workspace = true }
 rusqlite = { workspace = true, features = ["sqlcipher"] }
 rust-hsluv = "0.1"
 rustls-pki-types = "1.10.0"
-rustls = { version = "0.23.19", default-features = false }
+rustls = { version = "0.23.14", default-features = false }
 sanitize-filename = { workspace = true }
 serde_json = { workspace = true }
 serde_urlencoded = "0.7.1"
 serde = { workspace = true, features = ["derive"] }
 sha-1 = "0.10"
-sha2 = "0.10"
 shadowsocks = { version = "1.21.0", default-features = false, features = ["aead-cipher-2022"] }
 smallvec = "1.13.2"
 strum = "0.26"
@@ -109,7 +108,7 @@ tokio = { workspace = true, features = ["fs", "rt-multi-thread", "macros"] }
 toml = "0.8"
 url = "2"
 uuid = { version = "1", features = ["serde", "v4"] }
-webpki-roots = "0.26.7"
+webpki-roots = "0.26.6"
 
 [dev-dependencies]
 anyhow = { workspace = true, features = ["backtrace"] } # Enable `backtrace` feature in tests.
@@ -150,7 +149,6 @@ harness = false
 
 [[bench]]
 name = "receive_emails"
-required-features = ["internals"]
 harness = false
 
 [[bench]]
@@ -174,7 +172,7 @@ deltachat-contact-tools = { path = "deltachat-contact-tools" }
 deltachat-jsonrpc = { path = "deltachat-jsonrpc", default-features = false }
 deltachat = { path = ".", default-features = false }
 futures = "0.3.31"
-futures-lite = "2.5.0"
+futures-lite = "2.4.0"
 libc = "0.2"
 log = "0.4"
 nu-ansi-term = "0.46"
@@ -186,7 +184,7 @@ rusqlite = "0.32"
 sanitize-filename = "0.5"
 serde = "1.0"
 serde_json = "1"
-tempfile = "3.14.0"
+tempfile = "3.13.0"
 thiserror = "1"
 tokio = "1"
 tokio-util = "0.7.11"

README.md

@@ -161,6 +161,7 @@ $ cargo bolero test fuzz_format_flowed --release=false -e afl -s NONE
 ## Features
 
 - `vendored`: When using Openssl for TLS, this bundles a vendored version.
+- `nightly`: Enable nightly only performance and security related features.
 
 ## Update Provider Data
 

RELEASE.md

@@ -14,8 +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. Tag the release: `git tag --annotate v1.116.0`.
+6. Tag the release: `git tag -a v1.116.0`.
 
 7. Push the release tag: `git push origin v1.116.0`.
 
-8. Create a GitHub release: `gh release create v1.116.0 --notes ''`.
+8. Create a GitHub release: `gh release create v1.116.0 -n ''`.

STYLE.md

@@ -1,98 +0,0 @@
-# Coding conventions
-
-We format the code using `rustfmt`. Run `cargo fmt` prior to committing the code.
-Run `scripts/clippy.sh` to check the code for common mistakes with [Clippy].
-
-[Clippy]: https://doc.rust-lang.org/clippy/
-
-## SQL
-
-Multi-line SQL statements should be formatted using string literals,
-for example
-```
-    sql.execute(
-        "CREATE TABLE messages (
-id INTEGER PRIMARY KEY AUTOINCREMENT,
-text TEXT DEFAULT '' NOT NULL -- message text
-) STRICT",
-    )
-    .await?;
-```
-
-Do not use macros like [`concat!`](https://doc.rust-lang.org/std/macro.concat.html)
-or [`indoc!](https://docs.rs/indoc).
-Do not escape newlines like this:
-```
-    sql.execute(
-        "CREATE TABLE messages ( \
-id INTEGER PRIMARY KEY AUTOINCREMENT, \
-text TEXT DEFAULT '' NOT NULL \
-) STRICT",
-    )
-    .await?;
-```
-Escaping newlines
-is prone to errors like this if space before backslash is missing:
-```
-"SELECT foo\
- FROM bar"
-```
-Literal above results in `SELECT fooFROM bar` string.
-This style also does not allow using `--` comments.
-
----
-
-Declare new SQL tables with [`STRICT`](https://sqlite.org/stricttables.html) keyword
-to make SQLite check column types.
-
-Declare primary keys with [`AUTOINCREMENT`](https://www.sqlite.org/autoinc.html) keyword.
-This avoids reuse of the row IDs and can avoid dangerous bugs
-like forwarding wrong message because the message was deleted
-and another message took its row ID.
-
-Declare all new columns as `NOT NULL`
-and set the `DEFAULT` value if it is optional so the column can be skipped in `INSERT` statements.
-Dealing with `NULL` values both in SQL and in Rust is tricky and we try to avoid it.
-If column is already declared without `NOT NULL`, use `IFNULL` function to provide default value when selecting it.
-Use `HAVING COUNT(*) > 0` clause
-to [prevent aggregate functions such as `MIN` and `MAX` from returning `NULL`](https://stackoverflow.com/questions/66527856/aggregate-functions-max-etc-return-null-instead-of-no-rows).
-
-Don't delete unused columns too early, but maybe after several months/releases, unused columns are
-still used by older versions, so deleting them breaks downgrading the core or importing a backup in
-an older version. Also don't change the column type, consider adding a new column with another name
-instead. Finally, never change column semantics, this is especially dangerous because the `STRICT`
-keyword doesn't help here.
-
-## Errors
-
-Delta Chat core mostly uses [`anyhow`](https://docs.rs/anyhow/) errors.
-When using [`Context`](https://docs.rs/anyhow/latest/anyhow/trait.Context.html),
-capitalize it but do not add a full stop as the contexts will be separated by `:`.
-For example:
-```
-.with_context(|| format!("Unable to trash message {msg_id}"))
-```
-
-All errors should be handled in one of these ways:
-- With `if let Err() =` (incl. logging them into `warn!()`/`err!()`).
-- With `.log_err().ok()`.
-- Bubbled up with `?`.
-
-`backtrace` feature is enabled for `anyhow` crate
-and `debug = 1` option is set in the test profile.
-This allows to run `RUST_BACKTRACE=1 cargo test`
-and get a backtrace with line numbers in resultified tests
-which return `anyhow::Result`.
-
-## Logging
-
-For logging, use `info!`, `warn!` and `error!` macros.
-Log messages should be capitalized and have a full stop in the end. For example:
-```
-info!(context, "Ignoring addition of {added_addr:?} to {chat_id}.");
-```
-
-Format anyhow errors with `{:#}` to print all the contexts like this:
-```
-error!(context, "Failed to set selfavatar timestamp: {err:#}.");
-```

benches/receive_emails.rs

@@ -12,18 +12,18 @@ use deltachat::{
 };
 use tempfile::tempdir;
 
-async fn recv_all_emails(context: Context, iteration: u32) -> Context {
+async fn recv_all_emails(context: Context) -> Context {
     for i in 0..100 {
         let imf_raw = format!(
             "Subject: Benchmark
-Message-ID: Mr.{iteration}.{i}@testrun.org
+Message-ID: Mr.OssSYnOFkhR.{i}@testrun.org
 Date: Sat, 07 Dec 2019 19:00:27 +0000
 To: alice@example.com
 From: sender@testrun.org
 Chat-Version: 1.0
 Chat-Disposition-Notification-To: sender@testrun.org
 Chat-User-Avatar: 0
-In-Reply-To: Mr.{iteration}.{i_dec}@testrun.org
+In-Reply-To: Mr.OssSYnOFkhR.{i_dec}@testrun.org
 MIME-Version: 1.0
 
 Content-Type: text/plain; charset=utf-8; format=flowed; delsp=no
@@ -41,11 +41,11 @@ Hello {i}",
 
 /// Receive 100 emails that remove charlie@example.com and add
 /// him back
-async fn recv_groupmembership_emails(context: Context, iteration: u32) -> Context {
+async fn recv_groupmembership_emails(context: Context) -> Context {
     for i in 0..50 {
         let imf_raw = format!(
             "Subject: Benchmark
-Message-ID: Gr.{iteration}.ADD.{i}@testrun.org
+Message-ID: Gr.OssSYnOFkhR.{i}@testrun.org
 Date: Sat, 07 Dec 2019 19:00:27 +0000
 To: alice@example.com, b@example.com, c@example.com, d@example.com, e@example.com, f@example.com
 From: sender@testrun.org
@@ -53,12 +53,13 @@ Chat-Version: 1.0
 Chat-Disposition-Notification-To: sender@testrun.org
 Chat-User-Avatar: 0
 Chat-Group-Member-Added: charlie@example.com
-In-Reply-To: Gr.{iteration}.REMOVE.{i_dec}@testrun.org
+In-Reply-To: Gr.OssSYnOFkhR.{i_dec}@testrun.org
 MIME-Version: 1.0
 
 Content-Type: text/plain; charset=utf-8; format=flowed; delsp=no
 
 Hello {i}",
+            i = i,
             i_dec = i - 1,
         );
         receive_imf(&context, black_box(imf_raw.as_bytes()), false)
@@ -67,7 +68,7 @@ Hello {i}",
 
         let imf_raw = format!(
             "Subject: Benchmark
-Message-ID: Gr.{iteration}.REMOVE.{i}@testrun.org
+Message-ID: Gr.OssSYnOFkhR.{i}@testrun.org
 Date: Sat, 07 Dec 2019 19:00:27 +0000
 To: alice@example.com, b@example.com, c@example.com, d@example.com, e@example.com, f@example.com
 From: sender@testrun.org
@@ -75,12 +76,14 @@ Chat-Version: 1.0
 Chat-Disposition-Notification-To: sender@testrun.org
 Chat-User-Avatar: 0
 Chat-Group-Member-Removed: charlie@example.com
-In-Reply-To: Gr.{iteration}.ADD.{i}@testrun.org
+In-Reply-To: Gr.OssSYnOFkhR.{i_dec}@testrun.org
 MIME-Version: 1.0
 
 Content-Type: text/plain; charset=utf-8; format=flowed; delsp=no
 
-Hello {i}"
+Hello {i}",
+            i = i,
+            i_dec = i - 1,
         );
         receive_imf(&context, black_box(imf_raw.as_bytes()), false)
             .await
@@ -126,13 +129,11 @@ fn criterion_benchmark(c: &mut Criterion) {
     group.bench_function("Receive 100 simple text msgs", |b| {
         let rt = tokio::runtime::Runtime::new().unwrap();
         let context = rt.block_on(create_context());
-        let mut i = 0;
 
         b.to_async(&rt).iter(|| {
             let ctx = context.clone();
-            i += 1;
             async move {
-                recv_all_emails(black_box(ctx), i).await;
+                recv_all_emails(black_box(ctx)).await;
             }
         });
     });
@@ -141,13 +142,11 @@ fn criterion_benchmark(c: &mut Criterion) {
         |b| {
             let rt = tokio::runtime::Runtime::new().unwrap();
             let context = rt.block_on(create_context());
-            let mut i = 0;
 
             b.to_async(&rt).iter(|| {
                 let ctx = context.clone();
-                i += 1;
                 async move {
-                    recv_groupmembership_emails(black_box(ctx), i).await;
+                    recv_groupmembership_emails(black_box(ctx)).await;
                 }
             });
         },

deltachat-contact-tools/src/lib.rs

@@ -15,8 +15,7 @@
     clippy::explicit_into_iter_loop,
     clippy::cloned_instead_of_copied
 )]
-#![cfg_attr(not(test), forbid(clippy::indexing_slicing))]
-#![cfg_attr(not(test), forbid(clippy::string_slice))]
+#![cfg_attr(not(test), warn(clippy::indexing_slicing))]
 #![allow(
     clippy::match_bool,
     clippy::mixed_read_write_in_expression,

deltachat-ffi/Cargo.toml

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

deltachat-ffi/deltachat.h

@@ -418,7 +418,7 @@ char*           dc_get_blobdir               (const dc_context_t* context);
  * - `e2ee_enabled` = 0=no end-to-end-encryption, 1=prefer end-to-end-encryption (default)
  * - `mdns_enabled` = 0=do not send or request read receipts,
  *                    1=send and request read receipts
- *                    default=send and request read receipts, only send but not request if `bot` is set
+ *                    default=send and request read receipts, only send but not reuqest if `bot` is set
  * - `bcc_self`     = 0=do not send a copy of outgoing messages to self,
  *                    1=send a copy of outgoing messages to self (default).
  *                    Sending messages to self is needed for a proper multi-account setup,
@@ -722,6 +722,12 @@ char*           dc_get_connectivity_html     (dc_context_t* context);
 int              dc_get_push_state           (dc_context_t* context);
 
 
+/**
+ * Only used by the python tests.
+ */
+int             dc_all_work_done             (dc_context_t* context);
+
+
 // connect
 
 /**
@@ -979,7 +985,7 @@ uint32_t        dc_get_chat_id_by_contact_id (dc_context_t* context, uint32_t co
  * If the increation-method is not used - which is probably the normal case -
  * dc_send_msg() copies the file to the blob directory if it is not yet there.
  * To distinguish the two cases, msg->state must be set properly. The easiest
- * way to ensure this is to reuse the same object for both calls.
+ * way to ensure this is to re-use the same object for both calls.
  *
  * Example:
  * ~~~
@@ -1148,14 +1154,9 @@ uint32_t dc_send_videochat_invitation (dc_context_t* context, uint32_t chat_id);
  * @memberof dc_context_t
  * @param context The context object.
  * @param msg_id The ID of the message with the webxdc instance.
- * @param json program-readable data, this is created in JS land as:
- *     - `payload`: any JS object or primitive.
- *     - `info`: optional informational message. Will be shown in chat and may be added as system notification.
- *       note that also users that are not notified explicitly get the `info` or `summary` update shown in the chat.
- *     - `document`: optional document name. shown eg. in title bar.
- *     - `summary`: optional summary. shown beside app icon.
- *     - `notify`: optional array of other users `selfAddr` to be notified e.g. by a sound about `info` or `summary`.
- * @param descr Deprecated, set to NULL
+ * @param json program-readable data, the actual payload
+ * @param descr The user-visible description of JSON data,
+ *     in case of a chess game, e.g. the move.
  * @return 1=success, 0=error
  */
 int dc_send_webxdc_status_update (dc_context_t* context, uint32_t msg_id, const char* json, const char* descr);
@@ -2540,8 +2541,6 @@ void            dc_stop_ongoing_process      (dc_context_t* context);
  * - DC_QR_PROXY with dc_lot_t::text1=address:
  *   ask the user if they want to use the given proxy.
  *   if so, call dc_set_config_from_qr() and restart I/O.
- *   On success, dc_get_config(context, "proxy_url")
- *   will contain the new proxy in normalized form as the first element.
  *
  * - DC_QR_ADDR with dc_lot_t::id=Contact ID:
  *   e-mail address scanned, optionally, a draft message could be set in
@@ -2591,15 +2590,13 @@ dc_lot_t*       dc_check_qr                  (dc_context_t* context, const char*
 
 /**
  * Get QR code text that will offer an Setup-Contact or Verified-Group invitation.
+ * The QR code is compatible to the OPENPGP4FPR format
+ * so that a basic fingerprint comparison also works e.g. with OpenKeychain.
  *
  * The scanning device will pass the scanned content to dc_check_qr() then;
  * if dc_check_qr() returns DC_QR_ASK_VERIFYCONTACT or DC_QR_ASK_VERIFYGROUP
  * an out-of-band-verification can be joined using dc_join_securejoin()
  *
- * The returned text will also work as a normal https:-link,
- * so that the QR code is useful also without Delta Chat being installed
- * or can be passed to contacts through other channels.
- *
  * @memberof dc_context_t
  * @param context The context object.
  * @param chat_id If set to a group-chat-id,
@@ -4195,13 +4192,9 @@ char*             dc_msg_get_webxdc_blob      (const dc_msg_t* msg, const char*
  *   defaults to an empty string.
  *   Implementations may offer an menu or a button to open this URL.
  * - internet_access:
- *   true if the Webxdc should get internet access;
- *   this is the case i.e. for experimental maps integration.
- * - self_addr: address to be used for `window.webxdc.selfAddr` in JS land.
- * - send_update_interval: Milliseconds to wait before calling `sendUpdate()` again since the last call.
- *   Should be exposed to `webxdc.sendUpdateInterval` in JS land.
- * - send_update_max_size: Maximum number of bytes accepted for a serialized update object.
- *   Should be exposed to `webxdc.sendUpdateMaxSize` in JS land.
+ *   true if the Webxdc should get full internet access, including Webrtc.
+ *   currently, this is only true for encrypted Webxdc's in the self chat
+ *   that have requested internet access in the manifest.
  *
  * @memberof dc_msg_t
  * @param msg The webxdc instance.
@@ -4487,7 +4480,6 @@ int             dc_msg_is_info                (const dc_msg_t* msg);
  * - DC_INFO_INVALID_UNENCRYPTED_MAIL (13) - Info-message for "Provider requires end-to-end encryption which is not setup yet",
  *   the UI should change the corresponding string using #DC_STR_INVALID_UNENCRYPTED_MAIL
  *   and also offer a way to fix the encryption, eg. by a button offering a QR scan
- * - DC_INFO_WEBXDC_INFO_MESSAGE (32) - Info-message created by webxdc app sending `update.info`
  *
  * Even when you display an icon,
  * you should still display the text of the informational message using dc_msg_get_text()
@@ -4517,24 +4509,6 @@ int             dc_msg_get_info_type          (const dc_msg_t* msg);
 #define         DC_INFO_INVALID_UNENCRYPTED_MAIL  13
 #define         DC_INFO_WEBXDC_INFO_MESSAGE       32
 
-
-/**
- * Get link attached to an webxdc info message.
- * The info message needs to be of type DC_INFO_WEBXDC_INFO_MESSAGE.
- *
- * Typically, this is used to set `document.location.href` in JS land.
- *
- * Webxdc apps can define the link by setting `update.href` when sending and update,
- * see dc_send_webxdc_status_update().
- *
- * @memberof dc_msg_t
- * @param msg The info message object.
- *     Not: the webxdc instance.
- * @return The link to be set to `document.location.href` in JS land.
- *     Returns NULL if there is no link attached to the info message and on errors.
- */
-char*           dc_msg_get_webxdc_href        (const dc_msg_t* msg);
-
 /**
  * Check if a message is still in creation. A message is in creation between
  * the calls to dc_prepare_msg() and dc_send_msg().
@@ -4700,7 +4674,7 @@ int dc_msg_has_html (dc_msg_t* msg);
   *                                     If the download fails or succeeds,
   *                                     the event @ref DC_EVENT_MSGS_CHANGED is emitted.
   *
-  * - @ref DC_DOWNLOAD_UNDECIPHERABLE - The message does not need any further download action.
+  * - @ref DC_DOWNLOAD_UNDECIPHERABLE - The message does not need any futher download action.
   *                                     It was fully downloaded, but we failed to decrypt it.
   * - @ref DC_DOWNLOAD_FAILURE        - Download error, the user may start over calling dc_download_full_msg() again.
   *
@@ -5735,14 +5709,8 @@ int64_t         dc_lot_get_timestamp     (const dc_lot_t* lot);
 #define DC_CERTCK_STRICT 1
 
 /**
- * Accept certificates that are expired, self-signed
- * or not valid for the server hostname.
- */
-#define DC_CERTCK_ACCEPT_INVALID 2
-
-/**
- * For API compatibility only: Treat this as DC_CERTCK_ACCEPT_INVALID on reading.
- * Must not be written.
+ * Accept invalid certificates, including self-signed ones
+ * or having incorrect hostname.
  */
 #define DC_CERTCK_ACCEPT_INVALID_CERTIFICATES 3
 
@@ -5782,23 +5750,6 @@ void dc_jsonrpc_unref(dc_jsonrpc_instance_t* jsonrpc_instance);
  * returns immediately and once the result is ready it can be retrieved via dc_jsonrpc_next_response()
  * the jsonrpc specification defines an invocation id that can then be used to match request and response.
  *
- * An overview of JSON-RPC calls is available at
- * <https://js.jsonrpc.delta.chat/classes/RawClient.html>.
- * Note that the page describes only the rough methods.
- * Calling convention, casing etc. does vary, this is a known flaw,
- * and at some point we will get to improve that :)
- *
- * Also, note that most calls are more high-level than this CFFI, require more database calls and are slower.
- * They're more suitable for an environment that is totally async and/or cannot use CFFI, which might not be true for native apps.
- *
- * Notable exceptions that exist only as JSON-RPC and probably never get a CFFI counterpart:
- * - getMessageReactions(), sendReaction()
- * - getHttpResponse()
- * - draftSelfReport()
- * - getAccountFileSize()
- * - importVcard(), parseVcard(), makeVcard()
- * - sendWebxdcRealtimeData, sendWebxdcRealtimeAdvertisement(), leaveWebxdcRealtime()
- *
  * @memberof dc_jsonrpc_instance_t
  * @param jsonrpc_instance jsonrpc instance as returned from dc_jsonrpc_init().
  * @param request JSON-RPC request as string
@@ -5819,8 +5770,6 @@ char* dc_jsonrpc_next_response(dc_jsonrpc_instance_t* jsonrpc_instance);
 /**
  * Make a JSON-RPC call and return a response.
  *
- * See dc_jsonrpc_request() for an overview of possible calls and for more information.
- *
  * @memberof dc_jsonrpc_instance_t
  * @param jsonrpc_instance jsonrpc instance as returned from dc_jsonrpc_init().
  * @param input JSON-RPC request.
@@ -5916,26 +5865,15 @@ int dc_event_get_data2_int(dc_event_t* event);
 
 /**
  * Get data associated with an event object.
- * The meaning of the data depends on the event ID returned as @ref DC_EVENT constants.
+ * The meaning of the data depends on the event ID
+ * returned as @ref DC_EVENT constants by dc_event_get_id().
+ * See also dc_event_get_data1_int() and dc_event_get_data2_int().
  *
  * @memberof dc_event_t
  * @param event Event object as returned from dc_get_next_event().
- * @return "data1" string or NULL.
- *     The meaning depends on the event type associated with this event.
- *     Must be freed using dc_str_unref().
- */
-char* dc_event_get_data1_str(dc_event_t* event);
-
-
-/**
- * Get data associated with an event object.
- * The meaning of the data depends on the event ID returned as @ref DC_EVENT constants.
- *
- * @memberof dc_event_t
- * @param event Event object as returned from dc_get_next_event().
- * @return "data2" string or NULL.
- *     The meaning depends on the event type associated with this event.
- *     Must be freed using dc_str_unref().
+ * @return "data2" as a string or NULL.
+ *     the meaning depends on the event type associated with this event.
+ *     Once you're done with the string, you have to unref it using dc_unref_str().
  */
 char* dc_event_get_data2_str(dc_event_t* event);
 
@@ -6133,35 +6071,12 @@ void dc_event_unref(dc_event_t* event);
 #define DC_EVENT_INCOMING_REACTION        2002
 
 
-
-/**
- * A webxdc wants an info message or a changed summary to be notified.
- *
- * @param data1 (int) contact_id ID _and_ (char*) href.
- *      - dc_event_get_data1_int() returns contact_id of the sending contact.
- *      - dc_event_get_data1_str() returns the href as set to `update.href`.
- * @param data2 (int) msg_id _and_ (char*) text_to_notify.
- *      - dc_event_get_data2_int() returns the msg_id,
- *        referring to the webxdc-info-message, if there is any.
- *        Sometimes no webxdc-info-message is added to the chat
- *        and yet a notification is sent; in this case the msg_id
- *        of the webxdc instance is returned.
- *      - dc_event_get_data2_str() returns text_to_notify,
- *        the text that shall be shown in the notification.
- *        string must be passed to dc_str_unref() afterwards.
- */
-#define DC_EVENT_INCOMING_WEBXDC_NOTIFY   2003
-
-
 /**
  * There is a fresh message. Typically, the user will show an notification
  * when receiving this message.
  *
  * There is no extra #DC_EVENT_MSGS_CHANGED event send together with this event.
  *
- * If the message is a webxdc info message,
- * dc_msg_get_parent() returns the webxdc instance the notification belongs to.
- *
  * @param data1 (int) chat_id
  * @param data2 (int) msg_id
  */
@@ -6445,25 +6360,6 @@ void dc_event_unref(dc_event_t* event);
 
 #define DC_EVENT_CHATLIST_ITEM_CHANGED         2301
 
-/**
- * Inform that the list of accounts has changed (an account removed or added or (not yet implemented) the account order changes)
- *
- * This event is only emitted by the account manager.
- */
-
-#define DC_EVENT_ACCOUNTS_CHANGED              2302
-
-/**
- * Inform that an account property that might be shown in the account list changed, namely:
- * - is_configured (see dc_is_configured())
- * - displayname
- * - selfavatar
- * - private_tag
- * 
- * This event is emitted from the account whose property changed.
- */
-
-#define DC_EVENT_ACCOUNTS_ITEM_CHANGED         2303
 
 /**
  * Inform that some events have been skipped due to event channel overflow.

deltachat-ffi/src/lib.rs

@@ -413,6 +413,16 @@ pub unsafe extern "C" fn dc_get_push_state(context: *const dc_context_t) -> libc
     block_on(ctx.push_state()) as libc::c_int
 }
 
+#[no_mangle]
+pub unsafe extern "C" fn dc_all_work_done(context: *mut dc_context_t) -> libc::c_int {
+    if context.is_null() {
+        eprintln!("ignoring careless call to dc_all_work_done()");
+        return 0;
+    }
+    let ctx = &*context;
+    block_on(async move { ctx.all_work_done().await as libc::c_int })
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn dc_get_oauth2_url(
     context: *mut dc_context_t,
@@ -532,7 +542,6 @@ pub unsafe extern "C" fn dc_event_get_id(event: *mut dc_event_t) -> libc::c_int
         EventType::MsgsChanged { .. } => 2000,
         EventType::ReactionsChanged { .. } => 2001,
         EventType::IncomingReaction { .. } => 2002,
-        EventType::IncomingWebxdcNotify { .. } => 2003,
         EventType::IncomingMsg { .. } => 2005,
         EventType::IncomingMsgBunch { .. } => 2006,
         EventType::MsgsNoticed { .. } => 2008,
@@ -559,8 +568,6 @@ pub unsafe extern "C" fn dc_event_get_id(event: *mut dc_event_t) -> libc::c_int
         EventType::AccountsBackgroundFetchDone => 2200,
         EventType::ChatlistChanged => 2300,
         EventType::ChatlistItemChanged { .. } => 2301,
-        EventType::AccountsChanged => 2302,
-        EventType::AccountsItemChanged => 2303,
         EventType::EventChannelOverflow { .. } => 2400,
         #[allow(unreachable_patterns)]
         #[cfg(test)]
@@ -593,12 +600,9 @@ pub unsafe extern "C" fn dc_event_get_data1_int(event: *mut dc_event_t) -> libc:
         | EventType::ConfigSynced { .. }
         | EventType::IncomingMsgBunch { .. }
         | EventType::ErrorSelfNotInGroup(_)
-        | EventType::AccountsBackgroundFetchDone
-        | EventType::ChatlistChanged
-        | EventType::AccountsChanged
-        | EventType::AccountsItemChanged => 0,
-        EventType::IncomingReaction { contact_id, .. }
-        | EventType::IncomingWebxdcNotify { contact_id, .. } => contact_id.to_u32() as libc::c_int,
+        | EventType::AccountsBackgroundFetchDone => 0,
+        EventType::ChatlistChanged => 0,
+        EventType::IncomingReaction { contact_id, .. } => contact_id.to_u32() as libc::c_int,
         EventType::MsgsChanged { chat_id, .. }
         | EventType::ReactionsChanged { chat_id, .. }
         | EventType::IncomingMsg { chat_id, .. }
@@ -670,8 +674,6 @@ pub unsafe extern "C" fn dc_event_get_data2_int(event: *mut dc_event_t) -> libc:
         | EventType::AccountsBackgroundFetchDone
         | EventType::ChatlistChanged
         | EventType::ChatlistItemChanged { .. }
-        | EventType::AccountsChanged
-        | EventType::AccountsItemChanged
         | EventType::ConfigSynced { .. }
         | EventType::ChatModified(_)
         | EventType::WebxdcRealtimeAdvertisementReceived { .. }
@@ -679,7 +681,6 @@ pub unsafe extern "C" fn dc_event_get_data2_int(event: *mut dc_event_t) -> libc:
         EventType::MsgsChanged { msg_id, .. }
         | EventType::ReactionsChanged { msg_id, .. }
         | EventType::IncomingReaction { msg_id, .. }
-        | EventType::IncomingWebxdcNotify { msg_id, .. }
         | EventType::IncomingMsg { msg_id, .. }
         | EventType::MsgDelivered { msg_id, .. }
         | EventType::MsgFailed { msg_id, .. }
@@ -699,27 +700,6 @@ pub unsafe extern "C" fn dc_event_get_data2_int(event: *mut dc_event_t) -> libc:
     }
 }
 
-#[no_mangle]
-pub unsafe extern "C" fn dc_event_get_data1_str(event: *mut dc_event_t) -> *mut libc::c_char {
-    if event.is_null() {
-        eprintln!("ignoring careless call to dc_event_get_data1_str()");
-        return ptr::null_mut();
-    }
-
-    let event = &(*event).typ;
-
-    match event {
-        EventType::IncomingWebxdcNotify { href, .. } => {
-            if let Some(href) = href {
-                href.to_c_string().unwrap_or_default().into_raw()
-            } else {
-                ptr::null_mut()
-            }
-        }
-        _ => ptr::null_mut(),
-    }
-}
-
 #[no_mangle]
 pub unsafe extern "C" fn dc_event_get_data2_str(event: *mut dc_event_t) -> *mut libc::c_char {
     if event.is_null() {
@@ -768,8 +748,6 @@ pub unsafe extern "C" fn dc_event_get_data2_str(event: *mut dc_event_t) -> *mut
         | EventType::IncomingMsgBunch { .. }
         | EventType::ChatlistItemChanged { .. }
         | EventType::ChatlistChanged
-        | EventType::AccountsChanged
-        | EventType::AccountsItemChanged
         | EventType::WebxdcRealtimeAdvertisementReceived { .. }
         | EventType::EventChannelOverflow { .. } => ptr::null_mut(),
         EventType::ConfigureProgress { comment, .. } => {
@@ -797,9 +775,6 @@ pub unsafe extern "C" fn dc_event_get_data2_str(event: *mut dc_event_t) -> *mut
             .to_c_string()
             .unwrap_or_default()
             .into_raw(),
-        EventType::IncomingWebxdcNotify { text, .. } => {
-            text.to_c_string().unwrap_or_default().into_raw()
-        }
         #[allow(unreachable_patterns)]
         #[cfg(test)]
         _ => unreachable!("This is just to silence a rust_analyzer false-positive"),
@@ -1084,7 +1059,7 @@ pub unsafe extern "C" fn dc_send_webxdc_status_update(
     context: *mut dc_context_t,
     msg_id: u32,
     json: *const libc::c_char,
-    _descr: *const libc::c_char,
+    descr: *const libc::c_char,
 ) -> libc::c_int {
     if context.is_null() {
         eprintln!("ignoring careless call to dc_send_webxdc_status_update()");
@@ -1092,10 +1067,14 @@ pub unsafe extern "C" fn dc_send_webxdc_status_update(
     }
     let ctx = &*context;
 
-    block_on(ctx.send_webxdc_status_update(MsgId::new(msg_id), &to_string_lossy(json)))
-        .context("Failed to send webxdc update")
-        .log_err(ctx)
-        .is_ok() as libc::c_int
+    block_on(ctx.send_webxdc_status_update(
+        MsgId::new(msg_id),
+        &to_string_lossy(json),
+        &to_string_lossy(descr),
+    ))
+    .context("Failed to send webxdc update")
+    .log_err(ctx)
+    .is_ok() as libc::c_int
 }
 
 #[no_mangle]
@@ -3702,17 +3681,6 @@ pub unsafe extern "C" fn dc_msg_get_info_type(msg: *mut dc_msg_t) -> libc::c_int
     ffi_msg.message.get_info_type() as libc::c_int
 }
 
-#[no_mangle]
-pub unsafe extern "C" fn dc_msg_get_webxdc_href(msg: *mut dc_msg_t) -> *mut libc::c_char {
-    if msg.is_null() {
-        eprintln!("ignoring careless call to dc_msg_get_webxdc_href()");
-        return "".strdup();
-    }
-
-    let ffi_msg = &*msg;
-    ffi_msg.message.get_webxdc_href().strdup()
-}
-
 #[no_mangle]
 pub unsafe extern "C" fn dc_msg_is_increation(msg: *mut dc_msg_t) -> libc::c_int {
     if msg.is_null() {

deltachat-jsonrpc/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "deltachat-jsonrpc"
-version = "1.151.5"
+version = "1.149.0"
 description = "DeltaChat JSON-RPC API"
 edition = "2021"
 default-run = "deltachat-jsonrpc-server"

deltachat-jsonrpc/src/api.rs

@@ -1135,11 +1135,9 @@ impl CommandApi {
     async fn get_message(&self, account_id: u32, msg_id: u32) -> Result<MessageObject> {
         let ctx = self.get_context(account_id).await?;
         let msg_id = MsgId::new(msg_id);
-        let message_object = MessageObject::from_msg_id(&ctx, msg_id)
+        MessageObject::from_msg_id(&ctx, msg_id)
             .await
-            .with_context(|| format!("Failed to load message {msg_id} for account {account_id}"))?
-            .with_context(|| format!("Message {msg_id} does not exist for account {account_id}"))?;
-        Ok(message_object)
+            .with_context(|| format!("Failed to load message {msg_id} for account {account_id}"))
     }
 
     async fn get_message_html(&self, account_id: u32, message_id: u32) -> Result<Option<String>> {
@@ -1163,10 +1161,7 @@ impl CommandApi {
             messages.insert(
                 message_id,
                 match message_result {
-                    Ok(Some(message)) => MessageLoadResult::Message(message),
-                    Ok(None) => MessageLoadResult::LoadingError {
-                        error: "Message does not exist".to_string(),
-                    },
+                    Ok(message) => MessageLoadResult::Message(message),
                     Err(error) => MessageLoadResult::LoadingError {
                         error: format!("{error:#}"),
                     },
@@ -1767,10 +1762,10 @@ impl CommandApi {
         account_id: u32,
         instance_msg_id: u32,
         update_str: String,
-        _descr: Option<String>,
+        description: String,
     ) -> Result<()> {
         let ctx = self.get_context(account_id).await?;
-        ctx.send_webxdc_status_update(MsgId::new(instance_msg_id), &update_str)
+        ctx.send_webxdc_status_update(MsgId::new(instance_msg_id), &update_str, &description)
             .await
     }
 
@@ -1829,18 +1824,6 @@ impl CommandApi {
         WebxdcMessageInfo::get_for_message(&ctx, MsgId::new(instance_msg_id)).await
     }
 
-    /// Get href from a WebxdcInfoMessage which might include a hash holding
-    /// information about a specific position or state in a webxdc app (optional)
-    async fn get_webxdc_href(
-        &self,
-        account_id: u32,
-        instance_msg_id: u32,
-    ) -> Result<Option<String>> {
-        let ctx = self.get_context(account_id).await?;
-        let message = Message::load_from_db(&ctx, MsgId::new(instance_msg_id)).await?;
-        Ok(message.get_webxdc_href())
-    }
-
     /// Get blob encoded as base64 from a webxdc message
     ///
     /// path is the path of the file within webxdc archive
@@ -2016,7 +1999,9 @@ impl CommandApi {
     async fn get_draft(&self, account_id: u32, chat_id: u32) -> Result<Option<MessageObject>> {
         let ctx = self.get_context(account_id).await?;
         if let Some(draft) = ChatId::new(chat_id).get_draft(&ctx).await? {
-            Ok(MessageObject::from_msg_id(&ctx, draft.get_id()).await?)
+            Ok(Some(
+                MessageObject::from_msg_id(&ctx, draft.get_id()).await?,
+            ))
         } else {
             Ok(None)
         }
@@ -2185,9 +2170,7 @@ impl CommandApi {
                 .await?;
         }
         let msg_id = chat::send_msg(&ctx, ChatId::new(chat_id), &mut message).await?;
-        let message = MessageObject::from_msg_id(&ctx, msg_id)
-            .await?
-            .context("Just sent message does not exist")?;
+        let message = MessageObject::from_msg_id(&ctx, msg_id).await?;
         Ok((msg_id.to_u32(), message))
     }
 

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

@@ -88,17 +88,11 @@ pub(crate) async fn get_chat_list_item_by_id(
 
     let (last_updated, message_type) = match last_msgid {
         Some(id) => {
-            if let Some(last_message) =
-                deltachat::message::Message::load_from_db_optional(ctx, id).await?
-            {
-                (
-                    Some(last_message.get_timestamp() * 1000),
-                    Some(last_message.get_viewtype().into()),
-                )
-            } else {
-                // Message may be deleted by the time we try to load it.
-                (None, None)
-            }
+            let last_message = deltachat::message::Message::load_from_db(ctx, id).await?;
+            (
+                Some(last_message.get_timestamp() * 1000),
+                Some(last_message.get_viewtype().into()),
+            )
         }
         None => (None, None),
     };

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

@@ -69,7 +69,7 @@ pub enum EventType {
     /// or for functions that are expected to fail (eg. autocryptContinueKeyTransfer())
     /// it might be better to delay showing these events until the function has really
     /// failed (returned false). It should be sufficient to report only the *last* error
-    /// in a message box then.
+    /// in a messasge box then.
     Error { msg: String },
 
     /// An action cannot be performed because the user is not in the group.
@@ -106,15 +106,6 @@ pub enum EventType {
         reaction: String,
     },
 
-    /// Incoming webxdc info or summary update, should be notified.
-    #[serde(rename_all = "camelCase")]
-    IncomingWebxdcNotify {
-        contact_id: u32,
-        msg_id: u32,
-        text: String,
-        href: Option<String>,
-    },
-
     /// There is a fresh message. Typically, the user will show an notification
     /// when receiving this message.
     ///
@@ -286,20 +277,6 @@ pub enum EventType {
     #[serde(rename_all = "camelCase")]
     ChatlistItemChanged { chat_id: Option<u32> },
 
-    /// Inform that the list of accounts has changed (an account removed or added or (not yet implemented) the account order changes)
-    ///
-    /// This event is only emitted by the account manager
-    AccountsChanged,
-
-    /// Inform that an account property that might be shown in the account list changed, namely:
-    /// - is_configured (see is_configured())
-    /// - displayname
-    /// - selfavatar
-    /// - private_tag
-    ///
-    /// This event is emitted from the account whose property changed.
-    AccountsItemChanged,
-
     /// Inform than some events have been skipped due to event channel overflow.
     EventChannelOverflow { n: u64 },
 }
@@ -342,17 +319,6 @@ impl From<CoreEventType> for EventType {
                 msg_id: msg_id.to_u32(),
                 reaction: reaction.as_str().to_string(),
             },
-            CoreEventType::IncomingWebxdcNotify {
-                contact_id,
-                msg_id,
-                text,
-                href,
-            } => IncomingWebxdcNotify {
-                contact_id: contact_id.to_u32(),
-                msg_id: msg_id.to_u32(),
-                text,
-                href,
-            },
             CoreEventType::IncomingMsg { chat_id, msg_id } => IncomingMsg {
                 chat_id: chat_id.to_u32(),
                 msg_id: msg_id.to_u32(),
@@ -443,8 +409,6 @@ impl From<CoreEventType> for EventType {
             },
             CoreEventType::ChatlistChanged => ChatlistChanged,
             CoreEventType::EventChannelOverflow { n } => EventChannelOverflow { n },
-            CoreEventType::AccountsChanged => AccountsChanged,
-            CoreEventType::AccountsItemChanged => AccountsItemChanged,
             #[allow(unreachable_patterns)]
             #[cfg(test)]
             _ => unreachable!("This is just to silence a rust_analyzer false-positive"),

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

@@ -85,8 +85,6 @@ pub struct MessageObject {
 
     webxdc_info: Option<WebxdcMessageInfo>,
 
-    webxdc_href: Option<String>,
-
     download_state: DownloadState,
 
     reactions: Option<JSONRPCReactions>,
@@ -114,10 +112,8 @@ enum MessageQuote {
 }
 
 impl MessageObject {
-    pub async fn from_msg_id(context: &Context, msg_id: MsgId) -> Result<Option<Self>> {
-        let Some(message) = Message::load_from_db_optional(context, msg_id).await? else {
-            return Ok(None);
-        };
+    pub async fn from_msg_id(context: &Context, msg_id: MsgId) -> Result<Self> {
+        let message = Message::load_from_db(context, msg_id).await?;
 
         let sender_contact = Contact::get_by_id(context, message.get_from_id())
             .await
@@ -187,7 +183,7 @@ impl MessageObject {
             .map(Into::into)
             .collect();
 
-        let message_object = MessageObject {
+        Ok(MessageObject {
             id: msg_id.to_u32(),
             chat_id: message.get_chat_id().to_u32(),
             from_id: message.get_from_id().to_u32(),
@@ -243,17 +239,12 @@ impl MessageObject {
             file_name: message.get_filename(),
             webxdc_info,
 
-            // On a WebxdcInfoMessage this might include a hash holding
-            // information about a specific position or state in a webxdc app
-            webxdc_href: message.get_webxdc_href(),
-
             download_state,
 
             reactions,
 
             vcard_contact: vcard_contacts.first().cloned(),
-        };
-        Ok(Some(message_object))
+        })
     }
 }
 

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

@@ -35,14 +35,6 @@ pub struct WebxdcMessageInfo {
     source_code_url: Option<String>,
     /// True if full internet access should be granted to the app.
     internet_access: bool,
-    /// Address to be used for `window.webxdc.selfAddr` in JS land.
-    self_addr: String,
-    /// Milliseconds to wait before calling `sendUpdate()` again since the last call.
-    /// Should be exposed to `window.sendUpdateInterval` in JS land.
-    send_update_interval: usize,
-    /// Maximum number of bytes accepted for a serialized update object.
-    /// Should be exposed to `window.sendUpdateMaxSize` in JS land.
-    send_update_max_size: usize,
 }
 
 impl WebxdcMessageInfo {
@@ -57,11 +49,7 @@ impl WebxdcMessageInfo {
             document,
             summary,
             source_code_url,
-            request_integration: _,
             internet_access,
-            self_addr,
-            send_update_interval,
-            send_update_max_size,
         } = message.get_webxdc_info(context).await?;
 
         Ok(Self {
@@ -71,9 +59,6 @@ impl WebxdcMessageInfo {
             summary: maybe_empty_string_to_option(summary),
             source_code_url: maybe_empty_string_to_option(source_code_url),
             internet_access,
-            self_addr,
-            send_update_interval,
-            send_update_max_size,
         })
     }
 }

deltachat-jsonrpc/src/lib.rs

@@ -1,6 +1,4 @@
 #![recursion_limit = "256"]
-#![cfg_attr(not(test), forbid(clippy::indexing_slicing))]
-#![cfg_attr(not(test), forbid(clippy::string_slice))]
 pub mod api;
 pub use yerpc;
 

deltachat-jsonrpc/typescript/package.json

@@ -58,5 +58,5 @@
   },
   "type": "module",
   "types": "dist/deltachat.d.ts",
-  "version": "1.151.5"
+  "version": "1.149.0"
 }

deltachat-ratelimit/src/lib.rs

@@ -90,11 +90,6 @@ impl Ratelimit {
     pub fn until_can_send(&self) -> Duration {
         self.until_can_send_at(SystemTime::now())
     }
-
-    /// Returns minimum possible update interval in milliseconds.
-    pub fn update_interval(&self) -> usize {
-        (self.window.as_millis() as f64 / self.quota) as usize
-    }
 }
 
 #[cfg(test)]
@@ -107,7 +102,6 @@ mod tests {
 
         let mut ratelimit = Ratelimit::new_at(Duration::new(60, 0), 3.0, now);
         assert!(ratelimit.can_send_at(now));
-        assert_eq!(ratelimit.update_interval(), 20_000);
 
         // Send burst of 3 messages.
         ratelimit.send_at(now);

deltachat-repl/Cargo.toml

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

deltachat-repl/src/cmdline.rs

@@ -969,7 +969,9 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                 "Arguments <msg-id> <json status update> expected"
             );
             let msg_id = MsgId::new(arg1.parse()?);
-            context.send_webxdc_status_update(msg_id, arg2).await?;
+            context
+                .send_webxdc_status_update(msg_id, arg2, "this is a webxdc status update")
+                .await?;
         }
         "videochat" => {
             ensure!(sel_chat.is_some(), "No chat selected.");

deltachat-rpc-client/README.md

@@ -25,8 +25,7 @@ $ pip install .
 ## Testing
 
 1. Build `deltachat-rpc-server` with `cargo build -p deltachat-rpc-server`.
-2. Install tox `pip install -U tox`
-3. Run `CHATMAIL_DOMAIN=nine.testrun.org PATH="../target/debug:$PATH" tox`.
+2. Run `CHATMAIL_DOMAIN=nine.testrun.org PATH="../target/debug:$PATH" tox`.
 
 Additional arguments to `tox` are passed to pytest, e.g. `tox -- -s` does not capture test output.
 

deltachat-rpc-client/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "deltachat-rpc-client"
-version = "1.151.5"
+version = "1.149.0"
 description = "Python client for Delta Chat core JSON-RPC interface"
 classifiers = [
     "Development Status :: 5 - Production/Stable",
@@ -24,6 +24,9 @@ classifiers = [
     "Topic :: Communications :: Email"
 ]
 readme = "README.md"
+dependencies = [
+    "imap-tools",
+]
 
 [tool.setuptools.package-data]
 deltachat_rpc_client = [

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

@@ -61,8 +61,6 @@ class EventType(str, Enum):
     WEBXDC_INSTANCE_DELETED = "WebxdcInstanceDeleted"
     CHATLIST_CHANGED = "ChatlistChanged"
     CHATLIST_ITEM_CHANGED = "ChatlistItemChanged"
-    ACCOUNTS_CHANGED = "AccountsChanged"
-    ACCOUNTS_ITEM_CHANGED = "AccountsItemChanged"
     CONFIG_SYNCED = "ConfigSynced"
     WEBXDC_REALTIME_DATA = "WebxdcRealtimeData"
     WEBXDC_REALTIME_ADVERTISEMENT_RECEIVED = "WebxdcRealtimeAdvertisementReceived"

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

@@ -1,3 +1,7 @@
+"""
+Internal Python-level IMAP handling used by the tests.
+"""
+
 from __future__ import annotations
 
 import imaplib
@@ -7,11 +11,17 @@ import ssl
 from contextlib import contextmanager
 from typing import TYPE_CHECKING
 
-import pytest
-from imap_tools import AND, Header, MailBox, MailMessage, MailMessageFlags, errors
+from imap_tools import (
+    AND,
+    Header,
+    MailBox,
+    MailMessage,
+    MailMessageFlags,
+    errors,
+)
 
 if TYPE_CHECKING:
-    from deltachat_rpc_client import Account
+    from . import Account
 
 FLAGS = b"FLAGS"
 FETCH = b"FETCH"
@@ -19,8 +29,6 @@ ALL = "1:*"
 
 
 class DirectImap:
-    """Internal Python-level IMAP handling."""
-
     def __init__(self, account: Account) -> None:
         self.account = account
         self.logid = account.get_config("displayname") or id(account)
@@ -204,8 +212,3 @@ class IdleManager:
     def done(self):
         """send idle-done to server if we are currently in idle mode."""
         return self.direct_imap.conn.idle.stop()
-
-
-@pytest.fixture
-def direct_imap():
-    return DirectImap

deltachat-rpc-client/tests/test_account_events.py

@@ -1,29 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-from deltachat_rpc_client import EventType
-
-if TYPE_CHECKING:
-    from deltachat_rpc_client.pytestplugin import ACFactory
-
-
-def test_event_on_configuration(acfactory: ACFactory) -> None:
-    """
-    Test if ACCOUNTS_ITEM_CHANGED event is emitted on configure
-    """
-
-    account = acfactory.new_preconfigured_account()
-    account.clear_all_events()
-    assert not account.is_configured()
-    future = account.configure.future()
-    while True:
-        event = account.wait_for_event()
-        if event.kind == EventType.ACCOUNTS_ITEM_CHANGED:
-            break
-    assert account.is_configured()
-
-    future()
-
-
-# other tests are written in rust: src/tests/account_events.rs

deltachat-rpc-client/tests/test_something.py

@@ -12,6 +12,7 @@ import pytest
 
 from deltachat_rpc_client import Contact, EventType, Message, events
 from deltachat_rpc_client.const import DownloadState, MessageState
+from deltachat_rpc_client.direct_imap import DirectImap
 from deltachat_rpc_client.rpc import JsonRpcError
 
 
@@ -535,7 +536,7 @@ def test_reaction_to_partially_fetched_msg(acfactory, tmp_path):
     assert list(reactions.reactions_by_contact.values())[0] == [react_str]
 
 
-def test_reactions_for_a_reordering_move(acfactory, direct_imap):
+def test_reactions_for_a_reordering_move(acfactory):
     """When a batch of messages is moved from Inbox to DeltaChat folder with a single MOVE command,
     their UIDs may be reordered (e.g. Gmail is known for that) which led to that messages were
     processed by receive_imf in the wrong order, and, particularly, reactions were processed before
@@ -559,7 +560,7 @@ def test_reactions_for_a_reordering_move(acfactory, direct_imap):
     msg1.send_reaction(react_str).wait_until_delivered()
 
     logging.info("moving messages to ac2's DeltaChat folder in the reverse order")
-    ac2_direct_imap = direct_imap(ac2)
+    ac2_direct_imap = DirectImap(ac2)
     ac2_direct_imap.connect()
     for uid in sorted([m.uid for m in ac2_direct_imap.get_all_messages()], reverse=True):
         ac2_direct_imap.conn.move(uid, "DeltaChat")

deltachat-rpc-client/tests/test_webxdc.py

@@ -24,9 +24,6 @@ def test_webxdc(acfactory) -> None:
         "name": "Chess Board",
         "sourceCodeUrl": None,
         "summary": None,
-        "selfAddr": webxdc_info["selfAddr"],
-        "sendUpdateInterval": 1000,
-        "sendUpdateMaxSize": 18874368,
     }
 
     status_updates = message.get_webxdc_status_updates()

deltachat-rpc-client/tox.ini

@@ -16,7 +16,6 @@ deps =
     pytest
     pytest-timeout
     pytest-xdist
-    imap-tools
 
 [testenv:lint]
 skipsdist = True

deltachat-rpc-server/Cargo.toml

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

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

@@ -65,13 +65,13 @@ so by default it uses the prebuilds.
   - this will run `update_optional_dependencies_and_version.js` (in the `prepack` script),
     which puts all platform packages into `optionalDependencies` and updates the `version` in `package.json`
 
-## How to build a version you can use locally on your host machine for development
+## How to build a version you can use localy on your host machine for development
 
-You can not install the npm packet from the previous section locally, unless you have a local npm registry set up where you upload it too. This is why we have separate scripts for making it work for local installation.
+You can not install the npm packet from the previous section locally, unless you have a local npm registry set up where you upload it too. This is why we have seperate scripts for making it work for local installation.
 
 - If you just need your host platform run `python scripts/make_local_dev_version.py`
 - note: this clears the `platform_package` folder
-- (advanced) If you need more than one platform for local install you can just run `node scripts/update_optional_dependencies_and_version.js` after building multiple platforms with `build_platform_package.py`
+- (advanced) If you need more than one platform for local install you can just run `node scripts/update_optional_dependencies_and_version.js` after building multiple plaftorms with `build_platform_package.py`
 
 ## Thanks to nlnet
 

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

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

deltachat-rpc-server/npm-package/scripts/update_optional_dependencies_and_version.js

@@ -6,7 +6,7 @@ const expected_cwd = join(dirname(fileURLToPath(import.meta.url)), "..");
 
 if (process.cwd() !== expected_cwd) {
   console.error(
-    "CWD mismatch: this script needs to be run from " + expected_cwd,
+    "CWD missmatch: this script needs to be run from " + expected_cwd,
     { actual: process.cwd(), expected: expected_cwd }
   );
   process.exit(1);
@@ -40,7 +40,7 @@ const platform_package_names = await Promise.all(
         "has a different version than the version of the rpc server.",
         { rpc_server: version, platform_package: p.version }
       );
-      throw new Error("version mismatch");
+      throw new Error("version missmatch");
     }
     return { folder_name: name, package_name: p.name };
   })

deltachat-rpc-server/src/main.rs

@@ -66,7 +66,7 @@ async fn main_impl() -> Result<()> {
 
     // Logs from `log` crate and traces from `tracing` crate
     // are configurable with `RUST_LOG` environment variable
-    // and go to stderr to avoid interfering with JSON-RPC using stdout.
+    // and go to stderr to avoid interferring with JSON-RPC using stdout.
     tracing_subscriber::fmt()
         .with_env_filter(EnvFilter::from_default_env())
         .with_writer(std::io::stderr)

deny.toml

@@ -33,11 +33,9 @@ skip = [
      { name = "event-listener", version = "2.5.3" },
      { name = "event-listener", version = "4.0.3" },
      { name = "fastrand", version = "1.9.0" },
-     { name = "fiat-crypto", version = "0.1.20" },
      { name = "futures-lite", version = "1.13.0" },
      { name = "getrandom", version = "<0.2" },
      { name = "http", version = "0.2.12" },
-     { name = "idna", version = "0.5.0" },
      { name = "nix", version = "0.26.4" },
      { name = "quick-error", version = "<2.0" },
      { name = "rand_chacha", version = "<0.3" },
@@ -77,7 +75,6 @@ allow = [
     "MIT",
     "MPL-2.0",
     "OpenSSL",
-    "Unicode-3.0",
     "Unicode-DFS-2016",
     "Zlib",
 ]

flake.nix

@@ -8,8 +8,18 @@
     nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";
     android.url = "github:tadfisher/android-nixpkgs";
   };
-  outputs = { self, nixpkgs, flake-utils, nix-filter, naersk, fenix, android }:
-    flake-utils.lib.eachDefaultSystem (system:
+  outputs =
+    { self
+    , nixpkgs
+    , flake-utils
+    , nix-filter
+    , naersk
+    , fenix
+    , android
+    ,
+    }:
+    flake-utils.lib.eachDefaultSystem (
+      system:
       let
         pkgs = nixpkgs.legacyPackages.${system};
         inherit (pkgs.stdenv) isDarwin;
@@ -173,15 +183,17 @@
             # Use DWARF-2 instead of SJLJ for exception handling.
             winCC = pkgsWin32.buildPackages.wrapCC (
               (pkgsWin32.buildPackages.gcc-unwrapped.override
-                ({
+                {
                   threadsCross = {
                     model = "win32";
                     package = null;
                   };
-                })).overrideAttrs (oldAttr: {
-                configureFlags = oldAttr.configureFlags ++ [
-                  "--disable-sjlj-exceptions --with-dwarf2"
-                ];
+                }).overrideAttrs (oldAttr: {
+                configureFlags =
+                  oldAttr.configureFlags
+                  ++ [
+                    "--disable-sjlj-exceptions --with-dwarf2"
+                  ];
               })
             );
           in
@@ -325,214 +337,204 @@
           {
             "deltachat-repl-${arch}" = mkCrossRustPackage arch "deltachat-repl";
             "deltachat-rpc-server-${arch}" = rpc-server;
-            "deltachat-rpc-server-${arch}-wheel" =
-              pkgs.stdenv.mkDerivation {
-                pname = "deltachat-rpc-server-${arch}-wheel";
-                version = manifest.version;
-                src = nix-filter.lib {
-                  root = ./.;
-                  include = [
-                    "scripts/wheel-rpc-server.py"
-                    "deltachat-rpc-server/README.md"
-                    "LICENSE"
-                    "Cargo.toml"
-                  ];
-                };
-                nativeBuildInputs = [
-                  pkgs.python3
-                  pkgs.python3Packages.wheel
+            "deltachat-rpc-server-${arch}-wheel" = pkgs.stdenv.mkDerivation {
+              pname = "deltachat-rpc-server-${arch}-wheel";
+              version = manifest.version;
+              src = nix-filter.lib {
+                root = ./.;
+                include = [
+                  "scripts/wheel-rpc-server.py"
+                  "deltachat-rpc-server/README.md"
+                  "LICENSE"
+                  "Cargo.toml"
                 ];
-                buildInputs = [
-                  rpc-server
-                ];
-                buildPhase = ''
-                  mkdir tmp
-                  cp ${rpc-server}/bin/deltachat-rpc-server tmp/deltachat-rpc-server
-                  python3 scripts/wheel-rpc-server.py ${arch} tmp/deltachat-rpc-server
-                '';
-                installPhase = ''mkdir -p $out; cp -av deltachat_rpc_server-*.whl $out'';
               };
+              nativeBuildInputs = [
+                pkgs.python3
+                pkgs.python3Packages.wheel
+              ];
+              buildInputs = [
+                rpc-server
+              ];
+              buildPhase = ''
+                mkdir tmp
+                cp ${rpc-server}/bin/deltachat-rpc-server tmp/deltachat-rpc-server
+                python3 scripts/wheel-rpc-server.py ${arch} tmp/deltachat-rpc-server
+              '';
+              installPhase = ''mkdir -p $out; cp -av deltachat_rpc_server-*.whl $out'';
+            };
           };
       in
       {
         formatter = pkgs.nixpkgs-fmt;
 
         packages =
-          mkRustPackages "aarch64-linux" //
-          mkRustPackages "i686-linux" //
-          mkRustPackages "x86_64-linux" //
-          mkRustPackages "armv7l-linux" //
-          mkRustPackages "armv6l-linux" //
-          mkRustPackages "x86_64-darwin" //
-          mkRustPackages "aarch64-darwin" //
-          mkAndroidPackages "armeabi-v7a" //
-          mkAndroidPackages "arm64-v8a" //
-          mkAndroidPackages "x86" //
-          mkAndroidPackages "x86_64" // rec {
+          mkRustPackages "aarch64-linux"
+          // mkRustPackages "i686-linux"
+          // mkRustPackages "x86_64-linux"
+          // mkRustPackages "armv7l-linux"
+          // mkRustPackages "armv6l-linux"
+          // mkAndroidPackages "armeabi-v7a"
+          // mkAndroidPackages "arm64-v8a"
+          // mkAndroidPackages "x86"
+          // mkAndroidPackages "x86_64"
+          // rec {
             # Run with `nix run .#deltachat-repl foo.db`.
             deltachat-repl = mkRustPackage "deltachat-repl";
             deltachat-rpc-server = mkRustPackage "deltachat-rpc-server";
 
             deltachat-repl-win64 = mkWin64RustPackage "deltachat-repl";
             deltachat-rpc-server-win64 = mkWin64RustPackage "deltachat-rpc-server";
-            deltachat-rpc-server-win64-wheel =
-              pkgs.stdenv.mkDerivation {
-                pname = "deltachat-rpc-server-win64-wheel";
-                version = manifest.version;
-                src = nix-filter.lib {
-                  root = ./.;
-                  include = [
-                    "scripts/wheel-rpc-server.py"
-                    "deltachat-rpc-server/README.md"
-                    "LICENSE"
-                    "Cargo.toml"
-                  ];
-                };
-                nativeBuildInputs = [
-                  pkgs.python3
-                  pkgs.python3Packages.wheel
+            deltachat-rpc-server-win64-wheel = pkgs.stdenv.mkDerivation {
+              pname = "deltachat-rpc-server-win64-wheel";
+              version = manifest.version;
+              src = nix-filter.lib {
+                root = ./.;
+                include = [
+                  "scripts/wheel-rpc-server.py"
+                  "deltachat-rpc-server/README.md"
+                  "LICENSE"
+                  "Cargo.toml"
                 ];
-                buildInputs = [
-                  deltachat-rpc-server-win64
-                ];
-                buildPhase = ''
-                  mkdir tmp
-                  cp ${deltachat-rpc-server-win64}/bin/deltachat-rpc-server.exe tmp/deltachat-rpc-server.exe
-                  python3 scripts/wheel-rpc-server.py win64 tmp/deltachat-rpc-server.exe
-                '';
-                installPhase = ''mkdir -p $out; cp -av deltachat_rpc_server-*.whl $out'';
               };
+              nativeBuildInputs = [
+                pkgs.python3
+                pkgs.python3Packages.wheel
+              ];
+              buildInputs = [
+                deltachat-rpc-server-win64
+              ];
+              buildPhase = ''
+                mkdir tmp
+                cp ${deltachat-rpc-server-win64}/bin/deltachat-rpc-server.exe tmp/deltachat-rpc-server.exe
+                python3 scripts/wheel-rpc-server.py win64 tmp/deltachat-rpc-server.exe
+              '';
+              installPhase = ''mkdir -p $out; cp -av deltachat_rpc_server-*.whl $out'';
+            };
 
             deltachat-repl-win32 = mkWin32RustPackage "deltachat-repl";
             deltachat-rpc-server-win32 = mkWin32RustPackage "deltachat-rpc-server";
-            deltachat-rpc-server-win32-wheel =
-              pkgs.stdenv.mkDerivation {
-                pname = "deltachat-rpc-server-win32-wheel";
-                version = manifest.version;
-                src = nix-filter.lib {
-                  root = ./.;
-                  include = [
-                    "scripts/wheel-rpc-server.py"
-                    "deltachat-rpc-server/README.md"
-                    "LICENSE"
-                    "Cargo.toml"
-                  ];
-                };
-                nativeBuildInputs = [
-                  pkgs.python3
-                  pkgs.python3Packages.wheel
+            deltachat-rpc-server-win32-wheel = pkgs.stdenv.mkDerivation {
+              pname = "deltachat-rpc-server-win32-wheel";
+              version = manifest.version;
+              src = nix-filter.lib {
+                root = ./.;
+                include = [
+                  "scripts/wheel-rpc-server.py"
+                  "deltachat-rpc-server/README.md"
+                  "LICENSE"
+                  "Cargo.toml"
                 ];
-                buildInputs = [
-                  deltachat-rpc-server-win32
-                ];
-                buildPhase = ''
-                  mkdir tmp
-                  cp ${deltachat-rpc-server-win32}/bin/deltachat-rpc-server.exe tmp/deltachat-rpc-server.exe
-                  python3 scripts/wheel-rpc-server.py win32 tmp/deltachat-rpc-server.exe
-                '';
-                installPhase = ''mkdir -p $out; cp -av deltachat_rpc_server-*.whl $out'';
               };
+              nativeBuildInputs = [
+                pkgs.python3
+                pkgs.python3Packages.wheel
+              ];
+              buildInputs = [
+                deltachat-rpc-server-win32
+              ];
+              buildPhase = ''
+                mkdir tmp
+                cp ${deltachat-rpc-server-win32}/bin/deltachat-rpc-server.exe tmp/deltachat-rpc-server.exe
+                python3 scripts/wheel-rpc-server.py win32 tmp/deltachat-rpc-server.exe
+              '';
+              installPhase = ''mkdir -p $out; cp -av deltachat_rpc_server-*.whl $out'';
+            };
             # Run `nix build .#docs` to get C docs generated in `./result/`.
-            docs =
-              pkgs.stdenv.mkDerivation {
-                pname = "docs";
-                version = manifest.version;
-                src = pkgs.lib.cleanSource ./.;
-                nativeBuildInputs = [ pkgs.doxygen ];
-                buildPhase = ''scripts/run-doxygen.sh'';
-                installPhase = ''mkdir -p $out; cp -av deltachat-ffi/html deltachat-ffi/xml $out'';
-              };
+            docs = pkgs.stdenv.mkDerivation {
+              pname = "docs";
+              version = manifest.version;
+              src = pkgs.lib.cleanSource ./.;
+              nativeBuildInputs = [ pkgs.doxygen ];
+              buildPhase = ''scripts/run-doxygen.sh'';
+              installPhase = ''mkdir -p $out; cp -av deltachat-ffi/html deltachat-ffi/xml $out'';
+            };
 
-            libdeltachat =
-              pkgs.stdenv.mkDerivation {
-                pname = "libdeltachat";
-                version = manifest.version;
-                src = rustSrc;
-                cargoDeps = pkgs.rustPlatform.importCargoLock cargoLock;
+            libdeltachat = pkgs.stdenv.mkDerivation {
+              pname = "libdeltachat";
+              version = manifest.version;
+              src = rustSrc;
+              cargoDeps = pkgs.rustPlatform.importCargoLock cargoLock;
 
-                nativeBuildInputs = [
-                  pkgs.perl # Needed to build vendored OpenSSL.
-                  pkgs.cmake
-                  pkgs.rustPlatform.cargoSetupHook
-                  pkgs.cargo
-                ];
-                buildInputs = pkgs.lib.optionals isDarwin [
-                  pkgs.darwin.apple_sdk.frameworks.CoreFoundation
-                  pkgs.darwin.apple_sdk.frameworks.Security
-                  pkgs.darwin.apple_sdk.frameworks.SystemConfiguration
-                  pkgs.libiconv
-                ];
+              nativeBuildInputs = [
+                pkgs.perl # Needed to build vendored OpenSSL.
+                pkgs.cmake
+                pkgs.rustPlatform.cargoSetupHook
+                pkgs.cargo
+              ];
+              buildInputs = pkgs.lib.optionals isDarwin [
+                pkgs.darwin.apple_sdk.frameworks.CoreFoundation
+                pkgs.darwin.apple_sdk.frameworks.Security
+                pkgs.darwin.apple_sdk.frameworks.SystemConfiguration
+                pkgs.libiconv
+              ];
 
-                postInstall = ''
-                  substituteInPlace $out/include/deltachat.h \
-                    --replace __FILE__ '"${placeholder "out"}/include/deltachat.h"'
-                '';
-              };
+              postInstall = ''
+                substituteInPlace $out/include/deltachat.h \
+                  --replace __FILE__ '"${placeholder "out"}/include/deltachat.h"'
+              '';
+            };
 
             # Source package for deltachat-rpc-server.
             # Fake package that downloads Linux version,
             # needed to install deltachat-rpc-server on Android with `pip`.
-            deltachat-rpc-server-source =
-              pkgs.stdenv.mkDerivation {
-                pname = "deltachat-rpc-server-source";
-                version = manifest.version;
-                src = pkgs.lib.cleanSource ./.;
-                nativeBuildInputs = [
-                  pkgs.python3
-                  pkgs.python3Packages.wheel
-                ];
-                buildPhase = ''python3 scripts/wheel-rpc-server.py source deltachat_rpc_server-${manifest.version}.tar.gz'';
-                installPhase = ''mkdir -p $out; cp -av deltachat_rpc_server-${manifest.version}.tar.gz $out'';
-              };
+            deltachat-rpc-server-source = pkgs.stdenv.mkDerivation {
+              pname = "deltachat-rpc-server-source";
+              version = manifest.version;
+              src = pkgs.lib.cleanSource ./.;
+              nativeBuildInputs = [
+                pkgs.python3
+                pkgs.python3Packages.wheel
+              ];
+              buildPhase = ''python3 scripts/wheel-rpc-server.py source deltachat-rpc-server-${manifest.version}.tar.gz'';
+              installPhase = ''mkdir -p $out; cp -av deltachat-rpc-server-${manifest.version}.tar.gz $out'';
+            };
 
-            deltachat-rpc-client =
-              pkgs.python3Packages.buildPythonPackage {
-                pname = "deltachat-rpc-client";
-                version = manifest.version;
-                src = pkgs.lib.cleanSource ./deltachat-rpc-client;
-                format = "pyproject";
-                propagatedBuildInputs = [
-                  pkgs.python3Packages.setuptools
-                  pkgs.python3Packages.imap-tools
-                ];
-              };
+            deltachat-rpc-client = pkgs.python3Packages.buildPythonPackage {
+              pname = "deltachat-rpc-client";
+              version = manifest.version;
+              src = pkgs.lib.cleanSource ./deltachat-rpc-client;
+              format = "pyproject";
+              propagatedBuildInputs = [
+                pkgs.python3Packages.setuptools
+                pkgs.python3Packages.imap-tools
+              ];
+            };
 
-            deltachat-python =
-              pkgs.python3Packages.buildPythonPackage {
-                pname = "deltachat-python";
-                version = manifest.version;
-                src = pkgs.lib.cleanSource ./python;
-                format = "pyproject";
-                buildInputs = [
-                  libdeltachat
-                ];
-                nativeBuildInputs = [
-                  pkgs.pkg-config
-                ];
-                propagatedBuildInputs = [
-                  pkgs.python3Packages.setuptools
-                  pkgs.python3Packages.pkgconfig
-                  pkgs.python3Packages.cffi
-                  pkgs.python3Packages.imap-tools
-                  pkgs.python3Packages.pluggy
-                  pkgs.python3Packages.requests
-                ];
-              };
-            python-docs =
-              pkgs.stdenv.mkDerivation {
-                pname = "docs";
-                version = manifest.version;
-                src = pkgs.lib.cleanSource ./.;
-                buildInputs = [
-                  deltachat-python
-                  deltachat-rpc-client
-                  pkgs.python3Packages.breathe
-                  pkgs.python3Packages.sphinx_rtd_theme
-                ];
-                nativeBuildInputs = [ pkgs.sphinx ];
-                buildPhase = ''sphinx-build -b html -a python/doc/ dist/html'';
-                installPhase = ''mkdir -p $out; cp -av dist/html $out'';
-              };
+            deltachat-python = pkgs.python3Packages.buildPythonPackage {
+              pname = "deltachat-python";
+              version = manifest.version;
+              src = pkgs.lib.cleanSource ./python;
+              format = "pyproject";
+              buildInputs = [
+                libdeltachat
+              ];
+              nativeBuildInputs = [
+                pkgs.pkg-config
+              ];
+              propagatedBuildInputs = [
+                pkgs.python3Packages.setuptools
+                pkgs.python3Packages.pkgconfig
+                pkgs.python3Packages.cffi
+                pkgs.python3Packages.imap-tools
+                pkgs.python3Packages.pluggy
+                pkgs.python3Packages.requests
+              ];
+            };
+            python-docs = pkgs.stdenv.mkDerivation {
+              pname = "docs";
+              version = manifest.version;
+              src = pkgs.lib.cleanSource ./.;
+              buildInputs = [
+                deltachat-python
+                deltachat-rpc-client
+                pkgs.python3Packages.breathe
+                pkgs.python3Packages.sphinx_rtd_theme
+              ];
+              nativeBuildInputs = [ pkgs.sphinx ];
+              buildPhase = ''sphinx-build -b html -a python/doc/ dist/html'';
+              installPhase = ''mkdir -p $out; cp -av dist/html $out'';
+            };
           };
 
         devShells.default =
@@ -543,7 +545,6 @@
             };
           in
           pkgs.mkShell {
-
             buildInputs = with pkgs; [
               (fenix.packages.${system}.complete.withComponents [
                 "cargo"

format-flowed/src/lib.rs

@@ -8,8 +8,6 @@
 //! is assumed to be set to "no".
 //!
 //! For received messages, DelSp parameter is honoured.
-#![cfg_attr(not(test), forbid(clippy::indexing_slicing))]
-#![cfg_attr(not(test), forbid(clippy::string_slice))]
 
 /// Wraps line to 72 characters using format=flowed soft breaks.
 ///

node/constants.js

@@ -1,7 +1,6 @@
 // Generated!
 
 module.exports = {
-  DC_CERTCK_ACCEPT_INVALID: 2,
   DC_CERTCK_ACCEPT_INVALID_CERTIFICATES: 3,
   DC_CERTCK_AUTO: 0,
   DC_CERTCK_STRICT: 1,
@@ -31,8 +30,6 @@ module.exports = {
   DC_DOWNLOAD_IN_PROGRESS: 1000,
   DC_DOWNLOAD_UNDECIPHERABLE: 30,
   DC_EVENT_ACCOUNTS_BACKGROUND_FETCH_DONE: 2200,
-  DC_EVENT_ACCOUNTS_CHANGED: 2302,
-  DC_EVENT_ACCOUNTS_ITEM_CHANGED: 2303,
   DC_EVENT_CHANNEL_OVERFLOW: 2400,
   DC_EVENT_CHATLIST_CHANGED: 2300,
   DC_EVENT_CHATLIST_ITEM_CHANGED: 2301,
@@ -54,7 +51,6 @@ module.exports = {
   DC_EVENT_INCOMING_MSG: 2005,
   DC_EVENT_INCOMING_MSG_BUNCH: 2006,
   DC_EVENT_INCOMING_REACTION: 2002,
-  DC_EVENT_INCOMING_WEBXDC_NOTIFY: 2003,
   DC_EVENT_INFO: 100,
   DC_EVENT_LOCATION_CHANGED: 2035,
   DC_EVENT_MSGS_CHANGED: 2000,

node/events.js

@@ -17,7 +17,6 @@ module.exports = {
   2000: 'DC_EVENT_MSGS_CHANGED',
   2001: 'DC_EVENT_REACTIONS_CHANGED',
   2002: 'DC_EVENT_INCOMING_REACTION',
-  2003: 'DC_EVENT_INCOMING_WEBXDC_NOTIFY',
   2005: 'DC_EVENT_INCOMING_MSG',
   2006: 'DC_EVENT_INCOMING_MSG_BUNCH',
   2008: 'DC_EVENT_MSGS_NOTICED',
@@ -44,7 +43,5 @@ module.exports = {
   2200: 'DC_EVENT_ACCOUNTS_BACKGROUND_FETCH_DONE',
   2300: 'DC_EVENT_CHATLIST_CHANGED',
   2301: 'DC_EVENT_CHATLIST_ITEM_CHANGED',
-  2302: 'DC_EVENT_ACCOUNTS_CHANGED',
-  2303: 'DC_EVENT_ACCOUNTS_ITEM_CHANGED',
   2400: 'DC_EVENT_CHANNEL_OVERFLOW'
 }

node/lib/constants.ts

@@ -1,7 +1,6 @@
 // Generated!
 
 export enum C {
-  DC_CERTCK_ACCEPT_INVALID = 2,
   DC_CERTCK_ACCEPT_INVALID_CERTIFICATES = 3,
   DC_CERTCK_AUTO = 0,
   DC_CERTCK_STRICT = 1,
@@ -31,8 +30,6 @@ export enum C {
   DC_DOWNLOAD_IN_PROGRESS = 1000,
   DC_DOWNLOAD_UNDECIPHERABLE = 30,
   DC_EVENT_ACCOUNTS_BACKGROUND_FETCH_DONE = 2200,
-  DC_EVENT_ACCOUNTS_CHANGED = 2302,
-  DC_EVENT_ACCOUNTS_ITEM_CHANGED = 2303,
   DC_EVENT_CHANNEL_OVERFLOW = 2400,
   DC_EVENT_CHATLIST_CHANGED = 2300,
   DC_EVENT_CHATLIST_ITEM_CHANGED = 2301,
@@ -54,7 +51,6 @@ export enum C {
   DC_EVENT_INCOMING_MSG = 2005,
   DC_EVENT_INCOMING_MSG_BUNCH = 2006,
   DC_EVENT_INCOMING_REACTION = 2002,
-  DC_EVENT_INCOMING_WEBXDC_NOTIFY = 2003,
   DC_EVENT_INFO = 100,
   DC_EVENT_LOCATION_CHANGED = 2035,
   DC_EVENT_MSGS_CHANGED = 2000,
@@ -328,7 +324,6 @@ export const EventId2EventName: { [key: number]: string } = {
   2000: 'DC_EVENT_MSGS_CHANGED',
   2001: 'DC_EVENT_REACTIONS_CHANGED',
   2002: 'DC_EVENT_INCOMING_REACTION',
-  2003: 'DC_EVENT_INCOMING_WEBXDC_NOTIFY',
   2005: 'DC_EVENT_INCOMING_MSG',
   2006: 'DC_EVENT_INCOMING_MSG_BUNCH',
   2008: 'DC_EVENT_MSGS_NOTICED',
@@ -355,7 +350,5 @@ export const EventId2EventName: { [key: number]: string } = {
   2200: 'DC_EVENT_ACCOUNTS_BACKGROUND_FETCH_DONE',
   2300: 'DC_EVENT_CHATLIST_CHANGED',
   2301: 'DC_EVENT_CHATLIST_ITEM_CHANGED',
-  2302: 'DC_EVENT_ACCOUNTS_CHANGED',
-  2303: 'DC_EVENT_ACCOUNTS_ITEM_CHANGED',
   2400: 'DC_EVENT_CHANNEL_OVERFLOW',
 }

package.json

@@ -55,5 +55,5 @@
     "test:mocha": "mocha node/test/test.mjs --growl --reporter=spec --bail --exit"
   },
   "types": "node/dist/index.d.ts",
-  "version": "1.151.5"
+  "version": "1.149.0"
 }

python/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "deltachat"
-version = "1.151.5"
+version = "1.149.0"
 description = "Python bindings for the Delta Chat Core library using CFFI against the Rust-implemented libdeltachat"
 readme = "README.rst"
 requires-python = ">=3.7"

python/src/deltachat/account.py

@@ -671,6 +671,9 @@ class Account:
     def get_connectivity_html(self) -> str:
         return from_dc_charpointer(lib.dc_get_connectivity_html(self._dc_context))
 
+    def all_work_done(self):
+        return lib.dc_all_work_done(self._dc_context)
+
     def start_io(self):
         """start this account's IO scheduling (Rust-core async scheduler).
 

python/src/deltachat/events.py

@@ -158,6 +158,12 @@ class FFIEventTracker:
 
             self.get_matching("DC_EVENT_CONNECTIVITY_CHANGED")
 
+    def wait_for_all_work_done(self):
+        while True:
+            if self.account.all_work_done():
+                return
+            self.get_matching("DC_EVENT_CONNECTIVITY_CHANGED")
+
     def ensure_event_not_queued(self, event_name_regex):
         __tracebackhide__ = True
         rex = re.compile(f"(?:{event_name_regex}).*")

python/src/deltachat/testplugin.py

@@ -152,7 +152,7 @@ class TestProcess:
 
     def get_liveconfig_producer(self):
         """provide live account configs, cached on a per-test-process scope
-        so that test functions can reuse already known live configs.
+        so that test functions can re-use already known live configs.
         """
         chatmail_opt = self.pytestconfig.getoption("--chatmail")
         if chatmail_opt:

python/tests/test_1_online.py

@@ -1899,11 +1899,10 @@ def test_connectivity(acfactory, lp):
 
     ac1.start_io()
     ac1._evtracker.wait_for_connectivity(dc.const.DC_CONNECTIVITY_CONNECTING)
-    ac1._evtracker.wait_for_connectivity_change(dc.const.DC_CONNECTIVITY_CONNECTING, dc.const.DC_CONNECTIVITY_WORKING)
-    ac1._evtracker.wait_for_connectivity_change(dc.const.DC_CONNECTIVITY_WORKING, dc.const.DC_CONNECTIVITY_CONNECTED)
+    ac1._evtracker.wait_for_connectivity_change(dc.const.DC_CONNECTIVITY_CONNECTING, dc.const.DC_CONNECTIVITY_CONNECTED)
 
     lp.sec(
-        "Test that after calling start_io(), maybe_network() and waiting for `DC_CONNECTIVITY_CONNECTED`, "
+        "Test that after calling start_io(), maybe_network() and waiting for `all_work_done()`, "
         "all messages are fetched",
     )
 
@@ -1912,7 +1911,7 @@ def test_connectivity(acfactory, lp):
         ac2.create_chat(ac1).send_text("Hi")
         idle1.wait_for_new_message()
     ac1.maybe_network()
-    ac1._evtracker.wait_for_connectivity(dc.const.DC_CONNECTIVITY_CONNECTED)
+    ac1._evtracker.wait_for_all_work_done()
     msgs = ac1.create_chat(ac2).get_messages()
     assert len(msgs) == 1
     assert msgs[0].text == "Hi"
@@ -1928,6 +1927,30 @@ def test_connectivity(acfactory, lp):
     assert len(msgs) == 2
     assert msgs[1].text == "Hi 2"
 
+    lp.sec("Test that the connectivity doesn't flicker to WORKING if there are no new messages")
+
+    ac1.maybe_network()
+    while 1:
+        assert ac1.get_connectivity() == dc.const.DC_CONNECTIVITY_CONNECTED
+        if ac1.all_work_done():
+            break
+        ac1._evtracker.get_matching("DC_EVENT_CONNECTIVITY_CHANGED")
+
+    lp.sec("Test that the connectivity doesn't flicker to WORKING if the sender of the message is blocked")
+    ac1.create_contact(ac2).block()
+
+    ac1.direct_imap.select_config_folder("inbox")
+    with ac1.direct_imap.idle() as idle1:
+        ac2.create_chat(ac1).send_text("Hi")
+        idle1.wait_for_new_message()
+    ac1.maybe_network()
+
+    while 1:
+        assert ac1.get_connectivity() == dc.const.DC_CONNECTIVITY_CONNECTED
+        if ac1.all_work_done():
+            break
+        ac1._evtracker.get_matching("DC_EVENT_CONNECTIVITY_CHANGED")
+
     lp.sec("Test that the connectivity is NOT_CONNECTED if the password is wrong")
 
     ac1.set_config("configured_mail_pw", "abc")
@@ -1938,6 +1961,32 @@ def test_connectivity(acfactory, lp):
     ac1._evtracker.wait_for_connectivity(dc.const.DC_CONNECTIVITY_NOT_CONNECTED)
 
 
+def test_all_work_done(acfactory, lp):
+    """
+    Tests that calling start_io() immediately followed by maybe_network()
+    and then waiting for all_work_done() reliably fetches the messages
+    delivered while account was offline.
+    In other words, connectivity should not change to a state
+    where all_work_done() returns true until IMAP connection goes idle.
+    """
+    ac1, ac2 = acfactory.get_online_accounts(2)
+
+    ac1.stop_io()
+    ac1._evtracker.wait_for_connectivity(dc.const.DC_CONNECTIVITY_NOT_CONNECTED)
+
+    ac1.direct_imap.select_config_folder("inbox")
+    with ac1.direct_imap.idle() as idle1:
+        ac2.create_chat(ac1).send_text("Hi")
+        idle1.wait_for_new_message()
+
+    ac1.start_io()
+    ac1.maybe_network()
+    ac1._evtracker.wait_for_all_work_done()
+    msgs = ac1.create_chat(ac2).get_messages()
+    assert len(msgs) == 1
+    assert msgs[0].text == "Hi"
+
+
 def test_fetch_deleted_msg(acfactory, lp):
     """This is a regression test: Messages with \\Deleted flag were downloaded again and again,
     hundreds of times, because uid_next was not updated.

python/tests/test_3_offline.py

@@ -705,7 +705,7 @@ class TestOfflineChat:
         ac1 = acfactory.get_pseudo_configured_account()
         ac2 = acfactory.get_pseudo_configured_account()
         qr = ac1.get_setup_contact_qr()
-        assert qr.startswith("https://i.delta.chat")
+        assert qr.startswith("OPENPGP4FPR:")
         res = ac2.check_qr(qr)
         assert res.is_ask_verifycontact()
         assert not res.is_ask_verifygroup()

release-date.in

@@ -1 +1 @@
-2024-12-05
+2024-11-05

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.83.0
+RUST_VERSION=1.82.0
 
 ARCH="$(uname -m)"
 test -f "/lib/libc.musl-$ARCH.so.1" && LIBC=musl || LIBC=gnu

scripts/wheel-rpc-server.py

@@ -25,7 +25,7 @@ def build_source_package(version, filename):
 
         def pack(name, contents):
             contents = contents.encode()
-            tar_info = tarfile.TarInfo(f"deltachat_rpc_server-{version}/{name}")
+            tar_info = tarfile.TarInfo(f"deltachat-rpc-server-{version}/{name}")
             tar_info.mode = 0o644
             tar_info.size = len(contents)
             pkg.addfile(tar_info, BytesIO(contents))
@@ -167,7 +167,7 @@ def main():
         cargo_manifest = tomllib.load(fp)
     version = cargo_manifest["package"]["version"]
     if sys.argv[1] == "source":
-        filename = f"deltachat_rpc_server-{version}.tar.gz"
+        filename = f"deltachat-rpc-server-{version}.tar.gz"
         build_source_package(version, filename)
     else:
         arch = sys.argv[1]

src/accounts.rs

@@ -139,7 +139,6 @@ impl Accounts {
         ctx.open("".to_string()).await?;
 
         self.accounts.insert(account_config.id, ctx);
-        self.emit_event(EventType::AccountsChanged);
 
         Ok(account_config.id)
     }
@@ -157,7 +156,6 @@ impl Accounts {
             .build()
             .await?;
         self.accounts.insert(account_config.id, ctx);
-        self.emit_event(EventType::AccountsChanged);
 
         Ok(account_config.id)
     }
@@ -192,7 +190,6 @@ impl Accounts {
                 .context("failed to remove account data")?;
         }
         self.config.remove_account(id).await?;
-        self.emit_event(EventType::AccountsChanged);
 
         Ok(())
     }

src/authres.rs

@@ -260,6 +260,7 @@ fn parse_authservid_candidates_config(config: &Option<String>) -> BTreeSet<&str>
 
 #[cfg(test)]
 mod tests {
+    #![allow(clippy::indexing_slicing)]
     use tokio::fs;
     use tokio::io::AsyncReadExt;
 

src/chat.rs

@@ -567,14 +567,6 @@ impl ChatId {
         contact_id: Option<ContactId>,
         timestamp_sort: i64,
     ) -> Result<()> {
-        if contact_id == Some(ContactId::SELF) {
-            // Do not add protection messages to Saved Messages chat.
-            // This chat never gets protected and unprotected,
-            // we do not want the first message
-            // to be a protection message with an arbitrary timestamp.
-            return Ok(());
-        }
-
         let text = context.stock_protection_msg(protect, contact_id).await;
         let cmd = match protect {
             ProtectionStatus::Protected => SystemMessage::ChatProtectionEnabled,
@@ -773,19 +765,27 @@ impl ChatId {
         );
 
         let chat = Chat::load_from_db(context, self).await?;
+        context
+            .sql
+            .execute(
+                "DELETE FROM msgs_mdns WHERE msg_id IN (SELECT id FROM msgs WHERE chat_id=?);",
+                (self,),
+            )
+            .await?;
 
         context
             .sql
-            .transaction(|transaction| {
-                transaction.execute(
-                    "DELETE FROM msgs_mdns WHERE msg_id IN (SELECT id FROM msgs WHERE chat_id=?)",
-                    (self,),
-                )?;
-                transaction.execute("DELETE FROM msgs WHERE chat_id=?", (self,))?;
-                transaction.execute("DELETE FROM chats_contacts WHERE chat_id=?", (self,))?;
-                transaction.execute("DELETE FROM chats WHERE id=?", (self,))?;
-                Ok(())
-            })
+            .execute("DELETE FROM msgs WHERE chat_id=?;", (self,))
+            .await?;
+
+        context
+            .sql
+            .execute("DELETE FROM chats_contacts WHERE chat_id=?;", (self,))
+            .await?;
+
+        context
+            .sql
+            .execute("DELETE FROM chats WHERE id=?;", (self,))
             .await?;
 
         context.emit_msgs_changed_without_ids();
@@ -922,27 +922,24 @@ impl ChatId {
                     && old_draft.chat_id == self
                     && old_draft.state == MessageState::OutDraft
                 {
-                    let affected_rows = context
-                        .sql.execute(
-                                "UPDATE msgs
-                                SET timestamp=?1,type=?2,txt=?3,txt_normalized=?4,param=?5,mime_in_reply_to=?6
-                                WHERE id=?7
-                                AND (type <> ?2 
-                                    OR txt <> ?3 
-                                    OR txt_normalized <> ?4
-                                    OR param <> ?5
-                                    OR mime_in_reply_to <> ?6);",
-                                (
-                                    time(),
-                                    msg.viewtype,
-                                    &msg.text,
-                                    message::normalize_text(&msg.text),
-                                    msg.param.to_string(),
-                                    msg.in_reply_to.as_deref().unwrap_or_default(),
-                                    msg.id,
-                                ),
-                            ).await?;
-                    return Ok(affected_rows > 0);
+                    context
+                        .sql
+                        .execute(
+                            "UPDATE msgs
+                            SET timestamp=?,type=?,txt=?,txt_normalized=?,param=?,mime_in_reply_to=?
+                            WHERE id=?;",
+                            (
+                                time(),
+                                msg.viewtype,
+                                &msg.text,
+                                message::normalize_text(&msg.text),
+                                msg.param.to_string(),
+                                msg.in_reply_to.as_deref().unwrap_or_default(),
+                                msg.id,
+                            ),
+                        )
+                        .await?;
+                    return Ok(true);
                 }
             }
         }
@@ -1399,7 +1396,7 @@ impl ChatId {
     ///
     /// `message_timestamp` should be either the message "sent" timestamp or a timestamp of the
     /// corresponding event in case of a system message (usually the current system time).
-    /// `always_sort_to_bottom` makes this adjust the returned timestamp up so that the message goes
+    /// `always_sort_to_bottom` makes this ajust the returned timestamp up so that the message goes
     /// to the chat bottom.
     /// `received` -- whether the message is received. Otherwise being sent.
     /// `incoming` -- whether the message is incoming.
@@ -2104,19 +2101,13 @@ impl Chat {
         } else {
             None
         };
-        let new_mime_headers = new_mime_headers.map(|s| new_html_mimepart(s).build().as_string());
         let new_mime_headers = new_mime_headers.or_else(|| match was_truncated {
-            // We need to add some headers so that they are stripped before formatting HTML by
-            // `MsgId::get_html()`, not a part of the actual text. Let's add "Content-Type", it's
-            // anyway a useful metadata about the stored text.
-            true => Some(
-                "Content-Type: text/plain; charset=utf-8\r\n\r\n".to_string() + &msg.text + "\r\n",
-            ),
+            true => Some(msg.text.clone()),
             false => None,
         });
         let new_mime_headers = match new_mime_headers {
             Some(h) => Some(tokio::task::block_in_place(move || {
-                buf_compress(h.as_bytes())
+                buf_compress(new_html_mimepart(h).build().as_string().as_bytes())
             })?),
             None => None,
         };
@@ -2216,9 +2207,7 @@ impl Chat {
             msg.id = MsgId::new(u32::try_from(raw_id)?);
 
             maybe_set_logging_xdc(context, msg, self.id).await?;
-            context
-                .update_webxdc_integration_database(msg, context)
-                .await?;
+            context.update_webxdc_integration_database(msg).await?;
         }
         context.scheduler.interrupt_ephemeral_task().await;
         Ok(msg.id)
@@ -2607,12 +2596,10 @@ impl ChatIdBlocked {
             _ => (),
         }
 
-        let protected = contact_id == ContactId::SELF || {
-            let peerstate = Peerstate::from_addr(context, contact.get_addr()).await?;
-            peerstate.is_some_and(|p| {
-                p.is_using_verified_key() && p.prefer_encrypt == EncryptPreference::Mutual
-            })
-        };
+        let peerstate = Peerstate::from_addr(context, contact.get_addr()).await?;
+        let protected = peerstate.map_or(false, |p| {
+            p.is_using_verified_key() && p.prefer_encrypt == EncryptPreference::Mutual
+        });
         let smeared_time = create_smeared_timestamp(context);
 
         let chat_id = context
@@ -2995,8 +2982,8 @@ pub(crate) async fn create_send_msg_jobs(context: &Context, msg: &mut Message) -
         recipients.push(from);
     }
 
-    // Default Webxdc integrations are hidden messages and must not be sent out
-    if msg.param.get_int(Param::WebxdcIntegration).is_some() && msg.hidden {
+    // Webxdc integrations are messages, however, shipped with main app and must not be sent out
+    if msg.param.get_int(Param::WebxdcIntegration).is_some() {
         recipients.clear();
     }
 
@@ -4501,7 +4488,7 @@ pub(crate) async fn delete_and_reset_all_device_msgs(context: &Context) -> Resul
         .await?;
     context.sql.execute("DELETE FROM devmsglabels;", ()).await?;
 
-    // Insert labels for welcome messages to avoid them being re-added on reconfiguration.
+    // Insert labels for welcome messages to avoid them being readded on reconfiguration.
     context
         .sql
         .execute(
@@ -4663,9 +4650,9 @@ impl Context {
                     Contact::create_ex(self, Nosync, to, addr).await?;
                     return Ok(());
                 }
-                let addr = ContactAddress::new(addr).context("Invalid address")?;
-                let (contact_id, _) =
-                    Contact::add_or_lookup(self, "", &addr, Origin::Hidden).await?;
+                let contact_id = Contact::lookup_id_by_addr_ex(self, addr, Origin::Unknown, None)
+                    .await?
+                    .with_context(|| format!("No contact for addr '{addr}'"))?;
                 match action {
                     SyncAction::Block => {
                         return contact::set_blocked(self, Nosync, contact_id, true).await
@@ -4675,10 +4662,9 @@ impl Context {
                     }
                     _ => (),
                 }
-                // Use `Request` so that even if the program crashes, the user doesn't have to look
-                // into the blocked contacts.
-                ChatIdBlocked::get_for_contact(self, contact_id, Blocked::Request)
+                ChatIdBlocked::lookup_by_contact(self, contact_id)
                     .await?
+                    .with_context(|| format!("No chat for addr '{addr}'"))?
                     .id
             }
             SyncId::Grpid(grpid) => {
@@ -4715,7 +4701,7 @@ impl Context {
 
     /// Emits the appropriate `MsgsChanged` event. Should be called if the number of unnoticed
     /// archived chats could decrease. In general we don't want to make an extra db query to know if
-    /// a noticed chat is archived. Emitting events should be cheap, a false-positive `MsgsChanged`
+    /// a noticied chat is archived. Emitting events should be cheap, a false-positive `MsgsChanged`
     /// is ok.
     pub(crate) fn on_archived_chats_maybe_noticed(&self) {
         self.emit_msgs_changed(DC_CHAT_ID_ARCHIVED_LINK, MsgId::new(0));
@@ -7484,71 +7470,6 @@ mod tests {
         Ok(())
     }
 
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_sync_accept_before_first_msg() -> Result<()> {
-        let alice0 = &TestContext::new_alice().await;
-        let alice1 = &TestContext::new_alice().await;
-        for a in [alice0, alice1] {
-            a.set_config_bool(Config::SyncMsgs, true).await?;
-        }
-        let bob = TestContext::new_bob().await;
-
-        let ba_chat = bob.create_chat(alice0).await;
-        let sent_msg = bob.send_text(ba_chat.id, "hi").await;
-        let a0b_chat_id = alice0.recv_msg(&sent_msg).await.chat_id;
-        assert_eq!(alice0.get_chat(&bob).await.blocked, Blocked::Request);
-        a0b_chat_id.accept(alice0).await?;
-        let a0b_contact = alice0.add_or_lookup_contact(&bob).await;
-        assert_eq!(a0b_contact.origin, Origin::CreateChat);
-        assert_eq!(alice0.get_chat(&bob).await.blocked, Blocked::Not);
-
-        sync(alice0, alice1).await;
-        let a1b_contact = alice1.add_or_lookup_contact(&bob).await;
-        assert_eq!(a1b_contact.origin, Origin::CreateChat);
-        let a1b_chat = alice1.get_chat(&bob).await;
-        assert_eq!(a1b_chat.blocked, Blocked::Not);
-        let chats = Chatlist::try_load(alice1, 0, None, None).await?;
-        assert_eq!(chats.len(), 1);
-
-        let rcvd_msg = alice1.recv_msg(&sent_msg).await;
-        assert_eq!(rcvd_msg.chat_id, a1b_chat.id);
-        Ok(())
-    }
-
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_sync_block_before_first_msg() -> Result<()> {
-        let alice0 = &TestContext::new_alice().await;
-        let alice1 = &TestContext::new_alice().await;
-        for a in [alice0, alice1] {
-            a.set_config_bool(Config::SyncMsgs, true).await?;
-        }
-        let bob = TestContext::new_bob().await;
-
-        let ba_chat = bob.create_chat(alice0).await;
-        let sent_msg = bob.send_text(ba_chat.id, "hi").await;
-        let a0b_chat_id = alice0.recv_msg(&sent_msg).await.chat_id;
-        assert_eq!(alice0.get_chat(&bob).await.blocked, Blocked::Request);
-        a0b_chat_id.block(alice0).await?;
-        let a0b_contact = alice0.add_or_lookup_contact(&bob).await;
-        assert_eq!(a0b_contact.origin, Origin::IncomingUnknownFrom);
-        assert_eq!(alice0.get_chat(&bob).await.blocked, Blocked::Yes);
-
-        sync(alice0, alice1).await;
-        let a1b_contact = alice1.add_or_lookup_contact(&bob).await;
-        assert_eq!(a1b_contact.origin, Origin::Hidden);
-        assert!(ChatIdBlocked::lookup_by_contact(alice1, a1b_contact.id)
-            .await?
-            .is_none());
-
-        let rcvd_msg = alice1.recv_msg(&sent_msg).await;
-        let a1b_contact = alice1.add_or_lookup_contact(&bob).await;
-        assert_eq!(a1b_contact.origin, Origin::IncomingUnknownFrom);
-        let a1b_chat = alice1.get_chat(&bob).await;
-        assert_eq!(a1b_chat.blocked, Blocked::Yes);
-        assert_eq!(rcvd_msg.chat_id, a1b_chat.id);
-        Ok(())
-    }
-
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_sync_adhoc_grp() -> Result<()> {
         let alice0 = &TestContext::new_alice().await;
@@ -7775,19 +7696,4 @@ mod tests {
 
         Ok(())
     }
-
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_do_not_overwrite_draft() -> Result<()> {
-        let mut tcm = TestContextManager::new();
-        let alice = tcm.alice().await;
-        let mut msg = Message::new_text("This is a draft message".to_string());
-        let self_chat = alice.get_self_chat().await.id;
-        self_chat.set_draft(&alice, Some(&mut msg)).await.unwrap();
-        let draft1 = self_chat.get_draft(&alice).await?.unwrap();
-        SystemTime::shift(Duration::from_secs(1));
-        self_chat.set_draft(&alice, Some(&mut msg)).await.unwrap();
-        let draft2 = self_chat.get_draft(&alice).await?.unwrap();
-        assert_eq!(draft1.timestamp_sort, draft2.timestamp_sort);
-        Ok(())
-    }
 }

src/chatlist.rs

@@ -394,32 +394,25 @@ impl Chatlist {
             &chat_loaded
         };
 
-        let lastmsg = if let Some(lastmsg_id) = lastmsg_id {
-            // Message may be deleted by the time we try to load it,
-            // so use `load_from_db_optional` instead of `load_from_db`.
-            Message::load_from_db_optional(context, lastmsg_id)
+        let (lastmsg, lastcontact) = if let Some(lastmsg_id) = lastmsg_id {
+            let lastmsg = Message::load_from_db(context, lastmsg_id)
                 .await
-                .context("Loading message failed")?
-        } else {
-            None
-        };
-
-        let lastcontact = if let Some(lastmsg) = &lastmsg {
+                .context("loading message failed")?;
             if lastmsg.from_id == ContactId::SELF {
-                None
+                (Some(lastmsg), None)
             } else {
                 match chat.typ {
                     Chattype::Group | Chattype::Broadcast | Chattype::Mailinglist => {
                         let lastcontact = Contact::get_by_id(context, lastmsg.from_id)
                             .await
                             .context("loading contact failed")?;
-                        Some(lastcontact)
+                        (Some(lastmsg), Some(lastcontact))
                     }
-                    Chattype::Single => None,
+                    Chattype::Single => (Some(lastmsg), None),
                 }
             }
         } else {
-            None
+            (None, None)
         };
 
         if chat.id.is_archived_link() {
@@ -768,25 +761,6 @@ mod tests {
         assert_eq!(summary.text, "foo: bar test"); // the linebreak should be removed from summary
     }
 
-    /// Tests that summary does not fail to load
-    /// if the draft was deleted after loading the chatlist.
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_get_summary_deleted_draft() {
-        let t = TestContext::new().await;
-
-        let chat_id = create_group_chat(&t, ProtectionStatus::Unprotected, "a chat")
-            .await
-            .unwrap();
-        let mut msg = Message::new_text("Foobar".to_string());
-        chat_id.set_draft(&t, Some(&mut msg)).await.unwrap();
-
-        let chats = Chatlist::try_load(&t, 0, None, None).await.unwrap();
-        chat_id.set_draft(&t, None).await.unwrap();
-
-        let summary_res = chats.get_summary(&t, 0, None).await;
-        assert!(summary_res.is_ok());
-    }
-
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_load_broken() {
         let t = TestContext::new_bob().await;

src/config.rs

@@ -80,7 +80,7 @@ pub enum Config {
     /// SMTP server security (e.g. TLS, STARTTLS).
     SendSecurity,
 
-    /// Deprecated option for backwards compatibility.
+    /// Deprecated option for backwards compatibilty.
     ///
     /// Certificate checks for SMTP are actually controlled by `imap_certificate_checks` config.
     SmtpCertificateChecks,
@@ -441,12 +441,6 @@ pub enum Config {
     /// Enable webxdc realtime features.
     #[strum(props(default = "1"))]
     WebxdcRealtimeEnabled,
-
-    /// Last device token stored on the chatmail server.
-    ///
-    /// If it has not changed, we do not store
-    /// the device token again.
-    DeviceToken,
 }
 
 impl Config {
@@ -797,12 +791,6 @@ impl Context {
                 self.sql.set_raw_config(key.as_ref(), value).await?;
             }
         }
-        if matches!(
-            key,
-            Config::Displayname | Config::Selfavatar | Config::PrivateTag
-        ) {
-            self.emit_event(EventType::AccountsItemChanged);
-        }
         if key.is_synced() {
             self.emit_event(EventType::ConfigSynced { key });
         }

src/configure.rs

@@ -36,10 +36,10 @@ use crate::message::Message;
 use crate::oauth2::get_oauth2_addr;
 use crate::provider::{Protocol, Socket, UsernamePattern};
 use crate::smtp::Smtp;
+use crate::stock_str;
 use crate::sync::Sync::*;
 use crate::tools::time;
 use crate::{chat, e2ee, provider};
-use crate::{stock_str, EventType};
 use deltachat_contact_tools::addr_cmp;
 
 macro_rules! progress {
@@ -486,7 +486,6 @@ async fn configure(ctx: &Context, param: &EnteredLoginParam) -> Result<Configure
     update_device_chats_handle.await??;
 
     ctx.sql.set_raw_config_bool("configured", true).await?;
-    ctx.emit_event(EventType::AccountsItemChanged);
 
     Ok(configured_param)
 }
@@ -612,6 +611,8 @@ pub enum Error {
 
 #[cfg(test)]
 mod tests {
+    #![allow(clippy::indexing_slicing)]
+
     use super::*;
     use crate::config::Config;
     use crate::login_param::EnteredServerLoginParam;

src/configure/auto_mozilla.rs

@@ -67,15 +67,19 @@ fn parse_server<B: BufRead>(
 
     let typ = server_event
         .attributes()
-        .find_map(|attr| {
-            attr.ok().filter(|a| {
-                String::from_utf8_lossy(a.key.as_ref())
-                    .trim()
-                    .eq_ignore_ascii_case("type")
-            })
+        .find(|attr| {
+            attr.as_ref()
+                .map(|a| {
+                    String::from_utf8_lossy(a.key.as_ref())
+                        .trim()
+                        .to_lowercase()
+                        == "type"
+                })
+                .unwrap_or_default()
         })
         .map(|typ| {
-            typ.decode_and_unescape_value(reader.decoder())
+            typ.unwrap()
+                .decode_and_unescape_value(reader.decoder())
                 .unwrap_or_default()
                 .to_lowercase()
         })
@@ -268,6 +272,8 @@ pub(crate) async fn moz_autoconfigure(
 
 #[cfg(test)]
 mod tests {
+    #![allow(clippy::indexing_slicing)]
+
     use super::*;
 
     #[test]

src/configure/auto_outlook.rs

@@ -215,6 +215,8 @@ pub(crate) async fn outlk_autodiscover(
 
 #[cfg(test)]
 mod tests {
+    #![allow(clippy::indexing_slicing)]
+
     use super::*;
 
     #[test]

src/contact.rs

@@ -144,7 +144,7 @@ impl ContactId {
         Ok(())
     }
 
-    /// Returns contact address.
+    /// Returns contact adress.
     pub async fn addr(&self, context: &Context) -> Result<String> {
         let addr = context
             .sql
@@ -1252,15 +1252,15 @@ impl Contact {
 
         let fingerprint_self = load_self_public_key(context)
             .await?
-            .dc_fingerprint()
+            .fingerprint()
             .to_string();
         let fingerprint_other_verified = peerstate
             .peek_key(true)
-            .map(|k| k.dc_fingerprint().to_string())
+            .map(|k| k.fingerprint().to_string())
             .unwrap_or_default();
         let fingerprint_other_unverified = peerstate
             .peek_key(false)
-            .map(|k| k.dc_fingerprint().to_string())
+            .map(|k| k.fingerprint().to_string())
             .unwrap_or_default();
         if addr < peerstate.addr {
             cat_fingerprint(&mut ret, &addr, &fingerprint_self, "");
@@ -3244,20 +3244,4 @@ Until the false-positive is fixed:
 
         Ok(())
     }
-
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_self_is_verified() -> Result<()> {
-        let mut tcm = TestContextManager::new();
-        let alice = tcm.alice().await;
-
-        let contact = Contact::get_by_id(&alice, ContactId::SELF).await?;
-        assert_eq!(contact.is_verified(&alice).await?, true);
-        assert!(contact.is_profile_verified(&alice).await?);
-        assert!(contact.get_verifier_id(&alice).await?.is_none());
-
-        let chat_id = ChatId::get_for_contact(&alice, ContactId::SELF).await?;
-        assert!(chat_id.is_protected(&alice).await.unwrap() == ProtectionStatus::Protected);
-
-        Ok(())
-    }
 }

src/context.rs

@@ -10,10 +10,9 @@ use std::time::Duration;
 
 use anyhow::{bail, ensure, Context as _, Result};
 use async_channel::{self as channel, Receiver, Sender};
-use pgp::types::PublicKeyTrait;
 use pgp::SignedPublicKey;
 use ratelimit::Ratelimit;
-use tokio::sync::{Mutex, Notify, RwLock};
+use tokio::sync::{Mutex, Notify, OnceCell, RwLock};
 
 use crate::aheader::EncryptPreference;
 use crate::chat::{get_chat_cnt, ChatId, ProtectionStatus};
@@ -276,7 +275,7 @@ pub struct InnerContext {
     /// The text of the last error logged and emitted as an event.
     /// If the ui wants to display an error after a failure,
     /// `last_error` should be used to avoid races with the event thread.
-    pub(crate) last_error: parking_lot::RwLock<String>,
+    pub(crate) last_error: std::sync::RwLock<String>,
 
     /// If debug logging is enabled, this contains all necessary information
     ///
@@ -292,7 +291,7 @@ pub struct InnerContext {
     pub(crate) push_subscribed: AtomicBool,
 
     /// Iroh for realtime peer channels.
-    pub(crate) iroh: Arc<RwLock<Option<Iroh>>>,
+    pub(crate) iroh: OnceCell<Iroh>,
 }
 
 /// The state of ongoing process.
@@ -446,11 +445,11 @@ impl Context {
             metadata: RwLock::new(None),
             creation_time: tools::Time::now(),
             last_full_folder_scan: Mutex::new(None),
-            last_error: parking_lot::RwLock::new("".to_string()),
+            last_error: std::sync::RwLock::new("".to_string()),
             debug_logging: std::sync::RwLock::new(None),
             push_subscriber,
             push_subscribed: AtomicBool::new(false),
-            iroh: Arc::new(RwLock::new(None)),
+            iroh: OnceCell::new(),
         };
 
         let ctx = Context {
@@ -472,33 +471,12 @@ impl Context {
             // Allow at least 1 message every second + a burst of 3.
             *lock = Ratelimit::new(Duration::new(3, 0), 3.0);
         }
-
-        // The next line is mainly for iOS:
-        // iOS starts a separate process for receiving notifications and if the user concurrently
-        // starts the app, the UI process opens the database but waits with calling start_io()
-        // until the notifications process finishes.
-        // Now, some configs may have changed, so, we need to invalidate the cache.
-        self.sql.config_cache.write().await.clear();
-
         self.scheduler.start(self.clone()).await;
     }
 
     /// Stops the IO scheduler.
     pub async fn stop_io(&self) {
         self.scheduler.stop(self).await;
-        if let Some(iroh) = self.iroh.write().await.take() {
-            // Close all QUIC connections.
-
-            // Spawn into a separate task,
-            // because Iroh calls `wait_idle()` internally
-            // and it may take time, especially if the network
-            // has become unavailable.
-            tokio::spawn(async move {
-                // We do not log the error because we do not want the task
-                // to hold the reference to Context.
-                let _ = tokio::time::timeout(Duration::from_secs(60), iroh.close()).await;
-            });
-        }
     }
 
     /// Restarts the IO scheduler if it was running before
@@ -509,7 +487,7 @@ impl Context {
 
     /// Indicate that the network likely has come back.
     pub async fn maybe_network(&self) {
-        if let Some(ref iroh) = *self.iroh.read().await {
+        if let Some(iroh) = self.iroh.get() {
             iroh.network_change().await;
         }
         self.scheduler.maybe_network().await;
@@ -803,7 +781,7 @@ impl Context {
             .count("SELECT COUNT(*) FROM acpeerstates;", ())
             .await?;
         let fingerprint_str = match load_self_public_key(self).await {
-            Ok(key) => key.dc_fingerprint().hex(),
+            Ok(key) => key.fingerprint().hex(),
             Err(err) => format!("<key failure: {err}>"),
         };
 
@@ -1199,7 +1177,7 @@ impl Context {
             EncryptPreference::Mutual,
             &public_key,
         );
-        let fingerprint = public_key.dc_fingerprint();
+        let fingerprint = public_key.fingerprint();
         peerstate.set_verified(public_key, fingerprint, "".to_string())?;
         peerstate.save_to_db(&self.sql).await?;
         chat_id
@@ -1771,7 +1749,6 @@ mod tests {
             "socks5_password",
             "key_id",
             "webxdc_integration",
-            "device_token",
         ];
         let t = TestContext::new().await;
         let info = t.get_info().await.unwrap();
@@ -2086,41 +2063,4 @@ mod tests {
 
         Ok(())
     }
-
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_cache_is_cleared_when_io_is_started() -> Result<()> {
-        let alice = TestContext::new_alice().await;
-        assert_eq!(
-            alice.get_config(Config::ShowEmails).await?,
-            Some("2".to_string())
-        );
-
-        // Change the config circumventing the cache
-        // This simulates what the notification plugin on iOS might do
-        // because it runs in a different process
-        alice
-            .sql
-            .execute(
-                "INSERT OR REPLACE INTO config (keyname, value) VALUES ('show_emails', '0')",
-                (),
-            )
-            .await?;
-
-        // Alice's Delta Chat doesn't know about it yet:
-        assert_eq!(
-            alice.get_config(Config::ShowEmails).await?,
-            Some("2".to_string())
-        );
-
-        // Starting IO will fail of course because no server settings are configured,
-        // but it should invalidate the caches:
-        alice.start_io().await;
-
-        assert_eq!(
-            alice.get_config(Config::ShowEmails).await?,
-            Some("0".to_string())
-        );
-
-        Ok(())
-    }
 }

src/debug_logging.rs

@@ -60,11 +60,9 @@ pub async fn debug_logging_loop(context: &Context, events: Receiver<DebugEventLo
                         "time": time,
                     }),
                     info: None,
-                    href: None,
                     summary: None,
                     document: None,
                     uid: None,
-                    notify: None,
                 },
                 time,
             )

src/decrypt.rs

@@ -182,7 +182,7 @@ pub(crate) async fn get_autocrypt_peerstate(
             // if the fingerprint is verified.
             peerstate = Peerstate::from_verified_fingerprint_or_addr(
                 context,
-                &header.public_key.dc_fingerprint(),
+                &header.public_key.fingerprint(),
                 from,
             )
             .await?;

src/download.rs

@@ -440,7 +440,7 @@ mod tests {
         let _sent1 = alice.send_msg(chat_id, &mut instance).await;
 
         alice
-            .send_webxdc_status_update(instance.id, r#"{"payload":7}"#)
+            .send_webxdc_status_update(instance.id, r#"{"payload":7}"#, "d")
             .await?;
         alice.flush_status_updates().await?;
         let sent2 = alice.pop_sent_msg().await;

src/e2ee.rs

@@ -303,12 +303,12 @@ Sent with my Delta Chat Messenger: https://delta.chat";
             last_seen_autocrypt: 14,
             prefer_encrypt,
             public_key: Some(pub_key.clone()),
-            public_key_fingerprint: Some(pub_key.dc_fingerprint()),
+            public_key_fingerprint: Some(pub_key.fingerprint()),
             gossip_key: Some(pub_key.clone()),
             gossip_timestamp: 15,
-            gossip_key_fingerprint: Some(pub_key.dc_fingerprint()),
+            gossip_key_fingerprint: Some(pub_key.fingerprint()),
             verified_key: Some(pub_key.clone()),
-            verified_key_fingerprint: Some(pub_key.dc_fingerprint()),
+            verified_key_fingerprint: Some(pub_key.fingerprint()),
             verifier: None,
             secondary_verified_key: None,
             secondary_verified_key_fingerprint: None,

src/events/payload.rs

@@ -59,7 +59,7 @@ pub enum EventType {
     /// or for functions that are expected to fail (eg. dc_continue_key_transfer())
     /// it might be better to delay showing these events until the function has really
     /// failed (returned false). It should be sufficient to report only the *last* error
-    /// in a message box then.
+    /// in a messasge box then.
     Error(String),
 
     /// An action cannot be performed because the user is not in the group.
@@ -107,21 +107,6 @@ pub enum EventType {
         reaction: Reaction,
     },
 
-    /// A webxdc wants an info message or a changed summary to be notified.
-    IncomingWebxdcNotify {
-        /// ID of the contact sending.
-        contact_id: ContactId,
-
-        /// ID of the added info message or webxdc instance in case of summary change.
-        msg_id: MsgId,
-
-        /// Text to notify.
-        text: String,
-
-        /// Link assigned to this notification, if any.
-        href: Option<String>,
-    },
-
     /// There is a fresh message. Typically, the user will show an notification
     /// when receiving this message.
     ///
@@ -347,20 +332,6 @@ pub enum EventType {
         chat_id: Option<ChatId>,
     },
 
-    /// Inform that the list of accounts has changed (an account removed or added or (not yet implemented) the account order changes)
-    ///
-    /// This event is only emitted by the account manager
-    AccountsChanged,
-
-    /// Inform that an account property that might be shown in the account list changed, namely:
-    /// - is_configured (see [crate::context::Context::is_configured])
-    /// - displayname
-    /// - selfavatar
-    /// - private_tag
-    ///
-    /// This event is emitted from the account whose property changed.
-    AccountsItemChanged,
-
     /// Event for using in tests, e.g. as a fence between normally generated events.
     #[cfg(test)]
     Test,

src/imap.rs

@@ -41,7 +41,6 @@ use crate::mimeparser;
 use crate::net::proxy::ProxyConfig;
 use crate::net::session::SessionStream;
 use crate::oauth2::get_oauth2_access_token;
-use crate::push::encrypt_device_token;
 use crate::receive_imf::{
     from_field_to_contact_id, get_prefetch_parent_message, receive_imf_inner, ReceivedMsg,
 };
@@ -408,7 +407,7 @@ impl Imap {
                         "IMAP-LOGIN as {}",
                         lp.user
                     )));
-                    self.connectivity.set_preparing(context).await;
+                    self.connectivity.set_connected(context).await;
                     info!(context, "Successfully logged into IMAP server");
                     return Ok(session);
                 }
@@ -1560,53 +1559,17 @@ impl Session {
             return Ok(());
         };
 
-        let device_token_changed = context
-            .get_config(Config::DeviceToken)
-            .await?
-            .map_or(true, |config_token| device_token != config_token);
-
-        if device_token_changed && self.can_metadata() && self.can_push() {
+        if self.can_metadata() && self.can_push() {
             let folder = context
                 .get_config(Config::ConfiguredInboxFolder)
                 .await?
                 .context("INBOX is not configured")?;
 
-            let encrypted_device_token =
-                encrypt_device_token(&device_token).context("Failed to encrypt device token")?;
-
-            // We expect that the server supporting `XDELTAPUSH` capability
-            // has non-synchronizing literals support as well:
-            // <https://www.rfc-editor.org/rfc/rfc7888>.
-            let encrypted_device_token_len = encrypted_device_token.len();
-
-            if encrypted_device_token_len <= 4096 {
-                self.run_command_and_check_ok(&format_setmetadata(
-                    &folder,
-                    &encrypted_device_token,
-                ))
-                .await
-                .context("SETMETADATA command failed")?;
-
-                // Store device token saved on the server
-                // to prevent storing duplicate tokens.
-                // The server cannot deduplicate on its own
-                // because encryption gives a different
-                // result each time.
-                context
-                    .set_config_internal(Config::DeviceToken, Some(&device_token))
-                    .await?;
-            } else {
-                // If Apple or Google (FCM) gives us a very large token,
-                // do not even try to give it to IMAP servers.
-                //
-                // Limit of 4096 is arbitrarily selected
-                // to be the same as required by LITERAL- IMAP extension.
-                //
-                // Dovecot supports LITERAL+ and non-synchronizing literals
-                // of any length, but there is no reason for tokens
-                // to be that large even after OpenPGP encryption.
-                warn!(context, "Device token is too long for LITERAL-, ignoring.");
-            }
+            self.run_command_and_check_ok(format!(
+                "SETMETADATA \"{folder}\" (/private/devicetoken \"{device_token}\")"
+            ))
+            .await
+            .context("SETMETADATA command failed")?;
             context.push_subscribed.store(true, Ordering::Relaxed);
         } else if !context.push_subscriber.heartbeat_subscribed().await {
             let context = context.clone();
@@ -1618,13 +1581,6 @@ impl Session {
     }
 }
 
-fn format_setmetadata(folder: &str, device_token: &str) -> String {
-    let device_token_len = device_token.len();
-    format!(
-        "SETMETADATA \"{folder}\" (/private/devicetoken {{{device_token_len}+}}\r\n{device_token})"
-    )
-}
-
 impl Session {
     /// Returns success if we successfully set the flag or we otherwise
     /// think add_flag should not be retried: Disconnection during setting
@@ -2908,16 +2864,4 @@ mod tests {
             vec![("INBOX".to_string(), vec![1, 2, 3], "2:3".to_string())]
         );
     }
-
-    #[test]
-    fn test_setmetadata_device_token() {
-        assert_eq!(
-            format_setmetadata("INBOX", "foobarbaz"),
-            "SETMETADATA \"INBOX\" (/private/devicetoken {9+}\r\nfoobarbaz)"
-        );
-        assert_eq!(
-            format_setmetadata("INBOX", "foo\r\nbar\r\nbaz\r\n"),
-            "SETMETADATA \"INBOX\" (/private/devicetoken {15+}\r\nfoo\r\nbar\r\nbaz\r\n)"
-        );
-    }
 }

src/imex.rs

@@ -4,7 +4,7 @@ use std::ffi::OsStr;
 use std::path::{Path, PathBuf};
 use std::pin::Pin;
 
-use ::pgp::types::PublicKeyTrait;
+use ::pgp::types::KeyTrait;
 use anyhow::{bail, ensure, format_err, Context as _, Result};
 use futures::TryStreamExt;
 use futures_lite::FutureExt;
@@ -426,7 +426,6 @@ async fn import_backup_stream_inner<R: tokio::io::AsyncRead + Unpin>(
     if res.is_ok() {
         context.emit_event(EventType::ImexProgress(999));
         res = context.sql.run_migrations(context).await;
-        context.emit_event(EventType::AccountsItemChanged);
     }
     if res.is_ok() {
         delete_and_reset_all_device_msgs(context)
@@ -751,7 +750,7 @@ where
             true => "private",
         };
         let id = id.map_or("default".into(), |i| i.to_string());
-        let fp = key.dc_fingerprint().hex();
+        let fp = DcKey::fingerprint(key).hex();
         format!("{kind}-key-{addr}-{id}-{fp}.asc")
     };
     let path = dir.join(&file_name);
@@ -879,7 +878,7 @@ mod tests {
             .unwrap()
             .strip_suffix(".asc")
             .unwrap();
-        assert_eq!(fingerprint, key.dc_fingerprint().hex());
+        assert_eq!(fingerprint, DcKey::fingerprint(&key).hex());
         let blobdir = context.ctx.get_blobdir().to_str().unwrap();
         let filename = format!("{blobdir}/{filename}");
         let bytes = tokio::fs::read(&filename).await.unwrap();

src/key.rs

@@ -11,8 +11,7 @@ use num_traits::FromPrimitive;
 use pgp::composed::Deserializable;
 pub use pgp::composed::{SignedPublicKey, SignedSecretKey};
 use pgp::ser::Serialize;
-use pgp::types::{PublicKeyTrait, SecretKeyTrait};
-use rand::thread_rng;
+use pgp::types::{KeyTrait, SecretKeyTrait};
 use tokio::runtime::Handle;
 
 use crate::config::Config;
@@ -27,7 +26,7 @@ use crate::tools::{self, time_elapsed};
 /// This trait is implemented for rPGP's [SignedPublicKey] and
 /// [SignedSecretKey] types and makes working with them a little
 /// easier in the deltachat world.
-pub(crate) trait DcKey: Serialize + Deserializable + PublicKeyTrait + Clone {
+pub(crate) trait DcKey: Serialize + Deserializable + KeyTrait + Clone {
     /// Create a key from some bytes.
     fn from_slice(bytes: &[u8]) -> Result<Self> {
         Ok(<Self as Deserializable>::from_bytes(Cursor::new(bytes))?)
@@ -94,8 +93,8 @@ pub(crate) trait DcKey: Serialize + Deserializable + PublicKeyTrait + Clone {
     fn to_asc(&self, header: Option<(&str, &str)>) -> String;
 
     /// The fingerprint for the key.
-    fn dc_fingerprint(&self) -> Fingerprint {
-        PublicKeyTrait::fingerprint(self).into()
+    fn fingerprint(&self) -> Fingerprint {
+        Fingerprint::new(KeyTrait::fingerprint(self))
     }
 
     fn is_private() -> bool;
@@ -234,8 +233,7 @@ impl DcSecretKey for SignedSecretKey {
     fn split_public_key(&self) -> Result<SignedPublicKey> {
         self.verify()?;
         let unsigned_pubkey = SecretKeyTrait::public_key(self);
-        let mut rng = thread_rng();
-        let signed_pubkey = unsigned_pubkey.sign(&mut rng, self, || "".into())?;
+        let signed_pubkey = unsigned_pubkey.sign(self, || "".into())?;
         Ok(signed_pubkey)
     }
 }
@@ -397,12 +395,6 @@ impl Fingerprint {
     }
 }
 
-impl From<pgp::types::Fingerprint> for Fingerprint {
-    fn from(fingerprint: pgp::types::Fingerprint) -> Fingerprint {
-        Self::new(fingerprint.as_bytes().into())
-    }
-}
-
 impl fmt::Debug for Fingerprint {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("Fingerprint")

src/lib.rs

@@ -16,8 +16,7 @@
     clippy::explicit_into_iter_loop,
     clippy::cloned_instead_of_copied
 )]
-#![cfg_attr(not(test), forbid(clippy::indexing_slicing))]
-#![cfg_attr(not(test), forbid(clippy::string_slice))]
+#![cfg_attr(not(test), warn(clippy::indexing_slicing))]
 #![allow(
     clippy::match_bool,
     clippy::mixed_read_write_in_expression,

src/location.rs

@@ -244,14 +244,18 @@ impl Kml {
             self.tag = KmlTag::PlacemarkPoint;
         } else if tag == "coordinates" && self.tag == KmlTag::PlacemarkPoint {
             self.tag = KmlTag::PlacemarkPointCoordinates;
-            if let Some(acc) = event.attributes().find_map(|attr| {
-                attr.ok().filter(|a| {
-                    String::from_utf8_lossy(a.key.as_ref())
-                        .trim()
-                        .eq_ignore_ascii_case("accuracy")
-                })
+            if let Some(acc) = event.attributes().find(|attr| {
+                attr.as_ref()
+                    .map(|a| {
+                        String::from_utf8_lossy(a.key.as_ref())
+                            .trim()
+                            .to_lowercase()
+                            == "accuracy"
+                    })
+                    .unwrap_or_default()
             }) {
                 let v = acc
+                    .unwrap()
                     .decode_and_unescape_value(reader.decoder())
                     .unwrap_or_default();
 
@@ -876,6 +880,8 @@ async fn maybe_send_locations(context: &Context) -> Result<Option<u64>> {
 
 #[cfg(test)]
 mod tests {
+    #![allow(clippy::indexing_slicing)]
+
     use super::*;
     use crate::config::Config;
     use crate::message::MessageState;

src/log.rs

@@ -50,13 +50,13 @@ impl Context {
     /// Set last error string.
     /// Implemented as blocking as used from macros in different, not always async blocks.
     pub fn set_last_error(&self, error: &str) {
-        let mut last_error = self.last_error.write();
+        let mut last_error = self.last_error.write().unwrap();
         *last_error = error.to_string();
     }
 
     /// Get last error string.
     pub fn get_last_error(&self) -> String {
-        let last_error = &*self.last_error.read();
+        let last_error = &*self.last_error.read().unwrap();
         last_error.clone()
     }
 }

src/message.rs

@@ -724,7 +724,7 @@ impl Message {
     /// `contact_id` set to [`ContactId::SELF`].
     ///
     /// `latitude` is the North-south position of the location.
-    /// `longitude` is the East-west position of the location.
+    /// `longitutde` is the East-west position of the location.
     ///
     /// [`location::set()`]: crate::location::set
     /// [`send_locations_to_chat()`]: crate::location::send_locations_to_chat
@@ -1693,7 +1693,6 @@ pub async fn markseen_msgs(context: &Context, msg_ids: Vec<MsgId>) -> Result<()>
                     m.id AS id,
                     m.chat_id AS chat_id,
                     m.state AS state,
-                    m.download_state as download_state,
                     m.ephemeral_timer AS ephemeral_timer,
                     m.param AS param,
                     m.from_id AS from_id,
@@ -1709,7 +1708,6 @@ pub async fn markseen_msgs(context: &Context, msg_ids: Vec<MsgId>) -> Result<()>
                 let id: MsgId = row.get("id")?;
                 let chat_id: ChatId = row.get("chat_id")?;
                 let state: MessageState = row.get("state")?;
-                let download_state: DownloadState = row.get("download_state")?;
                 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")?;
@@ -1721,7 +1719,6 @@ pub async fn markseen_msgs(context: &Context, msg_ids: Vec<MsgId>) -> Result<()>
                         id,
                         chat_id,
                         state,
-                        download_state,
                         param,
                         from_id,
                         rfc724_mid,
@@ -1751,7 +1748,6 @@ pub async fn markseen_msgs(context: &Context, msg_ids: Vec<MsgId>) -> Result<()>
             id,
             curr_chat_id,
             curr_state,
-            curr_download_state,
             curr_param,
             curr_from_id,
             curr_rfc724_mid,
@@ -1761,14 +1757,7 @@ pub async fn markseen_msgs(context: &Context, msg_ids: Vec<MsgId>) -> Result<()>
         _curr_ephemeral_timer,
     ) in msgs
     {
-        if curr_download_state != DownloadState::Done {
-            if curr_state == MessageState::InFresh {
-                // Don't mark partially downloaded messages as seen or send a read receipt since
-                // they are not really seen by the user.
-                update_msg_state(context, id, MessageState::InNoticed).await?;
-                updated_chat_ids.insert(curr_chat_id);
-            }
-        } else if curr_state == MessageState::InFresh || curr_state == MessageState::InNoticed {
+        if curr_state == MessageState::InFresh || curr_state == MessageState::InNoticed {
             update_msg_state(context, id, MessageState::InSeen).await?;
             info!(context, "Seen message {}.", id);
 
@@ -2594,110 +2583,6 @@ mod tests {
         Ok(())
     }
 
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_markseen_not_downloaded_msg() -> Result<()> {
-        let mut tcm = TestContextManager::new();
-        let alice = &tcm.alice().await;
-        alice.set_config(Config::DownloadLimit, Some("1")).await?;
-        let bob = &tcm.bob().await;
-        let bob_chat_id = tcm.send_recv_accept(alice, bob, "hi").await.chat_id;
-
-        let file_bytes = include_bytes!("../test-data/image/screenshot.png");
-        let mut msg = Message::new(Viewtype::Image);
-        msg.set_file_from_bytes(bob, "a.jpg", file_bytes, None)
-            .await?;
-        let sent_msg = bob.send_msg(bob_chat_id, &mut msg).await;
-        let msg = alice.recv_msg(&sent_msg).await;
-        assert_eq!(msg.download_state, DownloadState::Available);
-        assert!(!msg.param.get_bool(Param::WantsMdn).unwrap_or_default());
-        assert_eq!(msg.state, MessageState::InFresh);
-        markseen_msgs(alice, vec![msg.id]).await?;
-        // A not downloaded message can be seen only if it's seen on another device.
-        assert_eq!(msg.id.get_state(alice).await?, MessageState::InNoticed);
-        // Marking the message as seen again is a no op.
-        markseen_msgs(alice, vec![msg.id]).await?;
-        assert_eq!(msg.id.get_state(alice).await?, MessageState::InNoticed);
-
-        msg.id
-            .update_download_state(alice, DownloadState::InProgress)
-            .await?;
-        markseen_msgs(alice, vec![msg.id]).await?;
-        assert_eq!(msg.id.get_state(alice).await?, MessageState::InNoticed);
-        msg.id
-            .update_download_state(alice, DownloadState::Failure)
-            .await?;
-        markseen_msgs(alice, vec![msg.id]).await?;
-        assert_eq!(msg.id.get_state(alice).await?, MessageState::InNoticed);
-        msg.id
-            .update_download_state(alice, DownloadState::Undecipherable)
-            .await?;
-        markseen_msgs(alice, vec![msg.id]).await?;
-        assert_eq!(msg.id.get_state(alice).await?, MessageState::InNoticed);
-
-        assert!(
-            !alice
-                .sql
-                .exists("SELECT COUNT(*) FROM smtp_mdns", ())
-                .await?
-        );
-
-        alice.set_config(Config::DownloadLimit, None).await?;
-        // Let's assume that Alice and Bob resolved the problem with encryption.
-        let old_msg = msg;
-        let msg = alice.recv_msg(&sent_msg).await;
-        assert_eq!(msg.chat_id, old_msg.chat_id);
-        assert_eq!(msg.download_state, DownloadState::Done);
-        assert!(msg.param.get_bool(Param::WantsMdn).unwrap_or_default());
-        assert!(msg.get_showpadlock());
-        // The message state mustn't be downgraded to `InFresh`.
-        assert_eq!(msg.state, MessageState::InNoticed);
-        markseen_msgs(alice, vec![msg.id]).await?;
-        let msg = Message::load_from_db(alice, msg.id).await?;
-        assert_eq!(msg.state, MessageState::InSeen);
-        assert_eq!(
-            alice
-                .sql
-                .count("SELECT COUNT(*) FROM smtp_mdns", ())
-                .await?,
-            1
-        );
-        Ok(())
-    }
-
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_msg_seen_on_imap_when_downloaded() -> Result<()> {
-        let mut tcm = TestContextManager::new();
-        let alice = &tcm.alice().await;
-        alice.set_config(Config::DownloadLimit, Some("1")).await?;
-        let bob = &tcm.bob().await;
-        let bob_chat_id = tcm.send_recv_accept(alice, bob, "hi").await.chat_id;
-
-        let file_bytes = include_bytes!("../test-data/image/screenshot.png");
-        let mut msg = Message::new(Viewtype::Image);
-        msg.set_file_from_bytes(bob, "a.jpg", file_bytes, None)
-            .await?;
-        let sent_msg = bob.send_msg(bob_chat_id, &mut msg).await;
-        let msg = alice.recv_msg(&sent_msg).await;
-        assert_eq!(msg.download_state, DownloadState::Available);
-        assert_eq!(msg.state, MessageState::InFresh);
-
-        alice.set_config(Config::DownloadLimit, None).await?;
-        let seen = true;
-        let rcvd_msg = receive_imf(alice, sent_msg.payload().as_bytes(), seen)
-            .await
-            .unwrap()
-            .unwrap();
-        assert_eq!(rcvd_msg.chat_id, msg.chat_id);
-        let msg = Message::load_from_db(alice, *rcvd_msg.msg_ids.last().unwrap())
-            .await
-            .unwrap();
-        assert_eq!(msg.download_state, DownloadState::Done);
-        assert!(msg.param.get_bool(Param::WantsMdn).unwrap_or_default());
-        assert!(msg.get_showpadlock());
-        assert_eq!(msg.state, MessageState::InSeen);
-        Ok(())
-    }
-
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_get_state() -> Result<()> {
         let alice = TestContext::new_alice().await;

src/mimefactory.rs

@@ -6,6 +6,7 @@ use anyhow::{bail, Context as _, Result};
 use base64::Engine as _;
 use chrono::TimeZone;
 use email::Mailbox;
+use format_flowed::{format_flowed, format_flowed_quote};
 use lettre_email::{Address, Header, MimeMultipartType, PartBuilder};
 use tokio::fs;
 
@@ -356,7 +357,7 @@ impl MimeFactory {
                     let gossip_period = context.get_config_i64(Config::GossipPeriod).await?;
                     // `gossip_period == 0` is a special case for testing,
                     // enabling gossip in every message.
-                    // Otherwise "smeared timestamps" may result in the condition
+                    // Othewise "smeared timestamps" may result in the condition
                     // to fail even if the clock is monotonic.
                     if gossip_period == 0 || time() >= gossiped_timestamp + gossip_period {
                         Ok(true)
@@ -1299,18 +1300,9 @@ impl MimeFactory {
 
         let final_text = placeholdertext.as_deref().unwrap_or(&msg.text);
 
-        let mut quoted_text = None;
-        if let Some(msg_quoted_text) = msg.quoted_text() {
-            let mut some_quoted_text = String::new();
-            for quoted_line in msg_quoted_text.split('\n') {
-                some_quoted_text += "> ";
-                some_quoted_text += quoted_line;
-                some_quoted_text += "\r\n";
-            }
-            some_quoted_text += "\r\n";
-            quoted_text = Some(some_quoted_text)
-        }
-
+        let mut quoted_text = msg
+            .quoted_text()
+            .map(|quote| format_flowed_quote(&quote) + "\r\n\r\n");
         if !is_encrypted && msg.param.get_bool(Param::ProtectQuote).unwrap_or_default() {
             // Message is not encrypted but quotes encrypted message.
             quoted_text = Some("> ...\r\n\r\n".to_string());
@@ -1320,6 +1312,7 @@ impl MimeFactory {
             // Delta Chat.
             quoted_text = Some("\r\n".to_string());
         }
+        let flowed_text = format_flowed(final_text);
 
         let is_reaction = msg.param.get_int(Param::Reaction).unwrap_or_default() != 0;
 
@@ -1329,7 +1322,7 @@ impl MimeFactory {
             "{}{}{}{}{}{}",
             fwdhint.unwrap_or_default(),
             quoted_text.unwrap_or_default(),
-            escape_message_footer_marks(final_text),
+            escape_message_footer_marks(&flowed_text),
             if !final_text.is_empty() && !footer.is_empty() {
                 "\r\n\r\n"
             } else {
@@ -1339,8 +1332,10 @@ impl MimeFactory {
             footer
         );
 
-        let mut main_part =
-            PartBuilder::new().header(("Content-Type", "text/plain; charset=utf-8"));
+        let mut main_part = PartBuilder::new().header((
+            "Content-Type",
+            "text/plain; charset=utf-8; format=flowed; delsp=no",
+        ));
         main_part = self.add_message_text(main_part, message_text);
 
         if is_reaction {
@@ -2279,6 +2274,7 @@ mod tests {
         let msg = message.as_string();
 
         let header_end = msg.find("Hi").unwrap();
+        #[allow(clippy::indexing_slicing)]
         let headers = msg[0..header_end].trim();
 
         assert!(!headers.lines().any(|l| l.trim().is_empty()));

src/mimeparser.rs

@@ -665,13 +665,11 @@ impl MimeMessage {
     /// Delta Chat sends attachments, such as images, in two-part messages, with the first message
     /// containing a description. If such a message is detected, text from the first part can be
     /// moved to the second part, and the first part dropped.
+    #[allow(clippy::indexing_slicing)]
     fn squash_attachment_parts(&mut self) {
-        if self.parts.len() == 2
-            && self.parts.first().map(|textpart| textpart.typ) == Some(Viewtype::Text)
-            && self
-                .parts
-                .get(1)
-                .is_some_and(|filepart| match filepart.typ {
+        if let [textpart, filepart] = &self.parts[..] {
+            let need_drop = textpart.typ == Viewtype::Text
+                && match filepart.typ {
                     Viewtype::Image
                     | Viewtype::Gif
                     | Viewtype::Sticker
@@ -682,24 +680,24 @@ impl MimeMessage {
                     | Viewtype::File
                     | Viewtype::Webxdc => true,
                     Viewtype::Unknown | Viewtype::Text | Viewtype::VideochatInvitation => false,
-                })
-        {
-            let mut parts = std::mem::take(&mut self.parts);
-            let Some(mut filepart) = parts.pop() else {
-                // Should never happen.
-                return;
-            };
-            let Some(textpart) = parts.pop() else {
-                // Should never happen.
-                return;
-            };
+                };
 
-            filepart.msg.clone_from(&textpart.msg);
-            if let Some(quote) = textpart.param.get(Param::Quote) {
-                filepart.param.set(Param::Quote, quote);
+            if need_drop {
+                let mut filepart = self.parts.swap_remove(1);
+
+                // insert new one
+                filepart.msg.clone_from(&self.parts[0].msg);
+                if let Some(quote) = self.parts[0].param.get(Param::Quote) {
+                    filepart.param.set(Param::Quote, quote);
+                }
+
+                // forget the one we use now
+                self.parts[0].msg = "".to_string();
+
+                // swap new with old
+                self.parts.push(filepart); // push to the end
+                let _ = self.parts.swap_remove(0); // drops first element, replacing it with the last one in O(1)
             }
-
-            self.parts = vec![filepart];
         }
     }
 
@@ -1667,11 +1665,10 @@ impl MimeMessage {
             {
                 let mut to_list =
                     get_all_addresses_from_header(&report.headers, "x-failed-recipients");
-                let to = if to_list.len() != 1 {
-                    // We do not know which recipient failed
-                    None
+                let to = if to_list.len() == 1 {
+                    Some(to_list.pop().unwrap())
                 } else {
-                    to_list.pop()
+                    None // We do not know which recipient failed
                 };
 
                 return Ok(Some(DeliveryReport {
@@ -1754,6 +1751,7 @@ impl MimeMessage {
     /// Some providers like GMX and Yahoo do not send standard NDNs (Non Delivery notifications).
     /// If you improve heuristics here you might also have to change prefetch_should_download() in imap/mod.rs.
     /// Also you should add a test in receive_imf.rs (there already are lots of test_parse_ndn_* tests).
+    #[allow(clippy::indexing_slicing)]
     async fn heuristically_parse_ndn(&mut self, context: &Context) {
         let maybe_ndn = if let Some(from) = self.get_header(HeaderDef::From_) {
             let from = from.to_ascii_lowercase();
@@ -1916,17 +1914,18 @@ pub(crate) struct DeliveryReport {
     pub failure: bool,
 }
 
+#[allow(clippy::indexing_slicing)]
 pub(crate) fn parse_message_ids(ids: &str) -> Vec<String> {
     // take care with mailparse::msgidparse() that is pretty untolerant eg. wrt missing `<` or `>`
     let mut msgids = Vec::new();
     for id in ids.split_whitespace() {
         let mut id = id.to_string();
-        if let Some(id_without_prefix) = id.strip_prefix('<') {
-            id = id_without_prefix.to_string();
-        };
-        if let Some(id_without_suffix) = id.strip_suffix('>') {
-            id = id_without_suffix.to_string();
-        };
+        if id.starts_with('<') {
+            id = id[1..].to_string();
+        }
+        if id.ends_with('>') {
+            id = id[..id.len() - 1].to_string();
+        }
         if !id.is_empty() {
             msgids.push(id);
         }
@@ -2363,6 +2362,8 @@ async fn ndn_maybe_add_info_msg(
 
 #[cfg(test)]
 mod tests {
+    #![allow(clippy::indexing_slicing)]
+
     use mailparse::ParsedMail;
 
     use super::*;
@@ -3653,10 +3654,9 @@ On 2020-10-25, Bob wrote:
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_mime_modified_large_plain() -> Result<()> {
         let t = TestContext::new_alice().await;
-        let t1 = TestContext::new_alice().await;
 
         static REPEAT_TXT: &str = "this text with 42 chars is just repeated.\n";
-        static REPEAT_CNT: usize = DC_DESIRED_TEXT_LEN / REPEAT_TXT.len() + 2;
+        static REPEAT_CNT: usize = 2000; // results in a text of 84k, should be more than DC_DESIRED_TEXT_LEN
         let long_txt = format!("From: alice@c.de\n\n{}", REPEAT_TXT.repeat(REPEAT_CNT));
         assert_eq!(long_txt.matches("just repeated").count(), REPEAT_CNT);
         assert!(long_txt.len() > DC_DESIRED_TEXT_LEN);
@@ -3677,21 +3677,22 @@ On 2020-10-25, Bob wrote:
             if draft {
                 chat.id.set_draft(&t, Some(&mut msg)).await?;
             }
-            let sent_msg = t.send_msg(chat.id, &mut msg).await;
+            t.send_msg(chat.id, &mut msg).await;
             let msg = t.get_last_msg_in(chat.id).await;
             assert!(msg.has_html());
-            let html = msg.id.get_html(&t).await?.unwrap();
-            assert_eq!(html.matches("<!DOCTYPE html>").count(), 1);
-            assert_eq!(html.matches("just repeated.<br/>").count(), REPEAT_CNT);
+            assert_eq!(
+                msg.id
+                    .get_html(&t)
+                    .await?
+                    .unwrap()
+                    .matches("just repeated")
+                    .count(),
+                REPEAT_CNT
+            );
             assert!(
-                msg.text.matches("just repeated.").count()
-                    <= DC_DESIRED_TEXT_LEN / REPEAT_TXT.len()
+                msg.text.matches("just repeated").count() <= DC_DESIRED_TEXT_LEN / REPEAT_TXT.len()
             );
             assert!(msg.text.len() <= DC_DESIRED_TEXT_LEN + DC_ELLIPSIS.len());
-
-            let msg = t1.recv_msg(&sent_msg).await;
-            assert!(msg.has_html());
-            assert_eq!(msg.id.get_html(&t1).await?.unwrap(), html);
         }
 
         t.set_config(Config::Bot, Some("1")).await?;

src/net.rs

@@ -47,7 +47,7 @@ pub(crate) async fn prune_connection_history(context: &Context) -> Result<()> {
     Ok(())
 }
 
-/// Update the timestamp of the last successful connection
+/// Update the timestamp of the last successfull connection
 /// to the given `host` and `port`
 /// with the given application protocol `alpn`.
 ///

src/net/proxy.rs

@@ -230,7 +230,7 @@ where
         .get(9..12)
         .context("HTTP status line does not contain a status code")?;
 
-    // Interpret status code according to
+    // Interpert status code according to
     // <https://datatracker.ietf.org/doc/html/rfc7231#section-6>.
     if status_code == b"407" {
         Err(format_err!("Proxy Authentication Required"))

src/peer_channels.rs

@@ -7,15 +7,15 @@
 //! when it's not required. Only when a webxdc subscribes to realtime data or when a reatlime message is sent,
 //! the p2p machinery should be started.
 //!
-//! Adding peer channels to webxdc needs upfront negotiation of a topic and sharing of public keys so that
+//! Adding peer channels to webxdc needs upfront negotation of a topic and sharing of public keys so that
 //! nodes can connect to each other. The explicit approach is as follows:
 //!
-//! 1. We introduce a new [`IrohGossipTopic`](crate::headerdef::HeaderDef::IrohGossipTopic) message header with a random 32-byte TopicId,
+//! 1. We introduce a new [GossipTopic](crate::headerdef::HeaderDef::IrohGossipTopic) message header with a random 32-byte TopicId,
 //!    securely generated on the initial webxdc sender's device. This message header is encrypted
 //!    and sent in the same message as the webxdc application.
 //! 2. Whenever `joinRealtimeChannel().setListener()` or `joinRealtimeChannel().send()` is called by the webxdc application,
 //!    we start a routine to establish p2p connectivity and join the gossip swarm with Iroh.
-//! 3. The first step of this routine is to introduce yourself with a regular message containing the [`IrohNodeAddr`](crate::headerdef::HeaderDef::IrohNodeAddr).
+//! 3. The first step of this routine is to introduce yourself with a regular message containing the `IrohPublicKey`.
 //!    This message contains the users relay-server and public key.
 //!    Direct IP address is not included as this information can be persisted by email providers.
 //! 4. After the announcement, the sending peer joins the gossip swarm with an empty list of peer IDs (as they don't know anyone yet).
@@ -78,14 +78,6 @@ impl Iroh {
         self.endpoint.network_change().await
     }
 
-    /// Closes the QUIC endpoint.
-    pub(crate) async fn close(self) -> Result<()> {
-        self.endpoint
-            .close(0u32.into(), b"")
-            .await
-            .context("Closing iroh endpoint failed")
-    }
-
     /// Join a topic and create the subscriber loop for it.
     ///
     /// If there is no gossip, create it.
@@ -293,36 +285,15 @@ impl Context {
     }
 
     /// Get or initialize the iroh peer channel.
-    pub async fn get_or_try_init_peer_channel(
-        &self,
-    ) -> Result<tokio::sync::RwLockReadGuard<'_, Iroh>> {
+    pub async fn get_or_try_init_peer_channel(&self) -> Result<&Iroh> {
         if !self.get_config_bool(Config::WebxdcRealtimeEnabled).await? {
             bail!("Attempt to get Iroh when realtime is disabled");
         }
 
-        if let Ok(lock) = tokio::sync::RwLockReadGuard::<'_, std::option::Option<Iroh>>::try_map(
-            self.iroh.read().await,
-            |opt_iroh| opt_iroh.as_ref(),
-        ) {
-            return Ok(lock);
-        }
-
-        let lock = self.iroh.write().await;
-        match tokio::sync::RwLockWriteGuard::<'_, std::option::Option<Iroh>>::try_downgrade_map(
-            lock,
-            |opt_iroh| opt_iroh.as_ref(),
-        ) {
-            Ok(lock) => Ok(lock),
-            Err(mut lock) => {
-                let iroh = self.init_peer_channels().await?;
-                *lock = Some(iroh);
-                tokio::sync::RwLockWriteGuard::<'_, std::option::Option<Iroh>>::try_downgrade_map(
-                    lock,
-                    |opt_iroh| opt_iroh.as_ref(),
-                )
-                .map_err(|_| anyhow!("Downgrade should succeed as we just stored `Some` value"))
-            }
-        }
+        let ctx = self.clone();
+        self.iroh
+            .get_or_try_init(|| async { ctx.init_peer_channels().await })
+            .await
     }
 }
 
@@ -655,6 +626,7 @@ mod tests {
                 break;
             }
         }
+        let bob_iroh = bob.get_or_try_init_peer_channel().await.unwrap();
 
         // Bob adds alice to gossip peers.
         let members = get_iroh_gossip_peers(bob, bob_webxdc.id)
@@ -664,23 +636,13 @@ mod tests {
             .map(|addr| addr.node_id)
             .collect::<Vec<_>>();
 
+        let alice_iroh = alice.get_or_try_init_peer_channel().await.unwrap();
         assert_eq!(
             members,
-            vec![
-                alice
-                    .get_or_try_init_peer_channel()
-                    .await
-                    .unwrap()
-                    .get_node_addr()
-                    .await
-                    .unwrap()
-                    .node_id
-            ]
+            vec![alice_iroh.get_node_addr().await.unwrap().node_id]
         );
 
-        bob.get_or_try_init_peer_channel()
-            .await
-            .unwrap()
+        bob_iroh
             .join_and_subscribe_gossip(bob, bob_webxdc.id)
             .await
             .unwrap()
@@ -689,10 +651,7 @@ mod tests {
             .unwrap();
 
         // Alice sends ephemeral message
-        alice
-            .get_or_try_init_peer_channel()
-            .await
-            .unwrap()
+        alice_iroh
             .send_webxdc_realtime_data(alice, alice_webxdc.id, "alice -> bob".as_bytes().to_vec())
             .await
             .unwrap();
@@ -711,9 +670,7 @@ mod tests {
             }
         }
         // Bob sends ephemeral message
-        bob.get_or_try_init_peer_channel()
-            .await
-            .unwrap()
+        bob_iroh
             .send_webxdc_realtime_data(bob, bob_webxdc.id, "bob -> alice".as_bytes().to_vec())
             .await
             .unwrap();
@@ -742,20 +699,10 @@ mod tests {
 
         assert_eq!(
             members,
-            vec![
-                bob.get_or_try_init_peer_channel()
-                    .await
-                    .unwrap()
-                    .get_node_addr()
-                    .await
-                    .unwrap()
-                    .node_id
-            ]
+            vec![bob_iroh.get_node_addr().await.unwrap().node_id]
         );
 
-        bob.get_or_try_init_peer_channel()
-            .await
-            .unwrap()
+        bob_iroh
             .send_webxdc_realtime_data(bob, bob_webxdc.id, "bob -> alice 2".as_bytes().to_vec())
             .await
             .unwrap();
@@ -773,12 +720,6 @@ mod tests {
                 }
             }
         }
-
-        // Calling stop_io() closes iroh endpoint as well,
-        // even though I/O was not started in this test.
-        assert!(alice.iroh.read().await.is_some());
-        alice.stop_io().await;
-        assert!(alice.iroh.read().await.is_none());
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
@@ -820,6 +761,7 @@ mod tests {
             .unwrap();
 
         bob.recv_msg_trash(&alice.pop_sent_msg().await).await;
+        let bob_iroh = bob.get_or_try_init_peer_channel().await.unwrap();
 
         // Bob adds alice to gossip peers.
         let members = get_iroh_gossip_peers(bob, bob_webxdc.id)
@@ -829,23 +771,13 @@ mod tests {
             .map(|addr| addr.node_id)
             .collect::<Vec<_>>();
 
+        let alice_iroh = alice.get_or_try_init_peer_channel().await.unwrap();
         assert_eq!(
             members,
-            vec![
-                alice
-                    .get_or_try_init_peer_channel()
-                    .await
-                    .unwrap()
-                    .get_node_addr()
-                    .await
-                    .unwrap()
-                    .node_id
-            ]
+            vec![alice_iroh.get_node_addr().await.unwrap().node_id]
         );
 
-        bob.get_or_try_init_peer_channel()
-            .await
-            .unwrap()
+        bob_iroh
             .join_and_subscribe_gossip(bob, bob_webxdc.id)
             .await
             .unwrap()
@@ -854,10 +786,7 @@ mod tests {
             .unwrap();
 
         // Alice sends ephemeral message
-        alice
-            .get_or_try_init_peer_channel()
-            .await
-            .unwrap()
+        alice_iroh
             .send_webxdc_realtime_data(alice, alice_webxdc.id, "alice -> bob".as_bytes().to_vec())
             .await
             .unwrap();
@@ -882,9 +811,7 @@ mod tests {
             .unwrap();
         let bob_sequence_number = bob
             .iroh
-            .read()
-            .await
-            .as_ref()
+            .get()
             .unwrap()
             .sequence_numbers
             .lock()
@@ -893,9 +820,7 @@ mod tests {
         leave_webxdc_realtime(bob, bob_webxdc.id).await.unwrap();
         let bob_sequence_number_after = bob
             .iroh
-            .read()
-            .await
-            .as_ref()
+            .get()
             .unwrap()
             .sequence_numbers
             .lock()
@@ -904,9 +829,7 @@ mod tests {
         // Check that sequence number is persisted when leaving the channel.
         assert_eq!(bob_sequence_number, bob_sequence_number_after);
 
-        bob.get_or_try_init_peer_channel()
-            .await
-            .unwrap()
+        bob_iroh
             .join_and_subscribe_gossip(bob, bob_webxdc.id)
             .await
             .unwrap()
@@ -914,9 +837,7 @@ mod tests {
             .await
             .unwrap();
 
-        bob.get_or_try_init_peer_channel()
-            .await
-            .unwrap()
+        bob_iroh
             .send_webxdc_realtime_data(bob, bob_webxdc.id, "bob -> alice".as_bytes().to_vec())
             .await
             .unwrap();
@@ -935,20 +856,11 @@ mod tests {
             }
         }
 
-        // channel is only used to remember if an advertisement has been sent
+        // channel is only used to remeber if an advertisement has been sent
         // bob for example does not change the channels because he never sends an
         // advertisement
         assert_eq!(
-            alice
-                .iroh
-                .read()
-                .await
-                .as_ref()
-                .unwrap()
-                .iroh_channels
-                .read()
-                .await
-                .len(),
+            alice.iroh.get().unwrap().iroh_channels.read().await.len(),
             1
         );
         leave_webxdc_realtime(alice, alice_webxdc.id).await.unwrap();
@@ -958,9 +870,7 @@ mod tests {
             .unwrap();
         assert!(alice
             .iroh
-            .read()
-            .await
-            .as_ref()
+            .get()
             .unwrap()
             .iroh_channels
             .read()
@@ -1053,19 +963,19 @@ mod tests {
             .await
             .unwrap();
 
-        assert!(alice.ctx.iroh.read().await.is_none());
+        assert!(alice.ctx.iroh.get().is_none());
 
         // creates iroh endpoint as side effect
         send_webxdc_realtime_data(alice, MsgId::new(1), vec![])
             .await
             .unwrap();
 
-        assert!(alice.ctx.iroh.read().await.is_none());
+        assert!(alice.ctx.iroh.get().is_none());
 
         // creates iroh endpoint as side effect
         leave_webxdc_realtime(alice, MsgId::new(1)).await.unwrap();
 
-        assert!(alice.ctx.iroh.read().await.is_none());
+        assert!(alice.ctx.iroh.get().is_none());
 
         // This internal function should return error
         // if accidentally called with the setting disabled.

src/peerstate.rs

@@ -121,7 +121,7 @@ impl Peerstate {
             last_seen_autocrypt: last_seen,
             prefer_encrypt,
             public_key: Some(public_key.clone()),
-            public_key_fingerprint: Some(public_key.dc_fingerprint()),
+            public_key_fingerprint: Some(public_key.fingerprint()),
             gossip_key: None,
             gossip_key_fingerprint: None,
             gossip_timestamp: 0,
@@ -153,7 +153,7 @@ impl Peerstate {
             public_key: None,
             public_key_fingerprint: None,
             gossip_key: Some(gossip_header.public_key.clone()),
-            gossip_key_fingerprint: Some(gossip_header.public_key.dc_fingerprint()),
+            gossip_key_fingerprint: Some(gossip_header.public_key.fingerprint()),
             gossip_timestamp: message_time,
             verified_key: None,
             verified_key_fingerprint: None,
@@ -308,7 +308,7 @@ impl Peerstate {
     pub fn recalc_fingerprint(&mut self) {
         if let Some(ref public_key) = self.public_key {
             let old_public_fingerprint = self.public_key_fingerprint.take();
-            self.public_key_fingerprint = Some(public_key.dc_fingerprint());
+            self.public_key_fingerprint = Some(public_key.fingerprint());
 
             if old_public_fingerprint.is_some()
                 && old_public_fingerprint != self.public_key_fingerprint
@@ -319,7 +319,7 @@ impl Peerstate {
 
         if let Some(ref gossip_key) = self.gossip_key {
             let old_gossip_fingerprint = self.gossip_key_fingerprint.take();
-            self.gossip_key_fingerprint = Some(gossip_key.dc_fingerprint());
+            self.gossip_key_fingerprint = Some(gossip_key.fingerprint());
 
             if old_gossip_fingerprint.is_none()
                 || self.gossip_key_fingerprint.is_none()
@@ -506,7 +506,7 @@ impl Peerstate {
         fingerprint: Fingerprint,
         verifier: String,
     ) -> Result<()> {
-        if key.dc_fingerprint() == fingerprint {
+        if key.fingerprint() == fingerprint {
             self.verified_key = Some(key);
             self.verified_key_fingerprint = Some(fingerprint);
             self.verifier = Some(verifier);
@@ -524,7 +524,7 @@ impl Peerstate {
     /// do nothing to avoid overwriting secondary verified key
     /// which may be different.
     pub fn set_secondary_verified_key(&mut self, gossip_key: SignedPublicKey, verifier: String) {
-        let fingerprint = gossip_key.dc_fingerprint();
+        let fingerprint = gossip_key.fingerprint();
         if self.verified_key_fingerprint.as_ref() != Some(&fingerprint) {
             self.secondary_verified_key = Some(gossip_key);
             self.secondary_verified_key_fingerprint = Some(fingerprint);
@@ -542,8 +542,6 @@ impl Peerstate {
     /// * `old_addr`: Old address of the peerstate in case of an AEAP transition.
     pub(crate) async fn save_to_db_ex(&self, sql: &Sql, old_addr: Option<&str>) -> Result<()> {
         let trans_fn = |t: &mut rusqlite::Transaction| {
-            let verified_key_fingerprint =
-                self.verified_key_fingerprint.as_ref().map(|fp| fp.hex());
             if let Some(old_addr) = old_addr {
                 // We are doing an AEAP transition to the new address and the SQL INSERT below will
                 // save the existing peerstate as belonging to this new address. We now need to
@@ -553,14 +551,11 @@ impl Peerstate {
                 // existing peerstate as this would break encryption to it. This is critical for
                 // non-verified groups -- if we can't encrypt to the old address, we can't securely
                 // remove it from the group (to add the new one instead).
-                //
-                // NB: We check that `verified_key_fingerprint` hasn't changed to protect from
-                // possible races.
                 t.execute(
-                    "UPDATE acpeerstates
-                     SET verified_key=NULL, verified_key_fingerprint='', verifier=''
-                     WHERE addr=? AND verified_key_fingerprint=?",
-                    (old_addr, &verified_key_fingerprint),
+                    "UPDATE acpeerstates \
+                     SET verified_key=NULL, verified_key_fingerprint='', verifier='' \
+                     WHERE addr=?",
+                    (old_addr,),
                 )?;
             }
             t.execute(
@@ -609,7 +604,7 @@ impl Peerstate {
                     self.public_key_fingerprint.as_ref().map(|fp| fp.hex()),
                     self.gossip_key_fingerprint.as_ref().map(|fp| fp.hex()),
                     self.verified_key.as_ref().map(|k| k.to_bytes()),
-                    &verified_key_fingerprint,
+                    self.verified_key_fingerprint.as_ref().map(|fp| fp.hex()),
                     self.verifier.as_deref().unwrap_or(""),
                     self.secondary_verified_key.as_ref().map(|k| k.to_bytes()),
                     self.secondary_verified_key_fingerprint
@@ -893,12 +888,12 @@ mod tests {
             last_seen_autocrypt: 11,
             prefer_encrypt: EncryptPreference::Mutual,
             public_key: Some(pub_key.clone()),
-            public_key_fingerprint: Some(pub_key.dc_fingerprint()),
+            public_key_fingerprint: Some(pub_key.fingerprint()),
             gossip_key: Some(pub_key.clone()),
             gossip_timestamp: 12,
-            gossip_key_fingerprint: Some(pub_key.dc_fingerprint()),
+            gossip_key_fingerprint: Some(pub_key.fingerprint()),
             verified_key: Some(pub_key.clone()),
-            verified_key_fingerprint: Some(pub_key.dc_fingerprint()),
+            verified_key_fingerprint: Some(pub_key.fingerprint()),
             verifier: None,
             secondary_verified_key: None,
             secondary_verified_key_fingerprint: None,
@@ -918,7 +913,7 @@ mod tests {
             .expect("no peerstate found in the database");
 
         assert_eq!(peerstate, peerstate_new);
-        let peerstate_new2 = Peerstate::from_fingerprint(&ctx.ctx, &pub_key.dc_fingerprint())
+        let peerstate_new2 = Peerstate::from_fingerprint(&ctx.ctx, &pub_key.fingerprint())
             .await
             .expect("failed to load peerstate from db")
             .expect("no peerstate found in the database");
@@ -937,7 +932,7 @@ mod tests {
             last_seen_autocrypt: 11,
             prefer_encrypt: EncryptPreference::Mutual,
             public_key: Some(pub_key.clone()),
-            public_key_fingerprint: Some(pub_key.dc_fingerprint()),
+            public_key_fingerprint: Some(pub_key.fingerprint()),
             gossip_key: None,
             gossip_timestamp: 12,
             gossip_key_fingerprint: None,
@@ -974,7 +969,7 @@ mod tests {
             last_seen_autocrypt: 11,
             prefer_encrypt: EncryptPreference::Mutual,
             public_key: Some(pub_key.clone()),
-            public_key_fingerprint: Some(pub_key.dc_fingerprint()),
+            public_key_fingerprint: Some(pub_key.fingerprint()),
             gossip_key: None,
             gossip_timestamp: 12,
             gossip_key_fingerprint: None,

src/pgp.rs

@@ -14,7 +14,7 @@ use pgp::composed::{
 use pgp::crypto::ecc_curve::ECCCurve;
 use pgp::crypto::hash::HashAlgorithm;
 use pgp::crypto::sym::SymmetricKeyAlgorithm;
-use pgp::types::{CompressionAlgorithm, PublicKeyTrait, SignatureBytes, StringToKey};
+use pgp::types::{CompressionAlgorithm, KeyTrait, Mpi, PublicKeyTrait, StringToKey};
 use rand::{thread_rng, CryptoRng, Rng};
 use tokio::runtime::Handle;
 
@@ -41,15 +41,8 @@ enum SignedPublicKeyOrSubkey<'a> {
     Subkey(&'a SignedPublicSubKey),
 }
 
-impl PublicKeyTrait for SignedPublicKeyOrSubkey<'_> {
-    fn version(&self) -> pgp::types::KeyVersion {
-        match self {
-            Self::Key(k) => k.version(),
-            Self::Subkey(k) => k.version(),
-        }
-    }
-
-    fn fingerprint(&self) -> pgp::types::Fingerprint {
+impl KeyTrait for SignedPublicKeyOrSubkey<'_> {
+    fn fingerprint(&self) -> Vec<u8> {
         match self {
             Self::Key(k) => k.fingerprint(),
             Self::Subkey(k) => k.fingerprint(),
@@ -69,26 +62,14 @@ impl PublicKeyTrait for SignedPublicKeyOrSubkey<'_> {
             Self::Subkey(k) => k.algorithm(),
         }
     }
+}
 
-    fn created_at(&self) -> &chrono::DateTime<chrono::Utc> {
-        match self {
-            Self::Key(k) => k.created_at(),
-            Self::Subkey(k) => k.created_at(),
-        }
-    }
-
-    fn expiration(&self) -> Option<u16> {
-        match self {
-            Self::Key(k) => k.expiration(),
-            Self::Subkey(k) => k.expiration(),
-        }
-    }
-
+impl PublicKeyTrait for SignedPublicKeyOrSubkey<'_> {
     fn verify_signature(
         &self,
         hash: HashAlgorithm,
         data: &[u8],
-        sig: &SignatureBytes,
+        sig: &[Mpi],
     ) -> pgp::errors::Result<()> {
         match self {
             Self::Key(k) => k.verify_signature(hash, data, sig),
@@ -98,27 +79,19 @@ impl PublicKeyTrait for SignedPublicKeyOrSubkey<'_> {
 
     fn encrypt<R: Rng + CryptoRng>(
         &self,
-        rng: R,
+        rng: &mut R,
         plain: &[u8],
-        typ: pgp::types::EskType,
-    ) -> pgp::errors::Result<pgp::types::PkeskBytes> {
+    ) -> pgp::errors::Result<Vec<Mpi>> {
         match self {
-            Self::Key(k) => k.encrypt(rng, plain, typ),
-            Self::Subkey(k) => k.encrypt(rng, plain, typ),
+            Self::Key(k) => k.encrypt(rng, plain),
+            Self::Subkey(k) => k.encrypt(rng, plain),
         }
     }
 
-    fn serialize_for_hashing(&self, writer: &mut impl io::Write) -> pgp::errors::Result<()> {
+    fn to_writer_old(&self, writer: &mut impl io::Write) -> pgp::errors::Result<()> {
         match self {
-            Self::Key(k) => k.serialize_for_hashing(writer),
-            Self::Subkey(k) => k.serialize_for_hashing(writer),
-        }
-    }
-
-    fn public_params(&self) -> &pgp::types::PublicParams {
-        match self {
-            Self::Key(k) => k.public_params(),
-            Self::Subkey(k) => k.public_params(),
+            Self::Key(k) => k.to_writer_old(writer),
+            Self::Subkey(k) => k.to_writer_old(writer),
         }
     }
 }
@@ -187,10 +160,9 @@ pub(crate) fn create_keypair(addr: EmailAddress, keygen_type: KeyGenType) -> Res
     let (signing_key_type, encryption_key_type) = match keygen_type {
         KeyGenType::Rsa2048 => (PgpKeyType::Rsa(2048), PgpKeyType::Rsa(2048)),
         KeyGenType::Rsa4096 => (PgpKeyType::Rsa(4096), PgpKeyType::Rsa(4096)),
-        KeyGenType::Ed25519 | KeyGenType::Default => (
-            PgpKeyType::EdDSALegacy,
-            PgpKeyType::ECDH(ECCCurve::Curve25519),
-        ),
+        KeyGenType::Ed25519 | KeyGenType::Default => {
+            (PgpKeyType::EdDSA, PgpKeyType::ECDH(ECCCurve::Curve25519))
+        }
     };
 
     let user_id = format!("<{addr}>");
@@ -227,11 +199,10 @@ pub(crate) fn create_keypair(addr: EmailAddress, keygen_type: KeyGenType) -> Res
         .build()
         .context("failed to build key parameters")?;
 
-    let mut rng = thread_rng();
     let secret_key = key_params
-        .generate(&mut rng)
+        .generate()
         .context("failed to generate the key")?
-        .sign(&mut rng, || "".into())
+        .sign(|| "".into())
         .context("failed to sign secret key")?;
     secret_key
         .verify()
@@ -290,19 +261,15 @@ pub async fn pk_encrypt(
             let mut rng = thread_rng();
 
             let encrypted_msg = if let Some(ref skey) = private_key_for_signing {
-                let signed_msg = lit_msg.sign(&mut rng, skey, || "".into(), HASH_ALGORITHM)?;
+                let signed_msg = lit_msg.sign(skey, || "".into(), HASH_ALGORITHM)?;
                 let compressed_msg = if compress {
                     signed_msg.compress(CompressionAlgorithm::ZLIB)?
                 } else {
                     signed_msg
                 };
-                compressed_msg.encrypt_to_keys_seipdv1(
-                    &mut rng,
-                    SYMMETRIC_KEY_ALGORITHM,
-                    &pkeys_refs,
-                )?
+                compressed_msg.encrypt_to_keys(&mut rng, SYMMETRIC_KEY_ALGORITHM, &pkeys_refs)?
             } else {
-                lit_msg.encrypt_to_keys_seipdv1(&mut rng, SYMMETRIC_KEY_ALGORITHM, &pkeys_refs)?
+                lit_msg.encrypt_to_keys(&mut rng, SYMMETRIC_KEY_ALGORITHM, &pkeys_refs)?
             };
 
             let encoded_msg = encrypted_msg.to_armored_string(Default::default())?;
@@ -317,9 +284,7 @@ pub fn pk_calc_signature(
     plain: &[u8],
     private_key_for_signing: &SignedSecretKey,
 ) -> Result<String> {
-    let mut rng = thread_rng();
     let msg = Message::new_literal_bytes("", plain).sign(
-        &mut rng,
         private_key_for_signing,
         || "".into(),
         HASH_ALGORITHM,
@@ -363,7 +328,7 @@ pub fn valid_signature_fingerprints(
     if let signed_msg @ pgp::composed::Message::Signed { .. } = msg {
         for pkey in public_keys_for_validation {
             if signed_msg.verify(&pkey.primary_key).is_ok() {
-                let fp = pkey.dc_fingerprint();
+                let fp = DcKey::fingerprint(pkey);
                 ret_signature_fingerprints.insert(fp);
             }
         }
@@ -390,7 +355,7 @@ pub fn pk_validate(
 
     for pkey in public_keys_for_validation {
         if standalone_signature.verify(pkey, content).is_ok() {
-            let fp = pkey.dc_fingerprint();
+            let fp = DcKey::fingerprint(pkey);
             ret.insert(fp);
         }
     }
@@ -405,12 +370,8 @@ pub async fn symm_encrypt(passphrase: &str, plain: &[u8]) -> Result<String> {
     tokio::task::spawn_blocking(move || {
         let mut rng = thread_rng();
         let s2k = StringToKey::new_default(&mut rng);
-        let msg = lit_msg.encrypt_with_password_seipdv1(
-            &mut rng,
-            s2k,
-            SYMMETRIC_KEY_ALGORITHM,
-            || passphrase,
-        )?;
+        let msg =
+            lit_msg.encrypt_with_password(&mut rng, s2k, SYMMETRIC_KEY_ALGORITHM, || passphrase)?;
 
         let encoded_msg = msg.to_armored_string(Default::default())?;
 

src/provider.rs

@@ -288,6 +288,8 @@ pub fn get_provider_by_id(id: &str) -> Option<&'static Provider> {
 
 #[cfg(test)]
 mod tests {
+    #![allow(clippy::indexing_slicing)]
+
     use super::*;
     use crate::test_utils::TestContext;
 

src/push.rs

@@ -1,24 +1,10 @@
-//! # Push notifications module.
-//!
-//! This module is responsible for Apple Push Notification Service
-//! and Firebase Cloud Messaging push notifications.
-//!
-//! It provides [`PushSubscriber`] type
-//! which holds push notification token for the device,
-//! shared by all accounts.
 use std::sync::atomic::Ordering;
 use std::sync::Arc;
 
-use anyhow::{Context as _, Result};
-use base64::Engine as _;
-use pgp::crypto::aead::AeadAlgorithm;
-use pgp::crypto::sym::SymmetricKeyAlgorithm;
-use pgp::ser::Serialize;
-use rand::thread_rng;
+use anyhow::Result;
 use tokio::sync::RwLock;
 
 use crate::context::Context;
-use crate::key::DcKey;
 
 /// Manages subscription to Apple Push Notification services.
 ///
@@ -38,85 +24,20 @@ pub struct PushSubscriber {
     inner: Arc<RwLock<PushSubscriberState>>,
 }
 
-/// The key was generated with
-/// `rsop generate-key --profile rfc9580`
-/// and public key was extracted with `rsop extract-cert`.
-const NOTIFIERS_PUBLIC_KEY: &str = "-----BEGIN PGP PUBLIC KEY BLOCK-----
-
-xioGZ03cdhsAAAAg6PasQQylEuWAp9N5PXN93rqjZdqOqN3s9RJEU/K8FZzCsAYf
-GwoAAABBBQJnTdx2AhsDAh4JCAsJCAcKDQwLBRUKCQgLAhYCIiEGiJJktnCmEtXa
-qsSIGRJtupMnxycz/yT0xZK9ez+YkmIAAAAAUfgg/sg0sR2mytzADFBpNAaY0Hyu
-aru8ics3eUkeNn2ziL4ZsIMx+4mcM5POvD0PG9LtH8Rz/y9iItD0c2aoRBab7iri
-/gDm6aQuj3xXgtAiXdaN9s+QPxR9gY/zG1t9iXgBzioGZ03cdhkAAAAgwJ0wQFsk
-MGH4jklfK1fFhYoQZMjEFCRBIk+r1S+WaSDClQYYGwgAAAAsBQJnTdx2AhsMIiEG
-iJJktnCmEtXaqsSIGRJtupMnxycz/yT0xZK9ez+YkmIAAAAKCRCIkmS2cKYS1WdP
-EFerccH2BoIPNbrxi6hwvxxy7G1mHg//ofD90fqmeY9xTfKMYl16bqQh4R1PiYd5
-LMc5VqgXHgioqTYKbltlOtWC+HDt/PrymQsN4q/aEmsM
-=5jvt
------END PGP PUBLIC KEY BLOCK-----";
-
-/// Pads the token with spaces.
-///
-/// This makes it impossible to tell
-/// if the user is an Apple user with shorter tokens
-/// or FCM user with longer tokens by the length of ciphertext.
-fn pad_device_token(s: &str) -> String {
-    // 512 is larger than any token, tokens seen so far have not been larger than 200 bytes.
-    let expected_len: usize = 512;
-    let payload_len = s.len();
-    let padding_len = expected_len.saturating_sub(payload_len);
-    let padding = " ".repeat(padding_len);
-    let res = format!("{s}{padding}");
-    debug_assert_eq!(res.len(), expected_len);
-    res
-}
-
-/// Encrypts device token with OpenPGP.
-///
-/// The result is base64-encoded and not ASCII armored to avoid dealing with newlines.
-pub(crate) fn encrypt_device_token(device_token: &str) -> Result<String> {
-    let public_key = pgp::composed::SignedPublicKey::from_asc(NOTIFIERS_PUBLIC_KEY)?.0;
-    let encryption_subkey = public_key
-        .public_subkeys
-        .first()
-        .context("No encryption subkey found")?;
-    let padded_device_token = pad_device_token(device_token);
-    let literal_message = pgp::composed::Message::new_literal("", &padded_device_token);
-    let mut rng = thread_rng();
-    let chunk_size = 8;
-
-    let encrypted_message = literal_message.encrypt_to_keys_seipdv2(
-        &mut rng,
-        SymmetricKeyAlgorithm::AES128,
-        AeadAlgorithm::Ocb,
-        chunk_size,
-        &[&encryption_subkey],
-    )?;
-    let encoded_message = encrypted_message.to_bytes()?;
-    Ok(format!(
-        "openpgp:{}",
-        base64::engine::general_purpose::STANDARD.encode(encoded_message)
-    ))
-}
-
 impl PushSubscriber {
     /// Creates new push notification subscriber.
     pub(crate) fn new() -> Self {
         Default::default()
     }
 
-    /// Sets device token for Apple Push Notification service
-    /// or Firebase Cloud Messaging.
+    /// Sets device token for Apple Push Notification service.
     pub(crate) async fn set_device_token(&self, token: &str) {
         self.inner.write().await.device_token = Some(token.to_string());
     }
 
     /// Retrieves device token.
     ///
-    /// The token is encrypted with OpenPGP.
-    ///
     /// Token may be not available if application is not running on Apple platform,
-    /// does not have Google Play services,
     /// failed to register for remote notifications or is in the process of registering.
     ///
     /// IMAP loop should periodically check if device token is available
@@ -200,37 +121,3 @@ impl Context {
         }
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_set_device_token() {
-        let push_subscriber = PushSubscriber::new();
-        assert_eq!(push_subscriber.device_token().await, None);
-
-        push_subscriber.set_device_token("some-token").await;
-        let device_token = push_subscriber.device_token().await.unwrap();
-        assert_eq!(device_token, "some-token");
-    }
-
-    #[test]
-    fn test_pad_device_token() {
-        let apple_token = "0155b93b7eb867a0d8b7328b978bb15bf22f70867e39e168d03f199af9496894";
-        assert_eq!(pad_device_token(apple_token).trim(), apple_token);
-    }
-
-    #[test]
-    fn test_encrypt_device_token() {
-        let fcm_token = encrypt_device_token("fcm-chat.delta:c67DVcpVQN2rJHiSszKNDW:APA91bErcJV2b8qG0IT4aiuCqw6Al0_SbydSuz3V0CHBR1X7Fp8YzyvlpxNZIOGYVDFKejZGE1YiGSaqxmkr9ds0DuALmZNDwqIhuZWGKKrs3r7DTSkQ9MQ").unwrap();
-        let fcm_beta_token = encrypt_device_token("fcm-chat.delta.beta:chu-GhZCTLyzq1XseJp3na:APA91bFlsfDawdszWTyOLbxBy7KeRCrYM-SBFqutebF5ix0EZKMuCFUT_Y7R7Ex_eTQG_LbOu3Ky_z5UlTMJtI7ufpIp5wEvsFmVzQcOo3YhrUpbiSVGIlk").unwrap();
-        let apple_token = encrypt_device_token(
-            "0155b93b7eb867a0d8b7328b978bb15bf22f70867e39e168d03f199af9496894",
-        )
-        .unwrap();
-
-        assert_eq!(fcm_token.len(), fcm_beta_token.len());
-        assert_eq!(apple_token.len(), fcm_token.len());
-    }
-}

src/qr.rs

@@ -270,7 +270,6 @@ fn starts_with_ignore_case(string: &str, pattern: &str) -> bool {
 /// The function should be called after a QR code is scanned.
 /// The function takes the raw text scanned and checks what can be done with it.
 pub async fn check_qr(context: &Context, qr: &str) -> Result<Qr> {
-    let qr = qr.trim();
     let qrcode = if starts_with_ignore_case(qr, OPENPGP4FPR_SCHEME) {
         decode_openpgp(context, qr)
             .await
@@ -368,10 +367,9 @@ pub fn format_backup(qr: &Qr) -> Result<String> {
 /// scheme: `OPENPGP4FPR:FINGERPRINT#a=ADDR&n=NAME&i=INVITENUMBER&s=AUTH`
 ///     or: `OPENPGP4FPR:FINGERPRINT#a=ADDR&g=GROUPNAME&x=GROUPID&i=INVITENUMBER&s=AUTH`
 ///     or: `OPENPGP4FPR:FINGERPRINT#a=ADDR`
+#[allow(clippy::indexing_slicing)]
 async fn decode_openpgp(context: &Context, qr: &str) -> Result<Qr> {
-    let payload = qr
-        .get(OPENPGP4FPR_SCHEME.len()..)
-        .context("Invalid OPENPGP4FPR scheme")?;
+    let payload = &qr[OPENPGP4FPR_SCHEME.len()..];
 
     // macOS and iOS sometimes replace the # with %23 (uri encode it), we should be able to parse this wrong format too.
     // see issue https://github.com/deltachat/deltachat-core-rust/issues/1969 for more info
@@ -548,7 +546,7 @@ async fn decode_ideltachat(context: &Context, prefix: &str, qr: &str) -> Result<
 fn decode_account(qr: &str) -> Result<Qr> {
     let payload = qr
         .get(DCACCOUNT_SCHEME.len()..)
-        .context("Invalid DCACCOUNT payload")?;
+        .context("invalid DCACCOUNT payload")?;
     let url = url::Url::parse(payload).context("Invalid account URL")?;
     if url.scheme() == "http" || url.scheme() == "https" {
         Ok(Qr::Account {
@@ -566,7 +564,7 @@ fn decode_account(qr: &str) -> Result<Qr> {
 fn decode_webrtc_instance(_context: &Context, qr: &str) -> Result<Qr> {
     let payload = qr
         .get(DCWEBRTC_SCHEME.len()..)
-        .context("Invalid DCWEBRTC payload")?;
+        .context("invalid DCWEBRTC payload")?;
 
     let (_type, url) = Message::parse_webrtc_instance(payload);
     let url = url::Url::parse(&url).context("Invalid WebRTC instance")?;
@@ -639,7 +637,7 @@ fn decode_shadowsocks_proxy(qr: &str) -> Result<Qr> {
 fn decode_backup2(qr: &str) -> Result<Qr> {
     let payload = qr
         .strip_prefix(DCBACKUP2_SCHEME)
-        .ok_or_else(|| anyhow!("Invalid DCBACKUP2 scheme"))?;
+        .ok_or_else(|| anyhow!("invalid DCBACKUP scheme"))?;
     let (auth_token, node_addr) = payload
         .split_once('&')
         .context("Backup QR code has no separator")?;
@@ -670,10 +668,9 @@ struct CreateAccountErrorResponse {
 /// take a qr of the type DC_QR_ACCOUNT, parse it's parameters,
 /// download additional information from the contained url and set the parameters.
 /// on success, a configure::configure() should be able to log in to the account
+#[allow(clippy::indexing_slicing)]
 async fn set_account_from_qr(context: &Context, qr: &str) -> Result<()> {
-    let url_str = qr
-        .get(DCACCOUNT_SCHEME.len()..)
-        .context("Invalid DCACCOUNT scheme")?;
+    let url_str = &qr[DCACCOUNT_SCHEME.len()..];
 
     if !url_str.starts_with(HTTPS_SCHEME) {
         bail!("DCACCOUNT QR codes must use HTTPS scheme");
@@ -803,12 +800,15 @@ pub async fn set_config_from_qr(context: &Context, qr: &str) -> Result<()> {
 /// Extract address for the mailto scheme.
 ///
 /// Scheme: `mailto:addr...?subject=...&body=..`
+#[allow(clippy::indexing_slicing)]
 async fn decode_mailto(context: &Context, qr: &str) -> Result<Qr> {
-    let payload = qr
-        .get(MAILTO_SCHEME.len()..)
-        .context("Invalid mailto: scheme")?;
+    let payload = &qr[MAILTO_SCHEME.len()..];
 
-    let (addr, query) = payload.split_once('?').unwrap_or((payload, ""));
+    let (addr, query) = if let Some(query_index) = payload.find('?') {
+        (&payload[..query_index], &payload[query_index + 1..])
+    } else {
+        (payload, "")
+    };
 
     let param: BTreeMap<&str, &str> = query
         .split('&')
@@ -855,12 +855,16 @@ async fn decode_mailto(context: &Context, qr: &str) -> Result<Qr> {
 /// Extract address for the smtp scheme.
 ///
 /// Scheme: `SMTP:addr...:subject...:body...`
+#[allow(clippy::indexing_slicing)]
 async fn decode_smtp(context: &Context, qr: &str) -> Result<Qr> {
-    let payload = qr.get(SMTP_SCHEME.len()..).context("Invalid SMTP scheme")?;
+    let payload = &qr[SMTP_SCHEME.len()..];
+
+    let addr = if let Some(query_index) = payload.find(':') {
+        &payload[..query_index]
+    } else {
+        bail!("Invalid SMTP found");
+    };
 
-    let (addr, _rest) = payload
-        .split_once(':')
-        .context("Invalid SMTP scheme payload")?;
     let addr = normalize_address(addr)?;
     let name = "";
     Qr::from_address(context, name, &addr, None).await
@@ -871,13 +875,14 @@ async fn decode_smtp(context: &Context, qr: &str) -> Result<Qr> {
 /// Scheme: `MATMSG:TO:addr...;SUB:subject...;BODY:body...;`
 ///
 /// There may or may not be linebreaks after the fields.
+#[allow(clippy::indexing_slicing)]
 async fn decode_matmsg(context: &Context, qr: &str) -> Result<Qr> {
     // Does not work when the text `TO:` is used in subject/body _and_ TO: is not the first field.
     // we ignore this case.
     let addr = if let Some(to_index) = qr.find("TO:") {
-        let addr = qr.get(to_index + 3..).unwrap_or_default().trim();
+        let addr = qr[to_index + 3..].trim();
         if let Some(semi_index) = addr.find(';') {
-            addr.get(..semi_index).unwrap_or_default().trim()
+            addr[..semi_index].trim()
         } else {
             addr
         }
@@ -898,6 +903,7 @@ static VCARD_EMAIL_RE: Lazy<regex::Regex> =
 /// Extract address for the vcard scheme.
 ///
 /// Scheme: `VCARD:BEGIN\nN:last name;first name;...;\nEMAIL;<type>:addr...;`
+#[allow(clippy::indexing_slicing)]
 async fn decode_vcard(context: &Context, qr: &str) -> Result<Qr> {
     let name = VCARD_NAME_RE
         .captures(qr)
@@ -909,8 +915,8 @@ async fn decode_vcard(context: &Context, qr: &str) -> Result<Qr> {
         })
         .unwrap_or_default();
 
-    let addr = if let Some(cap) = VCARD_EMAIL_RE.captures(qr).and_then(|caps| caps.get(2)) {
-        normalize_address(cap.as_str().trim())?
+    let addr = if let Some(caps) = VCARD_EMAIL_RE.captures(qr) {
+        normalize_address(caps[2].trim())?
     } else {
         bail!("Bad e-mail address");
     };
@@ -995,17 +1001,6 @@ mod tests {
             }
         );
 
-        // Test that QR code whitespace is stripped.
-        // Users can copy-paste QR code contents and "scan"
-        // from the clipboard.
-        let qr = check_qr(&ctx.ctx, "  \thttp://www.hello.com/hello  \n\t \r\n ").await?;
-        assert_eq!(
-            qr,
-            Qr::Url {
-                url: "http://www.hello.com/hello".to_string(),
-            }
-        );
-
         Ok(())
     }
 
@@ -1314,7 +1309,7 @@ mod tests {
             last_seen_autocrypt: 1,
             prefer_encrypt: EncryptPreference::Mutual,
             public_key: Some(pub_key.clone()),
-            public_key_fingerprint: Some(pub_key.dc_fingerprint()),
+            public_key_fingerprint: Some(pub_key.fingerprint()),
             gossip_key: None,
             gossip_timestamp: 0,
             gossip_key_fingerprint: None,
@@ -1345,10 +1340,7 @@ mod tests {
 
         let qr = check_qr(
             &ctx.ctx,
-            &format!(
-                "OPENPGP4FPR:{}#a=alice@example.org",
-                pub_key.dc_fingerprint()
-            ),
+            &format!("OPENPGP4FPR:{}#a=alice@example.org", pub_key.fingerprint()),
         )
         .await?;
         if let Qr::FprOk { contact_id, .. } = qr {
@@ -1755,9 +1747,7 @@ mod tests {
         );
 
         // Test URL without port.
-        //
-        // Also check that whitespace is trimmed.
-        let res = set_config_from_qr(&t, " https://t.me/socks?server=1.2.3.4\n").await;
+        let res = set_config_from_qr(&t, "https://t.me/socks?server=1.2.3.4").await;
         assert!(res.is_ok());
         assert_eq!(t.get_config_bool(Config::ProxyEnabled).await?, true);
         assert_eq!(

src/reaction.rs

@@ -558,12 +558,7 @@ Here's my footer -- bob@example.net"
     ) -> Result<()> {
         let event = t
             .evtracker
-            .get_matching(|evt| {
-                matches!(
-                    evt,
-                    EventType::ReactionsChanged { .. } | EventType::IncomingMsg { .. }
-                )
-            })
+            .get_matching(|evt| matches!(evt, EventType::ReactionsChanged { .. }))
             .await;
         match event {
             EventType::ReactionsChanged {
@@ -575,7 +570,7 @@ Here's my footer -- bob@example.net"
                 assert_eq!(msg_id, expected_msg_id);
                 assert_eq!(contact_id, expected_contact_id);
             }
-            _ => panic!("Unexpected event {event:?}."),
+            _ => unreachable!(),
         }
         Ok(())
     }
@@ -588,14 +583,7 @@ Here's my footer -- bob@example.net"
     ) -> Result<()> {
         let event = t
             .evtracker
-            // Check for absence of `IncomingMsg` events -- it appeared that it's quite easy to make
-            // bugs when `IncomingMsg` is issued for reactions.
-            .get_matching(|evt| {
-                matches!(
-                    evt,
-                    EventType::IncomingReaction { .. } | EventType::IncomingMsg { .. }
-                )
-            })
+            .get_matching(|evt| matches!(evt, EventType::IncomingReaction { .. }))
             .await;
         match event {
             EventType::IncomingReaction {
@@ -607,25 +595,16 @@ Here's my footer -- bob@example.net"
                 assert_eq!(contact_id, expected_contact_id);
                 assert_eq!(reaction, Reaction::from(expected_reaction));
             }
-            _ => panic!("Unexpected event {event:?}."),
+            _ => unreachable!(),
         }
         Ok(())
     }
 
-    /// Checks that no unwanted events remain after expecting "wanted" reaction events.
-    async fn expect_no_unwanted_events(t: &TestContext) {
-        let ev = t
-            .evtracker
-            .get_matching_opt(t, |evt| {
-                matches!(
-                    evt,
-                    EventType::IncomingReaction { .. } | EventType::IncomingMsg { .. }
-                )
-            })
-            .await;
-        if let Some(ev) = ev {
-            panic!("Unwanted event {ev:?}.")
-        }
+    async fn has_incoming_reactions_event(t: &TestContext) -> bool {
+        t.evtracker
+            .get_matching_opt(t, |evt| matches!(evt, EventType::IncomingReaction { .. }))
+            .await
+            .is_some()
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
@@ -656,10 +635,9 @@ Here's my footer -- bob@example.net"
 
         bob_msg.chat_id.accept(&bob).await?;
 
-        bob.evtracker.clear_events();
         send_reaction(&bob, bob_msg.id, "👍").await.unwrap();
         expect_reactions_changed_event(&bob, bob_msg.chat_id, bob_msg.id, ContactId::SELF).await?;
-        expect_no_unwanted_events(&bob).await;
+        assert!(!has_incoming_reactions_event(&bob).await);
         assert_eq!(get_chat_msgs(&bob, bob_msg.chat_id).await?.len(), 2);
 
         let bob_reaction_msg = bob.pop_sent_msg().await;
@@ -678,7 +656,6 @@ Here's my footer -- bob@example.net"
         expect_reactions_changed_event(&alice, chat_alice.id, alice_msg.sender_msg_id, *bob_id)
             .await?;
         expect_incoming_reactions_event(&alice, alice_msg.sender_msg_id, *bob_id, "👍").await?;
-        expect_no_unwanted_events(&alice).await;
 
         // Alice reacts to own message.
         send_reaction(&alice, alice_msg.sender_msg_id, "👍 😀")
@@ -707,7 +684,6 @@ Here's my footer -- bob@example.net"
         let bob = TestContext::new_bob().await;
         alice.set_config(Config::Displayname, Some("ALICE")).await?;
         bob.set_config(Config::Displayname, Some("BOB")).await?;
-        let alice_bob_id = alice.add_or_lookup_contact_id(&bob).await;
 
         // Alice sends message to Bob
         let alice_chat = alice.create_chat(&bob).await;
@@ -720,9 +696,7 @@ Here's my footer -- bob@example.net"
         send_reaction(&bob, bob_msg1.id, "👍").await?;
         let bob_send_reaction = bob.pop_sent_msg().await;
         alice.recv_msg_trash(&bob_send_reaction).await;
-        expect_incoming_reactions_event(&alice, alice_msg1.sender_msg_id, alice_bob_id, "👍")
-            .await?;
-        expect_no_unwanted_events(&alice).await;
+        assert!(has_incoming_reactions_event(&alice).await);
 
         let chatlist = Chatlist::try_load(&bob, 0, None, None).await?;
         let summary = chatlist.get_summary(&bob, 0, None).await?;
@@ -737,9 +711,8 @@ Here's my footer -- bob@example.net"
         SystemTime::shift(Duration::from_secs(10));
         send_reaction(&alice, alice_msg1.sender_msg_id, "🍿").await?;
         let alice_send_reaction = alice.pop_sent_msg().await;
-        bob.evtracker.clear_events();
         bob.recv_msg_opt(&alice_send_reaction).await;
-        expect_no_unwanted_events(&bob).await;
+        assert!(!has_incoming_reactions_event(&bob).await);
 
         assert_summary(&alice, "You reacted 🍿 to \"Party?\"").await;
         assert_summary(&bob, "ALICE reacted 🍿 to \"Party?\"").await;
@@ -961,9 +934,7 @@ Here's my footer -- bob@example.net"
         expect_reactions_changed_event(&alice0, chat_id, alice0_msg_id, ContactId::SELF).await?;
         expect_reactions_changed_event(&alice1, alice1_msg.chat_id, alice1_msg.id, ContactId::SELF)
             .await?;
-        for a in [&alice0, &alice1] {
-            expect_no_unwanted_events(a).await;
-        }
+
         Ok(())
     }
 }

src/receive_imf.rs

@@ -6,7 +6,7 @@ use std::str::FromStr;
 use anyhow::{Context as _, Result};
 use deltachat_contact_tools::{addr_cmp, may_be_valid_addr, sanitize_single_line, ContactAddress};
 use iroh_gossip::proto::TopicId;
-use mailparse::SingleInfo;
+use mailparse::{parse_mail, SingleInfo};
 use num_traits::FromPrimitive;
 use once_cell::sync::Lazy;
 use regex::Regex;
@@ -73,13 +73,12 @@ pub struct ReceivedMsg {
 ///
 /// This method returns errors on a failure to parse the mail or extract Message-ID. It's only used
 /// for tests and REPL tool, not actual message reception pipeline.
-#[cfg(any(test, feature = "internals"))]
 pub async fn receive_imf(
     context: &Context,
     imf_raw: &[u8],
     seen: bool,
 ) -> Result<Option<ReceivedMsg>> {
-    let mail = mailparse::parse_mail(imf_raw).context("can't parse mail")?;
+    let mail = parse_mail(imf_raw).context("can't parse mail")?;
     let rfc724_mid =
         imap::prefetch_get_message_id(&mail.headers).unwrap_or_else(imap::create_message_id);
     if let Some(download_limit) = context.download_limit().await? {
@@ -106,7 +105,6 @@ pub async fn receive_imf(
 /// Emulates reception of a message from "INBOX".
 ///
 /// Only used for tests and REPL tool, not actual message reception pipeline.
-#[cfg(any(test, feature = "internals"))]
 pub(crate) async fn receive_imf_from_inbox(
     context: &Context,
     rfc724_mid: &str,
@@ -1356,7 +1354,7 @@ async fn add_parts(
         // 1. They can't be an attack (they are outgoing, not incoming)
         // 2. Probably the unencryptedness is just a temporary state, after all
         //    the user obviously still uses DC
-        //    -> Showing info messages every time would be a lot of noise
+        //    -> Showing info messages everytime would be a lot of noise
         // 3. The info messages that are shown to the user ("Your chat partner
         //    likely reinstalled DC" or similar) would be wrong.
         if chat.is_protected() && (mime_parser.incoming || chat.typ != Chattype::Single) {
@@ -1577,7 +1575,7 @@ INSERT INTO msgs
 ON CONFLICT (id) DO UPDATE
 SET rfc724_mid=excluded.rfc724_mid, chat_id=excluded.chat_id,
     from_id=excluded.from_id, to_id=excluded.to_id, timestamp_sent=excluded.timestamp_sent,
-    type=excluded.type, state=max(state,excluded.state), msgrmsg=excluded.msgrmsg,
+    type=excluded.type, msgrmsg=excluded.msgrmsg,
     txt=excluded.txt, txt_normalized=excluded.txt_normalized, subject=excluded.subject,
     txt_raw=excluded.txt_raw, param=excluded.param,
     hidden=excluded.hidden,bytes=excluded.bytes, mime_headers=excluded.mime_headers,
@@ -2467,16 +2465,14 @@ async fn create_or_lookup_mailinglist(
     }
 }
 
+#[allow(clippy::indexing_slicing)]
 fn compute_mailinglist_name(
     list_id_header: &str,
     listid: &str,
     mime_parser: &MimeMessage,
 ) -> String {
-    let mut name = match LIST_ID_REGEX
-        .captures(list_id_header)
-        .and_then(|caps| caps.get(1))
-    {
-        Some(cap) => cap.as_str().trim().to_string(),
+    let mut name = match LIST_ID_REGEX.captures(list_id_header) {
+        Some(cap) => cap[1].trim().to_string(),
         None => "".to_string(),
     };
 
@@ -2523,11 +2519,8 @@ fn compute_mailinglist_name(
         // 51231231231231231231231232869f58.xing.com -> xing.com
         static PREFIX_32_CHARS_HEX: Lazy<Regex> =
             Lazy::new(|| Regex::new(r"([0-9a-fA-F]{32})\.(.{6,})").unwrap());
-        if let Some(cap) = PREFIX_32_CHARS_HEX
-            .captures(listid)
-            .and_then(|caps| caps.get(2))
-        {
-            name = cap.as_str().to_string();
+        if let Some(cap) = PREFIX_32_CHARS_HEX.captures(listid) {
+            name = cap[2].to_string();
         } else {
             name = listid.to_string();
         }

src/receive_imf/tests.rs

@@ -1068,7 +1068,7 @@ async fn test_classic_mailing_list() -> Result<()> {
     let mime = sent.payload();
 
     println!("Sent mime message is:\n\n{mime}\n\n");
-    assert!(mime.contains("Content-Type: text/plain; charset=utf-8\r\n"));
+    assert!(mime.contains("Content-Type: text/plain; charset=utf-8; format=flowed; delsp=no\r\n"));
     assert!(mime.contains("Subject: =?utf-8?q?Re=3A_=5Bdelta-dev=5D_What=27s_up=3F?=\r\n"));
     assert!(mime.contains("MIME-Version: 1.0\r\n"));
     assert!(mime.contains("In-Reply-To: <38942@posteo.org>\r\n"));
@@ -4033,7 +4033,7 @@ async fn test_sync_member_list_on_rejoin() -> Result<()> {
     remove_contact_from_chat(&alice, alice_chat_id, claire_id).await?;
     alice.pop_sent_msg().await;
 
-    // re-add bob
+    // readd bob
     add_contact_to_chat(&alice, alice_chat_id, bob_id).await?;
     let add2 = alice.pop_sent_msg().await;
     bob.recv_msg(&add2).await;
@@ -4182,7 +4182,7 @@ async fn test_recreate_contact_list_on_missing_message() -> Result<()> {
     // since we missed a message, a new contact list should be build
     assert_eq!(get_chat_contacts(&alice, chat_id).await?.len(), 3);
 
-    // re-add fiona
+    // readd fiona
     add_contact_to_chat(&alice, chat_id, alice_fiona).await?;
 
     // delayed removal of fiona shouldn't remove her
@@ -4224,7 +4224,7 @@ async fn test_dont_readd_with_normal_msg() -> Result<()> {
     bob.recv_msg(&alice.pop_sent_msg().await).await;
 
     // Alice didn't receive Bob's leave message although a lot of time has
-    // passed, so Bob must re-add themselves otherwise other members would think
+    // passed, so Bob must readd themselves otherwise other members would think
     // Bob is still here while they aren't. Bob should retry to leave if they
     // think that Alice didn't re-add them on purpose (which is possible if Alice uses a classical
     // MUA).

src/scheduler/connectivity.rs

@@ -14,31 +14,12 @@ use crate::{context::Context, log::LogExt};
 
 use super::InnerSchedulerState;
 
-/// Rough connectivity status for display in the status bar in the UI.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, EnumProperty, PartialOrd, Ord)]
 pub enum Connectivity {
-    /// Not connected.
-    ///
-    /// This may be because we just started,
-    /// because we lost connection and
-    /// were not able to connect and log in yet
-    /// or because I/O is not started.
     NotConnected = 1000,
-
-    /// Attempting to connect and log in.
     Connecting = 2000,
-
-    /// Fetching or sending messages.
+    /// Fetching or sending messages
     Working = 3000,
-
-    /// We are connected but not doing anything.
-    ///
-    /// This is the most common state,
-    /// so mobile UIs display the profile name
-    /// instead of connectivity status in this state.
-    /// Desktop UI displays "Connected" in the tooltip,
-    /// which signals that no more messages
-    /// are coming in.
     Connected = 4000,
 }
 
@@ -51,17 +32,13 @@ enum DetailedConnectivity {
     Error(String),
     #[default]
     Uninitialized,
-
-    /// Attempting to connect,
-    /// until we successfully log in.
     Connecting,
 
-    /// Connection is just established,
-    /// there may be work to do.
-    Preparing,
+    /// Connection is just established, but there may be work to do.
+    Connected,
 
     /// There is actual work to do, e.g. there are messages in SMTP queue
-    /// or we detected a message on IMAP server that should be downloaded.
+    /// or we detected a message that should be downloaded.
     Working,
 
     InterruptingIdle,
@@ -80,14 +57,8 @@ impl DetailedConnectivity {
             DetailedConnectivity::Uninitialized => Some(Connectivity::NotConnected),
             DetailedConnectivity::Connecting => Some(Connectivity::Connecting),
             DetailedConnectivity::Working => Some(Connectivity::Working),
-            DetailedConnectivity::InterruptingIdle => Some(Connectivity::Working),
-
-            // At this point IMAP has just connected,
-            // but does not know yet if there are messages to download.
-            // We still convert this to Working state
-            // so user can see "Updating..." and not "Connected"
-            // which is reserved for idle state.
-            DetailedConnectivity::Preparing => Some(Connectivity::Working),
+            DetailedConnectivity::InterruptingIdle => Some(Connectivity::Connected),
+            DetailedConnectivity::Connected => Some(Connectivity::Connected),
 
             // Just don't return a connectivity, probably the folder is configured not to be
             // watched or there is e.g. no "Sent" folder, so we are not interested in it
@@ -103,9 +74,9 @@ impl DetailedConnectivity {
             | DetailedConnectivity::Uninitialized
             | DetailedConnectivity::NotConfigured => "<span class=\"red dot\"></span>".to_string(),
             DetailedConnectivity::Connecting => "<span class=\"yellow dot\"></span>".to_string(),
-            DetailedConnectivity::Preparing
-            | DetailedConnectivity::Working
+            DetailedConnectivity::Working
             | DetailedConnectivity::InterruptingIdle
+            | DetailedConnectivity::Connected
             | DetailedConnectivity::Idle => "<span class=\"green dot\"></span>".to_string(),
         }
     }
@@ -115,12 +86,10 @@ impl DetailedConnectivity {
             DetailedConnectivity::Error(e) => stock_str::error(context, e).await,
             DetailedConnectivity::Uninitialized => "Not started".to_string(),
             DetailedConnectivity::Connecting => stock_str::connecting(context).await,
-            DetailedConnectivity::Preparing | DetailedConnectivity::Working => {
-                stock_str::updating(context).await
-            }
-            DetailedConnectivity::InterruptingIdle | DetailedConnectivity::Idle => {
-                stock_str::connected(context).await
-            }
+            DetailedConnectivity::Working => stock_str::updating(context).await,
+            DetailedConnectivity::InterruptingIdle
+            | DetailedConnectivity::Connected
+            | DetailedConnectivity::Idle => stock_str::connected(context).await,
             DetailedConnectivity::NotConfigured => "Not configured".to_string(),
         }
     }
@@ -138,7 +107,7 @@ impl DetailedConnectivity {
             // since sending the last message, connectivity could have changed, which we don't notice
             // until another message is sent
             DetailedConnectivity::InterruptingIdle
-            | DetailedConnectivity::Preparing
+            | DetailedConnectivity::Connected
             | DetailedConnectivity::Idle => stock_str::last_msg_sent_successfully(context).await,
             DetailedConnectivity::NotConfigured => "Not configured".to_string(),
         }
@@ -151,7 +120,7 @@ impl DetailedConnectivity {
             DetailedConnectivity::Connecting => false,
             DetailedConnectivity::Working => false,
             DetailedConnectivity::InterruptingIdle => false,
-            DetailedConnectivity::Preparing => false, // Just connected, there may still be work to do.
+            DetailedConnectivity::Connected => false, // Just connected, there may still be work to do.
             DetailedConnectivity::NotConfigured => true,
             DetailedConnectivity::Idle => true,
         }
@@ -179,8 +148,8 @@ impl ConnectivityStore {
     pub(crate) async fn set_working(&self, context: &Context) {
         self.set(context, DetailedConnectivity::Working).await;
     }
-    pub(crate) async fn set_preparing(&self, context: &Context) {
-        self.set(context, DetailedConnectivity::Preparing).await;
+    pub(crate) async fn set_connected(&self, context: &Context) {
+        self.set(context, DetailedConnectivity::Connected).await;
     }
     pub(crate) async fn set_not_configured(&self, context: &Context) {
         self.set(context, DetailedConnectivity::NotConfigured).await;
@@ -200,8 +169,8 @@ impl ConnectivityStore {
     }
 }
 
-/// Set all folder states to InterruptingIdle in case they were `Idle` before.
-/// Called during `dc_maybe_network()` to make sure that `all_work_done()`
+/// Set all folder states to InterruptingIdle in case they were `Connected` before.
+/// Called during `dc_maybe_network()` to make sure that `dc_all_work_done()`
 /// returns false immediately after `dc_maybe_network()`.
 pub(crate) async fn idle_interrupted(inbox: ConnectivityStore, oboxes: Vec<ConnectivityStore>) {
     let mut connectivity_lock = inbox.0.lock().await;
@@ -210,7 +179,8 @@ pub(crate) async fn idle_interrupted(inbox: ConnectivityStore, oboxes: Vec<Conne
     // returns Connected. But after dc_maybe_network(), dc_get_connectivity() must not
     // return Connected until DC is completely done with fetching folders; this also
     // includes scan_folders() which happens on the inbox thread.
-    if *connectivity_lock == DetailedConnectivity::Idle
+    if *connectivity_lock == DetailedConnectivity::Connected
+        || *connectivity_lock == DetailedConnectivity::Idle
         || *connectivity_lock == DetailedConnectivity::NotConfigured
     {
         *connectivity_lock = DetailedConnectivity::InterruptingIdle;
@@ -219,7 +189,9 @@ pub(crate) async fn idle_interrupted(inbox: ConnectivityStore, oboxes: Vec<Conne
 
     for state in oboxes {
         let mut connectivity_lock = state.0.lock().await;
-        if *connectivity_lock == DetailedConnectivity::Idle {
+        if *connectivity_lock == DetailedConnectivity::Connected
+            || *connectivity_lock == DetailedConnectivity::Idle
+        {
             *connectivity_lock = DetailedConnectivity::InterruptingIdle;
         }
     }

src/securejoin.rs

@@ -104,7 +104,7 @@ pub async fn get_securejoin_qr(context: &Context, group: Option<ChatId>) -> Resu
             context.scheduler.interrupt_inbox().await;
         }
         format!(
-            "https://i.delta.chat/#{}&a={}&g={}&x={}&i={}&s={}",
+            "OPENPGP4FPR:{}#a={}&g={}&x={}&i={}&s={}",
             fingerprint.hex(),
             self_addr_urlencoded,
             &group_name_urlencoded,
@@ -119,7 +119,7 @@ pub async fn get_securejoin_qr(context: &Context, group: Option<ChatId>) -> Resu
             context.scheduler.interrupt_inbox().await;
         }
         format!(
-            "https://i.delta.chat/#{}&a={}&n={}&i={}&s={}",
+            "OPENPGP4FPR:{}#a={}&n={}&i={}&s={}",
             fingerprint.hex(),
             self_addr_urlencoded,
             self_name_urlencoded,
@@ -136,7 +136,7 @@ async fn get_self_fingerprint(context: &Context) -> Result<Fingerprint> {
     let key = load_self_public_key(context)
         .await
         .context("Failed to load key")?;
-    Ok(key.dc_fingerprint())
+    Ok(key.fingerprint())
 }
 
 /// Take a scanned QR-code and do the setup-contact/join-group/invite handshake.
@@ -244,10 +244,10 @@ async fn verify_sender_by_fingerprint(
 
 /// What to do with a Secure-Join handshake message after it was handled.
 ///
-/// This status is returned to [`receive_imf_inner`] which will use it to decide what to do
+/// This status is returned to [`receive_imf`] which will use it to decide what to do
 /// next with this incoming setup-contact/secure-join handshake message.
 ///
-/// [`receive_imf_inner`]: crate::receive_imf::receive_imf_inner
+/// [`receive_imf`]: crate::receive_imf::receive_imf
 #[derive(Debug, PartialEq, Eq)]
 pub(crate) enum HandshakeMessage {
     /// The message has been fully handled and should be removed/delete.
@@ -279,6 +279,7 @@ pub(crate) enum HandshakeMessage {
 ///
 /// When `handle_securejoin_handshake()` is called, the message is not yet filed in the
 /// database; this is done by `receive_imf()` later on as needed.
+#[allow(clippy::indexing_slicing)]
 pub(crate) async fn handle_securejoin_handshake(
     context: &Context,
     mime_message: &MimeMessage,
@@ -297,9 +298,9 @@ pub(crate) async fn handle_securejoin_handshake(
 
     if !matches!(step, "vg-request" | "vc-request") {
         let mut self_found = false;
-        let self_fingerprint = load_self_public_key(context).await?.dc_fingerprint();
+        let self_fingerprint = load_self_public_key(context).await?.fingerprint();
         for (addr, key) in &mime_message.gossiped_keys {
-            if key.dc_fingerprint() == self_fingerprint && context.is_self_addr(addr).await? {
+            if key.fingerprint() == self_fingerprint && context.is_self_addr(addr).await? {
                 self_found = true;
                 break;
             }
@@ -347,7 +348,7 @@ pub(crate) async fn handle_securejoin_handshake(
             send_alice_handshake_msg(
                 context,
                 contact_id,
-                &format!("{}-auth-required", &step.get(..2).unwrap_or_default()),
+                &format!("{}-auth-required", &step[..2]),
             )
             .await
             .context("failed sending auth-required handshake message")?;
@@ -935,10 +936,7 @@ mod tests {
             "vc-request-with-auth"
         );
         assert!(msg.get_header(HeaderDef::SecureJoinAuth).is_some());
-        let bob_fp = load_self_public_key(&bob.ctx)
-            .await
-            .unwrap()
-            .dc_fingerprint();
+        let bob_fp = load_self_public_key(&bob.ctx).await.unwrap().fingerprint();
         assert_eq!(
             *msg.get_header(HeaderDef::SecureJoinFingerprint).unwrap(),
             bob_fp.hex()
@@ -1108,10 +1106,10 @@ mod tests {
             last_seen_autocrypt: 10,
             prefer_encrypt: EncryptPreference::Mutual,
             public_key: Some(alice_pubkey.clone()),
-            public_key_fingerprint: Some(alice_pubkey.dc_fingerprint()),
+            public_key_fingerprint: Some(alice_pubkey.fingerprint()),
             gossip_key: Some(alice_pubkey.clone()),
             gossip_timestamp: 10,
-            gossip_key_fingerprint: Some(alice_pubkey.dc_fingerprint()),
+            gossip_key_fingerprint: Some(alice_pubkey.fingerprint()),
             verified_key: None,
             verified_key_fingerprint: None,
             verifier: None,
@@ -1159,7 +1157,7 @@ mod tests {
             "vc-request-with-auth"
         );
         assert!(msg.get_header(HeaderDef::SecureJoinAuth).is_some());
-        let bob_fp = load_self_public_key(&bob.ctx).await?.dc_fingerprint();
+        let bob_fp = load_self_public_key(&bob.ctx).await?.fingerprint();
         assert_eq!(
             *msg.get_header(HeaderDef::SecureJoinFingerprint).unwrap(),
             bob_fp.hex()
@@ -1322,7 +1320,7 @@ mod tests {
             "vg-request-with-auth"
         );
         assert!(msg.get_header(HeaderDef::SecureJoinAuth).is_some());
-        let bob_fp = load_self_public_key(&bob.ctx).await?.dc_fingerprint();
+        let bob_fp = load_self_public_key(&bob.ctx).await?.fingerprint();
         assert_eq!(
             *msg.get_header(HeaderDef::SecureJoinFingerprint).unwrap(),
             bob_fp.hex()

src/securejoin/bobstate.rs

@@ -389,7 +389,7 @@ async fn send_handshake_message(
             msg.param.set_int(Param::GuaranteeE2ee, 1);
 
             // Sends our own fingerprint in the Secure-Join-Fingerprint header.
-            let bob_fp = load_self_public_key(context).await?.dc_fingerprint();
+            let bob_fp = load_self_public_key(context).await?.fingerprint();
             msg.param.set(Param::Arg3, bob_fp.hex());
 
             // Sends the grpid in the Secure-Join-Group header.

src/simplify.rs

@@ -1,5 +1,4 @@
 //! # Simplify incoming plaintext.
-use crate::tools::IsNoneOrEmpty;
 
 /// Protects lines starting with `--` against being treated as a footer.
 /// for that, we insert a ZERO WIDTH SPACE (ZWSP, 0x200B);
@@ -21,6 +20,7 @@ pub fn escape_message_footer_marks(text: &str) -> String {
 /// Returns `(lines, footer_lines)` tuple;
 /// `footer_lines` is set to `Some` if the footer was actually removed from `lines`
 /// (which is equal to the input array otherwise).
+#[allow(clippy::indexing_slicing)]
 pub(crate) fn remove_message_footer<'a>(
     lines: &'a [&str],
 ) -> (&'a [&'a str], Option<&'a [&'a str]>) {
@@ -28,13 +28,14 @@ pub(crate) fn remove_message_footer<'a>(
     for (ix, &line) in lines.iter().enumerate() {
         match line {
             // some providers encode `-- ` to `-- =20` which results in `--  `
-            "-- " | "--  " => return (lines.get(..ix).unwrap_or(lines), lines.get(ix + 1..)),
+            "-- " | "--  " => return (&lines[..ix], lines.get(ix + 1..)),
             // some providers encode `-- ` to `=2D-` which results in only `--`;
             // use that only when no other footer is found
             // and if the line before is empty and the line after is not empty
             "--" => {
-                if (ix == 0 || lines.get(ix.saturating_sub(1)).is_none_or_empty())
-                    && !lines.get(ix + 1).is_none_or_empty()
+                if (ix == 0 || lines[ix - 1].is_empty())
+                    && ix != lines.len() - 1
+                    && !lines[ix + 1].is_empty()
                 {
                     nearly_standard_footer = Some(ix);
                 }
@@ -43,7 +44,7 @@ pub(crate) fn remove_message_footer<'a>(
         }
     }
     if let Some(ix) = nearly_standard_footer {
-        return (lines.get(..ix).unwrap_or(lines), lines.get(ix + 1..));
+        return (&lines[..ix], lines.get(ix + 1..));
     }
     (lines, None)
 }
@@ -52,6 +53,7 @@ pub(crate) fn remove_message_footer<'a>(
 /// Returns `(lines, is_footer_removed)` tuple;
 /// `is_footer_removed` is set to `true` if the footer was actually removed from `lines`
 /// (which is equal to the input array otherwise).
+#[allow(clippy::indexing_slicing)]
 fn remove_nonstandard_footer<'a>(lines: &'a [&str]) -> (&'a [&'a str], bool) {
     for (ix, &line) in lines.iter().enumerate() {
         if line == "--"
@@ -61,10 +63,7 @@ fn remove_nonstandard_footer<'a>(lines: &'a [&str]) -> (&'a [&'a str], bool) {
             || line.starts_with("*****")
             || line.starts_with("~~~~~")
         {
-            // `get` should always return `Some` here.
-            if let Some(lines) = lines.get(..ix) {
-                return (lines, true);
-            }
+            return (&lines[..ix], true);
         }
     }
     (lines, false)
@@ -174,6 +173,7 @@ fn skip_forward_header<'a>(lines: &'a [&str]) -> (&'a [&'a str], bool) {
     }
 }
 
+#[allow(clippy::indexing_slicing)]
 fn remove_bottom_quote<'a>(lines: &'a [&str]) -> (&'a [&'a str], Option<String>) {
     let mut first_quoted_line = lines.len();
     let mut last_quoted_line = None;
@@ -188,36 +188,30 @@ fn remove_bottom_quote<'a>(lines: &'a [&str]) -> (&'a [&'a str], Option<String>)
         }
     }
     if let Some(mut l_last) = last_quoted_line {
-        let quoted_text = lines
+        let quoted_text = lines[l_last..first_quoted_line]
             .iter()
-            .take(first_quoted_line)
-            .skip(l_last)
             .map(|s| {
                 s.strip_prefix('>')
                     .map_or(*s, |u| u.strip_prefix(' ').unwrap_or(u))
             })
             .collect::<Vec<&str>>()
             .join("\n");
-        if l_last > 1 {
-            if let Some(line) = lines.get(l_last - 1) {
-                if is_empty_line(line) {
-                    l_last -= 1
-                }
-            }
+        if l_last > 1 && is_empty_line(lines[l_last - 1]) {
+            l_last -= 1
         }
         if l_last > 1 {
-            if let Some(line) = lines.get(l_last - 1) {
-                if is_quoted_headline(line) {
-                    l_last -= 1
-                }
+            let line = lines[l_last - 1];
+            if is_quoted_headline(line) {
+                l_last -= 1
             }
         }
-        (lines.get(..l_last).unwrap_or(lines), Some(quoted_text))
+        (&lines[..l_last], Some(quoted_text))
     } else {
         (lines, None)
     }
 }
 
+#[allow(clippy::indexing_slicing)]
 fn remove_top_quote<'a>(
     lines: &'a [&str],
     is_chat_message: bool,
@@ -244,12 +238,10 @@ fn remove_top_quote<'a>(
     }
     if let Some(last_quoted_line) = last_quoted_line {
         (
-            lines.get(last_quoted_line + 1..).unwrap_or(lines),
+            &lines[last_quoted_line + 1..],
             Some(
-                lines
+                lines[first_quoted_line..last_quoted_line + 1]
                     .iter()
-                    .take(last_quoted_line + 1)
-                    .skip(first_quoted_line)
                     .map(|s| {
                         s.strip_prefix('>')
                             .map_or(*s, |u| u.strip_prefix(' ').unwrap_or(u))

src/smtp.rs

@@ -244,27 +244,32 @@ pub(crate) async fn smtp_send(
                 async_smtp::error::Error::Transient(ref response) => {
                     // We got a transient 4xx response from SMTP server.
                     // Give some time until the server-side error maybe goes away.
-                    //
-                    // One particular case is
-                    // `450 4.1.2 <alice@example.org>: Recipient address rejected: Domain not found`.
-                    // known to be returned by Postfix.
-                    //
-                    // [RFC 3463](https://tools.ietf.org/html/rfc3463#section-3.2)
-                    // says "This code is only useful for permanent failures."
-                    // in X.1.1, X.1.2 and X.1.3 descriptions.
-                    //
-                    // Previous Delta Chat core versions
-                    // from 1.51.0 to 1.151.1
-                    // were treating such errors as permanent.
-                    //
-                    // This was later reverted because such errors were observed
-                    // for existing domains and turned out to be actually transient,
-                    // likely caused by nameserver downtime.
-                    info!(
-                        context,
-                        "Transient error {response:?}, postponing retry for later."
-                    );
-                    SendResult::Retry
+
+                    if let Some(first_word) = response.first_word() {
+                        if first_word.ends_with(".1.1")
+                            || first_word.ends_with(".1.2")
+                            || first_word.ends_with(".1.3")
+                        {
+                            // Sometimes we receive transient errors that should be permanent.
+                            // Any extended smtp status codes like x.1.1, x.1.2 or x.1.3 that we
+                            // receive as a transient error are misconfigurations of the smtp server.
+                            // See <https://tools.ietf.org/html/rfc3463#section-3.2>
+                            info!(context, "Received extended status code {first_word} for a transient error. This looks like a misconfigured SMTP server, let's fail immediately.");
+                            SendResult::Failure(format_err!("Permanent SMTP error: {}", err))
+                        } else {
+                            info!(
+                                context,
+                                "Transient error with status code {first_word}, postponing retry for later."
+                            );
+                            SendResult::Retry
+                        }
+                    } else {
+                        info!(
+                            context,
+                            "Transient error without status code, postponing retry for later."
+                        );
+                        SendResult::Retry
+                    }
                 }
                 _ => {
                     info!(

src/sql.rs

@@ -887,11 +887,13 @@ pub async fn remove_unused_files(context: &Context) -> Result<()> {
                         }
                         unreferenced_count += 1;
                         let recently_created =
-                            stats.created().is_ok_and(|t| t > keep_files_newer_than);
-                        let recently_modified =
-                            stats.modified().is_ok_and(|t| t > keep_files_newer_than);
-                        let recently_accessed =
-                            stats.accessed().is_ok_and(|t| t > keep_files_newer_than);
+                            stats.created().map_or(false, |t| t > keep_files_newer_than);
+                        let recently_modified = stats
+                            .modified()
+                            .map_or(false, |t| t > keep_files_newer_than);
+                        let recently_accessed = stats
+                            .accessed()
+                            .map_or(false, |t| t > keep_files_newer_than);
 
                         if p == blobdir
                             && (recently_created || recently_modified || recently_accessed)
@@ -940,12 +942,15 @@ pub async fn remove_unused_files(context: &Context) -> Result<()> {
     Ok(())
 }
 
+#[allow(clippy::indexing_slicing)]
 fn is_file_in_use(files_in_use: &HashSet<String>, namespc_opt: Option<&str>, name: &str) -> bool {
     let name_to_check = if let Some(namespc) = namespc_opt {
-        let Some(name) = name.strip_suffix(namespc) else {
+        let name_len = name.len();
+        let namespc_len = namespc.len();
+        if name_len <= namespc_len || !name.ends_with(namespc) {
             return false;
-        };
-        name
+        }
+        &name[..name_len - namespc_len]
     } else {
         name
     };

src/sql/migrations.rs

@@ -1070,24 +1070,6 @@ CREATE INDEX msgs_status_updates_index2 ON msgs_status_updates (uid);
         .await?;
     }
 
-    inc_and_check(&mut migration_version, 124)?;
-    if dbversion < migration_version {
-        // Mark Saved Messages chat as protected if it already exists.
-        sql.execute_migration(
-            "UPDATE chats
-             SET protected=1 -- ProtectionStatus::Protected
-             WHERE type==100 -- Chattype::Single
-             AND EXISTS (
-                 SELECT 1 FROM chats_contacts cc
-                 WHERE cc.chat_id==chats.id
-                 AND cc.contact_id=1
-             )
-             ",
-            migration_version,
-        )
-        .await?;
-    }
-
     let new_version = sql
         .get_raw_config_int(VERSION_CFG)
         .await?

src/sql/pool.rs

@@ -83,7 +83,7 @@ impl InnerPool {
     /// Retrieves a connection from the pool.
     ///
     /// Sets `query_only` pragma to the provided value
-    /// to prevent accidental misuse of connection
+    /// to prevent accidentaly misuse of connection
     /// for writing when reading is intended.
     /// Only pass `query_only=false` if you want
     /// to use the connection for writing.

src/stock_str.rs

@@ -541,7 +541,7 @@ impl ContactId {
             .unwrap_or_else(|_| self.to_string())
     }
 
-    /// Get contact name, e.g. `Bob`, or `bob@example.net` if no name is set.
+    /// Get contact name, e.g. `Bob`, or `bob@exmple.net` if no name is set.
     async fn get_stock_name(self, context: &Context) -> String {
         Contact::get_by_id(context, self)
             .await

src/summary.rs

@@ -289,7 +289,7 @@ mod tests {
     use super::*;
     use crate::chat::ChatId;
     use crate::param::Param;
-    use crate::test_utils::TestContext;
+    use crate::test_utils as test;
 
     async fn assert_summary_texts(msg: &Message, ctx: &Context, expected: &str) {
         assert_eq!(msg.get_summary_text(ctx).await, expected);
@@ -298,7 +298,7 @@ mod tests {
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_get_summary_text() {
-        let d = TestContext::new_alice().await;
+        let d = test::TestContext::new().await;
         let ctx = &d.ctx;
         let chat_id = ChatId::create_for_contact(ctx, ContactId::SELF)
             .await