From 1f7714f98eeb1b3cfc7e3ea6ab01e3fd1449dac1 Mon Sep 17 00:00:00 2001 From: Jazz Turner-Baggs <473256+jazzz@users.noreply.github.com> Date: Sun, 21 Jun 2026 22:38:58 -0700 Subject: [PATCH] Clean + fixes --- .../src/conversation/group_v2.rs | 5 ++- core/conversations/src/utils.rs | 10 +++--- crates/client/src/client.rs | 33 ++++++++++--------- crates/client/src/delegate.rs | 2 ++ crates/client/tests/saro_and_raya.rs | 20 ++++++----- 5 files changed, 38 insertions(+), 32 deletions(-) diff --git a/core/conversations/src/conversation/group_v2.rs b/core/conversations/src/conversation/group_v2.rs index fb00d0d..5cef07b 100644 --- a/core/conversations/src/conversation/group_v2.rs +++ b/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( service_ctx: &mut ServiceContext, ) -> Result { - 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( service_ctx: &mut ServiceContext, ) -> Result { - 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()?; diff --git a/core/conversations/src/utils.rs b/core/conversations/src/utils.rs index 4dde6a4..7ee1432 100644 --- a/core/conversations/src/utils.rs +++ b/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::().chars().rev().collect(); + format!("{head}..{tail}") } diff --git a/crates/client/src/client.rs b/crates/client/src/client.rs index e0bc0db..e7c2336 100644 --- a/crates/client/src/client.rs +++ b/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 ChatClient { /// Create an in-memory, ephemeral client. Identity is lost on drop. - pub fn new(name: impl Into, mut transport: T) -> (Self, Receiver) { + pub fn new(_: impl Into, mut transport: T) -> (Self, Receiver) { let inbound = transport.inbound(); let delegate = DelegateSigner::random(); @@ -73,7 +73,7 @@ impl ChatClient { /// If an identity already exists in storage it is loaded; otherwise a new /// one is created and saved. pub fn open( - name: impl Into, + _: impl Into, config: StorageConfig, mut transport: T, ) -> Result<(Self, Receiver), 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, + _: impl Into, config: StorageConfig, mut transport: T, registry: R, @@ -132,7 +132,7 @@ where delegate: DelegateSigner, mut transport: T, reg: R, - ) -> (Self, Receiver) { + ) -> Result<(Self, Receiver), 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 { } } +fn decode_credential(encoded: Vec) { + 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 { 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 { 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, diff --git a/crates/client/src/delegate.rs b/crates/client/src/delegate.rs index 032fc36..82d0b83 100644 --- a/crates/client/src/delegate.rs +++ b/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); } diff --git a/crates/client/tests/saro_and_raya.rs b/crates/client/tests/saro_and_raya.rs index 1c500f1..9b80652 100644 --- a/crates/client/tests/saro_and_raya.rs +++ b/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), }); }