perf: five cuts to the per-message allocation count

src/client/app_state.rs

@@ -1110,11 +1110,12 @@ impl Client {
                 let result = async {
                     self.ensure_e2e_sessions(std::slice::from_ref(&peer))
                         .await?;
+                    let request_id = self.generate_message_id();
                     self.send_message_impl(
                         peer,
                         msg,
                         crate::send::SendPipelineOptions {
-                            request_id: Some(self.generate_message_id()),
+                            request_id: Some(&request_id),
                             peer: true,
                             ..Default::default()
                         },

src/client/context_impl.rs

@@ -70,11 +70,6 @@ impl SendContextResolver for Client {
         }
         // Reuse the DM path's helpers so both lock the identical per-device mutexes.
         let keys = self.build_session_lock_keys(device_jids).await;
-        let mutexes = self.session_mutexes_for(&keys).await;
-        let mut guards = Vec::with_capacity(mutexes.len());
-        for mutex in &mutexes {
-            guards.push(mutex.lock_arc().await);
-        }
-        SessionLockGuard::hold(Box::new(guards))
+        SessionLockGuard::hold(Box::new(self.session_guards_for(&keys).await))
     }
 }

src/client/messaging.rs

@@ -197,7 +197,7 @@ impl Client {
             &edit_container_message,
             crate::send::SendPipelineOptions {
                 edit: Some(crate::types::message::EditAttribute::MessageEdit),
-                request_id,
+                request_id: request_id.as_deref(),
                 borrowed_message_id,
                 ..Default::default()
             },

src/client/tests.rs

@@ -1478,7 +1478,7 @@ async fn cleanup_connection_state_flushes_dirty_signal_state() {
     let client = create_offline_sync_test_client().await;
 
     // A dirty identity lives only in the write-back cache until flushed.
-    let addr = ProtocolAddress::new("5550001000@s.whatsapp.net".to_string(), 1u32.into());
+    let addr = ProtocolAddress::new("5550001000@s.whatsapp.net", 1u32.into());
     client.signal_cache.put_identity(&addr, &[7u8; 32]).await;
 
     client.cleanup_connection_state().await;
@@ -1579,7 +1579,7 @@ async fn cleanup_connection_state_keeps_state_when_flush_fails() {
 
     // A malformed identity (not 32 bytes) makes flush() error out, standing
     // in for a transient backend write failure during cleanup.
-    let bad = ProtocolAddress::new("5550002000@s.whatsapp.net".to_string(), 1u32.into());
+    let bad = ProtocolAddress::new("5550002000@s.whatsapp.net", 1u32.into());
     client.signal_cache.put_identity(&bad, &[0u8; 16]).await;
 
     // A valid dirty sender key that must not be dropped when the flush fails.

src/features/groups.rs

@@ -1400,7 +1400,7 @@ impl<'a> Groups<'a> {
                 group_jid.clone(),
                 &msg,
                 crate::send::SendPipelineOptions {
-                    request_id: Some(message_id.clone()),
+                    request_id: Some(&message_id),
                     extra_stanza_nodes: meta.into_iter().collect(),
                     ..Default::default()
                 },

src/features/signal.rs

@@ -649,11 +649,7 @@ impl<'a> Signal<'a> {
 
         // Acquire per-device session locks before encrypting (matches DM send path)
         let lock_jids = self.client.build_session_lock_keys(&device_jids).await;
-        let session_mutexes = self.client.session_mutexes_for(&lock_jids).await;
-        let mut _session_guards = Vec::with_capacity(session_mutexes.len());
-        for mutex in &session_mutexes {
-            _session_guards.push(mutex.lock().await);
-        }
+        let _session_guards = self.client.session_guards_for(&lock_jids).await;
 
         let plaintext = MessageUtils::encode_and_pad(message);
         let mut adapter = self.client.signal_adapter().await;

src/message/special.rs

@@ -354,7 +354,7 @@ impl Client {
             requester.clone(),
             message,
             crate::send::SendPipelineOptions {
-                request_id: Some(message_id.to_owned()),
+                request_id: Some(message_id),
                 peer: true,
                 ..Default::default()
             },

src/pdo.rs

@@ -273,7 +273,7 @@ impl Client {
             to,
             msg,
             crate::send::SendPipelineOptions {
-                request_id: Some(msg_id.clone()),
+                request_id: Some(&msg_id),
                 peer: true,
                 ..Default::default()
             },