Split DiscardFunding from SpliceFailed event

fuzz/src/full_stack.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,7 +31,7 @@ use bitcoin::hashes::Hash as _;
 use bitcoin::hex::FromHex;
 use bitcoin::WPubkeyHash;
 
-use lightning::ln::funding::{FundingTxInput, SpliceContribution};
+use lightning::ln::funding::SpliceContribution;
 
 use lightning::blinded_path::message::{BlindedMessagePath, MessageContext, MessageForwardNode};
 use lightning::blinded_path::payment::{BlindedPaymentPath, ReceiveTlvs};
@@ -39,7 +40,6 @@ use lightning::chain::chaininterface::{BroadcasterInterface, ConfirmationTarget,
 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::Event;
 use lightning::ln::channel_state::ChannelDetails;
 use lightning::ln::channelmanager::{
@@ -65,12 +65,14 @@ 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;
 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;
 
@@ -227,7 +229,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 +241,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 +268,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 +293,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 +528,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 +676,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,21 +1032,15 @@ 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 contribution = SpliceContribution::splice_in(
+					Amount::from_sat(splice_in_sats.min(900_000)), // Cap at available funds minus fees
+				);
+				let _ = channelmanager.splice_channel(
+					&chan.channel_id,
+					&chan.counterparty.node_id,
+					contribution,
+					FeeRate::from_sat_per_kwu(253),
+				);
 			},
 			// Splice-out: remove funds from a channel
 			51 => {
@@ -1070,8 +1070,7 @@ pub fn do_test(mut data: &[u8], logger: &Arc<dyn Logger>) {
 					&chan.channel_id,
 					&chan.counterparty.node_id,
 					contribution,
-					253, // funding_feerate_per_kw
-					None,
+					FeeRate::from_sat_per_kwu(253),
 				);
 			},
 			_ => return,
@@ -1102,6 +1101,21 @@ pub fn do_test(mut data: &[u8], logger: &Arc<dyn Logger>) {
 						intercepted_htlcs.push(intercept_id);
 					}
 				},
+				Event::FundingNeeded {
+					channel_id, counterparty_node_id, funding_template, ..
+				} => {
+					let wallet = WalletSync::new(&wallet, Arc::clone(&logger));
+					let contribution = funding_template.build_sync(&wallet).unwrap();
+					let locktime = None;
+					channelmanager
+						.funding_contributed(
+							&channel_id,
+							&counterparty_node_id,
+							contribution,
+							locktime,
+						)
+						.unwrap();
+				},
 				Event::FundingTransactionReadyForSigning {
 					channel_id,
 					counterparty_node_id,
@@ -1128,14 +1142,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);
 }
@@ -1921,6 +1936,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};
@@ -1952,7 +1968,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
@@ -1987,7 +2003,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));
@@ -2000,7 +2016,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/lsps_message.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();

lightning-tests/src/upgrade_downgrade_tests.rs

@@ -46,8 +46,8 @@ 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::util::wallet_utils::WalletSourceSync;
 use lightning::ln::functional_test_utils::*;
 use lightning::ln::funding::SpliceContribution;
 use lightning::ln::msgs::BaseMessageHandler as _;
@@ -455,7 +455,8 @@ fn do_test_0_1_htlc_forward_after_splice(fail_htlc: bool) {
 		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 (splice_tx, _) =
+		splice_channel(&nodes[0], &nodes[1], ChannelId(chan_id_bytes_a), contribution);
 	for node in nodes.iter() {
 		mine_transaction(node, &splice_tx);
 		connect_blocks(node, ANTI_REORG_DELAY - 1);