Handle public_data in commitments message

src/commit.rs

@@ -1,5 +1,5 @@
 use std::{
-    collections::{HashMap, HashSet},
+    collections::{BTreeMap, HashMap, HashSet},
     sync::{Mutex, MutexGuard, OnceLock},
 };
 
@@ -108,6 +108,7 @@ fn handle_new_process(commit_msg: &CommitMessage) -> Result<Process> {
         roles: commit_msg.roles.clone().into_iter().collect(),
         pcd_commitment: commit_msg.pcd_commitment.clone(),        
         state_id: merkle_root_bin.to_lower_hex_string(),
+        public_data: commit_msg.public_data.clone(),
         ..Default::default()
     };
 
@@ -124,7 +125,7 @@ pub fn lock_members() -> Result<MutexGuard<'static, HashMap<OutPoint, Member>>,
         .lock_anyhow()
 }
 
-fn handle_member_list(roles: &HashMap<String, RoleDefinition>, process_id: OutPoint) -> Result<OutPoint> {
+fn handle_member_list(roles: &BTreeMap<String, RoleDefinition>, process_id: OutPoint) -> Result<OutPoint> {
     //Check if there is one role with one member
     if roles.len() != 1 {
         return Err(Error::msg("Process is not a pairing process"));
@@ -191,28 +192,22 @@ pub fn dump_cached_processes(processes: HashMap<OutPoint, Process>) -> Result<()
     Ok(())
 }
 
-// pub fn load_cached_processes() -> Result<(), anyhow::Error> {
-//     let storage = STORAGE.get().ok_or(Error::msg("STORAGE is not initialized"))?.lock_anyhow()?;
-
-//     let processes_file = &storage.processes_file;
-
-//     let raw_data = processes_file.load()?;
-//     let processes: HashMap<OutPoint, Process> = serde_json::from_slice(&raw_data)?;
-
-//     let mut cached_processes = lock_processes()?;
-
-//     *cached_processes = processes;
-    
-//     Ok(())
-// }
-
 // Register a new state
 fn register_new_state(process: &mut Process, commit_msg: &CommitMessage) -> Result<String> {
+    let last_commited_state = process.get_latest_commited_state();
+
+    let new_state_id = commit_msg.pcd_commitment.create_merkle_tree()?.root().unwrap().to_lower_hex_string();
+
+    if let Some(state) = last_commited_state {
+        if new_state_id == state.state_id {
+            return Err(Error::msg(format!("{}", new_state_id)));
+        }
+    }
+
     let concurrent_states = process.get_latest_concurrent_states()?;
     let (empty_state, actual_states) = concurrent_states.split_last().unwrap();
     let current_outpoint = empty_state.commited_in;
 
-    let new_state_id = commit_msg.pcd_commitment.create_merkle_tree()?.root().unwrap().to_lower_hex_string();
 
     // Ensure no duplicate states
     if actual_states
@@ -228,6 +223,7 @@ fn register_new_state(process: &mut Process, commit_msg: &CommitMessage) -> Resu
         pcd_commitment: commit_msg.pcd_commitment.clone(),
         state_id: new_state_id.clone(),
         roles: commit_msg.roles.clone().into_iter().collect(),
+        public_data: commit_msg.public_data.clone(),
         ..Default::default()
     };
     process.insert_concurrent_state(new_state)?;
@@ -487,12 +483,13 @@ mod tests {
             validation_rules: vec![validation_rule],
             storages: vec![],
         };
-        let roles = HashMap::from([(String::from("role_name"), role_def)]);
+        let roles = BTreeMap::from([(String::from("role_name"), role_def)]);
         let pcd_commitment = json!({field_name: "b30212b9649054b71f938fbe0d1c08e72de95bdb12b8008082795c6e9c4ad26a"});
 
         let commit_msg = CommitMessage {
             process_id,
             roles: roles.clone(),
+            public_data: BTreeMap::new(),
             validation_tokens: vec![],
             pcd_commitment: pcd_commitment.clone(),
             error: None,