Provide timestamps in identity action updates (#1073)

bindings_ffi/src/mls.rs

@@ -1044,15 +1044,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,
@@ -2289,7 +2290,7 @@ mod tests {
             .await
             .unwrap();
 
-        let members = group.list_members().unwrap();
+        let members = group.list_members().await.unwrap();
         assert_eq!(members.len(), 2);
     }
 
@@ -2314,7 +2315,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");
@@ -2578,10 +2579,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
@@ -2599,12 +2600,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);
     }
 
@@ -2852,11 +2853,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);
     }
 
@@ -2878,11 +2879,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
@@ -2906,11 +2907,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);
     }
 
@@ -3749,6 +3750,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};
@@ -213,10 +214,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",
@@ -337,7 +340,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)

xmtp_id/src/associations/association_log.rs

@@ -40,6 +40,7 @@ pub trait IdentityAction: Send + 'static {
     fn update_state(
         &self,
         existing_state: Option<AssociationState>,
+        client_timestamp_ns: u64,
     ) -> Result<AssociationState, AssociationError>;
     fn signatures(&self) -> Vec<Vec<u8>>;
     fn replay_check(&self, state: &AssociationState) -> Result<(), AssociationError> {
@@ -66,6 +67,7 @@ impl IdentityAction for CreateInbox {
     fn update_state(
         &self,
         existing_state: Option<AssociationState>,
+        _client_timestamp_ns: u64,
     ) -> Result<AssociationState, AssociationError> {
         if existing_state.is_some() {
             return Err(AssociationError::MultipleCreate);
@@ -106,6 +108,7 @@ impl IdentityAction for AddAssociation {
     fn update_state(
         &self,
         maybe_existing_state: Option<AssociationState>,
+        client_timestamp_ns: u64,
     ) -> Result<AssociationState, AssociationError> {
         let existing_state = maybe_existing_state.ok_or(AssociationError::NotCreated)?;
         self.replay_check(&existing_state)?;
@@ -176,7 +179,11 @@ impl IdentityAction for AddAssociation {
             self.new_member_identifier.kind(),
         )?;
 
-        let new_member = Member::new(new_member_address.clone(), Some(existing_entity_id));
+        let new_member = Member::new(
+            new_member_address.clone(),
+            Some(existing_entity_id),
+            Some(client_timestamp_ns),
+        );
 
         Ok(existing_state.add(new_member))
     }
@@ -200,6 +207,7 @@ impl IdentityAction for RevokeAssociation {
     fn update_state(
         &self,
         maybe_existing_state: Option<AssociationState>,
+        _client_timestamp_ns: u64,
     ) -> Result<AssociationState, AssociationError> {
         let existing_state = maybe_existing_state.ok_or(AssociationError::NotCreated)?;
         self.replay_check(&existing_state)?;
@@ -255,6 +263,7 @@ impl IdentityAction for ChangeRecoveryAddress {
     fn update_state(
         &self,
         existing_state: Option<AssociationState>,
+        _client_timestamp_ns: u64,
     ) -> Result<AssociationState, AssociationError> {
         let existing_state = existing_state.ok_or(AssociationError::NotCreated)?;
         self.replay_check(&existing_state)?;
@@ -292,12 +301,19 @@ impl IdentityAction for Action {
     fn update_state(
         &self,
         existing_state: Option<AssociationState>,
+        client_timestamp_ns: u64,
     ) -> Result<AssociationState, AssociationError> {
         match self {
-            Action::CreateInbox(event) => event.update_state(existing_state),
-            Action::AddAssociation(event) => event.update_state(existing_state),
-            Action::RevokeAssociation(event) => event.update_state(existing_state),
-            Action::ChangeRecoveryAddress(event) => event.update_state(existing_state),
+            Action::CreateInbox(event) => event.update_state(existing_state, client_timestamp_ns),
+            Action::AddAssociation(event) => {
+                event.update_state(existing_state, client_timestamp_ns)
+            }
+            Action::RevokeAssociation(event) => {
+                event.update_state(existing_state, client_timestamp_ns)
+            }
+            Action::ChangeRecoveryAddress(event) => {
+                event.update_state(existing_state, client_timestamp_ns)
+            }
         }
     }
 
@@ -333,10 +349,11 @@ impl IdentityAction for IdentityUpdate {
     fn update_state(
         &self,
         existing_state: Option<AssociationState>,
+        _client_timestamp_ns: u64,
     ) -> Result<AssociationState, AssociationError> {
         let mut state = existing_state.clone();
         for action in &self.actions {
-            state = Some(action.update_state(state)?);
+            state = Some(action.update_state(state, self.client_timestamp_ns)?);
         }
 
         let new_state = state.ok_or(AssociationError::NotCreated)?;

xmtp_id/src/associations/member.rs

@@ -77,13 +77,19 @@ impl From<Vec<u8>> for MemberIdentifier {
 pub struct Member {
     pub identifier: MemberIdentifier,
     pub added_by_entity: Option<MemberIdentifier>,
+    pub client_timestamp_ns: Option<u64>,
 }
 
 impl Member {
-    pub fn new(identifier: MemberIdentifier, added_by_entity: Option<MemberIdentifier>) -> Self {
+    pub fn new(
+        identifier: MemberIdentifier,
+        added_by_entity: Option<MemberIdentifier>,
+        client_timestamp_ns: Option<u64>,
+    ) -> Self {
         Self {
             identifier,
             added_by_entity,
+            client_timestamp_ns,
         }
     }
 
@@ -118,6 +124,7 @@ mod tests {
             Self {
                 identifier: MemberIdentifier::default(),
                 added_by_entity: None,
+                client_timestamp_ns: None,
             }
         }
     }

xmtp_id/src/associations/mod.rs

@@ -23,7 +23,7 @@ pub fn apply_update(
     initial_state: AssociationState,
     update: IdentityUpdate,
 ) -> Result<AssociationState, AssociationError> {
-    update.update_state(Some(initial_state))
+    update.update_state(Some(initial_state), update.client_timestamp_ns)
 }
 
 // Get the current state from an array of `IdentityUpdate`s. Entire operation fails if any operation fails
@@ -32,7 +32,7 @@ pub fn get_state<Updates: AsRef<[IdentityUpdate]>>(
 ) -> Result<AssociationState, AssociationError> {
     let mut state = None;
     for update in updates.as_ref().iter() {
-        let res = update.update_state(state);
+        let res = update.update_state(state, update.client_timestamp_ns);
         state = Some(res?);
     }
 

xmtp_id/src/associations/serialization.rs

@@ -318,6 +318,7 @@ impl From<Member> for MemberProto {
         MemberProto {
             identifier: Some(member.identifier.into()),
             added_by_entity: member.added_by_entity.map(Into::into),
+            client_timestamp_ns: member.client_timestamp_ns,
         }
     }
 }
@@ -332,6 +333,7 @@ impl TryFrom<MemberProto> for Member {
                 .ok_or(DeserializationError::MissingMemberIdentifier)?
                 .try_into()?,
             added_by_entity: proto.added_by_entity.map(TryInto::try_into).transpose()?,
+            client_timestamp_ns: proto.client_timestamp_ns,
         })
     }
 }

xmtp_id/src/associations/state.rs

@@ -163,13 +163,9 @@ impl AssociationState {
     pub fn new(account_address: String, nonce: u64) -> Self {
         let inbox_id = generate_inbox_id(&account_address, &nonce);
         let identifier = MemberIdentifier::Address(account_address.clone());
-        let new_member = Member::new(identifier.clone(), None);
+        let new_member = Member::new(identifier.clone(), None, None);
         Self {
-            members: {
-                let mut members = HashMap::new();
-                members.insert(identifier, new_member);
-                members
-            },
+            members: HashMap::from_iter([(identifier, new_member)]),
             seen_signatures: HashSet::new(),
             recovery_address: account_address.to_lowercase(),
             inbox_id,

xmtp_mls/migrations/2024-09-18-185314_clear_association_states_cache/up.sql

@@ -0,0 +1 @@
+DELETE FROM association_state;