Merge pull request #4290 from jkczyz/2025-12-new-splice-api

Split splice initiation into two phases

Author: TheBlueMatt

fuzz/src/chanmon_consistency.rs

@@ -22,6 +22,7 @@ use bitcoin::opcodes;
 use bitcoin::script::{Builder, ScriptBuf};
 use bitcoin::transaction::Version;
 use bitcoin::transaction::{Transaction, TxIn, TxOut};
+use bitcoin::FeeRate;
 
 use bitcoin::hash_types::{BlockHash, Txid};
 use bitcoin::hashes::sha256::Hash as Sha256;
@@ -30,18 +31,16 @@ use bitcoin::hashes::Hash as _;
 use bitcoin::hex::FromHex;
 use bitcoin::WPubkeyHash;
 
-use lightning::ln::funding::{FundingTxInput, SpliceContribution};
-
 use lightning::blinded_path::message::{BlindedMessagePath, MessageContext, MessageForwardNode};
 use lightning::blinded_path::payment::{BlindedPaymentPath, ReceiveTlvs};
 use lightning::chain;
 use lightning::chain::chaininterface::{
-	TransactionType, BroadcasterInterface, ConfirmationTarget, FeeEstimator,
+	BroadcasterInterface, ConfirmationTarget, FeeEstimator, TransactionType,
 };
 use lightning::chain::chainmonitor;
 use lightning::chain::transaction::OutPoint;
 use lightning::chain::{BestBlock, ChannelMonitorUpdateStatus, Confirm, Listen};
-use lightning::events::bump_transaction::sync::WalletSourceSync;
+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};
@@ -65,6 +64,7 @@ use lightning::sign::{
 	SignerProvider,
 };
 use lightning::types::payment::{PaymentHash, PaymentPreimage, PaymentSecret};
+use lightning::util::async_poll::{MaybeSend, MaybeSync};
 use lightning::util::config::{ChannelConfig, UserConfig};
 use lightning::util::hash_tables::*;
 use lightning::util::logger::Logger;
@@ -227,7 +227,7 @@ type ChannelMan<'a> = ChannelManager<
 			Arc<dyn chain::Filter>,
 			Arc<TestBroadcaster>,
 			Arc<FuzzEstimator>,
-			Arc<dyn Logger>,
+			Arc<dyn Logger + MaybeSend + MaybeSync>,
 			Arc<TestPersister>,
 			Arc<KeyProvider>,
 		>,
@@ -239,14 +239,20 @@ type ChannelMan<'a> = ChannelManager<
 	Arc<FuzzEstimator>,
 	&'a FuzzRouter,
 	&'a FuzzRouter,
-	Arc<dyn Logger>,
+	Arc<dyn Logger + MaybeSend + MaybeSync>,
 >;
 type PeerMan<'a> = PeerManager<
 	Peer<'a>,
 	Arc<ChannelMan<'a>>,
-	Arc<P2PGossipSync<Arc<NetworkGraph<Arc<dyn Logger>>>, Arc<dyn UtxoLookup>, Arc<dyn Logger>>>,
+	Arc<
+		P2PGossipSync<
+			Arc<NetworkGraph<Arc<dyn Logger + MaybeSend + MaybeSync>>>,
+			Arc<dyn UtxoLookup>,
+			Arc<dyn Logger + MaybeSend + MaybeSync>,
+		>,
+	>,
 	IgnoringMessageHandler,
-	Arc<dyn Logger>,
+	Arc<dyn Logger + MaybeSend + MaybeSync>,
 	IgnoringMessageHandler,
 	Arc<KeyProvider>,
 	IgnoringMessageHandler,
@@ -260,7 +266,7 @@ struct MoneyLossDetector<'a> {
 			Arc<dyn chain::Filter>,
 			Arc<TestBroadcaster>,
 			Arc<FuzzEstimator>,
-			Arc<dyn Logger>,
+			Arc<dyn Logger + MaybeSend + MaybeSync>,
 			Arc<TestPersister>,
 			Arc<KeyProvider>,
 		>,
@@ -285,7 +291,7 @@ impl<'a> MoneyLossDetector<'a> {
 				Arc<dyn chain::Filter>,
 				Arc<TestBroadcaster>,
 				Arc<FuzzEstimator>,
-				Arc<dyn Logger>,
+				Arc<dyn Logger + MaybeSend + MaybeSync>,
 				Arc<TestPersister>,
 				Arc<KeyProvider>,
 			>,
@@ -520,7 +526,7 @@ impl SignerProvider for KeyProvider {
 }
 
 #[inline]
-pub fn do_test(mut data: &[u8], logger: &Arc<dyn Logger>) {
+pub fn do_test(mut data: &[u8], logger: &Arc<dyn Logger + MaybeSend + MaybeSync>) {
 	if data.len() < 32 {
 		return;
 	}
@@ -668,9 +674,7 @@ pub fn do_test(mut data: &[u8], logger: &Arc<dyn Logger>) {
 			script_pubkey: wallet.get_change_script().unwrap(),
 		}],
 	};
-	let coinbase_txid = coinbase_tx.compute_txid();
-	wallet
-		.add_utxo(bitcoin::OutPoint { txid: coinbase_txid, vout: 0 }, Amount::from_sat(1_000_000));
+	wallet.add_utxo(coinbase_tx.clone(), 0);
 
 	loop {
 		match get_slice!(1)[0] {
@@ -1026,20 +1030,24 @@ pub fn do_test(mut data: &[u8], logger: &Arc<dyn Logger>) {
 				if splice_in_sats == 0 {
 					continue;
 				}
-				// Create a funding input from the coinbase transaction
-				if let Ok(input) = FundingTxInput::new_p2wpkh(coinbase_tx.clone(), 0) {
-					let contribution = SpliceContribution::splice_in(
-						Amount::from_sat(splice_in_sats.min(900_000)), // Cap at available funds minus fees
-						vec![input],
-						Some(wallet.get_change_script().unwrap()),
-					);
-					let _ = channelmanager.splice_channel(
-						&chan.channel_id,
-						&chan.counterparty.node_id,
-						contribution,
-						253, // funding_feerate_per_kw
-						None,
-					);
+				let chan_id = chan.channel_id;
+				let counterparty = chan.counterparty.node_id;
+				if let Ok(funding_template) = channelmanager.splice_channel(
+					&chan_id,
+					&counterparty,
+					FeeRate::from_sat_per_kwu(253),
+				) {
+					let wallet_sync = WalletSync::new(&wallet, Arc::clone(&logger));
+					if let Ok(contribution) = funding_template
+						.splice_in_sync(Amount::from_sat(splice_in_sats.min(900_000)), &wallet_sync)
+					{
+						let _ = channelmanager.funding_contributed(
+							&chan_id,
+							&counterparty,
+							contribution,
+							None,
+						);
+					}
 				}
 			},
 			// Splice-out: remove funds from a channel
@@ -1062,17 +1070,29 @@ pub fn do_test(mut data: &[u8], logger: &Arc<dyn Logger>) {
 				// Cap splice-out at a reasonable portion of channel capacity
 				let max_splice_out = chan.channel_value_satoshis / 4;
 				let splice_out_sats = splice_out_sats.min(max_splice_out).max(546); // At least dust limit
-				let contribution = SpliceContribution::splice_out(vec![TxOut {
-					value: Amount::from_sat(splice_out_sats),
-					script_pubkey: wallet.get_change_script().unwrap(),
-				}]);
-				let _ = channelmanager.splice_channel(
-					&chan.channel_id,
-					&chan.counterparty.node_id,
-					contribution,
-					253, // funding_feerate_per_kw
-					None,
-				);
+				let chan_id = chan.channel_id;
+				let counterparty = chan.counterparty.node_id;
+				if let Ok(funding_template) = channelmanager.splice_channel(
+					&chan_id,
+					&counterparty,
+					FeeRate::from_sat_per_kwu(253),
+				) {
+					let outputs = vec![TxOut {
+						value: Amount::from_sat(splice_out_sats),
+						script_pubkey: wallet.get_change_script().unwrap(),
+					}];
+					let wallet_sync = WalletSync::new(&wallet, Arc::clone(&logger));
+					if let Ok(contribution) =
+						funding_template.splice_out_sync(outputs, &wallet_sync)
+					{
+						let _ = channelmanager.funding_contributed(
+							&chan_id,
+							&counterparty,
+							contribution,
+							None,
+						);
+					}
+				}
 			},
 			_ => return,
 		}
@@ -1139,14 +1159,15 @@ pub fn do_test(mut data: &[u8], logger: &Arc<dyn Logger>) {
 	}
 }
 
-pub fn full_stack_test<Out: test_logger::Output>(data: &[u8], out: Out) {
-	let logger: Arc<dyn Logger> = Arc::new(test_logger::TestLogger::new("".to_owned(), out));
+pub fn full_stack_test<Out: test_logger::Output + MaybeSend + MaybeSync>(data: &[u8], out: Out) {
+	let logger: Arc<dyn Logger + MaybeSend + MaybeSync> =
+		Arc::new(test_logger::TestLogger::new("".to_owned(), out));
 	do_test(data, &logger);
 }
 
 #[no_mangle]
 pub extern "C" fn full_stack_run(data: *const u8, datalen: usize) {
-	let logger: Arc<dyn Logger> =
+	let logger: Arc<dyn Logger + MaybeSend + MaybeSync> =
 		Arc::new(test_logger::TestLogger::new("".to_owned(), test_logger::DevNull {}));
 	do_test(unsafe { std::slice::from_raw_parts(data, datalen) }, &logger);
 }
@@ -1932,6 +1953,7 @@ pub fn write_fst_seeds(path: &str) {
 
 #[cfg(test)]
 mod tests {
+	use lightning::util::async_poll::{MaybeSend, MaybeSync};
 	use lightning::util::logger::{Logger, Record};
 	use std::collections::HashMap;
 	use std::sync::{Arc, Mutex};
@@ -1963,7 +1985,7 @@ mod tests {
 		let test = super::two_peer_forwarding_seed();
 
 		let logger = Arc::new(TrackingLogger { lines: Mutex::new(HashMap::new()) });
-		super::do_test(&test, &(Arc::clone(&logger) as Arc<dyn Logger>));
+		super::do_test(&test, &(Arc::clone(&logger) as Arc<dyn Logger + MaybeSend + MaybeSync>));
 
 		let log_entries = logger.lines.lock().unwrap();
 		// 1
@@ -1998,7 +2020,7 @@ mod tests {
 		let test = super::gossip_exchange_seed();
 
 		let logger = Arc::new(TrackingLogger { lines: Mutex::new(HashMap::new()) });
-		super::do_test(&test, &(Arc::clone(&logger) as Arc<dyn Logger>));
+		super::do_test(&test, &(Arc::clone(&logger) as Arc<dyn Logger + MaybeSend + MaybeSync>));
 
 		let log_entries = logger.lines.lock().unwrap();
 		assert_eq!(log_entries.get(&("lightning::ln::peer_handler".to_string(), "Sending message to all peers except Some(PublicKey(0000000000000000000000000000000000000000000000000000000000000002ff00000000000000000000000000000000000000000000000000000000000002)) or the announced channel's counterparties: ChannelAnnouncement { node_signature_1: 3026020200b202200303030303030303030303030303030303030303030303030303030303030303, node_signature_2: 3026020200b202200202020202020202020202020202020202020202020202020202020202020202, bitcoin_signature_1: 3026020200b202200303030303030303030303030303030303030303030303030303030303030303, bitcoin_signature_2: 3026020200b202200202020202020202020202020202020202020202020202020202020202020202, contents: UnsignedChannelAnnouncement { features: [], chain_hash: 6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000, short_channel_id: 42, node_id_1: NodeId(030303030303030303030303030303030303030303030303030303030303030303), node_id_2: NodeId(020202020202020202020202020202020202020202020202020202020202020202), bitcoin_key_1: NodeId(030303030303030303030303030303030303030303030303030303030303030303), bitcoin_key_2: NodeId(020202020202020202020202020202020202020202020202020202020202020202), excess_data: [] } }".to_string())), Some(&1));
@@ -2011,7 +2033,7 @@ mod tests {
 		let test = super::splice_seed();
 
 		let logger = Arc::new(TrackingLogger { lines: Mutex::new(HashMap::new()) });
-		super::do_test(&test, &(Arc::clone(&logger) as Arc<dyn Logger>));
+		super::do_test(&test, &(Arc::clone(&logger) as Arc<dyn Logger + MaybeSend + MaybeSync>));
 
 		let log_entries = logger.lines.lock().unwrap();
 

fuzz/src/full_stack.rs

@@ -77,17 +77,20 @@ pub fn do_test(data: &[u8]) {
 		genesis_block.header.time,
 	));
 
-	let liquidity_manager = Arc::new(LiquidityManagerSync::new(
-		Arc::clone(&keys_manager),
-		Arc::clone(&keys_manager),
-		Arc::clone(&manager),
-		None::<Arc<dyn Filter + Send + Sync>>,
-		None,
-		kv_store,
-		Arc::clone(&tx_broadcaster),
-		None,
-		None,
-	).unwrap());
+	let liquidity_manager = Arc::new(
+		LiquidityManagerSync::new(
+			Arc::clone(&keys_manager),
+			Arc::clone(&keys_manager),
+			Arc::clone(&manager),
+			None::<Arc<dyn Filter + Send + Sync>>,
+			None,
+			kv_store,
+			Arc::clone(&tx_broadcaster),
+			None,
+			None,
+		)
+		.unwrap(),
+	);
 	let mut reader = data;
 	if let Ok(Some(msg)) = liquidity_manager.read(LSPS_MESSAGE_TYPE_ID, &mut reader) {
 		let secp = Secp256k1::signing_only();

fuzz/src/lsps_message.rs

@@ -49,7 +49,6 @@ 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::funding::SpliceContribution;
 use lightning::ln::msgs::BaseMessageHandler as _;
 use lightning::ln::msgs::ChannelMessageHandler as _;
 use lightning::ln::msgs::MessageSendEvent;
@@ -453,11 +452,13 @@ fn do_test_0_1_htlc_forward_after_splice(fail_htlc: bool) {
 	reconnect_b_c_args.send_announcement_sigs = (true, true);
 	reconnect_nodes(reconnect_b_c_args);
 
-	let contribution = SpliceContribution::splice_out(vec![TxOut {
+	let outputs = vec![TxOut {
 		value: Amount::from_sat(1_000),
 		script_pubkey: nodes[0].wallet_source.get_change_script().unwrap(),
-	}]);
-	let splice_tx = splice_channel(&nodes[0], &nodes[1], ChannelId(chan_id_bytes_a), contribution);
+	}];
+	let channel_id = ChannelId(chan_id_bytes_a);
+	let funding_contribution = initiate_splice_out(&nodes[0], &nodes[1], channel_id, outputs);
+	let (splice_tx, _) = splice_channel(&nodes[0], &nodes[1], channel_id, funding_contribution);
 	for node in nodes.iter() {
 		mine_transaction(node, &splice_tx);
 		connect_blocks(node, ANTI_REORG_DELAY - 1);