f Drop spending callback fn

.. and use `OutputSpender`/`ChangeDestinationSource`/`FeeEstimator`
traits instead.

Author: tnull

lightning/src/util/sweep.rs

@@ -8,14 +8,14 @@
 //! [`SpendableOutputDescriptor`]s, i.e., persists them in a given [`KVStore`] and regularly retries
 //! sweeping them.
 
-use crate::chain::chaininterface::BroadcasterInterface;
+use crate::chain::chaininterface::{BroadcasterInterface, ConfirmationTarget, FeeEstimator};
 use crate::chain::channelmonitor::ANTI_REORG_DELAY;
 use crate::chain::{self, BestBlock, Confirm, Filter, Listen, WatchedOutput};
 use crate::io;
 use crate::ln::msgs::DecodeError;
 use crate::ln::ChannelId;
-use crate::prelude::{Box, Vec};
-use crate::sign::SpendableOutputDescriptor;
+use crate::prelude::Vec;
+use crate::sign::{ChangeDestinationSource, OutputSpender, SpendableOutputDescriptor};
 use crate::sync::Mutex;
 use crate::util::logger::Logger;
 use crate::util::persist::{
@@ -26,6 +26,8 @@ use crate::util::ser::{Readable, ReadableArgs, Writeable};
 use crate::{impl_writeable_tlv_based, log_debug, log_error};
 
 use bitcoin::blockdata::block::Header;
+use bitcoin::blockdata::locktime::absolute::LockTime;
+use bitcoin::secp256k1::Secp256k1;
 use bitcoin::{BlockHash, Transaction, Txid};
 
 use core::ops::Deref;
@@ -307,121 +309,66 @@ impl_writeable_tlv_based_enum!(OutputSpendStatus,
 /// constructor.
 ///
 /// [`Event::SpendableOutputs`]: crate::events::Event::SpendableOutputs
-pub struct OutputSweeper<B: Deref, F: Deref, K: Deref, L: Deref>
+pub struct OutputSweeper<B: Deref, D: Deref, E: Deref, F: Deref, K: Deref, L: Deref, O: Deref>
 where
 	B::Target: BroadcasterInterface,
+	D::Target: ChangeDestinationSource,
+	E::Target: FeeEstimator,
 	F::Target: Filter + Sync + Send,
 	K::Target: KVStore,
 	L::Target: Logger,
+	O::Target: OutputSpender,
 {
 	sweeper_state: Mutex<SweeperState>,
 	broadcaster: B,
-	kv_store: K,
+	fee_estimator: E,
 	chain_data_source: Option<F>,
+	output_spender: O,
+	change_destination_source: D,
+	kv_store: K,
 	logger: L,
-	spend_outputs_callback: Box<
-		dyn Fn(&[&SpendableOutputDescriptor]) -> Result<Transaction, ()> + Send + Sync + 'static,
-	>,
 }
 
-impl<B: Deref, F: Deref, K: Deref, L: Deref> OutputSweeper<B, F, K, L>
+impl<B: Deref, D: Deref, E: Deref, F: Deref, K: Deref, L: Deref, O: Deref>
+	OutputSweeper<B, D, E, F, K, L, O>
 where
 	B::Target: BroadcasterInterface,
+	D::Target: ChangeDestinationSource,
+	E::Target: FeeEstimator,
 	F::Target: Filter + Sync + Send,
 	K::Target: KVStore,
 	L::Target: Logger,
+	O::Target: OutputSpender,
 {
 	/// Constructs a new [`OutputSweeper`].
 	///
 	/// If chain data is provided via the [`Confirm`] interface or via filtered blocks, users also
 	/// need to register their [`Filter`] implementation via the given `chain_data_source`.
-	///
-	/// The given `spend_outputs_callback` is a function takes a list of
-	/// [`SpendableOutputDescriptor`] and returns a fully signed ready-for-broadcast
-	/// [`Transaction`]. Usually, this should retrieve a change address from the on-chain wallet
-	/// and call [`KeysManager::spend_spendable_outputs`].
-	///
-	/// [`KeysManager::spend_spendable_outputs`]: crate::sign::KeysManager::spend_spendable_outputs
-	///
-	/// #### Example:
-	/// ```
-	/// # use bitcoin::key::Secp256k1;
-	/// # use bitcoin::{Network, Script, ScriptBuf, Transaction, Txid};
-	/// # use std::sync::Arc;
-	/// # use lightning::sign::SpendableOutputDescriptor;
-	/// # use lightning::sign::KeysManager;
-	/// # use lightning::chain::chaininterface::{ConfirmationTarget, FeeEstimator, BroadcasterInterface};
-	/// # use lightning::chain::{BestBlock, Filter, WatchedOutput};
-	/// # use lightning::util::persist::KVStore;
-	/// # use lightning::util::sweep::OutputSweeper;
-	/// # use lightning::util::logger::{Logger, Record};
-	/// # use lightning::io;
-	/// # struct MyWallet {}
-	/// # impl MyWallet {
-	/// #     fn get_new_address(&self) -> ScriptBuf { ScriptBuf::new() }
-	/// # }
-	/// # fn example<K: KVStore, E: FeeEstimator + Send + Sync + 'static, B: BroadcasterInterface,
-	/// #     F: Filter + Sync + Send, L: Logger>
-	/// # (
-	/// #     store: Arc<K>, fee_estimator: Arc<E>, broadcaster: Arc<B>, chain_data_source: Arc<F>,
-	/// #     logger: Arc<L>
-	/// # ) {
-	/// # let wallet = Arc::new(MyWallet{});
-	/// # let keys_manager = Arc::new(KeysManager::new(&[42u8; 32], 0, 0));
-	/// # let best_block = BestBlock::from_network(Network::Regtest);
-	/// let spend_wallet = Arc::clone(&wallet);
-	/// let spend_keys_manager = Arc::clone(&keys_manager);
-	/// let spend_fee_estimator = Arc::clone(&fee_estimator);
-	/// let spend_outputs_callback = move |output_descriptors: &[&SpendableOutputDescriptor]| {
-	/// 	let change_destination_script = spend_wallet.get_new_address();
-	/// 	let fee_rate = spend_fee_estimator.get_est_sat_per_1000_weight(
-	/// 		ConfirmationTarget::NonAnchorChannelFee
-	/// 	);
-	/// 	spend_keys_manager.spend_spendable_outputs(
-	/// 		output_descriptors,
-	/// 		Vec::new(),
-	/// 		change_destination_script,
-	/// 		fee_rate,
-	/// 		None,
-	/// 		&Secp256k1::new(),
-	/// 	)
-	/// };
-	///
-	/// let sweeper = OutputSweeper::new(broadcaster, store, best_block, Some(chain_data_source),
-	/// 	logger, spend_outputs_callback
-	/// );
-	/// # }
-	///```
 	pub fn new(
-		broadcaster: B, kv_store: K, best_block: BestBlock, chain_data_source: Option<F>,
-		logger: L,
-		spend_outputs_callback: impl Fn(&[&SpendableOutputDescriptor]) -> Result<Transaction, ()>
-			+ Send
-			+ Sync
-			+ 'static,
+		best_block: BestBlock, broadcaster: B, fee_estimator: E, chain_data_source: Option<F>,
+		output_spender: O, change_destination_source: D, kv_store: K, logger: L,
 	) -> Self {
 		let outputs = Vec::new();
 		Self::from_outputs(
 			outputs,
-			broadcaster,
-			kv_store,
 			best_block,
+			broadcaster,
+			fee_estimator,
 			chain_data_source,
+			output_spender,
+			change_destination_source,
+			kv_store,
 			logger,
-			spend_outputs_callback,
 		)
 	}
 
 	/// Constructs an [`OutputSweeper`] from the given list of [`TrackedSpendableOutput`]s.
 	///
 	/// See [`Self::new`] for more information regarding the remaining arguments.
 	pub fn from_outputs(
-		outputs: Vec<TrackedSpendableOutput>, broadcaster: B, kv_store: K, best_block: BestBlock,
-		chain_data_source: Option<F>, logger: L,
-		spend_outputs_callback: impl Fn(&[&SpendableOutputDescriptor]) -> Result<Transaction, ()>
-			+ Send
-			+ Sync
-			+ 'static,
+		outputs: Vec<TrackedSpendableOutput>, best_block: BestBlock, broadcaster: B,
+		fee_estimator: E, chain_data_source: Option<F>, output_spender: O,
+		change_destination_source: D, kv_store: K, logger: L,
 	) -> Self {
 		if let Some(filter) = chain_data_source.as_ref() {
 			for output_info in &outputs {
@@ -431,14 +378,15 @@ where
 		}
 
 		let sweeper_state = Mutex::new(SweeperState { outputs, best_block });
-		let spend_outputs_callback = Box::new(spend_outputs_callback);
 		Self {
 			sweeper_state,
 			broadcaster,
-			kv_store,
+			fee_estimator,
 			chain_data_source,
+			output_spender,
+			change_destination_source,
+			kv_store,
 			logger,
-			spend_outputs_callback,
 		}
 	}
 
@@ -532,7 +480,7 @@ where
 			return None;
 		}
 
-		let spending_tx = match (self.spend_outputs_callback)(&respend_descriptors) {
+		let spending_tx = match self.spend_outputs(&*sweeper_state, respend_descriptors) {
 			Ok(spending_tx) => {
 				log_debug!(
 					self.logger,
@@ -600,14 +548,37 @@ where
 				e
 			})
 	}
+
+	fn spend_outputs(
+		&self, sweeper_state: &SweeperState, descriptors: Vec<&SpendableOutputDescriptor>,
+	) -> Result<Transaction, ()> {
+		let tx_feerate =
+			self.fee_estimator.get_est_sat_per_1000_weight(ConfirmationTarget::AnchorChannelFee);
+		let change_destination_script =
+			self.change_destination_source.get_change_destination_script()?;
+		let cur_height = sweeper_state.best_block.height;
+		let locktime = Some(LockTime::from_height(cur_height).unwrap_or(LockTime::ZERO));
+		self.output_spender.spend_spendable_outputs(
+			&descriptors,
+			Vec::new(),
+			change_destination_script,
+			tx_feerate,
+			locktime,
+			&Secp256k1::new(),
+		)
+	}
 }
 
-impl<B: Deref, F: Deref, K: Deref, L: Deref> Listen for OutputSweeper<B, F, K, L>
+impl<B: Deref, D: Deref, E: Deref, F: Deref, K: Deref, L: Deref, O: Deref> Listen
+	for OutputSweeper<B, D, E, F, K, L, O>
 where
 	B::Target: BroadcasterInterface,
+	D::Target: ChangeDestinationSource,
+	E::Target: FeeEstimator,
 	F::Target: Filter + Sync + Send,
 	K::Target: KVStore,
 	L::Target: Logger,
+	O::Target: OutputSpender,
 {
 	fn filtered_block_connected(
 		&self, header: &Header, txdata: &chain::transaction::TransactionData, height: u32,
@@ -649,12 +620,16 @@ where
 	}
 }
 
-impl<B: Deref, F: Deref, K: Deref, L: Deref> Confirm for OutputSweeper<B, F, K, L>
+impl<B: Deref, D: Deref, E: Deref, F: Deref, K: Deref, L: Deref, O: Deref> Confirm
+	for OutputSweeper<B, D, E, F, K, L, O>
 where
 	B::Target: BroadcasterInterface,
+	D::Target: ChangeDestinationSource,
+	E::Target: FeeEstimator,
 	F::Target: Filter + Sync + Send,
 	K::Target: KVStore,
 	L::Target: Logger,
+	O::Target: OutputSpender,
 {
 	fn transactions_confirmed(
 		&self, header: &Header, txdata: &chain::transaction::TransactionData, height: u32,
@@ -749,50 +724,40 @@ impl_writeable_tlv_based!(SweeperState, {
 	(2, best_block, required),
 });
 
-impl<B: Deref, F: Deref, K: Deref, L: Deref>
-	ReadableArgs<(
-		B,
-		Option<F>,
-		K,
-		L,
-		Box<
-			dyn Fn(&[&SpendableOutputDescriptor]) -> Result<Transaction, ()>
-				+ Send
-				+ Sync
-				+ 'static,
-		>,
-	)> for OutputSweeper<B, F, K, L>
+impl<B: Deref, D: Deref, E: Deref, F: Deref, K: Deref, L: Deref, O: Deref>
+	ReadableArgs<(B, E, Option<F>, O, D, K, L)> for OutputSweeper<B, D, E, F, K, L, O>
 where
 	B::Target: BroadcasterInterface,
+	D::Target: ChangeDestinationSource,
+	E::Target: FeeEstimator,
 	F::Target: Filter + Sync + Send,
 	K::Target: KVStore,
 	L::Target: Logger,
+	O::Target: OutputSpender,
 {
 	#[inline]
 	fn read<R: io::Read>(
-		reader: &mut R,
-		args: (
-			B,
-			Option<F>,
-			K,
-			L,
-			Box<
-				dyn Fn(&[&SpendableOutputDescriptor]) -> Result<Transaction, ()>
-					+ Send
-					+ Sync
-					+ 'static,
-			>,
-		),
+		reader: &mut R, args: (B, E, Option<F>, O, D, K, L),
 	) -> Result<Self, DecodeError> {
-		let (broadcaster, chain_data_source, kv_store, logger, spend_outputs_callback) = args;
+		let (
+			broadcaster,
+			fee_estimator,
+			chain_data_source,
+			output_spender,
+			change_destination_source,
+			kv_store,
+			logger,
+		) = args;
 		let sweeper_state = Readable::read(reader)?;
 		Ok(Self {
 			sweeper_state,
 			broadcaster,
-			kv_store,
+			fee_estimator,
 			chain_data_source,
+			output_spender,
+			change_destination_source,
+			kv_store,
 			logger,
-			spend_outputs_callback,
 		})
 	}
 }