Merge pull request #4382 from jkczyz/2026-01-wallet-utils

Author: wpaulino

fuzz/src/chanmon_consistency.rs

@@ -47,7 +47,6 @@ use lightning::chain::{
 	chainmonitor, channelmonitor, BestBlock, ChannelMonitorUpdateStatus, Confirm, Watch,
 };
 use lightning::events;
-use lightning::events::bump_transaction::sync::{WalletSourceSync, WalletSync};
 use lightning::ln::channel::{
 	FEE_SPIKE_BUFFER_FEE_INCREASE_MULTIPLE, MAX_STD_OUTPUT_DUST_LIMIT_SATOSHIS,
 };
@@ -83,6 +82,7 @@ use lightning::util::logger::Logger;
 use lightning::util::ser::{LengthReadable, ReadableArgs, Writeable, Writer};
 use lightning::util::test_channel_signer::{EnforcementState, SignerOp, TestChannelSigner};
 use lightning::util::test_utils::TestWalletSource;
+use lightning::util::wallet_utils::{WalletSourceSync, WalletSync};
 
 use lightning_invoice::RawBolt11Invoice;
 

fuzz/src/full_stack.rs

@@ -40,7 +40,6 @@ use lightning::chain::chaininterface::{
 use lightning::chain::chainmonitor;
 use lightning::chain::transaction::OutPoint;
 use lightning::chain::{BestBlock, ChannelMonitorUpdateStatus, Confirm, Listen};
-use lightning::events::bump_transaction::sync::{WalletSourceSync, WalletSync};
 use lightning::events::Event;
 use lightning::ln::channel_state::ChannelDetails;
 use lightning::ln::channelmanager::{ChainParameters, ChannelManager, InterceptId, PaymentId};
@@ -71,6 +70,7 @@ use lightning::util::logger::Logger;
 use lightning::util::ser::{Readable, Writeable};
 use lightning::util::test_channel_signer::{EnforcementState, TestChannelSigner};
 use lightning::util::test_utils::TestWalletSource;
+use lightning::util::wallet_utils::{WalletSourceSync, WalletSync};
 
 use lightning_invoice::RawBolt11Invoice;
 

lightning-tests/src/upgrade_downgrade_tests.rs

@@ -46,7 +46,6 @@ use lightning_0_0_125::routing::router as router_0_0_125;
 use lightning_0_0_125::util::ser::Writeable as _;
 
 use lightning::chain::channelmonitor::{ANTI_REORG_DELAY, HTLC_FAIL_BACK_BUFFER};
-use lightning::events::bump_transaction::sync::WalletSourceSync;
 use lightning::events::{ClosureReason, Event, HTLCHandlingFailureType};
 use lightning::ln::functional_test_utils::*;
 use lightning::ln::msgs::BaseMessageHandler as _;
@@ -55,6 +54,7 @@ use lightning::ln::msgs::MessageSendEvent;
 use lightning::ln::splicing_tests::*;
 use lightning::ln::types::ChannelId;
 use lightning::sign::OutputSpender;
+use lightning::util::wallet_utils::WalletSourceSync;
 
 use lightning_types::payment::{PaymentHash, PaymentPreimage, PaymentSecret};
 

lightning/src/events/bump_transaction/mod.rs

@@ -15,258 +15,12 @@ use core::pin::pin;
 use core::task;
 
 use crate::chain::chaininterface::BroadcasterInterface;
-use crate::chain::ClaimId;
-use crate::prelude::*;
 use crate::sign::SignerProvider;
-use crate::util::async_poll::{dummy_waker, MaybeSend, MaybeSync};
+use crate::util::async_poll::dummy_waker;
 use crate::util::logger::Logger;
+use crate::util::wallet_utils::{CoinSelectionSourceSync, CoinSelectionSourceSyncWrapper};
 
-use bitcoin::{OutPoint, Psbt, ScriptBuf, Transaction, TxOut};
-
-use super::BumpTransactionEvent;
-use super::{
-	BumpTransactionEventHandler, CoinSelection, CoinSelectionSource, Input, Utxo, Wallet,
-	WalletSource,
-};
-
-/// An alternative to [`CoinSelectionSourceSync`] that can be implemented and used along
-/// [`WalletSync`] to provide a default implementation to [`CoinSelectionSourceSync`].
-///
-/// For an asynchronous version of this trait, see [`WalletSource`].
-// Note that updates to documentation on this trait should be copied to the asynchronous version.
-pub trait WalletSourceSync {
-	/// Returns all UTXOs, with at least 1 confirmation each, that are available to spend.
-	fn list_confirmed_utxos(&self) -> Result<Vec<Utxo>, ()>;
-
-	/// Returns the previous transaction containing the UTXO referenced by the outpoint.
-	fn get_prevtx(&self, outpoint: OutPoint) -> Result<Transaction, ()>;
-
-	/// Returns a script to use for change above dust resulting from a successful coin selection
-	/// attempt.
-	fn get_change_script(&self) -> Result<ScriptBuf, ()>;
-
-	/// Signs and provides the full [`TxIn::script_sig`] and [`TxIn::witness`] for all inputs within
-	/// the transaction known to the wallet (i.e., any provided via
-	/// [`WalletSource::list_confirmed_utxos`]).
-	///
-	/// If your wallet does not support signing PSBTs you can call `psbt.extract_tx()` to get the
-	/// unsigned transaction and then sign it with your wallet.
-	///
-	/// [`TxIn::script_sig`]: bitcoin::TxIn::script_sig
-	/// [`TxIn::witness`]: bitcoin::TxIn::witness
-	fn sign_psbt(&self, psbt: Psbt) -> Result<Transaction, ()>;
-}
-
-pub(crate) struct WalletSourceSyncWrapper<T: Deref>(T)
-where
-	T::Target: WalletSourceSync;
-
-// Implement `Deref` directly on WalletSourceSyncWrapper so that it can be used directly
-// below, rather than via a wrapper.
-impl<T: Deref> Deref for WalletSourceSyncWrapper<T>
-where
-	T::Target: WalletSourceSync,
-{
-	type Target = Self;
-	fn deref(&self) -> &Self {
-		self
-	}
-}
-
-impl<T: Deref> WalletSource for WalletSourceSyncWrapper<T>
-where
-	T::Target: WalletSourceSync,
-{
-	fn list_confirmed_utxos<'a>(
-		&'a self,
-	) -> impl Future<Output = Result<Vec<Utxo>, ()>> + MaybeSend + 'a {
-		let utxos = self.0.list_confirmed_utxos();
-		async move { utxos }
-	}
-
-	fn get_prevtx<'a>(
-		&'a self, outpoint: OutPoint,
-	) -> impl Future<Output = Result<Transaction, ()>> + MaybeSend + 'a {
-		let prevtx = self.0.get_prevtx(outpoint);
-		Box::pin(async move { prevtx })
-	}
-
-	fn get_change_script<'a>(
-		&'a self,
-	) -> impl Future<Output = Result<ScriptBuf, ()>> + MaybeSend + 'a {
-		let script = self.0.get_change_script();
-		async move { script }
-	}
-
-	fn sign_psbt<'a>(
-		&'a self, psbt: Psbt,
-	) -> impl Future<Output = Result<Transaction, ()>> + MaybeSend + 'a {
-		let signed_psbt = self.0.sign_psbt(psbt);
-		async move { signed_psbt }
-	}
-}
-
-/// A wrapper over [`WalletSourceSync`] that implements [`CoinSelectionSourceSync`] by preferring
-/// UTXOs that would avoid conflicting double spends. If not enough UTXOs are available to do so,
-/// conflicting double spends may happen.
-///
-/// For an asynchronous version of this wrapper, see [`Wallet`].
-// Note that updates to documentation on this struct should be copied to the asynchronous version.
-pub struct WalletSync<W: Deref + MaybeSync + MaybeSend, L: Logger + MaybeSync + MaybeSend>
-where
-	W::Target: WalletSourceSync + MaybeSend,
-{
-	wallet: Wallet<WalletSourceSyncWrapper<W>, L>,
-}
-
-impl<W: Deref + MaybeSync + MaybeSend, L: Logger + MaybeSync + MaybeSend> WalletSync<W, L>
-where
-	W::Target: WalletSourceSync + MaybeSend,
-{
-	/// Constructs a new [`WalletSync`] instance.
-	pub fn new(source: W, logger: L) -> Self {
-		Self { wallet: Wallet::new(WalletSourceSyncWrapper(source), logger) }
-	}
-}
-
-impl<W: Deref + MaybeSync + MaybeSend, L: Logger + MaybeSync + MaybeSend> CoinSelectionSourceSync
-	for WalletSync<W, L>
-where
-	W::Target: WalletSourceSync + MaybeSend + MaybeSync,
-{
-	fn select_confirmed_utxos(
-		&self, claim_id: Option<ClaimId>, must_spend: Vec<Input>, must_pay_to: &[TxOut],
-		target_feerate_sat_per_1000_weight: u32, max_tx_weight: u64,
-	) -> Result<CoinSelection, ()> {
-		let fut = self.wallet.select_confirmed_utxos(
-			claim_id,
-			must_spend,
-			must_pay_to,
-			target_feerate_sat_per_1000_weight,
-			max_tx_weight,
-		);
-		let mut waker = dummy_waker();
-		let mut ctx = task::Context::from_waker(&mut waker);
-		match pin!(fut).poll(&mut ctx) {
-			task::Poll::Ready(result) => result,
-			task::Poll::Pending => {
-				unreachable!(
-					"Wallet::select_confirmed_utxos should not be pending in a sync context"
-				);
-			},
-		}
-	}
-
-	fn sign_psbt(&self, psbt: Psbt) -> Result<Transaction, ()> {
-		let fut = self.wallet.sign_psbt(psbt);
-		let mut waker = dummy_waker();
-		let mut ctx = task::Context::from_waker(&mut waker);
-		match pin!(fut).poll(&mut ctx) {
-			task::Poll::Ready(result) => result,
-			task::Poll::Pending => {
-				unreachable!("Wallet::sign_psbt should not be pending in a sync context");
-			},
-		}
-	}
-}
-
-/// An abstraction over a bitcoin wallet that can perform coin selection over a set of UTXOs and can
-/// sign for them. The coin selection method aims to mimic Bitcoin Core's `fundrawtransaction` RPC,
-/// which most wallets should be able to satisfy. Otherwise, consider implementing
-/// [`WalletSourceSync`], which can provide a default implementation of this trait when used with
-/// [`WalletSync`].
-///
-/// For an asynchronous version of this trait, see [`CoinSelectionSource`].
-// Note that updates to documentation on this trait should be copied to the asynchronous version.
-pub trait CoinSelectionSourceSync {
-	/// Performs coin selection of a set of UTXOs, with at least 1 confirmation each, that are
-	/// available to spend. Implementations are free to pick their coin selection algorithm of
-	/// choice, as long as the following requirements are met:
-	///
-	/// 1. `must_spend` contains a set of [`Input`]s that must be included in the transaction
-	///    throughout coin selection, but must not be returned as part of the result.
-	/// 2. `must_pay_to` contains a set of [`TxOut`]s that must be included in the transaction
-	///    throughout coin selection. In some cases, like when funding an anchor transaction, this
-	///    set is empty. Implementations should ensure they handle this correctly on their end,
-	///    e.g., Bitcoin Core's `fundrawtransaction` RPC requires at least one output to be
-	///    provided, in which case a zero-value empty OP_RETURN output can be used instead.
-	/// 3. Enough inputs must be selected/contributed for the resulting transaction (including the
-	///    inputs and outputs noted above) to meet `target_feerate_sat_per_1000_weight`.
-	/// 4. The final transaction must have a weight smaller than `max_tx_weight`; if this
-	///    constraint can't be met, return an `Err`. In the case of counterparty-signed HTLC
-	///    transactions, we will remove a chunk of HTLCs and try your algorithm again. As for
-	///    anchor transactions, we will try your coin selection again with the same input-output
-	///    set when you call [`ChannelMonitor::rebroadcast_pending_claims`], as anchor transactions
-	///    cannot be downsized.
-	///
-	/// Implementations must take note that [`Input::satisfaction_weight`] only tracks the weight of
-	/// the input's `script_sig` and `witness`. Some wallets, like Bitcoin Core's, may require
-	/// providing the full input weight. Failing to do so may lead to underestimating fee bumps and
-	/// delaying block inclusion.
-	///
-	/// The `claim_id` must map to the set of external UTXOs assigned to the claim, such that they
-	/// can be re-used within new fee-bumped iterations of the original claiming transaction,
-	/// ensuring that claims don't double spend each other. If a specific `claim_id` has never had a
-	/// transaction associated with it, and all of the available UTXOs have already been assigned to
-	/// other claims, implementations must be willing to double spend their UTXOs. The choice of
-	/// which UTXOs to double spend is left to the implementation, but it must strive to keep the
-	/// set of other claims being double spent to a minimum.
-	///
-	/// [`ChannelMonitor::rebroadcast_pending_claims`]: crate::chain::channelmonitor::ChannelMonitor::rebroadcast_pending_claims
-	fn select_confirmed_utxos(
-		&self, claim_id: Option<ClaimId>, must_spend: Vec<Input>, must_pay_to: &[TxOut],
-		target_feerate_sat_per_1000_weight: u32, max_tx_weight: u64,
-	) -> Result<CoinSelection, ()>;
-
-	/// Signs and provides the full witness for all inputs within the transaction known to the
-	/// trait (i.e., any provided via [`CoinSelectionSourceSync::select_confirmed_utxos`]).
-	///
-	/// If your wallet does not support signing PSBTs you can call `psbt.extract_tx()` to get the
-	/// unsigned transaction and then sign it with your wallet.
-	fn sign_psbt(&self, psbt: Psbt) -> Result<Transaction, ()>;
-}
-
-struct CoinSelectionSourceSyncWrapper<T: Deref>(T)
-where
-	T::Target: CoinSelectionSourceSync;
-
-// Implement `Deref` directly on CoinSelectionSourceSyncWrapper so that it can be used directly
-// below, rather than via a wrapper.
-impl<T: Deref> Deref for CoinSelectionSourceSyncWrapper<T>
-where
-	T::Target: CoinSelectionSourceSync,
-{
-	type Target = Self;
-	fn deref(&self) -> &Self {
-		self
-	}
-}
-
-impl<T: Deref> CoinSelectionSource for CoinSelectionSourceSyncWrapper<T>
-where
-	T::Target: CoinSelectionSourceSync,
-{
-	fn select_confirmed_utxos<'a>(
-		&'a self, claim_id: Option<ClaimId>, must_spend: Vec<Input>, must_pay_to: &'a [TxOut],
-		target_feerate_sat_per_1000_weight: u32, max_tx_weight: u64,
-	) -> impl Future<Output = Result<CoinSelection, ()>> + MaybeSend + 'a {
-		let coins = self.0.select_confirmed_utxos(
-			claim_id,
-			must_spend,
-			must_pay_to,
-			target_feerate_sat_per_1000_weight,
-			max_tx_weight,
-		);
-		async move { coins }
-	}
-
-	fn sign_psbt<'a>(
-		&'a self, psbt: Psbt,
-	) -> impl Future<Output = Result<Transaction, ()>> + MaybeSend + 'a {
-		let psbt = self.0.sign_psbt(psbt);
-		async move { psbt }
-	}
-}
+use super::{BumpTransactionEvent, BumpTransactionEventHandler};
 
 /// A handler for [`Event::BumpTransaction`] events that sources confirmed UTXOs from a
 /// [`CoinSelectionSourceSync`] to fee bump transactions via Child-Pays-For-Parent (CPFP) or

lightning/src/events/bump_transaction/sync.rs

@@ -10,7 +10,6 @@
 //! Tests for asynchronous signing. These tests verify that the channel state machine behaves
 //! properly with a signer implementation that asynchronously derives signatures.
 
-use crate::events::bump_transaction::sync::WalletSourceSync;
 use crate::ln::splicing_tests::{initiate_splice_out, negotiate_splice_tx};
 use crate::prelude::*;
 use crate::util::ser::Writeable;
@@ -31,6 +30,7 @@ use crate::sign::ecdsa::EcdsaChannelSigner;
 use crate::sign::SignerProvider;
 use crate::util::logger::Logger;
 use crate::util::test_channel_signer::SignerOp;
+use crate::util::wallet_utils::WalletSourceSync;
 
 #[test]
 fn test_open_channel() {

lightning/src/ln/async_signer_tests.rs

@@ -36,7 +36,6 @@ use crate::chain::channelmonitor::{
 };
 use crate::chain::transaction::{OutPoint, TransactionData};
 use crate::chain::BestBlock;
-use crate::events::bump_transaction::Input;
 use crate::events::{ClosureReason, FundingInfo};
 use crate::ln::chan_utils;
 use crate::ln::chan_utils::{
@@ -84,6 +83,7 @@ use crate::util::errors::APIError;
 use crate::util::logger::{Logger, Record, WithContext};
 use crate::util::scid_utils::{block_from_scid, scid_from_parts};
 use crate::util::ser::{Readable, ReadableArgs, RequiredWrapper, Writeable, Writer};
+use crate::util::wallet_utils::Input;
 use crate::{impl_readable_for_vec, impl_writeable_for_vec};
 
 use alloc::collections::{btree_map, BTreeMap};
@@ -12162,7 +12162,7 @@ where
 	}
 
 	/// Initiate splicing.
-	pub fn splice_channel(&mut self, feerate: FeeRate) -> Result<FundingTemplate, APIError> {
+	pub fn splice_channel(&self, feerate: FeeRate) -> Result<FundingTemplate, APIError> {
 		if self.holder_commitment_point.current_point().is_none() {
 			return Err(APIError::APIMisuseError {
 				err: format!(
@@ -12213,17 +12213,18 @@ where
 			satisfaction_weight: EMPTY_SCRIPT_SIG_WEIGHT + FUNDING_TRANSACTION_WITNESS_WEIGHT,
 		};
 
-		Ok(FundingTemplate::new(Some(shared_input), feerate, true))
+		Ok(FundingTemplate::new(Some(shared_input), feerate))
 	}
 
 	pub fn funding_contributed<L: Logger>(
 		&mut self, contribution: FundingContribution, locktime: LockTime, logger: &L,
 	) -> Result<Option<msgs::Stfu>, SpliceFundingFailed> {
 		debug_assert!(contribution.is_splice());
 
-		if let Err(e) = contribution.net_value().and_then(|our_funding_contribution| {
+		if let Err(e) = contribution.validate().and_then(|()| {
 			// For splice-out, our_funding_contribution is adjusted to cover fees if there
 			// aren't any inputs.
+			let our_funding_contribution = contribution.net_value();
 			self.validate_splice_contributions(our_funding_contribution, SignedAmount::ZERO)
 		}) {
 			log_error!(logger, "Channel {} cannot be funded: {}", self.context.channel_id(), e);
@@ -13566,24 +13567,12 @@ where
 					}
 
 					let prev_funding_input = self.funding.to_splice_funding_input();
-					let is_initiator = contribution.is_initiator();
-					let our_funding_contribution = match contribution.net_value() {
-						Ok(net_value) => net_value,
-						Err(e) => {
-							debug_assert!(false);
-							return Err(ChannelError::WarnAndDisconnect(
-								format!(
-									"Internal Error: Insufficient funding contribution: {}",
-									e,
-								)
-							));
-						},
-					};
+					let our_funding_contribution = contribution.net_value();
 					let funding_feerate_per_kw = contribution.feerate().to_sat_per_kwu() as u32;
 					let (our_funding_inputs, our_funding_outputs) = contribution.into_tx_parts();
 
 					let context = FundingNegotiationContext {
-						is_initiator,
+						is_initiator: true,
 						our_funding_contribution,
 						funding_tx_locktime: locktime,
 						funding_feerate_sat_per_1000_weight: funding_feerate_per_kw,