Clean + fixes

core/conversations/src/conversation/group_v2.rs

@@ -21,7 +21,6 @@ use de_mls::protos::de_mls::messages::v1::{
 };
 use de_mls::session::{Conversation, ConversationConfig, ConversationDeps};
 use hashgraph_like_consensus::signing::EthereumConsensusSigner;
-use openmls::credentials::Credential;
 use prost::Message;
 use shared_traits::{IdentId, IdentIdRef};
 use std::sync::Arc;
@@ -185,7 +184,7 @@ impl GroupV2Convo {
     pub fn new<S: ExternalServices>(
         service_ctx: &mut ServiceContext<S>,
     ) -> Result<Self, ChatError> {
-        let setup = DemlsSetup::new(service_ctx.mls_identity.display_name())?;
+        let setup = DemlsSetup::new(service_ctx.mls_identity.id().as_str().to_string())?;
         let convo_id = rand_string(5);
         let conversation = Conversation::create(&convo_id, setup.deps())?;
         let convo = GroupV2Convo {
@@ -206,7 +205,7 @@ impl GroupV2Convo {
     pub fn new_pending<S: ExternalServices>(
         service_ctx: &mut ServiceContext<S>,
     ) -> Result<Self, ChatError> {
-        let name = service_ctx.mls_identity.display_name();
+        let name = service_ctx.mls_identity.id().as_str().to_string();
         let setup = DemlsSetup::new(name.clone())?;
         let kp = setup.factory.generate_key_package()?;
 

core/conversations/src/utils.rs

@@ -72,11 +72,11 @@ pub fn hex_trunc(data: &[u8]) -> String {
     }
 }
 
-#[allow(unused)]
 pub fn trunc(data: &str) -> String {
-    if data.len() <= 8 {
-        data.to_string()
-    } else {
-        format!("{}..{}", &data[..4], &data[data.len() - 4..])
+    if data.chars().count() <= 8 {
+        return data.to_string();
     }
+    let head: String = data.chars().take(4).collect();
+    let tail: String = data.chars().rev().take(4).collect::<String>().chars().rev().collect();
+    format!("{head}..{tail}")
 }

crates/client/src/client.rs

@@ -9,7 +9,7 @@ use libchat::{
 };
 use parking_lot::Mutex;
 
-use crate::delegate::{self, DelegateCredential, DelegateSigner};
+use crate::delegate::{DelegateCredential, DelegateSigner};
 use crate::errors::ClientError;
 use crate::event::Event;
 
@@ -51,7 +51,7 @@ pub struct ChatClient<T: DeliveryService, R: RegistrationService = EphemeralRegi
 
 impl<T: Transport> ChatClient<T, EphemeralRegistry> {
     /// Create an in-memory, ephemeral client. Identity is lost on drop.
-    pub fn new(name: impl Into<String>, mut transport: T) -> (Self, Receiver<Event>) {
+    pub fn new(_: impl Into<String>, mut transport: T) -> (Self, Receiver<Event>) {
         let inbound = transport.inbound();
         let delegate = DelegateSigner::random();
 
@@ -73,7 +73,7 @@ impl<T: Transport> ChatClient<T, EphemeralRegistry> {
     /// If an identity already exists in storage it is loaded; otherwise a new
     /// one is created and saved.
     pub fn open(
-        name: impl Into<String>,
+        _: impl Into<String>,
         config: StorageConfig,
         mut transport: T,
     ) -> Result<(Self, Receiver<Event>), ClientError> {
@@ -109,7 +109,7 @@ where
     /// when a real registry is wired in we want each session to publish so
     /// other clients can fetch it.
     pub fn open_with_registry(
-        name: impl Into<String>,
+        _: impl Into<String>,
         config: StorageConfig,
         mut transport: T,
         registry: R,
@@ -132,7 +132,7 @@ where
         delegate: DelegateSigner,
         mut transport: T,
         reg: R,
-    ) -> (Self, Receiver<Event>) {
+    ) -> Result<(Self, Receiver<Event>), ClientError> {
         let inbound = transport.inbound();
 
         let (wakeup_tx, wakeup_rx) = crossbeam_channel::unbounded();
@@ -143,9 +143,8 @@ where
             reg,
             wakeup_service,
             ChatStorage::in_memory(),
-        )
-        .unwrap();
-        Self::spawn(core, inbound, wakeup_rx)
+        )?;
+        Ok(Self::spawn(core, inbound, wakeup_rx))
     }
 
     fn spawn(
@@ -309,17 +308,20 @@ fn events_from_inbound(result: PayloadOutcome) -> Vec<Event> {
     }
 }
 
+fn decode_credential(encoded: Vec<u8>) {
+    if let Ok(data) = hex::decode(encoded) {
+        if let Ok(cred) = DelegateCredential::try_from(data) {
+            tracing::debug!(?cred, "decoded sender credential");
+            // TODO: Integration Point
+        }
+    }
+}
+
 fn convo_events(outcome: ConvoOutcome) -> Vec<Event> {
     let ConvoOutcome { convo_id, content } = outcome;
     content
         .map(|c| {
-            if let Ok(data) = hex::decode(c.encoded_credential) {
-                if let Ok(delegate_cred) = DelegateCredential::try_from(data) {
-                    println!("{:?}", delegate_cred);
-                    // TODO: Integration Point
-                }
-            }
-
+            decode_credential(c.encoded_credential);
             Event::MessageReceived {
                 convo_id: Arc::from(convo_id),
                 content: c.bytes,
@@ -341,6 +343,7 @@ fn inbox_events(outcome: InboxOutcome) -> Vec<Event> {
         class: new_conversation.class,
     });
     if let Some(c) = initial.and_then(|co| co.content) {
+        decode_credential(c.encoded_credential);
         events.push(Event::MessageReceived {
             convo_id: Arc::clone(&id),
             content: c.bytes,

crates/client/src/delegate.rs

@@ -93,10 +93,12 @@ impl DelegateCredential {
         let mut data = Vec::new();
         data.extend_from_slice(&[0x23, 0x23]);
         let key_bytes = self.delegate_id.as_ref();
+        debug_assert!(key_bytes.len() <= 255, "delegate_id too large for 1-byte TLV length");
         data.extend_from_slice(&[Self::TAG_DELEGATE_ID, key_bytes.len() as u8]);
         data.extend_from_slice(key_bytes);
         if let Some(addr) = self.account_addr {
             let addr_bytes = addr.as_bytes();
+            debug_assert!(addr_bytes.len() <= 255, "account_addr too large for 1-byte TLV length");
             data.extend_from_slice(&[Self::TAG_ACCOUNT_ADDR, addr_bytes.len() as u8]);
             data.extend_from_slice(addr_bytes);
         }

crates/client/tests/saro_and_raya.rs

@@ -34,32 +34,34 @@ fn direct_v1_integration() {
     // TODO: Submit Delegate to Account for auth.
     saro_delegate.associate(saro_account.id().to_string());
 
-    dbg!(&saro_delegate.account_addr());
-
     let raya_account = TestLogosAccount::new("Raya");
     let mut raya_delegate = DelegateSigner::random();
     // TODO: Submit Delegate to Account for auth.
     raya_delegate.associate(raya_account.id().to_string());
     let raya_delegate_id = raya_delegate.id().clone();
 
-    let (mut saro, saro_events) =
-        ChatClient::new_ephemeral(saro_delegate, saro_delivery, reg_service.clone());
-    let (mut raya, raya_events) =
-        ChatClient::new_ephemeral(raya_delegate, raya_delivery, reg_service.clone());
+    let (mut saro, _saro_events) =
+        ChatClient::new_ephemeral(saro_delegate, saro_delivery, reg_service.clone()).unwrap();
+    let (_raya, raya_events) =
+        ChatClient::new_ephemeral(raya_delegate, raya_delivery, reg_service.clone()).unwrap();
 
     let convo_id = saro
         .create_direct_conversation(raya_delegate_id.as_str())
         .unwrap();
 
     // The invite payload yields ConversationStarted then MessageReceived.
-    let raya_convo_id = expect_event(&raya_events, "ConversationStarted", |e| match e {
+    expect_event(&raya_events, "ConversationStarted", |e| match e {
         Event::ConversationStarted { convo_id, .. } => Ok(convo_id),
         other => Err(other),
     });
 
-    saro.send_message(&convo_id, b"Hey from saro");
+    saro.send_message(&convo_id, b"Hey from saro")
+        .expect("payload mismatch");
     expect_event(&raya_events, "MessageReceived", |e| match e {
-        Event::MessageReceived { convo_id, content } => Ok(()),
+        Event::MessageReceived { content, .. } => {
+            assert_eq!(content.as_slice(), b"Hey from saro");
+            Ok(())
+        }
         other => Err(other),
     });
 }