add wallet checkpoint for balance updates

Author: sdmg15

Cargo.lock

@@ -11,6 +11,7 @@ use bdk_sp::{
         address::NetworkUnchecked,
         bip32,
         consensus::{deserialize, Decodable},
+        hashes::Hash,
         hex::{DisplayHex, FromHex},
         key::Secp256k1,
         script::PushBytesBuf,
@@ -578,6 +579,10 @@ async fn main() -> anyhow::Result<()> {
             }
         }
         Commands::ScanFrigate { rpc_args, start } => {
+            // The implementation done here differ from what mentionned in the section https://github.com/sparrowwallet/frigate/tree/master?tab=readme-ov-file#blockchainsilentpaymentssubscribe
+            // We are doing a one time scanning only. So instead of calling `blockchain.scripthash.subscribe` on each script from the wallet,
+            // we just subscribe and read the scanning result from the stream. On each result received we update the wallet state and once scanning progress reaches 1.0 (100%) we stop.
+
             let mut client = FrigateClient::connect(&rpc_args.url).await.unwrap();
             let labels = wallet
                 .indexer()
@@ -644,23 +649,34 @@ async fn main() -> anyhow::Result<()> {
                         let mut block: Block =
                             deserialize(&Vec::<u8>::from_hex(&raw_blk).unwrap()).unwrap();
 
+                        let mut blockhash = BlockHash::all_zeros();
+
                         let mut txs: Vec<Transaction> = vec![coinbase];
                         for key in secret.1.keys() {
-                            let raw_tx = client.get_transaction(key.to_string()).await.unwrap();
+                            let tx_result = client.get_transaction(key.to_string()).await.unwrap();
                             let tx: Transaction =
-                                deserialize(&Vec::<u8>::from_hex(&raw_tx).unwrap()).unwrap();
+                                deserialize(&Vec::<u8>::from_hex(&tx_result.1).unwrap()).unwrap();
                             txs.push(tx);
+
+                            blockhash = BlockHash::from_str(&tx_result.0)?;
                         }
 
                         block.txdata = txs;
                         tracing::debug!("Final block {:?}", block);
                         wallet.apply_block_relevant(&block, secret.1, secret.0);
+
+                        tracing::debug!("Checkpoint hash {blockhash:?}");
+                        let checkpoint = wallet.chain().tip().insert(BlockId {
+                            height: secret.0,
+                            hash: blockhash,
+                        });
+                        wallet.update_chain(checkpoint);
                     }
 
                     tracing::info!("Progress {progress}");
                     // Check the progress
                     if progress >= 1.0 {
-                        tracing::warn!("Scanning completed");
+                        tracing::info!("Scanning completed");
                         break;
                     }
                 }

cli/v2/src/main.rs

@@ -88,7 +88,7 @@ pub struct RequestPayload {
 }
 
 const SUBSCRIBE_RPC_METHOD: &str = "blockchain.silentpayments.subscribe";
-const _UNSUBSCRIBE_RPC_METHOD: &str = "blockchain.silentpayments.unsubscribe";
+const UNSUBSCRIBE_RPC_METHOD: &str = "blockchain.silentpayments.unsubscribe";
 const GET_RPC_METHOD: &str = "blockchain.transaction.get";
 const VERSION_RPC_METHOD: &str = "server.version";
 const _SUBSCRIBE_OWNED_OUTPUTS: &str = "blockchain.scripthash.subscribe";
@@ -109,7 +109,7 @@ impl FrigateClient {
         let mut buffer = vec![0; size];
         let n = self.client.read(&mut buffer).await?;
 
-        tracing::warn!("Read bytes from stream {n}");
+        tracing::debug!("Read bytes from stream {n}");
         match n {
             0 => Err(FrigateError::Generic("Nothing read".to_string())),
             _ => {
@@ -121,6 +121,7 @@ impl FrigateClient {
             }
         }
     }
+
     async fn send_request(&mut self, req_bytes: &[u8]) -> Result<Value, FrigateError> {
         self.client.write_all(req_bytes).await?;
 
@@ -145,8 +146,11 @@ impl FrigateClient {
         Ok(String::from(res["result"].as_str().unwrap()))
     }
 
-    pub async fn get_transaction(&mut self, txid: String) -> Result<String, FrigateError> {
-        let params = vec![txid];
+    pub async fn get_transaction(
+        &mut self,
+        txid: String,
+    ) -> Result<(String, String), FrigateError> {
+        let params = vec![txid, "true".to_string()];
         let req = RequestPayload {
             method: GET_RPC_METHOD.to_string(),
             params: serde_json::json!(params),
@@ -156,8 +160,10 @@ impl FrigateClient {
         let req_bytes = serde_json::to_vec(&req)?;
         let res = self.send_request(&req_bytes).await?;
 
-        tracing::debug!("[Get tx Request] Result {:?}", res);
-        Ok(String::from(res["result"].as_str().unwrap()))
+        tracing::debug!("[Get tx Request] Result {:#?}", res);
+        let blockhash = String::from(res["result"]["blockhash"].as_str().unwrap());
+        let hex = String::from(res["result"]["hex"].as_str().unwrap());
+        Ok((blockhash, hex))
     }
 
     pub async fn version(&mut self) -> Result<(), FrigateError> {
@@ -219,4 +225,23 @@ impl FrigateClient {
 
         Ok(None)
     }
+
+    pub async fn unsubscribe(&mut self, req: &UnsubscribeRequest) -> Result<String, FrigateError> {
+        let params: Vec<Value> = vec![
+            serde_json::json!(req.scan_privkey),
+            serde_json::json!(req.spend_pubkey),
+        ];
+
+        let req = RequestPayload {
+            method: UNSUBSCRIBE_RPC_METHOD.to_string(),
+            params: serde_json::json!(params),
+            id: serde_json::Value::from(189),
+            jsonrpc: "2.0".to_string(),
+        };
+
+        let req_bytes = serde_json::to_vec(&req)?;
+        let result = self.send_request(&req_bytes).await?;
+
+        Ok(result["result"].to_string())
+    }
 }