Move `sync_` methods to `SyncState`

[rust-lightning] / lightning-transaction-sync / src / esplora.rs

diff --git a/lightning-transaction-sync/src/esplora.rs b/lightning-transaction-sync/src/esplora.rs
index 807ef8075005c13ba12a29d99a393aea72328ac3..3f0d4828355161ac0a807a9004636ad3961814ac 100644 (file)
--- a/lightning-transaction-sync/src/esplora.rs
+++ b/lightning-transaction-sync/src/esplora.rs
@@ -2,7 +2,7 @@ use crate::error::{TxSyncError, InternalError};
 use crate::common::{SyncState, FilterQueue, ConfirmedTx};
 
 use lightning::util::logger::Logger;
-use lightning::{log_error, log_given_level, log_info, log_internal, log_debug, log_trace};
+use lightning::{log_error, log_debug, log_trace};
 use lightning::chain::WatchedOutput;
 use lightning::chain::{Confirm, Filter};
 
@@ -14,6 +14,7 @@ use esplora_client::r#async::AsyncClient;
 #[cfg(not(feature = "async-interface"))]
 use esplora_client::blocking::BlockingClient;
 
+use std::time::Instant;
 use std::collections::HashSet;
 use core::ops::Deref;
 
@@ -89,7 +90,10 @@ where
                #[cfg(feature = "async-interface")]
                let mut sync_state = self.sync_state.lock().await;
 
-               log_info!(self.logger, "Starting transaction sync.");
+               log_trace!(self.logger, "Starting transaction sync.");
+               let start_time = Instant::now();
+               let mut num_confirmed = 0;
+               let mut num_unconfirmed = 0;
 
                let mut tip_hash = maybe_await!(self.client.get_tip_hash())?;
 
@@ -113,14 +117,21 @@ where
                                                        let check_tip_hash = maybe_await!(self.client.get_tip_hash())?;
                                                        if check_tip_hash != tip_hash {
                                                                tip_hash = check_tip_hash;
+
+                                                               log_debug!(self.logger, "Encountered inconsistency during transaction sync, restarting.");
+                                                               sync_state.pending_sync = true;
                                                                continue;
                                                        }
-
-                                                       self.sync_unconfirmed_transactions(&mut sync_state, &confirmables, unconfirmed_txs);
+                                                       num_unconfirmed += unconfirmed_txs.len();
+                                                       sync_state.sync_unconfirmed_transactions(&confirmables, unconfirmed_txs);
                                                },
                                                Err(err) => {
                                                        // (Semi-)permanent failure, retry later.
-                                                       log_error!(self.logger, "Failed during transaction sync, aborting.");
+                                                       log_error!(self.logger,
+                                                               "Failed during transaction sync, aborting. Synced so far: {} confirmed, {} unconfirmed.",
+                                                               num_confirmed,
+                                                               num_unconfirmed
+                                                       );
                                                        sync_state.pending_sync = true;
                                                        return Err(TxSyncError::from(err));
                                                }
@@ -136,6 +147,11 @@ where
                                                }
                                                Err(err) => {
                                                        // (Semi-)permanent failure, retry later.
+                                                       log_error!(self.logger,
+                                                               "Failed during transaction sync, aborting. Synced so far: {} confirmed, {} unconfirmed.",
+                                                               num_confirmed,
+                                                               num_unconfirmed
+                                                       );
                                                        sync_state.pending_sync = true;
                                                        return Err(TxSyncError::from(err));
                                                }
@@ -152,8 +168,8 @@ where
                                                        continue;
                                                }
 
-                                               self.sync_confirmed_transactions(
-                                                       &mut sync_state,
+                                               num_confirmed += confirmed_txs.len();
+                                               sync_state.sync_confirmed_transactions(
                                                        &confirmables,
                                                        confirmed_txs,
                                                );
@@ -166,7 +182,11 @@ where
                                        }
                                        Err(err) => {
                                                // (Semi-)permanent failure, retry later.
-                                               log_error!(self.logger, "Failed during transaction sync, aborting.");
+                                               log_error!(self.logger,
+                                                       "Failed during transaction sync, aborting. Synced so far: {} confirmed, {} unconfirmed.",
+                                                       num_confirmed,
+                                                       num_unconfirmed
+                                               );
                                                sync_state.pending_sync = true;
                                                return Err(TxSyncError::from(err));
                                        }
@@ -175,7 +195,8 @@ where
                                sync_state.pending_sync = false;
                        }
                }
-               log_info!(self.logger, "Finished transaction sync.");
+               log_debug!(self.logger, "Finished transaction sync at tip {} in {}ms: {} confirmed, {} unconfirmed.",
+                               tip_hash, start_time.elapsed().as_millis(), num_confirmed, num_unconfirmed);
                Ok(())
        }
 
@@ -199,26 +220,6 @@ where
                Ok(())
        }
 
-       fn sync_confirmed_transactions(
-               &self, sync_state: &mut SyncState, confirmables: &Vec<&(dyn Confirm + Sync + Send)>, confirmed_txs: Vec<ConfirmedTx>,
-       ) {
-               for ctx in confirmed_txs {
-                       for c in confirmables {
-                               c.transactions_confirmed(
-                                       &ctx.block_header,
-                                       &[(ctx.pos, &ctx.tx)],
-                                       ctx.block_height,
-                               );
-                       }
-
-                       sync_state.watched_transactions.remove(&ctx.tx.txid());
-
-                       for input in &ctx.tx.input {
-                               sync_state.watched_outputs.remove(&input.previous_output);
-                       }
-               }
-       }
-
        #[maybe_async]
        fn get_confirmed_transactions(
                &self, sync_state: &SyncState,
@@ -286,7 +287,8 @@ where
                                return Err(InternalError::Failed);
                        }
 
-                       let pos = *indexes.get(0).ok_or(InternalError::Failed)? as usize;
+                       // unwrap() safety: len() > 0 is checked above
+                       let pos = *indexes.first().unwrap() as usize;
                        if let Some(tx) = maybe_await!(self.client.get_tx(&txid))? {
                                if let Some(block_height) = known_block_height {
                                        // We can take a shortcut here if a previous call already gave us the height.
@@ -316,11 +318,11 @@ where
                let relevant_txids = confirmables
                        .iter()
                        .flat_map(|c| c.get_relevant_txids())
-                       .collect::<HashSet<(Txid, Option<BlockHash>)>>();
+                       .collect::<HashSet<(Txid, u32, Option<BlockHash>)>>();
 
                let mut unconfirmed_txs = Vec::new();
 
-               for (txid, block_hash_opt) in relevant_txids {
+               for (txid, _conf_height, block_hash_opt) in relevant_txids {
                        if let Some(block_hash) = block_hash_opt {
                                let block_status = maybe_await!(self.client.get_block_status(&block_hash))?;
                                if block_status.in_best_chain {
@@ -337,18 +339,6 @@ where
                Ok(unconfirmed_txs)
        }
 
-       fn sync_unconfirmed_transactions(
-               &self, sync_state: &mut SyncState, confirmables: &Vec<&(dyn Confirm + Sync + Send)>, unconfirmed_txs: Vec<Txid>,
-       ) {
-               for txid in unconfirmed_txs {
-                       for c in confirmables {
-                               c.transaction_unconfirmed(&txid);
-                       }
-
-                       sync_state.watched_transactions.insert(txid);
-               }
-       }
-
        /// Returns a reference to the underlying esplora client.
        pub fn client(&self) -> &EsploraClientType {
                &self.client