From f899719cc1fa04959cb87b709fdb4c1d38ee936a Mon Sep 17 00:00:00 2001 From: Sosthene Date: Thu, 12 Dec 2024 16:47:36 +0100 Subject: [PATCH] Update ProcessState with descriptions --- src/api.rs | 61 +++++++++++++++++++----------------------------- tests/pairing.rs | 2 +- 2 files changed, 25 insertions(+), 38 deletions(-) diff --git a/src/api.rs b/src/api.rs index 8f8bd4a..3a33ccf 100644 --- a/src/api.rs +++ b/src/api.rs @@ -90,9 +90,11 @@ pub enum DiffStatus { #[tsify(into_wasm_abi)] #[allow(non_camel_case_types)] pub struct UserDiff { + pub process_id: String, pub new_state_merkle_root: String, // TODO add a merkle proof that the new_value belongs to that state pub value_commitment: String, pub field: String, + pub description: Option, pub previous_value: Value, pub new_value: Value, pub notify_user: bool, @@ -711,24 +713,30 @@ fn create_diffs(process: &Process, new_state: &ProcessState) -> AnyhowResult Map::new() }; + let new_state_descriptions = &new_state.descriptions; + + let process_id = process.get_process_id()?.to_string(); let mut diffs = vec![]; if let Some(prev_state) = process.get_latest_commited_state() { // We first decrypt as much as we can of the prev_state let clear_prev_state = prev_state.decrypt_pcd()?; // We just make a diff for values that are different from previous state for (field, prev_hash) in prev_state.pcd_commitment.as_object().unwrap() { + let description = new_state_descriptions.get(field).map(|d| d.to_string()); + let new_value = if let Some(val) = new_state_decrypted.get(field.as_str()) { val.clone() } else { Value::Null }; + let need_validation = if (is_pairing && field.as_str() == "roles" && new_value != Value::Null) || fields_to_validate.contains(field) { true } else { false }; if let Some(new_hash) = new_state_commitments.get(field.as_str()) { if new_hash.as_str() == prev_hash.as_str() { continue; } else { // There's a diff let previous_value = clear_prev_state.get(field.as_str()).unwrap().clone(); - let new_value = if let Some(val) = new_state_decrypted.get(field.as_str()) { val.clone() } else { Value::Null }; - let need_validation = if (is_pairing && field.as_str() == "roles" && new_value != Value::Null) || fields_to_validate.contains(field) { true } else { false }; diffs.push(UserDiff { + process_id: process_id.clone(), new_state_merkle_root: new_state_root.to_owned(), value_commitment: new_hash.as_str().unwrap().to_string(), field: field.to_owned(), + description, previous_value, new_value, notify_user: false, @@ -744,12 +752,15 @@ fn create_diffs(process: &Process, new_state: &ProcessState) -> AnyhowResult, fee_rate: u32) -> Ap #[wasm_bindgen] pub fn create_new_process( - init_state: String, + init_state_str: String, + descriptions_str: Option, relay_address: String, fee_rate: u32, ) -> ApiResult { - let pcd = ::new_from_string(&init_state)?; + let init_state = ::new_from_string(&init_state_str)?; + let descriptions = if let Some(d) = descriptions_str { ::new_from_string(&d)? } else { Value::Object(Map::new()) }; // check that we have a proper roles map - let roles = pcd.extract_roles()?; - - // We create the encryption keys for each field and encrypt them - let mut fields2keys = Map::new(); - let mut fields2cipher = Map::new(); - let fields_to_encrypt: Vec = pcd - .as_object() - .unwrap() - .keys() - .map(|k| k.clone()) - .collect(); - - pcd.encrypt_fields(&fields_to_encrypt, &mut fields2keys, &mut fields2cipher); + let roles = init_state.extract_roles()?; // We create a transaction that spends to the relay address let psbt = create_transaction_for_addresses(vec![relay_address.clone()], fee_rate)?; @@ -1184,26 +1185,13 @@ pub fn create_new_process( // We now have the outpoint that will serve as id for the whole process let outpoint = OutPoint::new(transaction.txid(), 0); - // We now need a hash that commits to the clear value of each field + the process id (or outpoint) - let pcd_commitment = Value::Object(pcd.hash_all_fields(outpoint)?); - - let merkle_root = pcd_commitment.create_merkle_tree()?.root().ok_or(ApiError::new("Invalid merkle tree".to_owned()))?.to_lower_hex_string(); + let new_state = ProcessState::new(outpoint, init_state.to_value_object()?, descriptions.to_value_object()?)?; let mut process = Process::new(outpoint); - // We now create the first process state with all that data - let process_state = ProcessState { - commited_in: outpoint, - pcd_commitment: pcd_commitment.clone(), - merkle_root: merkle_root.clone(), - encrypted_pcd: Value::Object(fields2cipher.clone()), - keys: fields2keys.clone(), - validation_tokens: vec![], - }; + let diffs = create_diffs(&process, &new_state)?; - let diffs = create_diffs(&process, &process_state)?; - - process.insert_concurrent_state(process_state.clone())?; + process.insert_concurrent_state(new_state.clone())?; { let mut processes = lock_processes()?; @@ -1214,7 +1202,7 @@ pub fn create_new_process( processes.insert(outpoint.clone(), process.clone()); } - let commit_msg = CommitMessage::new_first_commitment(transaction, pcd_commitment, roles); + let commit_msg = CommitMessage::new_first_commitment(transaction, new_state.pcd_commitment, roles); let updated_process = UpdatedProcess { commitment_tx: outpoint, @@ -1246,10 +1234,11 @@ pub fn update_process( .ok_or(ApiError::new("Process must have at least one state already commited".to_owned()))?; let last_state_commitments = &prev_state.pcd_commitment; + let last_state_descriptions = &prev_state.descriptions; let clear_new_state = Value::from_str(&new_state_str)?.to_value_object()?; - let new_state = ProcessState::new(prev_state.commited_in, clear_new_state.clone())?; + let new_state = ProcessState::new(prev_state.commited_in, clear_new_state.clone(), last_state_descriptions.clone())?; // We compare the new state with the previous one let last_state_merkle_root = &prev_state.merkle_root; @@ -1373,8 +1362,6 @@ pub fn create_update_message( return Err(ApiError::new("Empty ciphers list".to_owned())); } - process.insert_impending_request(full_prd); - let updated_process = UpdatedProcess { commitment_tx: outpoint, current_process: process.clone(), diff --git a/tests/pairing.rs b/tests/pairing.rs index 267b1c7..e06a5c3 100644 --- a/tests/pairing.rs +++ b/tests/pairing.rs @@ -166,7 +166,7 @@ fn test_pairing() { }); debug!("Alice creates the pairing process"); - let create_process_return = create_new_process(pairing_init_state.to_string(), RELAY_ADDRESS.to_owned(), 1).unwrap(); + let create_process_return = create_new_process(pairing_init_state.to_string(), None, RELAY_ADDRESS.to_owned(), 1).unwrap(); let commit_msg = create_process_return.commit_to_send.unwrap();