ApiReturn secrets is Option<SecretsStore> with only new secrets

src/api.rs

@@ -80,7 +80,7 @@ use crate::wallet::{generate_sp_wallet, lock_freezed_utxos};
 #[tsify(into_wasm_abi, from_wasm_abi)]
 #[allow(non_camel_case_types)]
 pub struct ApiReturn {
-    pub secrets: SecretsStore,
+    pub secrets: Option<SecretsStore>,
     pub updated_process: Option<(String, Process)>,
     pub new_tx_to_send: Option<NewTxMessage>,
     pub ciphers_to_send: Vec<String>,
@@ -538,6 +538,10 @@ fn handle_transaction(
         // We keep the shared_secret as unconfirmed
         shared_secrets.add_unconfirmed_secret(shared_secret);
 
+        // We also return it
+        let mut new_secret = SecretsStore::new();
+        new_secret.add_unconfirmed_secret(shared_secret);
+
         // We hash the shared secret to commit into the prd connect
         let secret_hash = AnkMessageHash::from_message(shared_secret.as_byte_array());
 
@@ -550,7 +554,7 @@ fn handle_transaction(
         let cipher = encrypt_with_key(shared_secret.as_byte_array(), msg.as_bytes())?;
 
         return Ok(ApiReturn {
-            secrets: shared_secrets.to_owned(),
+            secrets: Some(new_secret),
             ciphers_to_send: vec![cipher.to_lower_hex_string()],
             ..Default::default()
         })
@@ -736,10 +740,11 @@ fn handle_prd_connect(prd: Prd, secret: AnkSharedSecretHash) -> AnyhowResult<Api
         let proof = prd.proof.unwrap();
         let actual_sender = sender.get_address_for_key(&proof.get_key())
             .ok_or(anyhow::Error::msg("Signer of the proof is not part of sender"))?;
-        shared_secrets.confirm_secret_for_address(secret, actual_sender.try_into()?);
+        shared_secrets.confirm_secret_for_address(secret, actual_sender.clone().try_into()?);
-        debug!("updated secrets");
+        let mut secrets_return = SecretsStore::new();
+        secrets_return.confirm_secret_for_address(secret, actual_sender.try_into()?);
         return Ok(ApiReturn {
-            secrets: shared_secrets.to_owned(),
+            secrets: Some(secrets_return),
             ..Default::default()
         })
     } else {
@@ -748,7 +753,10 @@ fn handle_prd_connect(prd: Prd, secret: AnkSharedSecretHash) -> AnyhowResult<Api
         let actual_sender = sender.get_address_for_key(&proof.get_key())
             .ok_or(anyhow::Error::msg("Signer of the proof is not part of sender"))?;
 
-        shared_secrets.confirm_secret_for_address(secret, actual_sender.try_into()?);
+        shared_secrets.confirm_secret_for_address(secret, actual_sender.clone().try_into()?);
+
+        let mut secrets_return = SecretsStore::new();
+        secrets_return.confirm_secret_for_address(secret, actual_sender.try_into()?);
 
         let prd_connect = Prd::new_connect(local_member, secret_hash, prd.proof);
         let msg = prd_connect.to_network_msg(sp_wallet)?;
@@ -756,7 +764,7 @@ fn handle_prd_connect(prd: Prd, secret: AnkSharedSecretHash) -> AnyhowResult<Api
 
         return Ok(ApiReturn {
             ciphers_to_send: vec![cipher.to_lower_hex_string()],
-            secrets: shared_secrets.to_owned(),
+            secrets: Some(secrets_return),
             ..Default::default()
         })
     }
@@ -1059,13 +1067,15 @@ pub fn create_connect_transaction(members_str: Vec<String>, fee_rate: u32) -> Ap
     let transaction = psbt.extract_tx()?;
 
     let mut shared_secrets = lock_shared_secrets()?;
+    let mut secrets_return = SecretsStore::new();
     for (address, secret) in new_secrets {
         shared_secrets.confirm_secret_for_address(secret, address);
+        secrets_return.confirm_secret_for_address(secret, address);
     }
 
     Ok(ApiReturn {
         new_tx_to_send: Some(NewTxMessage::new(serialize(&transaction).to_lower_hex_string(), None)),
-        secrets: shared_secrets.to_owned(),
+        secrets: Some(secrets_return),
         ..Default::default()
     })
 }
@@ -1100,8 +1110,10 @@ pub fn create_new_process(
     let new_secrets = get_shared_secrets_in_transaction(&psbt, vec![relay_address])?;
 
     let mut shared_secrets = lock_shared_secrets()?;
+    let mut secrets_return = SecretsStore::new();
     for (address, secret) in new_secrets {
         shared_secrets.confirm_secret_for_address(secret, address);
+        secrets_return.confirm_secret_for_address(secret, address);
     }
 
     let transaction = psbt.extract_tx()?;
@@ -1135,7 +1147,7 @@ pub fn create_new_process(
     let commit_msg = CommitMessage::new_first_commitment(transaction, Value::Object(fields_commitment), roles);
 
     Ok(ApiReturn {
-        secrets: shared_secrets.clone(),
+        secrets: Some(secrets_return),
         commit_to_send: Some(commit_msg),
         updated_process: Some((outpoint.to_string(), process)),
         ..Default::default()

tests/connect.rs

@@ -106,7 +106,21 @@ fn test_connect() {
     let alice_connect_transaction = connect_tx_msg.transaction;
 
     let alice_device = dump_device().unwrap();
-    alice_secrets_store = alice_connect_return.secrets;
+
+    // Below is how to update our secrets store when secrets is Some
+    let secrets_update = alice_connect_return.secrets.unwrap();
+    let unconfirmed_secrets = secrets_update.get_all_unconfirmed_secrets();
+    if !unconfirmed_secrets.is_empty() {
+        for secret in unconfirmed_secrets {
+            alice_secrets_store.add_unconfirmed_secret(secret);
+        }
+    }
+    let updated_confirmed_secrets = secrets_update.get_all_confirmed_secrets();
+    if !updated_confirmed_secrets.is_empty() {
+        for (address, secret) in updated_confirmed_secrets {
+            alice_secrets_store.confirm_secret_for_address(secret, address);
+        }
+    }
 
     // ======================= Bob
     reset_device().unwrap();
@@ -119,7 +133,19 @@ fn test_connect() {
     let bob_to_alice_cipher = &bob_parsed_transaction_return.ciphers_to_send[0];
 
     let bob_device = dump_device().unwrap();
-    bob_secrets_store = bob_parsed_transaction_return.secrets;
+    let updated_secrets = bob_parsed_transaction_return.secrets.unwrap();
+    let updated_unconfirmed_secrets = updated_secrets.get_all_unconfirmed_secrets();
+    if !updated_unconfirmed_secrets.is_empty() {
+        for secret in updated_unconfirmed_secrets {
+            bob_secrets_store.add_unconfirmed_secret(secret);
+        }
+    }
+    let updated_confirmed_secrets = updated_secrets.get_all_confirmed_secrets();
+    if !updated_confirmed_secrets.is_empty() {
+        for (address, secret) in updated_confirmed_secrets {
+            bob_secrets_store.confirm_secret_for_address(secret, address);
+        }
+    }
 
     // ======================= Alice
     reset_device().unwrap();
@@ -132,7 +158,19 @@ fn test_connect() {
     // debug!("alice_parsed_confirm: {:#?}", alice_parsed_confirm);
 
     let alice_to_bob_cipher = alice_parsed_connect.ciphers_to_send.get(0).unwrap();
-    alice_secrets_store = alice_parsed_connect.secrets;
+    let secrets_update = alice_parsed_connect.secrets.unwrap();
+    let unconfirmed_secrets = secrets_update.get_all_unconfirmed_secrets();
+    if !unconfirmed_secrets.is_empty() {
+        for secret in unconfirmed_secrets {
+            alice_secrets_store.add_unconfirmed_secret(secret);
+        }
+    }
+    let updated_confirmed_secrets = secrets_update.get_all_confirmed_secrets();
+    if !updated_confirmed_secrets.is_empty() {
+        for (address, secret) in updated_confirmed_secrets {
+            alice_secrets_store.confirm_secret_for_address(secret, address);
+        }
+    }
 
     // ======================= Bob 
     reset_device().unwrap();
@@ -142,7 +180,19 @@ fn test_connect() {
     debug!("Bob parses alice prd connect");
     let bob_parsed_connect = parse_cipher(alice_to_bob_cipher.clone()).unwrap();
 
-    bob_secrets_store = bob_parsed_connect.secrets;
+    let updated_secrets = bob_parsed_connect.secrets.unwrap();
+    let updated_unconfirmed_secrets = updated_secrets.get_all_unconfirmed_secrets();
+    if !updated_unconfirmed_secrets.is_empty() {
+        for secret in updated_unconfirmed_secrets {
+            bob_secrets_store.add_unconfirmed_secret(secret);
+        }
+    }
+    let updated_confirmed_secrets = updated_secrets.get_all_confirmed_secrets();
+    if !updated_confirmed_secrets.is_empty() {
+        for (address, secret) in updated_confirmed_secrets {
+            bob_secrets_store.confirm_secret_for_address(secret, address);
+        }
+    }
 
     // Assert that Alice and Bob now has the same secret
     assert!(alice_secrets_store.get_secret_for_address(bob_address.try_into().unwrap()) == bob_secrets_store.get_secret_for_address(alice_address.try_into().unwrap()));

tests/pairing.rs

@@ -164,7 +164,21 @@ fn test_pairing() {
     let create_process_return = create_new_process(pairing_init_state.to_string(), RELAY_ADDRESS.to_owned(), 1).unwrap();
 
     let commit_msg = create_process_return.commit_to_send.unwrap();
-    alice_secrets_store = create_process_return.secrets;
+
+    let secrets_update = create_process_return.secrets.unwrap();
+    let unconfirmed_secrets = secrets_update.get_all_unconfirmed_secrets();
+    if !unconfirmed_secrets.is_empty() {
+        for secret in unconfirmed_secrets {
+            alice_secrets_store.add_unconfirmed_secret(secret);
+        }
+    }
+    let updated_confirmed_secrets = secrets_update.get_all_confirmed_secrets();
+    if !updated_confirmed_secrets.is_empty() {
+        for (address, secret) in updated_confirmed_secrets {
+            alice_secrets_store.confirm_secret_for_address(secret, address);
+        }
+    }
+
     let (outpoint, new_process) = create_process_return.updated_process.unwrap();
     alice_process_cache.insert(outpoint.clone(), new_process);