[BUG] Fix rescan during sync (#676)

* sync wallet after funding tx

* sync wallet during hashlock recovery

* fix maker logs

* update test assertion and sync after privkeyhandover

* another assertion fix

* [BUG] Sync bug & Fix offer maxsize calculation
- modified: ignored return value of rescan_blockchain
- check rescan status using get_wallet_info and exit accordingly
- updates last_synced_height after rescan completes
- log wallet's birth height and last_synced_height
- ADDS info log at sync site for maker
- Changes: `refresh_offer_maxsize_cache` calculation from spendable to max(swap, regular)
- Changes: `fn check_swap_liquidity` to use `refresh_offer_maxsize_cache`
insted of `sync_and_save`
- Udates: `fn check_swap_liquidity_taproot` to use `refresh_offer_maxsize_cache`
- Remove `sync_and_save` from update_fidelity_bond_conf_details
- Adds sync_and_save to test

---------

Co-authored-by: Rishabh <rishkwal@gmail.com>
Co-authored-by: mojoX911 <mojojojo48@protonmail.com>

Author: 3 people

src/maker/api.rs

@@ -340,6 +340,7 @@ impl Maker {
         }
         config.write_to_file(&data_dir.join("config.toml"))?;
 
+        log::info!("Sync at:----Maker init----");
         wallet.sync_and_save()?;
 
         let network_port = config.network_port;

src/maker/api2.rs

@@ -336,9 +336,8 @@ impl Maker {
 
         config.write_to_file(&data_dir.join("config.toml"))?;
 
-        log::info!("Initializing wallet sync");
+        log::info!("Sync at:----Maker init----");
         wallet.sync_and_save()?;
-        log::info!("Completed wallet sync");
 
         let network_port = config.network_port;
 
@@ -491,6 +490,7 @@ impl Maker {
             let mut wallet = self.wallet.write()?;
 
             // Sync wallet to get latest UTXO state
+            log::info!("Sync at:----verify_and_process_senders_contract----");
             wallet.sync_and_save()?;
 
             let balance = wallet.get_balances()?;

src/maker/handlers.rs

@@ -303,6 +303,7 @@ impl Maker {
                 .get(funding_output_index as usize)
                 .expect("funding output expected at this index");
 
+            log::info!("Sync at:----handle_proof_of_funding----");
             self.wallet.write()?.sync_and_save()?;
 
             let receiver_contract_tx = create_receivers_contract_tx(
@@ -706,6 +707,7 @@ impl Maker {
             }
         }
 
+        log::info!("Sync at:----handle_private_key_handover----");
         self.wallet.write()?.sync_and_save()?;
 
         log::info!("Successfully Completed Coinswap");
@@ -725,6 +727,7 @@ impl Maker {
                 swept_txids
             );
         }
+        log::info!("Sync at:----sweep_after_successful_coinswap----");
         self.wallet.write()?.sync_and_save()?;
         // For tests, terminate the maker at this stage.
         #[cfg(feature = "integration-test")]

src/maker/rpc/server.rs

@@ -109,6 +109,7 @@ fn handle_request<M: MakerRpc>(maker: &Arc<M>, socket: &mut TcpStream) -> Result
 
             let txid = maker.wallet().read()?.send_tx(&tx)?;
 
+            log::info!("Sync at:----handle_request----");
             maker.wallet().write()?.sync_and_save()?;
 
             RpcMsgResp::SendToAddressResp(txid.to_string())

src/maker/server.rs

@@ -305,6 +305,7 @@ fn setup_fidelity_bond(maker: &Maker, maker_address: &str) -> Result<FidelityPro
         while !maker.shutdown.load(Relaxed) {
             sleep_multiplier += 1;
             // sync the wallet
+            log::info!("Sync at:----setup_fidelity_bond----");
             maker.get_wallet().write()?.sync_and_save()?;
 
             let fidelity_result = maker.get_wallet().write()?.create_fidelity(
@@ -358,6 +359,7 @@ fn setup_fidelity_bond(maker: &Maker, maker_address: &str) -> Result<FidelityPro
                     *proof = Some(highest_proof);
 
                     // sync and save the wallet data to disk
+                    log::info!(" Sync at end:----setup_fidelity_bond----");
                     maker.get_wallet().write()?.sync_and_save()?;
                     break;
                 }
@@ -381,6 +383,7 @@ fn check_swap_liquidity(maker: &Maker) -> Result<(), MakerError> {
         .write()?
         .get_next_external_address(AddressType::P2WPKH)?;
     while !maker.shutdown.load(Relaxed) {
+        log::info!("Sync at:----check_swap_liquidity----");
         maker.get_wallet().write()?.sync_and_save()?;
         let offer_max_size = maker.get_wallet().read()?.store.offer_maxsize;
 
@@ -662,10 +665,8 @@ pub fn start_maker_server(maker: Arc<Maker>) -> Result<(), MakerError> {
     log::info!("[{network_port}] Maker is shutting down.");
     maker.thread_pool.join_all_threads()?;
 
-    log::info!("Shutdown wallet sync initiated.");
+    log::info!("sync at:----Shutdown wallet----");
     maker.get_wallet().write()?.sync_and_save()?;
-    log::info!("Shutdown wallet syncing completed.");
-    log::info!("Wallet file saved to disk.");
     log::info!("Maker Server is shut down successfully.");
     Ok(())
 }

src/maker/server2.rs

@@ -318,6 +318,7 @@ fn setup_fidelity_bond_taproot(
     while !maker.shutdown.load(Relaxed) {
         sleep_multiplier += 1;
         // sync the wallet
+        log::info!("Sync at:----setup_fidelity_bond----");
         maker.wallet().write()?.sync_and_save()?;
 
         let fidelity_result = maker.wallet().write()?.create_fidelity(
@@ -384,6 +385,7 @@ fn setup_fidelity_bond_taproot(
                 };
 
                 // sync and save the wallet data to disk
+                log::info!("Sync at end:----setup_fidelity_bond----");
                 maker.wallet().write()?.sync_and_save()?;
 
                 // Store the fidelity proof in maker
@@ -401,6 +403,10 @@ fn setup_fidelity_bond_taproot(
 
 /// Checks swap liquidity for taproot swaps
 fn check_swap_liquidity_taproot(maker: &Maker) -> Result<(), MakerError> {
+    {
+        let mut wallet = maker.wallet().write()?;
+        wallet.refresh_offer_maxsize_cache()?;
+    }
     let wallet_read = maker.wallet().read()?;
     let balances = wallet_read.get_balances()?;
 
@@ -797,6 +803,8 @@ pub fn start_maker_server_taproot(maker: Arc<Maker>) -> Result<(), MakerError> {
     // Join all threads
     maker.thread_pool.join_all_threads()?;
 
+    log::info!("sync at:----Taproot server shutdown----");
+    maker.wallet().write()?.sync_and_save()?;
     log::info!(
         "[{}] Taproot maker server stopped",
         maker.config.network_port

src/wallet/api.rs

@@ -4,7 +4,7 @@
 //! In the future, takers might adopt alternative synchronization methods, such as lightweight wallet solutions.
 
 use std::{
-    convert::TryFrom, fmt::Display, path::PathBuf, str::FromStr, thread, thread::sleep,
+    cmp::max, convert::TryFrom, fmt::Display, path::PathBuf, str::FromStr, thread, thread::sleep,
     time::Duration,
 };
 
@@ -292,6 +292,16 @@ impl Wallet {
             Some(wallet_birthday),
             &store_enc_material,
         )?;
+        let last_synced_height_val = match store.last_synced_height {
+            Some(height) => height.to_string(),
+            None => "None".to_string(),
+        };
+
+        log::info!(
+            "Wallet birth_height = {}, wallet last_sync_height = {}",
+            wallet_birthday,
+            last_synced_height_val
+        );
 
         Ok(Self {
             rpc,
@@ -1270,8 +1280,8 @@ impl Wallet {
 
     /// Refreshes the offer maximum size cache based on the current wallet's unspent transaction outputs (UTXOs).
     pub(crate) fn refresh_offer_maxsize_cache(&mut self) -> Result<(), WalletError> {
-        let balance = self.get_balances()?.spendable;
-        self.store.offer_maxsize = balance.to_sat();
+        let Balances { swap, regular, .. } = self.get_balances()?;
+        self.store.offer_maxsize = max(swap, regular).to_sat();
         Ok(())
     }
 

src/wallet/fidelity.rs

@@ -395,8 +395,6 @@ impl Wallet {
         bond.cert_expiry = Some(cert_expiry);
         bond.conf_height = Some(conf_height);
 
-        self.sync_and_save()?;
-
         Ok(())
     }
 

src/wallet/rpc.rs

@@ -2,7 +2,10 @@
 //!
 use std::{convert::TryFrom, thread};
 
-use bitcoind::bitcoincore_rpc::{json::ListUnspentResultEntry, Auth, Client, RpcApi};
+use bitcoind::bitcoincore_rpc::{
+    json::{ListUnspentResultEntry, ScanningDetails},
+    Auth, Client, RpcApi,
+};
 use serde_json::{json, Value};
 
 use crate::{utill::HEART_BEAT_INTERVAL, wallet::api::KeychainKind};
@@ -70,16 +73,10 @@ impl Wallet {
     /// This method first synchronizes the wallet with the Bitcoin Core node,
     /// then persists the wallet state in the disk.
     pub fn sync_and_save(&mut self) -> Result<(), WalletError> {
-        log::info!(
-            "Initializing wallet sync and save for {:?}",
-            &self.store.file_name
-        );
+        log::info!("Sync Started for {:?}", &self.store.file_name);
         self.sync_no_fail();
         self.save_to_disk()?;
-        log::info!(
-            "Completed wallet sync and save for {:?}",
-            &self.store.file_name
-        );
+        log::info!("Synced & Saved {:?}", &self.store.file_name);
         Ok(())
     }
 
@@ -130,40 +127,43 @@ impl Wallet {
             return Ok(());
         }
 
-        log::debug!("Importing Wallet spks/descriptors");
-
         self.import_descriptors(&descriptors_to_import, None)?;
 
-        // Now run the scan
-        log::debug!("Initializing TxOut scan. This may take a while.");
-
         // Sometimes in test multiple wallet scans can occur at same time, resulting in error.
-        // Just retry after 3 sec.
-        loop {
-            let last_synced_height = self
-                .store
-                .last_synced_height
-                .unwrap_or(0)
-                .max(self.store.wallet_birthday.unwrap_or(0));
-            let node_synced = self.rpc.get_block_count()?;
-            log::debug!("Re-scanning Blockchain from:{last_synced_height} to:{node_synced}");
-            match self.rpc.rescan_blockchain(
-                Some(last_synced_height as usize),
-                Some(node_synced as usize),
-            ) {
-                Ok(_) => {
-                    self.store.last_synced_height = Some(node_synced);
-                    break;
-                }
+        let last_synced_height = self
+            .store
+            .last_synced_height
+            .unwrap_or(0)
+            .max(self.store.wallet_birthday.unwrap_or(0));
+        let node_synced = self.rpc.get_block_count()?;
+        log::info!("Re-scanning Blockchain from:{last_synced_height} to:{node_synced}");
+
+        let _ = self.rpc.rescan_blockchain(
+            Some(last_synced_height as usize),
+            Some(node_synced as usize),
+        );
 
-                Err(e) => {
-                    log::warn!("Sync Error, Retrying: {e}");
+        // Returns when the scanning is completed
+        loop {
+            let wallet_info = self.rpc.get_wallet_info()?;
+            match wallet_info.scanning {
+                Some(ScanningDetails::Scanning { duration, .. }) => {
+                    // Todo: Show scan progress
+                    log::info!("Scanning for {}s", duration);
                     thread::sleep(HEART_BEAT_INTERVAL);
                     continue;
                 }
+                Some(ScanningDetails::NotScanning(_)) => {
+                    log::info!("Scanning completed");
+                    break;
+                }
+                None => {
+                    log::info!("No scan is in progress or Scanning completed");
+                    break;
+                }
             }
         }
-
+        self.store.last_synced_height = Some(node_synced);
         self.update_utxo_cache(self.get_all_utxo_from_rpc()?);
 
         let max_external_index = self.find_hd_next_index(KeychainKind::External)?;
@@ -177,6 +177,7 @@ impl Wallet {
     fn sync_no_fail(&mut self) {
         while let Err(e) = self.sync() {
             log::error!("Blockchain sync failed. Retrying. | {e:?}");
+            thread::sleep(HEART_BEAT_INTERVAL);
         }
     }
 

tests/fidelity.rs

@@ -161,6 +161,7 @@ fn test_fidelity() {
     log::info!("📊 Verifying balances with both fidelity bonds");
     // Verify balances
     {
+        maker.get_wallet().write().unwrap().sync_and_save().unwrap();
         let wallet_read = maker.get_wallet().read().unwrap();
 
         let balances = wallet_read.get_balances().unwrap();