diff --git a/src/commit.rs b/src/commit.rs
index a85e0e8..4521009 100644
--- a/src/commit.rs
+++ b/src/commit.rs
@@ -50,7 +50,7 @@ fn parse_initial_tx(init_tx: &str) -> Result<InitialTx> {
 
 // Handle the case where `init_tx` is a new transaction
 fn handle_initial_transaction(tx: Transaction, commit_msg: &CommitMessage) -> Result<OutPoint> {
-    let root_commitment = OutPoint::new(tx.txid(), 0);
+    let process_id = OutPoint::new(tx.txid(), 0);
 
     // Validation tokens must be empty for the initial transaction
     if !commit_msg.validation_tokens.is_empty() {
@@ -78,44 +78,40 @@ 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(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 Ok(pairing_process_id) = handle_member_list(pcd_commitment, &parsed_roles, 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);
+            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)
     }
 
-    let mut new_process = Process::new(root_commitment);
+    let mut new_process = Process::new(process_id);
     let init_state = ProcessState {
-        commited_in: root_commitment,
+        commited_in: process_id,
         encrypted_pcd: roles_only_map,
         pcd_commitment: commit_msg.pcd_commitment.clone(),        
         state_id: merkle_root_bin.to_lower_hex_string(),
@@ -126,17 +122,41 @@ fn handle_initial_transaction(tx: Transaction, commit_msg: &CommitMessage) -> Re
 
     // Cache the process
     lock_processes()?.insert(
-        root_commitment,
-        new_process,
+        process_id,
+        new_process.clone(),
     );
 
     // Dump to disk
     dump_cached_processes()?;
 
     // Add to frozen UTXOs
-    lock_freezed_utxos()?.insert(root_commitment);
+    lock_freezed_utxos()?.insert(process_id);
 
-    Ok(root_commitment)
+    // Send an update to all connected client
+    let our_sp_address = WALLET
+        .get()
+        .ok_or(Error::msg("Wallet not initialized"))?
+        .get_wallet()?
+        .get_client()
+        .get_receiving_address();
+    let mut new_process_map = HashMap::new();
+    new_process_map.insert(process_id, new_process);
+    let init_msg = HandshakeMessage::new(
+        our_sp_address, 
+        OutPointMemberMap(HashMap::new()),
+        OutPointProcessMap(new_process_map),
+    );
+
+    if let Err(e) = broadcast_message(
+        AnkFlag::Handshake, 
+        format!("{}", init_msg.to_string()), 
+        BroadcastType::ToAll
+    ) 
+    {
+        log::error!("Failed to send handshake message: {}", e);
+    }
+
+    Ok(process_id)
 }
 
 pub static MEMBERLIST: OnceLock<Mutex<HashMap<OutPoint, Member>>> = OnceLock::new();