[bug] fix saving/loading files

src/commit.rs

@@ -9,6 +9,7 @@ use anyhow::{Error, Result};
 use bitcoincore_rpc::bitcoin::hex::DisplayHex;
 use hex::FromHex;
 use sdk_common::pcd::{Member, Pcd, RoleDefinition};
+use sdk_common::serialization::{MemberOutPointMap, OutPointProcessMap};
 use sdk_common::silentpayments::create_transaction;
 use sdk_common::sp_client::spclient::Recipient;
 use sdk_common::network::CommitMessage;
@@ -153,15 +154,15 @@ fn handle_member_list(pcd_commitment: &Value, roles: &HashMap<String, RoleDefini
 
 // Handle the case where `init_tx` is a reference to an existing outpoint
 fn handle_existing_commitment(outpoint: OutPoint, commit_msg: CommitMessage) -> Result<OutPoint> {
-    let mut commitments = lock_processes()?;
-    let commitment = commitments
+    let mut processes = lock_processes()?;
+    let process = processes 
         .get_mut(&outpoint)
-        .ok_or(Error::msg("Commitment not found"))?;
+        .ok_or(Error::msg(format!("Commitment not found: {}", outpoint)))?;
 
     if commit_msg.validation_tokens.is_empty() {
-        register_new_state(commitment, commit_msg)
+        register_new_state(process, commit_msg)
     } else {
-        process_validation(commitment, commit_msg)
+        process_validation(process, commit_msg)
     }
 }
 
@@ -172,7 +173,9 @@ pub fn dump_cached_members() -> Result<(), anyhow::Error> {
 
     let members_file = &storage.members_file;
 
-    members_file.save(&members)?;
+    let members_map = MemberOutPointMap(members);
+    let json = serde_json::to_value(&members_map)?;
+    members_file.save(&json)?;
 
     log::debug!("saved members");
 
@@ -186,7 +189,9 @@ pub fn dump_cached_processes() -> Result<(), anyhow::Error> {
 
     let processes_file = &storage.processes_file;
 
-    processes_file.save(&processes)?;
+    let outpoints_map = OutPointProcessMap(processes);
+    let json = serde_json::to_value(&outpoints_map)?;
+    processes_file.save(&json)?;
 
     log::debug!("saved processes");
 

src/main.rs

@@ -16,7 +16,7 @@ use futures_util::{future, pin_mut, stream::TryStreamExt, FutureExt, StreamExt};
 use log::{debug, error, warn};
 use message::{broadcast_message, process_message, BroadcastType, MessageCache, MESSAGECACHE};
 use scan::{check_transaction_alone, compute_partial_tweak_to_transaction};
-use sdk_common::{network::HandshakeMessage, pcd::Member, process::{lock_processes, Process, CACHEDPROCESSES}, sp_client::{bitcoin::{
+use sdk_common::{network::HandshakeMessage, pcd::Member, process::{lock_processes, Process, CACHEDPROCESSES}, serialization::{MemberOutPointMap, OutPointProcessMap}, sp_client::{bitcoin::{
     consensus::deserialize,
     hex::{DisplayHex, FromHex},
     Amount, Network, Transaction,
@@ -32,7 +32,7 @@ use sdk_common::{
 };
 
 use sdk_common::sp_client::spclient::{derive_keys_from_seed, SpClient, SpendKey};
-use serde::{Deserialize, Serialize};
+use serde_json::Value;
 use tokio::net::{TcpListener, TcpStream};
 use tokio::sync::mpsc::{unbounded_channel, UnboundedSender};
 use tokio_stream::wrappers::UnboundedReceiverStream;
@@ -100,25 +100,26 @@ impl StateFile {
         Ok(())
     }
 
-    fn save<T: Serialize>(&self, data: &T) -> Result<()> {
+    fn save(&self, json: &Value) -> Result<()> {
         let mut f = fs::File::options()
             .write(true)
             .truncate(true)
             .open(&self.path)?;
 
-        let json = serde_json::to_string(data)?;
-        f.write_all(json.as_bytes())?;
+        let stringified = serde_json::to_string(&json)?;
+        let bin = stringified.as_bytes();
+        f.write_all(bin)?;
 
         Ok(())
     }
 
-    fn load<T: for<'de> Deserialize<'de>>(&self) -> Result<T> {
+    fn load(&self) -> Result<Value> {
         let mut f = fs::File::open(&self.path)?;
 
         let mut content = vec![];
         f.read_to_end(&mut content)?;
 
-        let res: T = serde_json::from_slice(&content)?;
+        let res: Value = serde_json::from_slice(&content)?;
 
         Ok(res)
     }
@@ -148,7 +149,8 @@ impl SilentPaymentWallet {
 
     pub fn save(&self) -> Result<()> {
         let wallet = self.sp_wallet.lock_anyhow()?.clone();
-        self.storage.lock_anyhow()?.save(&wallet)
+        let value = serde_json::from_str(&serde_json::to_string(&wallet)?)?;
+        self.storage.lock_anyhow()?.save(&value)
     }
 }
 
@@ -364,10 +366,10 @@ async fn main() -> Result<()> {
     let members_file = StateFile::new(members_file);
 
     // load an existing sp_wallet, or create a new one
-    let sp_wallet = match wallet_file.load() {
+    let sp_wallet: SpWallet = match wallet_file.load() {
         Ok(wallet) => {
             // TODO: Verify the wallet is compatible with the current network
-            wallet
+            serde_json::from_value(wallet)?
         }
         Err(_) => {
             // Create a new wallet file if it doesn't exist or fails to load
@@ -398,7 +400,8 @@ async fn main() -> Result<()> {
             outputs.update_last_scan(current_tip);
 
             // Save the newly created wallet to disk
-            wallet_file.save(&wallet)?;
+            let json = serde_json::to_value(wallet.clone())?;
+            wallet_file.save(&json)?;
 
             wallet
         }
@@ -406,7 +409,8 @@ async fn main() -> Result<()> {
 
     let cached_processes: HashMap<OutPoint, Process> = match processes_file.load() {
         Ok(processes) => {
-            processes
+            let deserialized: OutPointProcessMap = serde_json::from_value(processes)?;
+            deserialized.0
         }
         Err(_) => {
             debug!("creating process file at {}", processes_file.path.display());
@@ -417,7 +421,10 @@ async fn main() -> Result<()> {
     };
 
     let members: HashMap<Member, OutPoint> = match members_file.load() {
-        Ok(members) => members,
+        Ok(members) => {
+            let deserialized: MemberOutPointMap = serde_json::from_value(members)?;
+            deserialized.0
+        },
         Err(_) => {
             debug!("creating members file at {}", members_file.path.display());
             members_file.create()?;