Merge branch 'mls-dm-release' into cv/dm-dual-sending

bindings_ffi/src/mls.rs

@@ -31,6 +31,7 @@ use xmtp_mls::groups::intents::PermissionUpdateType;
 use xmtp_mls::groups::GroupMetadataOptions;
 use xmtp_mls::storage::consent_record::ConsentState;
 use xmtp_mls::storage::consent_record::ConsentType;
+use xmtp_mls::storage::consent_record::StoredConsentRecord;
 use xmtp_mls::{
     api::ApiClientWrapper,
     builder::ClientBuilder,
@@ -332,16 +333,12 @@ impl FfiXmtpClient {
         Ok(state.into())
     }
 
-    pub async fn set_consent_state(
-        &self,
-        state: FfiConsentState,
-        entity_type: FfiConsentEntityType,
-        entity: String,
-    ) -> Result<(), GenericError> {
+    pub async fn set_consent_states(&self, records: Vec<FfiConsent>) -> Result<(), GenericError> {
         let inner = self.inner_client.as_ref();
-        inner
-            .set_consent_state(state.into(), entity_type.into(), entity)
-            .await?;
+        let stored_records: Vec<StoredConsentRecord> =
+            records.into_iter().map(StoredConsentRecord::from).collect();
+
+        inner.set_consent_states(stored_records).await?;
         Ok(())
     }
 
@@ -1074,15 +1071,16 @@ impl FfiGroup {
         Ok(ffi_message)
     }
 
-    pub fn list_members(&self) -> Result<Vec<FfiGroupMember>, GenericError> {
+    pub async fn list_members(&self) -> Result<Vec<FfiGroupMember>, GenericError> {
         let group = MlsGroup::new(
             self.inner_client.context().clone(),
             self.group_id.clone(),
             self.created_at_ns,
         );
 
         let members: Vec<FfiGroupMember> = group
-            .members()?
+            .members(&self.inner_client)
+            .await?
             .into_iter()
             .map(|member| FfiGroupMember {
                 inbox_id: member.inbox_id,
@@ -1554,6 +1552,23 @@ impl From<StoredGroupMessage> for FfiMessage {
     }
 }
 
+#[derive(uniffi::Record)]
+pub struct FfiConsent {
+    pub entity_type: FfiConsentEntityType,
+    pub state: FfiConsentState,
+    pub entity: String,
+}
+
+impl From<FfiConsent> for StoredConsentRecord {
+    fn from(consent: FfiConsent) -> Self {
+        Self {
+            entity_type: consent.entity_type.into(),
+            state: consent.state.into(),
+            entity: consent.entity,
+        }
+    }
+}
+
 #[derive(uniffi::Object, Clone, Debug)]
 pub struct FfiStreamCloser {
     #[allow(clippy::type_complexity)]
@@ -1693,7 +1708,7 @@ impl FfiGroupPermissions {
 mod tests {
     use super::{create_client, signature_verifier, FfiMessage, FfiMessageCallback, FfiXmtpClient};
     use crate::{
-        get_inbox_id_for_address, inbox_owner::SigningError, logger::FfiLogger,
+        get_inbox_id_for_address, inbox_owner::SigningError, logger::FfiLogger, FfiConsent,
         FfiConsentEntityType, FfiConsentState, FfiConversationCallback, FfiCreateGroupOptions,
         FfiGroup, FfiGroupMessageKind, FfiGroupPermissionsOptions, FfiInboxOwner,
         FfiListConversationsOptions, FfiListMessagesOptions, FfiMetadataField, FfiPermissionPolicy,
@@ -2302,7 +2317,7 @@ mod tests {
             .await
             .unwrap();
 
-        let members = group.list_members().unwrap();
+        let members = group.list_members().await.unwrap();
         assert_eq!(members.len(), 2);
     }
 
@@ -2327,7 +2342,7 @@ mod tests {
             .await
             .unwrap();
 
-        let members = group.list_members().unwrap();
+        let members = group.list_members().await.unwrap();
         assert_eq!(members.len(), 2);
         assert_eq!(group.group_name().unwrap(), "Group Name");
         assert_eq!(group.group_image_url_square().unwrap(), "url");
@@ -2591,10 +2606,10 @@ mod tests {
         client2_group.sync().await.unwrap();
 
         // Assert both clients see 2 members
-        let client1_members = client1_group.list_members().unwrap();
+        let client1_members = client1_group.list_members().await.unwrap();
         assert_eq!(client1_members.len(), 2);
 
-        let client2_members = client2_group.list_members().unwrap();
+        let client2_members = client2_group.list_members().await.unwrap();
         assert_eq!(client2_members.len(), 2);
 
         // Drop and delete local database for client2
@@ -2612,12 +2627,12 @@ mod tests {
             .unwrap();
 
         // Assert client1 still sees 2 members
-        let client1_members = client1_group.list_members().unwrap();
+        let client1_members = client1_group.list_members().await.unwrap();
         assert_eq!(client1_members.len(), 2);
 
         client2.conversations().sync().await.unwrap();
         let client2_group = client2.group(group.id()).unwrap();
-        let client2_members = client2_group.list_members().unwrap();
+        let client2_members = client2_group.list_members().await.unwrap();
         assert_eq!(client2_members.len(), 2);
     }
 
@@ -2865,11 +2880,11 @@ mod tests {
             .unwrap();
 
         bo_group.sync().await.unwrap();
-        let bo_members = bo_group.list_members().unwrap();
+        let bo_members = bo_group.list_members().await.unwrap();
         assert_eq!(bo_members.len(), 4);
 
         alix_group.sync().await.unwrap();
-        let alix_members = alix_group.list_members().unwrap();
+        let alix_members = alix_group.list_members().await.unwrap();
         assert_eq!(alix_members.len(), 4);
     }
 
@@ -2891,11 +2906,11 @@ mod tests {
         let bo_group = bo.group(alix_group.id()).unwrap();
 
         alix_group.sync().await.unwrap();
-        let alix_members = alix_group.list_members().unwrap();
+        let alix_members = alix_group.list_members().await.unwrap();
         assert_eq!(alix_members.len(), 2);
 
         bo_group.sync().await.unwrap();
-        let bo_members = bo_group.list_members().unwrap();
+        let bo_members = bo_group.list_members().await.unwrap();
         assert_eq!(bo_members.len(), 2);
 
         let bo_messages = bo_group
@@ -2919,11 +2934,11 @@ mod tests {
         assert!(bo_messages.first().unwrap().kind == FfiGroupMessageKind::MembershipChange);
         assert_eq!(bo_messages.len(), 1);
 
-        let bo_members = bo_group.list_members().unwrap();
+        let bo_members = bo_group.list_members().await.unwrap();
         assert_eq!(bo_members.len(), 1);
 
         alix_group.sync().await.unwrap();
-        let alix_members = alix_group.list_members().unwrap();
+        let alix_members = alix_group.list_members().await.unwrap();
         assert_eq!(alix_members.len(), 1);
     }
 
@@ -3754,12 +3769,11 @@ mod tests {
             .unwrap();
         let alix_updated_consent = alix_group.consent_state().unwrap();
         assert_eq!(alix_updated_consent, FfiConsentState::Denied);
-
-        bo.set_consent_state(
-            FfiConsentState::Allowed,
-            FfiConsentEntityType::GroupId,
-            hex::encode(bo_group.id()),
-        )
+        bo.set_consent_states(vec![FfiConsent {
+            state: FfiConsentState::Allowed,
+            entity_type: FfiConsentEntityType::GroupId,
+            entity: hex::encode(bo_group.id()),
+        }])
         .await
         .unwrap();
         let bo_updated_consent = bo_group.consent_state().unwrap();
@@ -3779,11 +3793,11 @@ mod tests {
             )
             .await
             .unwrap();
-        alix.set_consent_state(
-            FfiConsentState::Allowed,
-            FfiConsentEntityType::Address,
-            bo.account_address.clone(),
-        )
+        alix.set_consent_states(vec![FfiConsent {
+            state: FfiConsentState::Allowed,
+            entity_type: FfiConsentEntityType::Address,
+            entity: bo.account_address.clone(),
+        }])
         .await
         .unwrap();
         let bo_consent = alix
@@ -3794,6 +3808,7 @@ mod tests {
 
         if let Some(member) = alix_group
             .list_members()
+            .await
             .unwrap()
             .iter()
             .find(|&m| m.inbox_id == bo.inbox_id())

bindings_node/src/groups.rs

@@ -209,15 +209,16 @@ impl NapiGroup {
   }
 
   #[napi]
-  pub fn list_members(&self) -> Result<Vec<NapiGroupMember>> {
+  pub async fn list_members(&self) -> Result<Vec<NapiGroupMember>> {
     let group = MlsGroup::new(
       self.inner_client.context().clone(),
       self.group_id.clone(),
       self.created_at_ns,
     );
 
     let members: Vec<NapiGroupMember> = group
-      .members()
+      .members(&self.inner_client)
+      .await
       .map_err(ErrorWrapper::from)?
       .into_iter()
       .map(|member| NapiGroupMember {

bindings_node/test/Conversations.test.ts

@@ -43,7 +43,7 @@ describe('Conversations', () => {
     })
     expect(group.addedByInboxId()).toBe(client1.inboxId())
     expect(group.findMessages().length).toBe(1)
-    const members = group.listMembers()
+    const members = await group.listMembers()
     expect(members.length).toBe(2)
     const memberInboxIds = members.map((member) => member.inboxId)
     expect(memberInboxIds).toContain(client1.inboxId())

examples/cli/Cargo.toml

@@ -16,6 +16,7 @@ path = "cli-client.rs"
 clap = { version = "4.4.6", features = ["derive"] }
 ethers = "2.0.4"
 femme = "2.2.1"
+futures.workspace = true
 hex = "0.4.3"
 kv-log-macro = "1.0.7"
 log = { workspace = true, features = [

examples/cli/cli-client.rs

@@ -15,6 +15,7 @@ use std::{fs, path::PathBuf, time::Duration};
 
 use clap::{Parser, Subcommand, ValueEnum};
 use ethers::signers::{coins_bip39::English, LocalWallet, MnemonicBuilder};
+use futures::future::join_all;
 use kv_log_macro::{error, info};
 use prost::Message;
 use xmtp_id::associations::unverified::{UnverifiedRecoverableEcdsaSignature, UnverifiedSignature};
@@ -214,10 +215,12 @@ async fn main() {
             for group in group_list.iter() {
                 group.sync(&client).await.expect("error syncing group");
             }
+
             let serializable_group_list = group_list
                 .iter()
-                .map(Into::into)
-                .collect::<Vec<SerializableGroup>>();
+                .map(|g| SerializableGroup::from(g, &client))
+                .collect::<Vec<_>>();
+            let serializable_group_list = join_all(serializable_group_list).await;
 
             info!(
                 "group members",
@@ -338,7 +341,7 @@ async fn main() {
                 .group(hex::decode(group_id).expect("bad group id"))
                 .expect("group not found");
             group.sync(&client).await.unwrap();
-            let serializable: SerializableGroup = group.into();
+            let serializable = SerializableGroup::from(group, &client).await;
             info!("Group {}", group_id, { command_output: true, group_id: group_id, group_info: make_value(&serializable) })
         }
         Commands::RequestHistorySync {} => {

examples/cli/serializable.rs

@@ -4,6 +4,7 @@ use xmtp_mls::{
     codecs::{text::TextCodec, ContentCodec},
     groups::MlsGroup,
     storage::group_message::StoredGroupMessage,
+    XmtpApi,
 };
 use xmtp_proto::xmtp::mls::message_contents::EncodedContent;
 
@@ -20,11 +21,15 @@ pub struct SerializableGroup {
     pub metadata: SerializableGroupMetadata,
 }
 
-impl<'a> From<&'a MlsGroup> for SerializableGroup {
-    fn from(group: &'a MlsGroup) -> Self {
+impl SerializableGroup {
+    pub async fn from<ApiClient: XmtpApi>(
+        group: &MlsGroup,
+        client: &xmtp_mls::Client<ApiClient>,
+    ) -> Self {
         let group_id = hex::encode(group.group_id.clone());
         let members = group
-            .members()
+            .members(client)
+            .await
             .expect("could not load members")
             .into_iter()
             .map(|m| m.inbox_id)