Send a partial update when a new member is created

src/commit.rs

@@ -12,13 +12,14 @@ use sdk_common::pcd::{Member, Pcd, RoleDefinition};
 use sdk_common::serialization::{OutPointMemberMap, OutPointProcessMap};
 use sdk_common::silentpayments::create_transaction;
 use sdk_common::sp_client::spclient::Recipient;
-use sdk_common::network::CommitMessage;
+use sdk_common::network::{AnkFlag, CommitMessage, HandshakeMessage};
 use sdk_common::sp_client::bitcoin::consensus::deserialize;
 use sdk_common::sp_client::bitcoin::{Amount, Transaction, OutPoint};
 use sdk_common::process::{lock_processes, Process, ProcessState};
 use serde_json::json;
 use serde_json::Value;
 
+use crate::message::{broadcast_message, BroadcastType};
 use crate::{lock_freezed_utxos, MutexExt, DAEMON, STORAGE, WALLET};
 
 pub(crate) fn handle_commit_request(commit_msg: CommitMessage) -> Result<OutPoint> {
@@ -78,8 +79,36 @@ fn handle_initial_transaction(tx: Transaction, commit_msg: &CommitMessage) -> Re
     let merkle_root_bin = pcd_commitment.create_merkle_tree()?.root().unwrap();
 
     match handle_member_list(pcd_commitment, &parsed_roles, root_commitment) {
-        Ok(()) => {
+        Ok(pairing_process_id) => {
             dump_cached_members()?;
+            // Send a handshake message to every connected client
+            if let Some(new_member) = lock_members().unwrap().get(&pairing_process_id) {
+                let our_sp_address = WALLET
+                    .get()
+                    .ok_or(Error::msg("Wallet not initialized"))?
+                    .get_wallet()?
+                    .get_client()
+                    .get_receiving_address();
+                let mut new_member_map = HashMap::new();
+                new_member_map.insert(pairing_process_id, new_member.clone());
+                let init_msg = HandshakeMessage::new(
+                    our_sp_address, 
+                    OutPointMemberMap(new_member_map),
+                    OutPointProcessMap(HashMap::new()),
+                );
+
+                if let Err(e) = broadcast_message(
+                    AnkFlag::Handshake, 
+                    format!("{}", init_msg.to_string()), 
+                    BroadcastType::ToAll
+                ) 
+                {
+                    log::error!("Failed to send handshake message: {}", e);
+                }
+            } else {
+                log::error!("Failed to find new member with process id {}", pairing_process_id);
+            }
+            
         }
         Err(e) => log::error!("{}", e)
     }
@@ -118,7 +147,7 @@ pub fn lock_members() -> Result<MutexGuard<'static, HashMap<OutPoint, Member>>,
         .lock_anyhow()
 }
 
-fn handle_member_list(pcd_commitment: &Value, roles: &HashMap<String, RoleDefinition>, root_commitment: OutPoint) -> Result<()> {
+fn handle_member_list(pcd_commitment: &Value, roles: &HashMap<String, RoleDefinition>, process_id: OutPoint) -> Result<OutPoint> {
     //Check if the keys exists in the pcd
     if let Value::Object(ref pcd_map) = pcd_commitment {
         if !pcd_map.contains_key("key_parity")
@@ -141,11 +170,11 @@ fn handle_member_list(pcd_commitment: &Value, roles: &HashMap<String, RoleDefini
             let member = owner_role.members.get(0).unwrap();
             let mut memberlist = lock_members()?;
             memberlist.insert(
-                root_commitment,
+                process_id,
                 member.to_owned(),
             );
 
-            return Ok(());
+            return Ok(process_id);
         }
     }