Generate rfc724_mid when creating Message

CHANGELOG.md

@@ -1,40 +1,5 @@
 # Changelog
 
-## [1.157.3] - 2025-03-19
-
-### API-Changes
-
-- jsonrpc: Add `copy_to_blob_dir` api ([#6660](https://github.com/chatmail/core/pull/6660)).
-- Add "delete_for_all" function in json-rpc ([#6672](https://github.com/chatmail/core/pull/6672)).
-- Sketch add_transport_from_qr(), add_transport(), list_transports(), delete_transport() APIs ([#6589](https://github.com/chatmail/core/pull/6589)).
-
-### Build system
-
-- Remove websocket support from deltachat-jsonrpc.
-- Remove encoded-words dependency.
-
-### Fixes
-
-- Never send empty `To:` header ([#6663](https://github.com/chatmail/core/pull/6663)).
-- Use protected `Date` header for signed messages.
-- Fix setting up a profile and immediately transferring to a second device ([#6657](https://github.com/chatmail/core/pull/6657)).
-- Don't SMTP-send self-only messages if DeleteServerAfter is "immediate" ([#6661](https://github.com/chatmail/core/pull/6661)).
-- Use protected `Date` with protected Autocrypt.
-
-### Miscellaneous Tasks
-
-- cargo: Bump uuid from 1.12.1 to 1.15.1.
-- Update `strum` dependency.
-
-### Refactor
-
-- deltachat-rpc-client: Use wait_for_event() type argument.
-
-### Tests
-
-- Avoid creating contacts in `test_sync_{accept,block}_before_first_msg()`.
-- Fix `test_no_old_msg_is_fresh` flakiness.
-
 ## [1.157.2] - 2025-03-15
 
 ### Fixes
@@ -6050,4 +6015,3 @@ https://github.com/chatmail/core/pulls?q=is%3Apr+is%3Aclosed
 [1.157.0]: https://github.com/chatmail/core/compare/v1.156.3..v1.157.0
 [1.157.1]: https://github.com/chatmail/core/compare/v1.157.0..v1.157.1
 [1.157.2]: https://github.com/chatmail/core/compare/v1.157.1..v1.157.2
-[1.157.3]: https://github.com/chatmail/core/compare/v1.157.2..v1.157.3

Cargo.lock

@@ -1266,7 +1266,7 @@ dependencies = [
 
 [[package]]
 name = "deltachat"
-version = "1.157.3"
+version = "1.157.2"
 dependencies = [
  "anyhow",
  "async-broadcast",
@@ -1377,7 +1377,7 @@ dependencies = [
 
 [[package]]
 name = "deltachat-jsonrpc"
-version = "1.157.3"
+version = "1.157.2"
 dependencies = [
  "anyhow",
  "async-channel 2.3.1",
@@ -1400,7 +1400,7 @@ dependencies = [
 
 [[package]]
 name = "deltachat-repl"
-version = "1.157.3"
+version = "1.157.2"
 dependencies = [
  "anyhow",
  "deltachat",
@@ -1416,7 +1416,7 @@ dependencies = [
 
 [[package]]
 name = "deltachat-rpc-server"
-version = "1.157.3"
+version = "1.157.2"
 dependencies = [
  "anyhow",
  "deltachat",
@@ -1445,7 +1445,7 @@ dependencies = [
 
 [[package]]
 name = "deltachat_ffi"
-version = "1.157.3"
+version = "1.157.2"
 dependencies = [
  "anyhow",
  "deltachat",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "deltachat"
-version = "1.157.3"
+version = "1.157.2"
 edition = "2021"
 license = "MPL-2.0"
 rust-version = "1.81"

deltachat-ffi/Cargo.toml

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

deltachat-jsonrpc/Cargo.toml

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

deltachat-jsonrpc/src/api.rs

@@ -39,8 +39,6 @@ use deltachat::{imex, info};
 use sanitize_filename::is_sanitized;
 use tokio::fs;
 use tokio::sync::{watch, Mutex, RwLock};
-use types::basic_message::{BasicMessageLoadResult, BasicMessageObject};
-use types::login_param::EnteredLoginParam;
 use walkdir::WalkDir;
 use yerpc::rpc;
 
@@ -350,8 +348,8 @@ impl CommandApi {
         Ok(ctx.get_blobdir().to_str().map(|s| s.to_owned()))
     }
 
-    /// Copy file to blob dir.
-    async fn copy_to_blob_dir(&self, account_id: u32, path: String) -> Result<PathBuf> {
+    /// Copy file to blobdir.
+    async fn copy_to_blobdir(&self, account_id: u32, path: String) -> Result<PathBuf> {
         let ctx = self.get_context(account_id).await?;
         let file = Path::new(&path);
         Ok(BlobObject::create_and_deduplicate(&ctx, file, file)?.to_abs_path())
@@ -433,9 +431,6 @@ impl CommandApi {
 
     /// Configures this account with the currently set parameters.
     /// Setup the credential config before calling this.
-    ///
-    /// Deprecated as of 2025-02; use `add_transport_from_qr()`
-    /// or `add_transport()` instead.
     async fn configure(&self, account_id: u32) -> Result<()> {
         let ctx = self.get_context(account_id).await?;
         ctx.stop_io().await;
@@ -450,69 +445,6 @@ impl CommandApi {
         Ok(())
     }
 
-    /// Configures a new email account using the provided parameters
-    /// and adds it as a transport.
-    ///
-    /// If the email address is the same as an existing transport,
-    /// then this existing account will be reconfigured instead of a new one being added.
-    ///
-    /// This function stops and starts IO as needed.
-    ///
-    /// Usually it will be enough to only set `addr` and `imap.password`,
-    /// and all the other settings will be autoconfigured.
-    ///
-    /// During configuration, ConfigureProgress events are emitted;
-    /// they indicate a successful configuration as well as errors
-    /// and may be used to create a progress bar.
-    /// This function will return after configuration is finished.
-    ///
-    /// If configuration is successful,
-    /// the working server parameters will be saved
-    /// and used for connecting to the server.
-    /// The parameters entered by the user will be saved separately
-    /// so that they can be prefilled when the user opens the server-configuration screen again.
-    ///
-    /// See also:
-    /// - [Self::is_configured()] to check whether there is
-    ///   at least one working transport.
-    /// - [Self::add_transport_from_qr()] to add a transport
-    ///   from a server encoded in a QR code.
-    /// - [Self::list_transports()] to get a list of all configured transports.
-    /// - [Self::delete_transport()] to remove a transport.
-    async fn add_transport(&self, account_id: u32, param: EnteredLoginParam) -> Result<()> {
-        let ctx = self.get_context(account_id).await?;
-        ctx.add_transport(&param.try_into()?).await
-    }
-
-    /// Adds a new email account as a transport
-    /// using the server encoded in the QR code.
-    /// See [Self::add_transport].
-    async fn add_transport_from_qr(&self, account_id: u32, qr: String) -> Result<()> {
-        let ctx = self.get_context(account_id).await?;
-        ctx.add_transport_from_qr(&qr).await
-    }
-
-    /// Returns the list of all email accounts that are used as a transport in the current profile.
-    /// Use [Self::add_transport()] to add or change a transport
-    /// and [Self::delete_transport()] to delete a transport.
-    async fn list_transports(&self, account_id: u32) -> Result<Vec<EnteredLoginParam>> {
-        let ctx = self.get_context(account_id).await?;
-        let res = ctx
-            .list_transports()
-            .await?
-            .into_iter()
-            .map(|t| t.into())
-            .collect();
-        Ok(res)
-    }
-
-    /// Removes the transport with the specified email address
-    /// (i.e. [EnteredLoginParam::addr]).
-    async fn delete_transport(&self, account_id: u32, addr: String) -> Result<()> {
-        let ctx = self.get_context(account_id).await?;
-        ctx.delete_transport(&addr).await
-    }
-
     /// Signal an ongoing process to stop.
     async fn stop_ongoing_process(&self, account_id: u32) -> Result<()> {
         let ctx = self.get_context(account_id).await?;
@@ -1267,48 +1199,6 @@ impl CommandApi {
         Ok(messages)
     }
 
-    async fn basic_get_message(&self, account_id: u32, msg_id: u32) -> Result<BasicMessageObject> {
-        let ctx = self.get_context(account_id).await?;
-        let msg_id = MsgId::new(msg_id);
-        let message_object = BasicMessageObject::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)
-    }
-
-    /// get multiple messages in one call (but only basic properties)
-    /// 
-    /// This is for optimized performance, the result of [get_messages] is more complete, but is more expensive.
-    /// 
-    /// if loading one message fails the error is stored in the result object in it's place.
-    /// 
-    /// this is the batch variant of [basic_get_message]
-    async fn basic_get_messages(
-        &self,
-        account_id: u32,
-        message_ids: Vec<u32>,
-    ) -> Result<HashMap<u32, BasicMessageLoadResult>> {
-        let ctx = self.get_context(account_id).await?;
-        let mut messages: HashMap<u32, BasicMessageLoadResult> = HashMap::new();
-        for message_id in message_ids {
-            let message_result = BasicMessageObject::from_msg_id(&ctx, MsgId::new(message_id)).await;
-            messages.insert(
-                message_id,
-                match message_result {
-                    Ok(Some(message)) => BasicMessageLoadResult::Message(message),
-                    Ok(None) => BasicMessageLoadResult::LoadingError {
-                        error: "Message does not exist".to_string(),
-                    },
-                    Err(error) => BasicMessageLoadResult::LoadingError {
-                        error: format!("{error:#}"),
-                    },
-                },
-            );
-        }
-        Ok(messages)
-    }
-
     /// Fetch info desktop needs for creating a notification for a message
     async fn get_message_notification_info(
         &self,

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

@@ -1,166 +0,0 @@
-use anyhow::{Context as _, Result};
-
-use deltachat::context::Context;
-use deltachat::message::Message;
-use deltachat::message::MsgId;
-use num_traits::cast::ToPrimitive;
-use serde::Serialize;
-use typescript_type_def::TypeDef;
-
-use super::message::DownloadState;
-use super::message::MessageViewtype;
-use super::message::SystemMessageType;
-
-#[derive(Serialize, TypeDef, schemars::JsonSchema)]
-#[serde(rename_all = "camelCase", tag = "kind")]
-pub enum BasicMessageLoadResult {
-    Message(BasicMessageObject),
-    LoadingError { error: String },
-}
-
-/// Message that only has basic properties that doen't require additional db calls
-#[derive(Serialize, TypeDef, schemars::JsonSchema)]
-#[serde(rename = "BasicMessage", rename_all = "camelCase")]
-pub struct BasicMessageObject {
-    id: u32,
-    chat_id: u32,
-    from_id: u32,
-
-    text: String,
-
-    is_edited: bool,
-
-    /// Check if a message has a POI location bound to it.
-    /// These locations are also returned by `get_locations` method.
-    /// The UI may decide to display a special icon beside such messages.
-    has_location: bool,
-    has_html: bool,
-    view_type: MessageViewtype,
-    state: u32,
-
-    /// An error text, if there is one.
-    error: Option<String>,
-
-    timestamp: i64,
-    sort_timestamp: i64,
-    received_timestamp: i64,
-    has_deviating_timestamp: bool,
-
-    // summary - use/create another function if you need it
-    subject: String,
-    show_padlock: bool,
-    is_setupmessage: bool,
-    is_info: bool,
-    is_forwarded: bool,
-
-    /// True if the message was sent by a bot.
-    is_bot: bool,
-
-    /// when is_info is true this describes what type of system message it is
-    system_message_type: SystemMessageType,
-
-    duration: i32,
-    dimensions_height: i32,
-    dimensions_width: i32,
-
-    videochat_type: Option<u32>,
-    videochat_url: Option<String>,
-
-    override_sender_name: Option<String>,
-
-    setup_code_begin: Option<String>,
-
-    file: Option<String>,
-    file_mime: Option<String>,
-    file_name: Option<String>,
-
-    webxdc_href: Option<String>,
-
-    download_state: DownloadState,
-
-    original_msg_id: Option<u32>,
-
-    saved_message_id: Option<u32>,
-}
-
-impl BasicMessageObject {
-    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);
-        };
-
-        let override_sender_name = message.get_override_sender_name();
-
-        let download_state = message.download_state().into();
-
-        let message_object = Self {
-            id: msg_id.to_u32(),
-            chat_id: message.get_chat_id().to_u32(),
-            from_id: message.get_from_id().to_u32(),
-            text: message.get_text(),
-            is_edited: message.is_edited(),
-            has_location: message.has_location(),
-            has_html: message.has_html(),
-            view_type: message.get_viewtype().into(),
-            state: message
-                .get_state()
-                .to_u32()
-                .context("state conversion to number failed")?,
-            error: message.error(),
-
-            timestamp: message.get_timestamp(),
-            sort_timestamp: message.get_sort_timestamp(),
-            received_timestamp: message.get_received_timestamp(),
-            has_deviating_timestamp: message.has_deviating_timestamp(),
-
-            subject: message.get_subject().to_owned(),
-            show_padlock: message.get_showpadlock(),
-            is_setupmessage: message.is_setupmessage(),
-            is_info: message.is_info(),
-            is_forwarded: message.is_forwarded(),
-            is_bot: message.is_bot(),
-            system_message_type: message.get_info_type().into(),
-
-            duration: message.get_duration(),
-            dimensions_height: message.get_height(),
-            dimensions_width: message.get_width(),
-
-            videochat_type: match message.get_videochat_type() {
-                Some(vct) => Some(
-                    vct.to_u32()
-                        .context("videochat type conversion to number failed")?,
-                ),
-                None => None,
-            },
-            videochat_url: message.get_videochat_url(),
-
-            override_sender_name,
-
-            setup_code_begin: message.get_setupcodebegin(context).await,
-
-            file: match message.get_file(context) {
-                Some(path_buf) => path_buf.to_str().map(|s| s.to_owned()),
-                None => None,
-            }, //BLOBS
-            file_mime: message.get_filemime(),
-            file_name: message.get_filename(),
-
-            // 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,
-
-            original_msg_id: message
-                .get_original_msg_id(context)
-                .await?
-                .map(|id| id.to_u32()),
-
-            saved_message_id: message
-                .get_saved_msg_id(context)
-                .await?
-                .map(|id| id.to_u32()),
-        };
-        Ok(Some(message_object))
-    }
-}

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

@@ -1,179 +0,0 @@
-use anyhow::Result;
-use deltachat::login_param as dc;
-use serde::Deserialize;
-use serde::Serialize;
-use yerpc::TypeDef;
-
-#[derive(Serialize, Deserialize, TypeDef, schemars::JsonSchema)]
-#[serde(rename_all = "camelCase")]
-pub struct EnteredServerLoginParam {
-    /// Server hostname or IP address.
-    pub server: String,
-
-    /// Server port.
-    ///
-    /// 0 if not specified.
-    pub port: u16,
-
-    /// Socket security.
-    pub security: Socket,
-
-    /// Username.
-    ///
-    /// Empty string if not specified.
-    pub user: String,
-
-    /// Password.
-    pub password: String,
-}
-
-impl From<dc::EnteredServerLoginParam> for EnteredServerLoginParam {
-    fn from(param: dc::EnteredServerLoginParam) -> Self {
-        Self {
-            server: param.server,
-            port: param.port,
-            security: param.security.into(),
-            user: param.user,
-            password: param.password,
-        }
-    }
-}
-
-impl From<EnteredServerLoginParam> for dc::EnteredServerLoginParam {
-    fn from(param: EnteredServerLoginParam) -> Self {
-        Self {
-            server: param.server,
-            port: param.port,
-            security: param.security.into(),
-            user: param.user,
-            password: param.password,
-        }
-    }
-}
-
-/// Login parameters entered by the user.
-
-#[derive(Serialize, Deserialize, TypeDef, schemars::JsonSchema)]
-#[serde(rename_all = "camelCase")]
-pub struct EnteredLoginParam {
-    /// Email address.
-    pub addr: String,
-
-    /// IMAP settings.
-    pub imap: EnteredServerLoginParam,
-
-    /// SMTP settings.
-    pub smtp: EnteredServerLoginParam,
-
-    /// TLS options: whether to allow invalid certificates and/or
-    /// invalid hostnames
-    pub certificate_checks: EnteredCertificateChecks,
-
-    /// If true, login via OAUTH2 (not recommended anymore)
-    pub oauth2: bool,
-}
-
-impl From<dc::EnteredLoginParam> for EnteredLoginParam {
-    fn from(param: dc::EnteredLoginParam) -> Self {
-        Self {
-            addr: param.addr,
-            imap: param.imap.into(),
-            smtp: param.smtp.into(),
-            certificate_checks: param.certificate_checks.into(),
-            oauth2: param.oauth2,
-        }
-    }
-}
-
-impl TryFrom<EnteredLoginParam> for dc::EnteredLoginParam {
-    type Error = anyhow::Error;
-
-    fn try_from(param: EnteredLoginParam) -> Result<Self> {
-        Ok(Self {
-            addr: param.addr,
-            imap: param.imap.into(),
-            smtp: param.smtp.into(),
-            certificate_checks: param.certificate_checks.into(),
-            oauth2: param.oauth2,
-        })
-    }
-}
-
-#[derive(Serialize, Deserialize, TypeDef, schemars::JsonSchema)]
-#[serde(rename_all = "camelCase")]
-pub enum Socket {
-    /// Unspecified socket security, select automatically.
-    Automatic,
-
-    /// TLS connection.
-    Ssl,
-
-    /// STARTTLS connection.
-    Starttls,
-
-    /// No TLS, plaintext connection.
-    Plain,
-}
-
-impl From<dc::Socket> for Socket {
-    fn from(value: dc::Socket) -> Self {
-        match value {
-            dc::Socket::Automatic => Self::Automatic,
-            dc::Socket::Ssl => Self::Ssl,
-            dc::Socket::Starttls => Self::Starttls,
-            dc::Socket::Plain => Self::Plain,
-        }
-    }
-}
-
-impl From<Socket> for dc::Socket {
-    fn from(value: Socket) -> Self {
-        match value {
-            Socket::Automatic => Self::Automatic,
-            Socket::Ssl => Self::Ssl,
-            Socket::Starttls => Self::Starttls,
-            Socket::Plain => Self::Plain,
-        }
-    }
-}
-
-#[derive(Serialize, Deserialize, TypeDef, schemars::JsonSchema)]
-#[serde(rename_all = "camelCase")]
-pub enum EnteredCertificateChecks {
-    /// `Automatic` means that provider database setting should be taken.
-    /// If there is no provider database setting for certificate checks,
-    /// check certificates strictly.
-    Automatic,
-
-    /// Ensure that TLS certificate is valid for the server hostname.
-    Strict,
-
-    /// Accept certificates that are expired, self-signed
-    /// or otherwise not valid for the server hostname.
-    AcceptInvalidCertificates,
-}
-
-impl From<dc::EnteredCertificateChecks> for EnteredCertificateChecks {
-    fn from(value: dc::EnteredCertificateChecks) -> Self {
-        match value {
-            dc::EnteredCertificateChecks::Automatic => Self::Automatic,
-            dc::EnteredCertificateChecks::Strict => Self::Strict,
-            dc::EnteredCertificateChecks::AcceptInvalidCertificates => {
-                Self::AcceptInvalidCertificates
-            }
-            dc::EnteredCertificateChecks::AcceptInvalidCertificates2 => {
-                Self::AcceptInvalidCertificates
-            }
-        }
-    }
-}
-
-impl From<EnteredCertificateChecks> for dc::EnteredCertificateChecks {
-    fn from(value: EnteredCertificateChecks) -> Self {
-        match value {
-            EnteredCertificateChecks::Automatic => Self::Automatic,
-            EnteredCertificateChecks::Strict => Self::Strict,
-            EnteredCertificateChecks::AcceptInvalidCertificates => Self::AcceptInvalidCertificates,
-        }
-    }
-}

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

@@ -1,12 +1,10 @@
 pub mod account;
-pub mod basic_message;
 pub mod chat;
 pub mod chat_list;
 pub mod contact;
 pub mod events;
 pub mod http;
 pub mod location;
-pub mod login_param;
 pub mod message;
 pub mod provider_info;
 pub mod qr;

deltachat-jsonrpc/typescript/package.json

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

deltachat-repl/Cargo.toml

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

deltachat-rpc-client/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "deltachat-rpc-client"
-version = "1.157.3"
+version = "1.157.2"
 description = "Python client for Delta Chat core JSON-RPC interface"
 classifiers = [
     "Development Status :: 5 - Production/Stable",

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

@@ -1,6 +1,8 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
+from pathlib import Path
+from tempfile import TemporaryDirectory
 from typing import TYPE_CHECKING, Optional, Union
 from warnings import warn
 
@@ -26,12 +28,9 @@ class Account:
     def _rpc(self) -> "Rpc":
         return self.manager.rpc
 
-    def wait_for_event(self, event_type=None) -> AttrDict:
+    def wait_for_event(self) -> AttrDict:
         """Wait until the next event and return it."""
-        while True:
-            next_event = AttrDict(self._rpc.wait_for_event(self.id))
-            if event_type is None or next_event.kind == event_type:
-                return next_event
+        return AttrDict(self._rpc.wait_for_event(self.id))
 
     def clear_all_events(self):
         """Removes all queued-up events for a given account. Useful for tests."""
@@ -42,14 +41,14 @@ class Account:
         self._rpc.remove_account(self.id)
 
     def clone(self) -> "Account":
-        """Clone given account.
-        This uses backup-transfer via iroh, i.e. the 'Add second device' feature."""
-        future = self._rpc.provide_backup.future(self.id)
-        qr = self._rpc.get_backup_qr(self.id)
-        new_account = self.manager.add_account()
-        new_account._rpc.get_backup(new_account.id, qr)
-        future()
-        return new_account
+        """Clone given account."""
+        with TemporaryDirectory() as tmp_dir:
+            tmp_path = Path(tmp_dir)
+            self.export_backup(tmp_path)
+            files = list(tmp_path.glob("*.tar"))
+            new_account = self.manager.add_account()
+            new_account.import_backup(files[0])
+            return new_account
 
     def start_io(self) -> None:
         """Start the account I/O."""
@@ -113,7 +112,10 @@ class Account:
     def bring_online(self):
         """Start I/O and wait until IMAP becomes IDLE."""
         self.start_io()
-        self.wait_for_event(EventType.IMAP_INBOX_IDLE)
+        while True:
+            event = self.wait_for_event()
+            if event.kind == EventType.IMAP_INBOX_IDLE:
+                break
 
     def create_contact(self, obj: Union[int, str, Contact], name: Optional[str] = None) -> Contact:
         """Create a new Contact or return an existing one.
@@ -332,15 +334,24 @@ class Account:
 
     def wait_for_incoming_msg_event(self):
         """Wait for incoming message event and return it."""
-        return self.wait_for_event(EventType.INCOMING_MSG)
+        while True:
+            event = self.wait_for_event()
+            if event.kind == EventType.INCOMING_MSG:
+                return event
 
     def wait_for_msgs_changed_event(self):
         """Wait for messages changed event and return it."""
-        return self.wait_for_event(EventType.MSGS_CHANGED)
+        while True:
+            event = self.wait_for_event()
+            if event.kind == EventType.MSGS_CHANGED:
+                return event
 
     def wait_for_msgs_noticed_event(self):
         """Wait for messages noticed event and return it."""
-        return self.wait_for_event(EventType.MSGS_NOTICED)
+        while True:
+            event = self.wait_for_event()
+            if event.kind == EventType.MSGS_NOTICED:
+                return event
 
     def wait_for_incoming_msg(self):
         """Wait for incoming message and return it.
@@ -361,7 +372,10 @@ class Account:
                 break
 
     def wait_for_reactions_changed(self):
-        return self.wait_for_event(EventType.REACTIONS_CHANGED)
+        while True:
+            event = self.wait_for_event()
+            if event.kind == EventType.REACTIONS_CHANGED:
+                return event
 
     def get_fresh_messages_in_arrival_order(self) -> list[Message]:
         """Return fresh messages list sorted in the order of their arrival, with ascending IDs."""

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

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

deltachat-rpc-client/tests/test_iroh_webxdc.py

@@ -175,11 +175,17 @@ def test_no_duplicate_messages(acfactory, path_to_webxdc):
 
     threading.Thread(target=thread_run, daemon=True).start()
 
-    event = ac2.wait_for_event(EventType.WEBXDC_REALTIME_DATA)
-    n = int(bytes(event.data).decode())
+    while 1:
+        event = ac2.wait_for_event()
+        if event.kind == EventType.WEBXDC_REALTIME_DATA:
+            n = int(bytes(event.data).decode())
+            break
 
-    event = ac2.wait_for_event(EventType.WEBXDC_REALTIME_DATA)
-    assert int(bytes(event.data).decode()) > n
+    while 1:
+        event = ac2.wait_for_event()
+        if event.kind == EventType.WEBXDC_REALTIME_DATA:
+            assert int(bytes(event.data).decode()) > n
+            break
 
 
 def test_no_reordering(acfactory, path_to_webxdc):
@@ -223,5 +229,8 @@ def test_advertisement_after_chatting(acfactory, path_to_webxdc):
     ac2_hello_msg_snapshot.chat.accept()
 
     ac2_webxdc_msg.send_webxdc_realtime_advertisement()
-    event = ac1.wait_for_event(EventType.WEBXDC_REALTIME_ADVERTISEMENT_RECEIVED)
-    assert event.msg_id == ac1_webxdc_msg.id
+    while 1:
+        event = ac1.wait_for_event()
+        if event.kind == EventType.WEBXDC_REALTIME_ADVERTISEMENT_RECEIVED:
+            assert event.msg_id == ac1_webxdc_msg.id
+            break

deltachat-rpc-client/tests/test_key_transfer.py

@@ -21,7 +21,6 @@ def test_autocrypt_setup_message_key_transfer(acfactory):
     alice2.set_config("addr", alice1.get_config("addr"))
     alice2.set_config("mail_pw", alice1.get_config("mail_pw"))
     alice2.configure()
-    alice2.bring_online()
 
     setup_code = alice1.initiate_autocrypt_key_transfer()
     msg = wait_for_autocrypt_setup_message(alice2)
@@ -35,12 +34,10 @@ def test_autocrypt_setup_message_key_transfer(acfactory):
 
 def test_ac_setup_message_twice(acfactory):
     alice1 = acfactory.get_online_account()
-
     alice2 = acfactory.get_unconfigured_account()
     alice2.set_config("addr", alice1.get_config("addr"))
     alice2.set_config("mail_pw", alice1.get_config("mail_pw"))
     alice2.configure()
-    alice2.bring_online()
 
     # Send the first Autocrypt Setup Message and ignore it.
     _setup_code = alice1.initiate_autocrypt_key_transfer()

deltachat-rpc-client/tests/test_securejoin.py

@@ -76,11 +76,17 @@ def test_qr_securejoin(acfactory, protect):
     bob.secure_join(qr_code)
 
     # Alice deletes "vg-request".
-    alice.wait_for_event(EventType.IMAP_MESSAGE_DELETED)
+    while True:
+        event = alice.wait_for_event()
+        if event["kind"] == "ImapMessageDeleted":
+            break
     alice.wait_for_securejoin_inviter_success()
     # Bob deletes "vg-auth-required", Alice deletes "vg-request-with-auth".
     for ac in [alice, bob]:
-        ac.wait_for_event(EventType.IMAP_MESSAGE_DELETED)
+        while True:
+            event = ac.wait_for_event()
+            if event["kind"] == "ImapMessageDeleted":
+                break
     bob.wait_for_securejoin_joiner_success()
 
     # Test that Alice verified Bob's profile.
@@ -457,7 +463,6 @@ def test_qr_new_group_unblocked(acfactory):
     assert ac2_msg.chat.get_basic_snapshot().is_contact_request
 
 
-@pytest.mark.skip(reason="AEAP is disabled for now")
 def test_aeap_flow_verified(acfactory):
     """Test that a new address is added to a contact when it changes its address."""
     ac1, ac2 = acfactory.get_online_accounts(2)

deltachat-rpc-client/tests/test_something.py

@@ -110,9 +110,12 @@ def test_account(acfactory) -> None:
     alice_chat_bob = alice_contact_bob.create_chat()
     alice_chat_bob.send_text("Hello!")
 
-    event = bob.wait_for_incoming_msg_event()
-    chat_id = event.chat_id
-    msg_id = event.msg_id
+    while True:
+        event = bob.wait_for_event()
+        if event.kind == EventType.INCOMING_MSG:
+            chat_id = event.chat_id
+            msg_id = event.msg_id
+            break
 
     message = bob.get_message_by_id(msg_id)
     snapshot = message.get_snapshot()
@@ -284,31 +287,6 @@ def test_message(acfactory) -> None:
     assert reactions == snapshot.reactions
 
 
-def test_selfavatar_sync(acfactory, data, log) -> None:
-    alice = acfactory.get_online_account()
-
-    log.section("Alice adds a second device")
-    alice2 = alice.clone()
-
-    log.section("Second device goes online")
-    alice2.start_io()
-
-    log.section("First device changes avatar")
-    image = data.get_path("image/avatar1000x1000.jpg")
-    alice.set_config("selfavatar", image)
-    avatar_config = alice.get_config("selfavatar")
-    avatar_hash = os.path.basename(avatar_config)
-    print("Info: avatar hash is ", avatar_hash)
-
-    log.section("First device receives avatar change")
-    alice2.wait_for_event(EventType.SELFAVATAR_CHANGED)
-    avatar_config2 = alice2.get_config("selfavatar")
-    avatar_hash2 = os.path.basename(avatar_config2)
-    print("Info: avatar hash on second device is ", avatar_hash2)
-    assert avatar_hash == avatar_hash2
-    assert avatar_config != avatar_config2
-
-
 def test_reaction_seen_on_another_dev(acfactory) -> None:
     alice, bob = acfactory.get_online_accounts(2)
     alice2 = alice.clone()
@@ -327,11 +305,18 @@ def test_reaction_seen_on_another_dev(acfactory) -> None:
     snapshot.chat.accept()
     message.send_reaction("😎")
     for a in [alice, alice2]:
-        a.wait_for_event(EventType.INCOMING_REACTION)
+        while True:
+            event = a.wait_for_event()
+            if event.kind == EventType.INCOMING_REACTION:
+                break
 
     alice2.clear_all_events()
     alice_chat_bob.mark_noticed()
-    chat_id = alice2.wait_for_event(EventType.MSGS_NOTICED).chat_id
+    while True:
+        event = alice2.wait_for_event()
+        if event.kind == EventType.MSGS_NOTICED:
+            chat_id = event.chat_id
+            break
     alice2_contact_bob = alice2.get_contact_by_addr(bob_addr)
     alice2_chat_bob = alice2_contact_bob.create_chat()
     assert chat_id == alice2_chat_bob.id
@@ -349,12 +334,16 @@ def test_is_bot(acfactory) -> None:
     alice.set_config("bot", "1")
     alice_chat_bob.send_text("Hello!")
 
-    event = bob.wait_for_incoming_msg_event()
-    message = bob.get_message_by_id(event.msg_id)
-    snapshot = message.get_snapshot()
-    assert snapshot.chat_id == event.chat_id
-    assert snapshot.text == "Hello!"
-    assert snapshot.is_bot
+    while True:
+        event = bob.wait_for_event()
+        if event.kind == EventType.INCOMING_MSG:
+            msg_id = event.msg_id
+            message = bob.get_message_by_id(msg_id)
+            snapshot = message.get_snapshot()
+            assert snapshot.chat_id == event.chat_id
+            assert snapshot.text == "Hello!"
+            assert snapshot.is_bot
+            break
 
 
 def test_bot(acfactory) -> None:
@@ -515,7 +504,10 @@ def test_mdn_doesnt_break_autocrypt(acfactory) -> None:
 
     # Alice reads Bob's message.
     message.mark_seen()
-    bob.wait_for_event(EventType.MSG_READ)
+    while True:
+        event = bob.wait_for_event()
+        if event.kind == EventType.MSG_READ:
+            break
 
     # Bob sends a message to Alice, it should also be encrypted.
     bob_chat_alice.send_text("Hi Alice!")
@@ -685,7 +677,10 @@ def test_markseen_contact_request(acfactory):
     assert message2.get_snapshot().state == MessageState.IN_FRESH
 
     message.mark_seen()
-    bob2.wait_for_event(EventType.MSGS_NOTICED)
+    while True:
+        event = bob2.wait_for_event()
+        if event.kind == EventType.MSGS_NOTICED:
+            break
     assert message2.get_snapshot().state == MessageState.IN_SEEN
 
 
@@ -733,7 +728,10 @@ def test_no_old_msg_is_fresh(acfactory):
     assert ac1.create_chat(ac2).get_fresh_message_count() == 1
     assert len(list(ac1.get_fresh_messages())) == 1
 
-    ac1.wait_for_event(EventType.IMAP_INBOX_IDLE)
+    while True:
+        event = ac1.wait_for_event()
+        if event.kind == EventType.IMAP_INBOX_IDLE:
+            break
 
     logging.info("Send a message from ac1_clone to ac2 and check that ac1 marks the first message as 'noticed'")
     ac1_clone_chat.send_text("Hi back")

deltachat-rpc-client/tests/test_webxdc.py

@@ -1,3 +1,6 @@
+from deltachat_rpc_client import EventType
+
+
 def test_webxdc(acfactory) -> None:
     alice, bob = acfactory.get_online_accounts(2)
 
@@ -6,9 +9,12 @@ def test_webxdc(acfactory) -> None:
     alice_chat_bob = alice_contact_bob.create_chat()
     alice_chat_bob.send_message(text="Let's play chess!", file="../test-data/webxdc/chess.xdc")
 
-    event = bob.wait_for_incoming_msg_event()
-    bob_chat_alice = bob.get_chat_by_id(event.chat_id)
-    message = bob.get_message_by_id(event.msg_id)
+    while True:
+        event = bob.wait_for_event()
+        if event.kind == EventType.INCOMING_MSG:
+            bob_chat_alice = bob.get_chat_by_id(event.chat_id)
+            message = bob.get_message_by_id(event.msg_id)
+            break
 
     webxdc_info = message.get_webxdc_info()
     assert webxdc_info == {

deltachat-rpc-server/Cargo.toml

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

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

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

python/pyproject.toml

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

release-date.in

@@ -1 +1 @@
-2025-03-19
+2025-03-15

src/chat.rs

@@ -2027,8 +2027,6 @@ impl Chat {
         let mut to_id = 0;
         let mut location_id = 0;
 
-        let new_rfc724_mid = create_outgoing_rfc724_mid();
-
         if self.typ == Chattype::Single {
             if let Some(id) = context
                 .sql
@@ -2123,7 +2121,7 @@ impl Chat {
             if references_vec.is_empty() {
                 // As a fallback, use our Message-ID,
                 // same as in the case of top-level message.
-                new_references = new_rfc724_mid.clone();
+                new_references = msg.rfc724_mid.clone();
             } else {
                 new_references = references_vec.join(" ");
             }
@@ -2133,8 +2131,9 @@ impl Chat {
             // This allows us to identify replies to our message even if
             // email server such as Outlook changes `Message-ID:` header.
             // MUAs usually keep the first Message-ID in `References:` header unchanged.
-            new_references = new_rfc724_mid.clone();
+            new_references = msg.rfc724_mid.clone();
         }
+        info!(context, "new references: {new_references:?}");
 
         // add independent location to database
         if msg.param.exists(Param::SetLatitude) {
@@ -2201,7 +2200,6 @@ impl Chat {
 
         msg.chat_id = self.id;
         msg.from_id = ContactId::SELF;
-        msg.rfc724_mid = new_rfc724_mid;
         msg.timestamp_sort = timestamp;
 
         // add message to the database
@@ -3029,10 +3027,10 @@ pub(crate) async fn create_send_msg_jobs(context: &Context, msg: &mut Message) -
     // disabled by default is fine.
     //
     // `from` must be the last addr, see `receive_imf_inner()` why.
-    recipients.retain(|x| x.to_lowercase() != lowercase_from);
-    if (context.get_config_bool(Config::BccSelf).await?
-        || msg.param.get_cmd() == SystemMessage::AutocryptSetupMessage)
-        && (context.get_config_delete_server_after().await? != Some(0) || !recipients.is_empty())
+    if context.get_config_bool(Config::BccSelf).await?
+        && !recipients
+            .iter()
+            .any(|x| x.to_lowercase() == lowercase_from)
     {
         recipients.push(from);
     }
@@ -4369,6 +4367,8 @@ pub async fn forward_msgs(context: &Context, msg_ids: &[MsgId], chat_id: ChatId)
         let new_msg_id = chat
             .prepare_msg_raw(context, &mut msg, None, curr_timestamp)
             .await?;
+
+        msg.rfc724_mid = create_outgoing_rfc724_mid();
         curr_timestamp += 1;
         if !create_send_msg_jobs(context, &mut msg).await?.is_empty() {
             context.scheduler.interrupt_smtp().await;

src/configure.rs

@@ -28,15 +28,13 @@ use crate::constants::NON_ALPHANUMERIC_WITHOUT_DOT;
 use crate::context::Context;
 use crate::imap::Imap;
 use crate::log::LogExt;
-pub use crate::login_param::EnteredLoginParam;
 use crate::login_param::{
     ConfiguredCertificateChecks, ConfiguredLoginParam, ConfiguredServerLoginParam,
-    ConnectionCandidate, EnteredCertificateChecks, ProxyConfig,
+    ConnectionCandidate, EnteredCertificateChecks, EnteredLoginParam,
 };
 use crate::message::Message;
 use crate::oauth2::get_oauth2_addr;
 use crate::provider::{Protocol, Socket, UsernamePattern};
-use crate::qr::set_account_from_qr;
 use crate::smtp::Smtp;
 use crate::sync::Sync::*;
 use crate::tools::time;
@@ -66,59 +64,8 @@ impl Context {
         self.sql.get_raw_config_bool("configured").await
     }
 
-    /// Configures this account with the currently provided parameters.
-    ///
-    /// Deprecated since 2025-02; use `add_transport_from_qr()`
-    /// or `add_transport()` instead.
+    /// Configures this account with the currently set parameters.
     pub async fn configure(&self) -> Result<()> {
-        let param = EnteredLoginParam::load(self).await?;
-
-        self.add_transport_inner(&param).await
-    }
-
-    /// Configures a new email account using the provided parameters
-    /// and adds it as a transport.
-    ///
-    /// If the email address is the same as an existing transport,
-    /// then this existing account will be reconfigured instead of a new one being added.
-    ///
-    /// This function stops and starts IO as needed.
-    ///
-    /// Usually it will be enough to only set `addr` and `imap.password`,
-    /// and all the other settings will be autoconfigured.
-    ///
-    /// During configuration, ConfigureProgress events are emitted;
-    /// they indicate a successful configuration as well as errors
-    /// and may be used to create a progress bar.
-    /// This function will return after configuration is finished.
-    ///
-    /// If configuration is successful,
-    /// the working server parameters will be saved
-    /// and used for connecting to the server.
-    /// The parameters entered by the user will be saved separately
-    /// so that they can be prefilled when the user opens the server-configuration screen again.
-    ///
-    /// See also:
-    /// - [Self::is_configured()] to check whether there is
-    ///   at least one working transport.
-    /// - [Self::add_transport_from_qr()] to add a transport
-    ///   from a server encoded in a QR code.
-    /// - [Self::list_transports()] to get a list of all configured transports.
-    /// - [Self::delete_transport()] to remove a transport.
-    pub async fn add_transport(&self, param: &EnteredLoginParam) -> Result<()> {
-        self.stop_io().await;
-        let result = self.add_transport_inner(param).await;
-        if result.is_err() {
-            if let Ok(true) = self.is_configured().await {
-                self.start_io().await;
-            }
-            return result;
-        }
-        self.start_io().await;
-        Ok(())
-    }
-
-    async fn add_transport_inner(&self, param: &EnteredLoginParam) -> Result<()> {
         ensure!(
             !self.scheduler.is_running().await,
             "cannot configure, already running"
@@ -127,63 +74,42 @@ impl Context {
             self.sql.is_open().await,
             "cannot configure, database not opened."
         );
-        let old_addr = self.get_config(Config::ConfiguredAddr).await?;
-        if self.is_configured().await? && !addr_cmp(&old_addr.unwrap_or_default(), &param.addr) {
-            bail!("Adding a new transport is not supported right now. Check back in a few months!");
-        }
         let cancel_channel = self.alloc_ongoing().await?;
 
         let res = self
-            .inner_configure(param)
+            .inner_configure()
             .race(cancel_channel.recv().map(|_| Err(format_err!("Cancelled"))))
             .await;
 
         self.free_ongoing().await;
 
         if let Err(err) = res.as_ref() {
-            // We are using Anyhow's .context() and to show the
-            // inner error, too, we need the {:#}:
-            let error_msg = stock_str::configuration_failed(self, &format!("{err:#}")).await;
-            progress!(self, 0, Some(error_msg));
+            progress!(
+                self,
+                0,
+                Some(
+                    stock_str::configuration_failed(
+                        self,
+                        // We are using Anyhow's .context() and to show the
+                        // inner error, too, we need the {:#}:
+                        &format!("{err:#}"),
+                    )
+                    .await
+                )
+            );
         } else {
-            param.save(self).await?;
             progress!(self, 1000);
         }
 
         res
     }
 
-    /// Adds a new email account as a transport
-    /// using the server encoded in the QR code.
-    /// See [Self::add_transport].
-    pub async fn add_transport_from_qr(&self, qr: &str) -> Result<()> {
-        set_account_from_qr(self, qr).await?;
-        self.configure().await?;
-
-        Ok(())
-    }
-
-    /// Returns the list of all email accounts that are used as a transport in the current profile.
-    /// Use [Self::add_transport()] to add or change a transport
-    /// and [Self::delete_transport()] to delete a transport.
-    pub async fn list_transports(&self) -> Result<Vec<EnteredLoginParam>> {
-        let param = EnteredLoginParam::load(self).await?;
-
-        Ok(vec![param])
-    }
-
-    /// Removes the transport with the specified email address
-    /// (i.e. [EnteredLoginParam::addr]).
-    #[expect(clippy::unused_async)]
-    pub async fn delete_transport(&self, _addr: &str) -> Result<()> {
-        bail!("Adding and removing additional transports is not supported yet. Check back in a few months!")
-    }
-
-    async fn inner_configure(&self, param: &EnteredLoginParam) -> Result<()> {
+    async fn inner_configure(&self) -> Result<()> {
         info!(self, "Configure ...");
 
+        let param = EnteredLoginParam::load(self).await?;
         let old_addr = self.get_config(Config::ConfiguredAddr).await?;
-        let configured_param = configure(self, param).await?;
+        let configured_param = configure(self, &param).await?;
         self.set_config_internal(Config::NotifyAboutWrongPw, Some("1"))
             .await?;
         on_configure_completed(self, configured_param, old_addr).await?;
@@ -259,7 +185,8 @@ async fn get_configured_param(
         param.smtp.password.clone()
     };
 
-    let proxy_enabled = ctx.get_config_bool(Config::ProxyEnabled).await?;
+    let proxy_config = param.proxy_config.clone();
+    let proxy_enabled = proxy_config.is_some();
 
     let mut addr = param.addr.clone();
     if param.oauth2 {
@@ -418,7 +345,7 @@ async fn get_configured_param(
             .collect(),
         smtp_user: param.smtp.user.clone(),
         smtp_password,
-        proxy_config: ProxyConfig::load(ctx).await?,
+        proxy_config: param.proxy_config.clone(),
         provider,
         certificate_checks: match param.certificate_checks {
             EnteredCertificateChecks::Automatic => ConfiguredCertificateChecks::Automatic,

src/imex/key_transfer.rs

@@ -46,11 +46,11 @@ pub async fn initiate_key_transfer(context: &Context) -> Result<String> {
     msg.force_plaintext();
     msg.param.set_int(Param::SkipAutocrypt, 1);
 
+    chat::send_msg(context, chat_id, &mut msg).await?;
+
     // Enable BCC-self, because transferring a key
     // means we have a multi-device setup.
     context.set_config_bool(Config::BccSelf, true).await?;
-
-    chat::send_msg(context, chat_id, &mut msg).await?;
     Ok(setup_code)
 }
 

src/imex/transfer.rs

@@ -45,7 +45,7 @@ use crate::message::Message;
 use crate::qr::Qr;
 use crate::stock_str::backup_transfer_msg_body;
 use crate::tools::{create_id, time, TempPathGuard};
-use crate::{e2ee, EventType};
+use crate::EventType;
 
 use super::{export_backup_stream, export_database, import_backup_stream, DBFILE_BACKUP_NAME};
 
@@ -109,11 +109,6 @@ impl BackupProvider {
             .parent()
             .context("Context dir not found")?;
 
-        // before we export, make sure the private key exists
-        e2ee::ensure_secret_key_exists(context)
-            .await
-            .context("Cannot create private key or private key not available")?;
-
         let dbfile = context_dir.join(DBFILE_BACKUP_NAME);
         if fs::metadata(&dbfile).await.is_ok() {
             fs::remove_file(&dbfile).await?;

src/lib.rs

@@ -68,7 +68,7 @@ mod imap;
 pub mod imex;
 pub mod key;
 pub mod location;
-pub mod login_param;
+mod login_param;
 pub mod message;
 mod mimefactory;
 pub mod mimeparser;

src/login_param.rs

@@ -4,7 +4,6 @@ use std::fmt;
 
 use anyhow::{format_err, Context as _, Result};
 use deltachat_contact_tools::EmailAddress;
-use num_traits::ToPrimitive as _;
 use serde::{Deserialize, Serialize};
 
 use crate::config::Config;
@@ -12,11 +11,9 @@ use crate::configure::server_params::{expand_param_vector, ServerParams};
 use crate::constants::{DC_LP_AUTH_FLAGS, DC_LP_AUTH_NORMAL, DC_LP_AUTH_OAUTH2};
 use crate::context::Context;
 use crate::net::load_connection_timestamp;
-pub use crate::net::proxy::ProxyConfig;
-pub use crate::provider::Socket;
-use crate::provider::{Protocol, Provider, UsernamePattern};
+use crate::net::proxy::ProxyConfig;
+use crate::provider::{Protocol, Provider, Socket, UsernamePattern};
 use crate::sql::Sql;
-use crate::tools::ToOption;
 
 /// User-entered setting for certificate checks.
 ///
@@ -47,7 +44,7 @@ pub enum EnteredCertificateChecks {
 #[derive(Copy, Clone, Debug, Display, FromPrimitive, ToPrimitive, PartialEq, Eq)]
 #[repr(u32)]
 #[strum(serialize_all = "snake_case")]
-pub(crate) enum ConfiguredCertificateChecks {
+pub enum ConfiguredCertificateChecks {
     /// Use configuration from the provider database.
     /// If there is no provider database setting for certificate checks,
     /// accept invalid certificates.
@@ -119,13 +116,15 @@ pub struct EnteredLoginParam {
     /// invalid hostnames
     pub certificate_checks: EnteredCertificateChecks,
 
-    /// If true, login via OAUTH2 (not recommended anymore)
+    /// Proxy configuration.
+    pub proxy_config: Option<ProxyConfig>,
+
     pub oauth2: bool,
 }
 
 impl EnteredLoginParam {
     /// Loads entered account settings.
-    pub(crate) async fn load(context: &Context) -> Result<Self> {
+    pub async fn load(context: &Context) -> Result<Self> {
         let addr = context
             .get_config(Config::Addr)
             .await?
@@ -197,6 +196,8 @@ impl EnteredLoginParam {
             .unwrap_or_default();
         let oauth2 = matches!(server_flags & DC_LP_AUTH_FLAGS, DC_LP_AUTH_OAUTH2);
 
+        let proxy_config = ProxyConfig::load(context).await?;
+
         Ok(EnteredLoginParam {
             addr,
             imap: EnteredServerLoginParam {
@@ -214,71 +215,10 @@ impl EnteredLoginParam {
                 password: send_pw,
             },
             certificate_checks,
+            proxy_config,
             oauth2,
         })
     }
-
-    /// Saves entered account settings,
-    /// so that they can be prefilled if the user wants to configure the server again.
-    pub(crate) async fn save(&self, context: &Context) -> Result<()> {
-        context.set_config(Config::Addr, Some(&self.addr)).await?;
-
-        context
-            .set_config(Config::MailServer, self.imap.server.to_option())
-            .await?;
-        context
-            .set_config(Config::MailPort, self.imap.port.to_option().as_deref())
-            .await?;
-        context
-            .set_config(
-                Config::MailSecurity,
-                self.imap.security.to_i32().to_option().as_deref(),
-            )
-            .await?;
-        context
-            .set_config(Config::MailUser, self.imap.user.to_option())
-            .await?;
-        context
-            .set_config(Config::MailPw, self.imap.password.to_option())
-            .await?;
-
-        context
-            .set_config(Config::SendServer, self.smtp.server.to_option())
-            .await?;
-        context
-            .set_config(Config::SendPort, self.smtp.port.to_option().as_deref())
-            .await?;
-        context
-            .set_config(
-                Config::SendSecurity,
-                self.smtp.security.to_i32().to_option().as_deref(),
-            )
-            .await?;
-        context
-            .set_config(Config::SendUser, self.smtp.user.to_option())
-            .await?;
-        context
-            .set_config(Config::SendPw, self.smtp.password.to_option())
-            .await?;
-
-        context
-            .set_config(
-                Config::ImapCertificateChecks,
-                self.certificate_checks.to_i32().to_option().as_deref(),
-            )
-            .await?;
-
-        let server_flags = if self.oauth2 {
-            Some(DC_LP_AUTH_OAUTH2.to_string())
-        } else {
-            None
-        };
-        context
-            .set_config(Config::ServerFlags, server_flags.as_deref())
-            .await?;
-
-        Ok(())
-    }
 }
 
 impl fmt::Display for EnteredLoginParam {
@@ -379,7 +319,7 @@ impl TryFrom<Socket> for ConnectionSecurity {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub(crate) struct ConfiguredServerLoginParam {
+pub struct ConfiguredServerLoginParam {
     pub connection: ConnectionCandidate,
 
     /// Username.
@@ -417,7 +357,7 @@ pub(crate) async fn prioritize_server_login_params(
 /// Login parameters saved to the database
 /// after successful configuration.
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct ConfiguredLoginParam {
+pub struct ConfiguredLoginParam {
     /// `From:` address that was used at the time of configuration.
     pub addr: String,
 
@@ -450,7 +390,6 @@ pub(crate) struct ConfiguredLoginParam {
     /// invalid hostnames
     pub certificate_checks: ConfiguredCertificateChecks,
 
-    /// If true, login via OAUTH2 (not recommended anymore)
     pub oauth2: bool,
 }
 
@@ -489,7 +428,7 @@ impl ConfiguredLoginParam {
     /// Load configured account settings from the database.
     ///
     /// Returns `None` if account is not configured.
-    pub(crate) async fn load(context: &Context) -> Result<Option<Self>> {
+    pub async fn load(context: &Context) -> Result<Option<Self>> {
         if !context.get_config_bool(Config::Configured).await? {
             return Ok(None);
         }
@@ -760,7 +699,7 @@ impl ConfiguredLoginParam {
     }
 
     /// Save this loginparam to the database.
-    pub(crate) async fn save_as_configured_params(&self, context: &Context) -> Result<()> {
+    pub async fn save_as_configured_params(&self, context: &Context) -> Result<()> {
         context.set_primary_self_addr(&self.addr).await?;
 
         context
@@ -837,7 +776,7 @@ impl ConfiguredLoginParam {
         Ok(())
     }
 
-    pub(crate) fn strict_tls(&self) -> bool {
+    pub fn strict_tls(&self) -> bool {
         let provider_strict_tls = self.provider.map(|provider| provider.opt.strict_tls);
         match self.certificate_checks {
             ConfiguredCertificateChecks::OldAutomatic => {
@@ -900,42 +839,6 @@ mod tests {
         Ok(())
     }
 
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_save_entered_login_param() -> Result<()> {
-        let t = TestContext::new().await;
-        let param = EnteredLoginParam {
-            addr: "alice@example.org".to_string(),
-            imap: EnteredServerLoginParam {
-                server: "".to_string(),
-                port: 0,
-                security: Socket::Starttls,
-                user: "".to_string(),
-                password: "foobar".to_string(),
-            },
-            smtp: EnteredServerLoginParam {
-                server: "".to_string(),
-                port: 2947,
-                security: Socket::default(),
-                user: "".to_string(),
-                password: "".to_string(),
-            },
-            certificate_checks: Default::default(),
-            oauth2: false,
-        };
-        param.save(&t).await?;
-        assert_eq!(
-            t.get_config(Config::Addr).await?.unwrap(),
-            "alice@example.org"
-        );
-        assert_eq!(t.get_config(Config::MailPw).await?.unwrap(), "foobar");
-        assert_eq!(t.get_config(Config::SendPw).await?, None);
-        assert_eq!(t.get_config_int(Config::SendPort).await?, 2947);
-
-        assert_eq!(EnteredLoginParam::load(&t).await?, param);
-
-        Ok(())
-    }
-
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_save_load_login_param() -> Result<()> {
         let t = TestContext::new().await;

src/message.rs

@@ -33,6 +33,7 @@ use crate::reaction::get_msg_reactions;
 use crate::sql;
 use crate::summary::Summary;
 use crate::sync::SyncData;
+use crate::tools::create_outgoing_rfc724_mid;
 use crate::tools::{
     buf_compress, buf_decompress, get_filebytes, get_filemeta, gm2local_offset, read_file,
     sanitize_filename, time, timestamp_to_str, truncate,
@@ -485,6 +486,7 @@ impl Message {
     pub fn new(viewtype: Viewtype) -> Self {
         Message {
             viewtype,
+            rfc724_mid: create_outgoing_rfc724_mid(),
             ..Default::default()
         }
     }
@@ -494,6 +496,7 @@ impl Message {
         Message {
             viewtype: Viewtype::Text,
             text,
+            rfc724_mid: create_outgoing_rfc724_mid(),
             ..Default::default()
         }
     }
@@ -2158,9 +2161,11 @@ pub(crate) async fn get_by_rfc724_mids(
     let mut latest = None;
     for id in mids.iter().rev() {
         let Some((msg_id, _)) = rfc724_mid_exists(context, id).await? else {
+            info!(context, "continue msgid");
             continue;
         };
         let Some(msg) = Message::load_from_db_optional(context, msg_id).await? else {
+            info!(context, "continue msg");
             continue;
         };
         if msg.download_state == DownloadState::Done {

src/message/message_tests.rs

@@ -147,8 +147,6 @@ async fn test_quote() {
 
     let mut msg = Message::new_text("Quoted message".to_string());
 
-    // Send message, so it gets a Message-Id.
-    assert!(msg.rfc724_mid.is_empty());
     let msg_id = chat::send_msg(ctx, chat.id, &mut msg).await.unwrap();
     let msg = Message::load_from_db(ctx, msg_id).await.unwrap();
     assert!(!msg.rfc724_mid.is_empty());
@@ -358,6 +356,7 @@ async fn test_markseen_msgs() -> Result<()> {
     let sent1 = alice.send_msg(alice_chat.id, &mut msg).await;
     let msg1 = bob.recv_msg(&sent1).await;
     let bob_chat_id = msg1.chat_id;
+    let mut msg = Message::new_text("this is the text!".to_string());
     let sent2 = alice.send_msg(alice_chat.id, &mut msg).await;
     let msg2 = bob.recv_msg(&sent2).await;
     assert_eq!(msg1.chat_id, msg2.chat_id);
@@ -380,9 +379,11 @@ async fn test_markseen_msgs() -> Result<()> {
 
     // bob sends to alice,
     // alice knows bob and messages appear in normal chat
+    let mut msg = Message::new_text("this is the text!".to_string());
     let msg1 = alice
         .recv_msg(&bob.send_msg(bob_chat_id, &mut msg).await)
         .await;
+    let mut msg = Message::new_text("this is the text!".to_string());
     let msg2 = alice
         .recv_msg(&bob.send_msg(bob_chat_id, &mut msg).await)
         .await;

src/mimefactory.rs

@@ -184,6 +184,9 @@ impl MimeFactory {
         let mut req_mdn = false;
 
         if chat.is_self_talk() {
+            if msg.param.get_cmd() == SystemMessage::AutocryptSetupMessage {
+                recipients.push(from_addr.to_string());
+            }
             to.push((from_displayname.to_string(), from_addr.to_string()));
         } else if chat.is_mailing_list() {
             let list_post = chat

src/mimefactory/mimefactory_tests.rs

@@ -727,6 +727,7 @@ async fn test_selfavatar_unencrypted_signed() {
         .is_some());
 
     // if another message is sent, that one must not contain the avatar
+    let mut msg = Message::new_text("this is the text!".to_string());
     let sent_msg = t.send_msg(chat.id, &mut msg).await;
     let mut payload = sent_msg.payload().splitn(4, "\r\n\r\n");
 

src/mimeparser.rs

@@ -345,13 +345,6 @@ impl MimeMessage {
                     }
 
                     decrypted_msg = Some(msg);
-
-                    timestamp_sent = Self::get_timestamp_sent(
-                        &decrypted_mail.headers,
-                        timestamp_sent,
-                        timestamp_rcvd,
-                    );
-
                     if let Some(protected_aheader_value) = decrypted_mail
                         .headers
                         .get_header_value(HeaderDef::Autocrypt)
@@ -423,6 +416,8 @@ impl MimeMessage {
             content
         });
         if let (Ok(mail), true) = (mail, encrypted) {
+            timestamp_sent =
+                Self::get_timestamp_sent(&mail.headers, timestamp_sent, timestamp_rcvd);
             if !signatures.is_empty() {
                 // Remove unsigned opportunistically protected headers from messages considered
                 // Autocrypt-encrypted / displayed with padlock.

src/net/proxy.rs

@@ -154,21 +154,18 @@ impl Socks5Config {
     }
 }
 
-/// Configuration for the proxy through which all traffic
-/// (except for iroh p2p connections)
-/// will be sent.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum ProxyConfig {
-    /// HTTP proxy.
+    // HTTP proxy.
     Http(HttpConfig),
 
-    /// HTTPS proxy.
+    // HTTPS proxy.
     Https(HttpConfig),
 
-    /// SOCKS5 proxy.
+    // SOCKS5 proxy.
     Socks5(Socks5Config),
 
-    /// Shadowsocks proxy.
+    // Shadowsocks proxy.
     Shadowsocks(ShadowsocksConfig),
 }
 
@@ -249,7 +246,7 @@ where
 
 impl ProxyConfig {
     /// Creates a new proxy configuration by parsing given proxy URL.
-    pub fn from_url(url: &str) -> Result<Self> {
+    pub(crate) fn from_url(url: &str) -> Result<Self> {
         let url = Url::parse(url).context("Cannot parse proxy URL")?;
         match url.scheme() {
             "http" => {
@@ -308,7 +305,7 @@ impl ProxyConfig {
     ///
     /// This function can be used to normalize proxy URL
     /// by parsing it and serializing back.
-    pub fn to_url(&self) -> String {
+    pub(crate) fn to_url(&self) -> String {
         match self {
             Self::Http(http_config) => http_config.to_url("http"),
             Self::Https(http_config) => http_config.to_url("https"),
@@ -394,7 +391,7 @@ impl ProxyConfig {
 
     /// If `load_dns_cache` is true, loads cached DNS resolution results.
     /// Use this only if the connection is going to be protected with TLS checks.
-    pub(crate) async fn connect(
+    pub async fn connect(
         &self,
         context: &Context,
         target_host: &str,

src/qr.rs

@@ -695,7 +695,7 @@ struct CreateAccountErrorResponse {
 /// take a qr of the type DC_QR_ACCOUNT, parse it's parameters,
 /// download additional information from the contained url and set the parameters.
 /// on success, a configure::configure() should be able to log in to the account
-pub(crate) async fn set_account_from_qr(context: &Context, qr: &str) -> Result<()> {
+async fn set_account_from_qr(context: &Context, qr: &str) -> Result<()> {
     let url_str = qr
         .get(DCACCOUNT_SCHEME.len()..)
         .context("Invalid DCACCOUNT scheme")?;

src/receive_imf.rs

@@ -3216,6 +3216,7 @@ async fn get_parent_message(
     if let Some(field) = references {
         mids.append(&mut parse_message_ids(field));
     }
+    info!(context, "mids: {mids:?}");
     message::get_by_rfc724_mids(context, &mids).await
 }
 

src/receive_imf/receive_imf_tests.rs

@@ -2218,17 +2218,6 @@ async fn test_no_smtp_job_for_self_chat() -> Result<()> {
     let mut msg = Message::new_text("Happy birthday to me".to_string());
     chat::send_msg(bob, chat_id, &mut msg).await?;
     assert!(bob.pop_sent_msg_opt(Duration::ZERO).await.is_none());
-
-    bob.set_config_bool(Config::BccSelf, true).await?;
-    bob.set_config(Config::DeleteServerAfter, Some("1")).await?;
-    let mut msg = Message::new_text("Happy birthday to me".to_string());
-    chat::send_msg(bob, chat_id, &mut msg).await?;
-    assert!(bob.pop_sent_msg_opt(Duration::ZERO).await.is_none());
-
-    bob.set_config(Config::DeleteServerAfter, None).await?;
-    let mut msg = Message::new_text("Happy birthday to me".to_string());
-    chat::send_msg(bob, chat_id, &mut msg).await?;
-    assert!(bob.pop_sent_msg_opt(Duration::ZERO).await.is_some());
     Ok(())
 }
 
@@ -5150,7 +5139,7 @@ async fn test_references() -> Result<()> {
     alice.set_config_bool(Config::BccSelf, true).await?;
 
     let alice_chat_id = create_group_chat(alice, ProtectionStatus::Unprotected, "Group").await?;
-    let _sent = alice
+    alice
         .send_text(alice_chat_id, "Hi! I created a group.")
         .await;
 

src/tools.rs

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