f Move common types to dedicated file

This will become useful when we introduce other client types, e.g.
Electrum.

Author: tnull

lightning-transaction-sync/src/esplora.rs

@@ -1,11 +1,12 @@
 use crate::error::{TxSyncError, InternalError};
+use crate::types::{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::chain::WatchedOutput;
 use lightning::chain::{Confirm, Filter};
 
-use bitcoin::{BlockHash, BlockHeader, Script, Transaction, Txid};
+use bitcoin::{BlockHash, Script, Txid};
 
 use esplora_client::Builder;
 #[cfg(feature = "async-interface")]
@@ -327,68 +328,6 @@ where
 	}
 }
 
-// Represents the current state.
-struct SyncState {
-	// Transactions that were previously processed, but must not be forgotten
-	// yet since they still need to be monitored for confirmation on-chain.
-	watched_transactions: HashSet<Txid>,
-	// Outputs that were previously processed, but must not be forgotten yet as
-	// as we still need to monitor any spends on-chain.
-	watched_outputs: HashSet<WatchedOutput>,
-	// The tip hash observed during our last sync.
-	last_sync_hash: Option<BlockHash>,
-	// Indicates whether we need to resync, e.g., after encountering an error.
-	pending_sync: bool,
-}
-
-impl SyncState {
-	fn new() -> Self {
-		Self {
-			watched_transactions: HashSet::new(),
-			watched_outputs: HashSet::new(),
-			last_sync_hash: None,
-			pending_sync: false,
-		}
-	}
-}
-
-// A queue that is to be filled by `Filter` and drained during the next syncing round.
-struct FilterQueue {
-	// Transactions that were registered via the `Filter` interface and have to be processed.
-	transactions: HashSet<Txid>,
-	// Outputs that were registered via the `Filter` interface and have to be processed.
-	outputs: HashSet<WatchedOutput>,
-}
-
-impl FilterQueue {
-	fn new() -> Self {
-		Self {
-			transactions: HashSet::new(),
-			outputs: HashSet::new(),
-		}
-	}
-
-	// Processes the transaction and output queues and adds them to the given [`SyncState`].
-	//
-	// Returns `true` if new items had been registered.
-	fn process_queues(&mut self, sync_state: &mut SyncState) -> bool {
-		let mut pending_registrations = false;
-
-		if !self.transactions.is_empty() {
-			pending_registrations = true;
-
-			sync_state.watched_transactions.extend(self.transactions.drain());
-		}
-
-		if !self.outputs.is_empty() {
-			pending_registrations = true;
-
-			sync_state.watched_outputs.extend(self.outputs.drain());
-		}
-		pending_registrations
-	}
-}
-
 #[cfg(feature = "async-interface")]
 type MutexType<I> = futures::lock::Mutex<I>;
 #[cfg(not(feature = "async-interface"))]
@@ -401,13 +340,6 @@ pub type EsploraClientType = AsyncClient;
 pub type EsploraClientType = BlockingClient;
 
 
-struct ConfirmedTx {
-	tx: Transaction,
-	block_header: BlockHeader,
-	block_height: u32,
-	pos: usize,
-}
-
 impl<L: Deref> Filter for EsploraSyncClient<L>
 where
 	L::Target: Logger,

lightning-transaction-sync/src/lib.rs

@@ -68,6 +68,9 @@ extern crate bdk_macros;
 #[cfg(any(feature = "esplora-blocking", feature = "esplora-async"))]
 mod esplora;
 
+#[cfg(any(feature = "esplora-blocking", feature = "esplora-async"))]
+mod types;
+
 #[cfg(test)]
 mod tests;
 

lightning-transaction-sync/src/types.rs

@@ -0,0 +1,74 @@
+use lightning::chain::WatchedOutput;
+use bitcoin::{Txid, BlockHash, Transaction, BlockHeader};
+use std::collections::HashSet;
+
+
+// Represents the current state.
+pub(crate) struct SyncState {
+	// Transactions that were previously processed, but must not be forgotten
+	// yet since they still need to be monitored for confirmation on-chain.
+	pub watched_transactions: HashSet<Txid>,
+	// Outputs that were previously processed, but must not be forgotten yet as
+	// as we still need to monitor any spends on-chain.
+	pub watched_outputs: HashSet<WatchedOutput>,
+	// The tip hash observed during our last sync.
+	pub last_sync_hash: Option<BlockHash>,
+	// Indicates whether we need to resync, e.g., after encountering an error.
+	pub pending_sync: bool,
+}
+
+impl SyncState {
+	pub fn new() -> Self {
+		Self {
+			watched_transactions: HashSet::new(),
+			watched_outputs: HashSet::new(),
+			last_sync_hash: None,
+			pending_sync: false,
+		}
+	}
+}
+
+
+// A queue that is to be filled by `Filter` and drained during the next syncing round.
+pub(crate) struct FilterQueue {
+	// Transactions that were registered via the `Filter` interface and have to be processed.
+	pub transactions: HashSet<Txid>,
+	// Outputs that were registered via the `Filter` interface and have to be processed.
+	pub outputs: HashSet<WatchedOutput>,
+}
+
+impl FilterQueue {
+	pub fn new() -> Self {
+		Self {
+			transactions: HashSet::new(),
+			outputs: HashSet::new(),
+		}
+	}
+
+	// Processes the transaction and output queues and adds them to the given [`SyncState`].
+	//
+	// Returns `true` if new items had been registered.
+	pub fn process_queues(&mut self, sync_state: &mut SyncState) -> bool {
+		let mut pending_registrations = false;
+
+		if !self.transactions.is_empty() {
+			pending_registrations = true;
+
+			sync_state.watched_transactions.extend(self.transactions.drain());
+		}
+
+		if !self.outputs.is_empty() {
+			pending_registrations = true;
+
+			sync_state.watched_outputs.extend(self.outputs.drain());
+		}
+		pending_registrations
+	}
+}
+
+pub(crate) struct ConfirmedTx {
+	pub tx: Transaction,
+	pub block_header: BlockHeader,
+	pub block_height: u32,
+	pub pos: usize,
+}