From f789b3037281123d2ed31bd51496eb5d5f41240f Mon Sep 17 00:00:00 2001
From: Sosthene <contact@sosthene.net>
Date: Wed, 11 Dec 2024 23:37:59 +0100
Subject: [PATCH] Update update_process

---
 src/api.rs | 58 +++++++++++++++---------------------------------------
 1 file changed, 16 insertions(+), 42 deletions(-)

diff --git a/src/api.rs b/src/api.rs
index 066ee64..2c8cf32 100644
--- a/src/api.rs
+++ b/src/api.rs
@@ -1314,7 +1314,7 @@ pub fn create_new_process(
 #[wasm_bindgen]
 pub fn update_process(
     init_commitment: String,
-    new_state: String,
+    new_state_str: String,
 ) -> ApiResult<ApiReturn> {
     let outpoint = OutPoint::from_str(&init_commitment)?;
 
@@ -1322,46 +1322,29 @@ pub fn update_process(
     let process = processes.get_mut(&outpoint)
         .ok_or(ApiError::new("Unknown process".to_owned()))?;
 
-    let last_state = process.get_latest_commited_state()
+    let prev_state = process.get_latest_commited_state()
         .ok_or(ApiError::new("Process must have at least one state already commited".to_owned()))?;
 
-    let last_state_commitments = &last_state.pcd_commitment;
+    let last_state_commitments = &prev_state.pcd_commitment;
 
-    let new_state_val = Value::from_str(&new_state)?;
+    let clear_new_state = Value::from_str(&new_state_str)?.to_value_object()?;
 
-    // We hash all the new values
-    let pcd_commitment = Value::Object(new_state_val.hash_all_fields(outpoint)?);
-    let new_state_merkle_root = <Value as Pcd>::create_merkle_tree(&pcd_commitment)?.root().unwrap();
+    let new_state = ProcessState::new(prev_state.commited_in, clear_new_state.clone())?;
 
     // We compare the new state with the previous one
-    let last_state_merkle_root = <Value as Pcd>::create_merkle_tree(last_state_commitments)?.root().unwrap();
+    let last_state_merkle_root = &prev_state.merkle_root;
 
-    if last_state_merkle_root == new_state_merkle_root {
+    if *last_state_merkle_root == new_state.merkle_root {
         return Err(ApiError::new("new proposed state is identical to the previous commited state".to_owned()));
     }
 
-    // We create the encrypted pcd
-    let mut fields2keys = Map::new();
-    let mut fields2cipher = Map::new();
-    let fields_to_encrypt: Vec<String> = new_state_val
-        .as_object()
-        .unwrap()
-        .keys()
-        .map(|k| k.clone())
-        .collect();
-    new_state_val.encrypt_fields(&fields_to_encrypt, &mut fields2keys, &mut fields2cipher);
+    // We check that we don't have already a similar concurrent state
+    let concurrent_processes = process.get_latest_concurrent_states()?;
+    if concurrent_processes.iter().any(|p| p.merkle_root == new_state.merkle_root) {
+        return Err(ApiError::new("New state already known".to_owned()));
+    }
 
-    let encrypted_pcd = Value::Object(fields2cipher);
-
-    let device = lock_local_device()?;
-
-    let new_state = ProcessState {
-        commited_in: outpoint,
-        pcd_commitment: pcd_commitment,
-        encrypted_pcd: encrypted_pcd,
-        keys: fields2keys,
-        validation_tokens: vec![]
-    };
+    let diffs = create_diffs(&process, &new_state)?;
 
     // Add the new state to the process
     process.insert_concurrent_state(new_state.clone())?;
@@ -1369,7 +1352,7 @@ pub fn update_process(
     let updated_process = UpdatedProcess {
         commitment_tx: outpoint,
         current_process: process.clone(),
-        new_state: Some(new_state),
+        new_diffs: diffs,
         ..Default::default()
     };
 
@@ -1391,19 +1374,10 @@ pub fn create_update_message(
     let process = processes.get_mut(&outpoint)
         .ok_or(ApiError::new("Unknown process".to_owned()))?;
 
-    let mut merkle_root_bin = [0u8; 32];
-    let merkle_root_vec = Vec::from_hex(&merkle_root_hex)?;
-
-    if merkle_root_vec.len() != 32 {
-        return Err(ApiError::new("merkle root must be 32B long".to_owned()));
-    }
-
-    merkle_root_bin.copy_from_slice(&merkle_root_vec);
-
-    let update_state = process.get_state_for_commitments_root(merkle_root_bin)?;
+    let update_state = process.get_state_for_commitments_root(&merkle_root_hex)?;
 
     // 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()?.to_value_object()?;
+    let clear_state = update_state.decrypt_pcd()?;
 
     let roles = Value::Object(clear_state).extract_roles()?;