create_response_message takes the merkle root

src/api.rs

@@ -1361,6 +1361,13 @@ pub fn create_update_message(
 
 #[wasm_bindgen]
 pub fn create_response_message(init_commitment: String, pcd_commitment: String, approval: bool) -> ApiResult<ApiReturn> {
+    let mut merkle_root = [0u8; 32];
+    let pcd_commitment_vec = Vec::from_hex(&pcd_commitment)?;
+    if pcd_commitment_vec.len() != 32 {
+        return Err(ApiError::new("pcd_commitment must be 32B long".to_owned()));
+    }
+    merkle_root.copy_from_slice(&pcd_commitment_vec);
+
     let mut processes = lock_processes()?;
 
     let outpoint = OutPoint::from_str(&init_commitment)?;
@@ -1368,17 +1375,7 @@ pub fn create_response_message(init_commitment: String, pcd_commitment: String,
     let process = processes.get_mut(&outpoint)
         .ok_or(ApiError::new("Unknown process".to_owned()))?;
 
-    let latest_states = process.get_latest_concurrent_states_mut()?;
+    let update_state: &mut ProcessState = process.get_state_for_commitments_root(merkle_root)?;
-    // This is a map of keys to hash of the clear values
-    let new_state_commitments = <Value as Pcd>::from_string(&pcd_commitment)?;
-
-    let update_state: &mut ProcessState;
-    if let Some(state) = latest_states.into_iter().find(|state| state.pcd_commitment == new_state_commitments) 
-    {
-        update_state = state; 
-    } else {
-        return Err(ApiError::new("Can't find the state to update".to_owned()));
-    }
 
     // We must have at least the key for the roles field, otherwise we don't know who to send the message to
     let clear_state = update_state.decrypt_pcd().as_object().unwrap().clone();
@@ -1420,14 +1417,10 @@ pub fn create_response_message(init_commitment: String, pcd_commitment: String,
     let sender: Member = local_device
         .to_member();
 
-    let encrypted_pcd_hash = update_state.encrypted_pcd.hash_fields(OutPoint::null())?;
-    let encrypted_pcd_merkle_root = <Value as Pcd>::create_merkle_tree(&Value::Object(encrypted_pcd_hash))?.root().unwrap();
-
-    let root = <Value as Pcd>::create_merkle_tree(&new_state_commitments)?.root().unwrap();
     let message_hash = if approval {
-        AnkHash::ValidationYes(AnkValidationYesHash::from_byte_array(root))
+        AnkHash::ValidationYes(AnkValidationYesHash::from_byte_array(merkle_root))
     } else {
-        AnkHash::ValidationNo(AnkValidationNoHash::from_byte_array(root))
+        AnkHash::ValidationNo(AnkValidationNoHash::from_byte_array(merkle_root))
     };
     let proof = Proof::new(message_hash, sp_wallet.get_client().get_spend_key().try_into()?);
 
@@ -1435,7 +1428,7 @@ pub fn create_response_message(init_commitment: String, pcd_commitment: String,
         outpoint,
         serde_json::to_string(&sender)?,
         vec![proof], 
-        new_state_commitments
+        update_state.pcd_commitment.clone(),
     );
     let prd_msg = response_prd.to_network_msg(sp_wallet)?;
 

tests/pairing.rs

@@ -251,8 +251,10 @@ fn test_pairing() {
     let concurrent_states = relevant_process.get_latest_concurrent_states().unwrap();
     let relevant_state = concurrent_states.into_iter().find(|s| s.pcd_commitment == commit_msg.pcd_commitment).unwrap();
 
+    let root = <Value as Pcd>::create_merkle_tree(&relevant_state.pcd_commitment).unwrap().root().unwrap();
+
     // Alice can also sign her response and send it to Bob
-    let alice_response = create_response_message(commit_msg.init_tx, relevant_state.pcd_commitment.to_string(), true).unwrap();
+    let alice_response = create_response_message(commit_msg.init_tx, root.to_lower_hex_string(), true).unwrap();
 
     let (outpoint, updated_process) = alice_response.updated_process.unwrap();
 
@@ -316,16 +318,7 @@ fn test_pairing() {
 
     // If user is ok, we can add our own validation token
     // Get the whole commitment from the process
-    let process = alice_process_cache.get(&root_outpoint).unwrap();
+    let bob_response = create_response_message(root_outpoint, pcd_commitment_root.to_string(), true).unwrap();
-    let mut pcd_commitment = String::default();
-    for p in process.get_latest_concurrent_states().unwrap() {
-        let root = <Value as Pcd>::create_merkle_tree(&p.pcd_commitment).unwrap().root().unwrap();
-        if *pcd_commitment_root == root.to_lower_hex_string() { 
-            pcd_commitment = p.pcd_commitment.to_string();
-            break;
-        }
-    }
-    let bob_response = create_response_message(root_outpoint, pcd_commitment, true).unwrap();
 
     let (root_outpoint, updated_process) = bob_response.updated_process.unwrap();
     let ciphers = bob_response.ciphers_to_send; // We would send it to Alice to let her know we agree

tests/utils.rs

@@ -69,7 +69,7 @@ pub fn helper_parse_transaction(transaction: &str, tweak_data: &str) -> ApiRetur
     ))
     .unwrap();
     // debug!("new_tx_msg: {:?}", new_tx_msg);
-    let result = parse_new_tx(new_tx_msg, 0, 1);
+    let result = parse_new_tx(new_tx_msg, 0);
     match result {
         Ok(m) => m,
         Err(e) => panic!("Unexpected error: {}", e.message),