Simplify new splice test; inputs also contain the weight

Author: optout21

lightning/src/ln/channel.rs

@@ -8380,7 +8380,7 @@ impl<SP: Deref> FundedChannel<SP> where
 	/// Initiate splicing
 	#[cfg(splicing)]
 	pub fn splice_channel(&mut self, our_funding_contribution_satoshis: i64,
-		our_funding_inputs: Vec<(TxIn, Transaction)>, funding_feerate_perkw: u32, locktime: u32,
+		our_funding_inputs: Vec<(TxIn, Transaction, Weight)>, funding_feerate_perkw: u32, locktime: u32,
 	) -> Result<msgs::SpliceInit, ChannelError> {
 		// Check if a splice has been initiated already.
 		// Note: this could be handled more nicely, and support multiple outstanding splice's, the incoming splice_ack matters anyways.
@@ -8415,7 +8415,7 @@ impl<SP: Deref> FundedChannel<SP> where
 
 		// Check that inputs are sufficient to cover our contribution
 		let sum_input: i64 = our_funding_inputs.into_iter().map(
-			|(txin, tx)| tx.output.get(txin.previous_output.vout as usize).map(|tx| tx.value.to_sat() as i64).unwrap_or(0)
+			|(txin, tx, _)| tx.output.get(txin.previous_output.vout as usize).map(|tx| tx.value.to_sat() as i64).unwrap_or(0)
 		).sum();
 		if sum_input < our_funding_contribution_satoshis {
 			return Err(ChannelError::Warn(format!(

lightning/src/ln/channelmanager.rs

@@ -31,6 +31,8 @@ use bitcoin::hash_types::{BlockHash, Txid};
 use bitcoin::secp256k1::{SecretKey,PublicKey};
 use bitcoin::secp256k1::Secp256k1;
 use bitcoin::{secp256k1, Sequence, TxIn};
+#[cfg(splicing)]
+use bitcoin::Weight;
 
 use crate::events::FundingInfo;
 use crate::blinded_path::message::{AsyncPaymentsContext, MessageContext, OffersContext};
@@ -4288,7 +4290,7 @@ where
 	#[cfg(splicing)]
 	pub fn splice_channel(
 		&self, channel_id: &ChannelId, counterparty_node_id: &PublicKey, our_funding_contribution_satoshis: i64,
-		our_funding_inputs: Vec<(TxIn, Transaction)>, funding_feerate_perkw: u32, locktime: u32,
+		our_funding_inputs: Vec<(TxIn, Transaction, Weight)>, funding_feerate_perkw: u32, locktime: u32,
 	) -> Result<(), APIError> {
 		let per_peer_state = self.per_peer_state.read().unwrap();
 

lightning/src/ln/dual_funding_tests.rs

@@ -49,7 +49,7 @@ fn do_test_v2_channel_establishment(session: V2ChannelEstablishmentTestSession)
 		&[session.initiator_input_value_satoshis],
 	)
 	.into_iter()
-	.map(|(txin, tx)| (txin, TransactionU16LenLimited::new(tx).unwrap()))
+	.map(|(txin, tx, _)| (txin, TransactionU16LenLimited::new(tx).unwrap()))
 	.collect();
 
 	// Alice creates a dual-funded channel as initiator.

lightning/src/ln/functional_test_utils.rs

@@ -38,7 +38,7 @@ use crate::util::test_utils;
 use crate::util::test_utils::{TestChainMonitor, TestScorer, TestKeysInterface};
 use crate::util::ser::{ReadableArgs, Writeable};
 
-use bitcoin::WPubkeyHash;
+use bitcoin::{Weight, WPubkeyHash};
 use bitcoin::amount::Amount;
 use bitcoin::block::{Block, Header, Version as BlockVersion};
 use bitcoin::locktime::absolute::{LockTime, LOCK_TIME_THRESHOLD};
@@ -60,6 +60,7 @@ use core::mem;
 use core::ops::Deref;
 use crate::io;
 use crate::prelude::*;
+use crate::sign::P2WPKH_WITNESS_WEIGHT;
 use crate::sync::{Arc, Mutex, LockTestExt, RwLock};
 
 pub const CHAN_CONFIRM_DEPTH: u32 = 10;
@@ -1236,9 +1237,11 @@ fn internal_create_funding_transaction<'a, 'b, 'c>(node: &Node<'a, 'b, 'c>,
 	}
 }
 
+/// Create test inputs for a funding transaction.
+/// Return the inputs (with prev tx), and the total witness weight for these inputs
 pub fn create_dual_funding_utxos_with_prev_txs(
 	node: &Node<'_, '_, '_>, utxo_values_in_satoshis: &[u64],
-) -> Vec<(TxIn, Transaction)> {
+) -> Vec<(TxIn, Transaction, Weight)> {
 	// Ensure we have unique transactions per node by using the locktime.
 	let tx = Transaction {
 		version: TxVersion::TWO,
@@ -1251,9 +1254,9 @@ pub fn create_dual_funding_utxos_with_prev_txs(
 		}).collect()
 	};
 
-	let mut result = vec![];
+	let mut inputs = vec![];
 	for i in 0..utxo_values_in_satoshis.len() {
-		result.push(
+		inputs.push(
 			(TxIn {
 				previous_output: OutPoint {
 					txid: tx.compute_txid(),
@@ -1262,9 +1265,13 @@ pub fn create_dual_funding_utxos_with_prev_txs(
 				script_sig: ScriptBuf::new(),
 				sequence: Sequence::ZERO,
 				witness: Witness::new(),
-			}, tx.clone()));
+			},
+			tx.clone(),
+			Weight::from_wu(P2WPKH_WITNESS_WEIGHT),
+		));
 	}
-	result
+
+	inputs
 }
 
 pub fn sign_funding_transaction<'a, 'b, 'c>(node_a: &Node<'a, 'b, 'c>, node_b: &Node<'a, 'b, 'c>, channel_value: u64, expected_temporary_channel_id: ChannelId) -> Transaction {

lightning/src/ln/functional_tests_splice.rs

@@ -7,27 +7,17 @@
 // You may not use this file except in accordance with one or both of these
 // licenses.
 
-//! Tests that test standing up a network of ChannelManagers, creating channels, sending
-//! payments/messages between them, and often checking the resulting ChannelMonitors are able to
-//! claim outputs on-chain.
-
-use crate::events::{Event, MessageSendEvent, MessageSendEventsProvider};
+use crate::events::{MessageSendEvent, MessageSendEventsProvider};
 use crate::ln::functional_test_utils::*;
 use crate::ln::msgs::ChannelMessageHandler;
-use crate::util::config::{ChannelHandshakeConfig, UserConfig};
 
 /// Splicing test, simple splice-in flow. Starts with opening a V1 channel first.
 /// Builds on test_channel_open_simple()
 #[test]
 fn test_v1_splice_in() {
-	// Set up a network of 2 nodes
-	let cfg = UserConfig {
-		channel_handshake_config: ChannelHandshakeConfig { ..Default::default() },
-		..Default::default()
-	};
 	let chanmon_cfgs = create_chanmon_cfgs(2);
 	let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
-	let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[Some(cfg), None]);
+	let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
 	let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 
 	// Initiator and Acceptor nodes
@@ -41,193 +31,31 @@ fn test_v1_splice_in() {
 	let push_msat = 0;
 	let channel_reserve_amnt_sat = 1_000;
 
+	let (_, _, channel_id, _) = create_announced_chan_between_nodes_with_value(
+		&nodes,
+		initiator_node_index,
+		acceptor_node_index,
+		channel_value_sat,
+		push_msat,
+	);
+
 	let expected_funded_channel_id =
 		"ae3367da2c13bc1ceb86bf56418f62828f7ce9d6bfb15a46af5ba1f1ed8b124f";
+	assert_eq!(channel_id.to_string(), expected_funded_channel_id);
 
-	// Have initiator_node initiate a channel to acceptor_node with aforementioned parameters
-	let channel_id_temp1 = initiator_node
-		.node
-		.create_channel(
-			acceptor_node.node.get_our_node_id(),
-			channel_value_sat,
-			push_msat,
-			42,
-			None,
-			None,
-		)
-		.unwrap();
-
-	// Extract the channel open message from initiator_node to acceptor_node
-	let open_channel_message = get_event_msg!(
-		initiator_node,
-		MessageSendEvent::SendOpenChannel,
-		acceptor_node.node.get_our_node_id()
-	);
 	let expected_initiator_funding_key =
 		"03c21e841cbc0b48197d060c71e116c185fa0ac281b7d0aa5924f535154437ca3b";
-	assert_eq!(
-		open_channel_message.common_fields.funding_pubkey.to_string(),
-		expected_initiator_funding_key
-	);
-
-	let _res = acceptor_node
-		.node
-		.handle_open_channel(initiator_node.node.get_our_node_id(), &open_channel_message.clone());
-	// Extract the accept channel message from acceptor_node to initiator_node
-	let accept_channel_message = get_event_msg!(
-		acceptor_node,
-		MessageSendEvent::SendAcceptChannel,
-		initiator_node.node.get_our_node_id()
-	);
 	let expected_acceptor_funding_key =
 		"039481c28b904cbe12681e79937373fc76245c1b29871028ae60ba3152162c319b";
-	assert_eq!(
-		accept_channel_message.common_fields.funding_pubkey.to_string(),
-		expected_acceptor_funding_key
-	);
-
-	let _res = initiator_node.node.handle_accept_channel(
-		acceptor_node.node.get_our_node_id(),
-		&accept_channel_message.clone(),
-	);
-	// Note: FundingGenerationReady emitted, checked and used below
-	let (_channel_id_temp2, funding_tx, _funding_output) = create_funding_transaction(
-		&initiator_node,
-		&acceptor_node.node.get_our_node_id(),
-		channel_value_sat,
-		42,
-	);
-
-	// Funding transation created, provide it
-	let _res = initiator_node
-		.node
-		.funding_transaction_generated(
-			channel_id_temp1,
-			acceptor_node.node.get_our_node_id(),
-			funding_tx.clone(),
-		)
-		.unwrap();
-
-	let funding_created_message = get_event_msg!(
-		initiator_node,
-		MessageSendEvent::SendFundingCreated,
-		acceptor_node.node.get_our_node_id()
-	);
-
-	let _res = acceptor_node
-		.node
-		.handle_funding_created(initiator_node.node.get_our_node_id(), &funding_created_message);
-
-	assert_eq!(initiator_node.node.list_channels().len(), 1);
-	{
-		let channel = &initiator_node.node.list_channels()[0];
-		assert!(!channel.is_channel_ready);
-	}
-	// do checks on the acceptor node as well (capacity, etc.)
-	assert_eq!(acceptor_node.node.list_channels().len(), 1);
-	{
-		let channel = &acceptor_node.node.list_channels()[0];
-		assert!(!channel.is_channel_ready);
-	}
-
-	let funding_signed_message = get_event_msg!(
-		acceptor_node,
-		MessageSendEvent::SendFundingSigned,
-		initiator_node.node.get_our_node_id()
-	);
-	let _res = initiator_node
-		.node
-		.handle_funding_signed(acceptor_node.node.get_our_node_id(), &funding_signed_message);
-	// Take new channel ID
-	let channel_id2 = funding_signed_message.channel_id;
-	assert_eq!(channel_id2.to_string(), expected_funded_channel_id);
-
-	// Check that funding transaction has been broadcasted
-	assert_eq!(
-		chanmon_cfgs[initiator_node_index].tx_broadcaster.txn_broadcasted.lock().unwrap().len(),
-		1
-	);
-	let broadcasted_funding_tx =
-		chanmon_cfgs[initiator_node_index].tx_broadcaster.txn_broadcasted.lock().unwrap()[0]
-			.clone();
-
-	check_added_monitors!(initiator_node, 1);
-	let _ev = get_event!(initiator_node, Event::ChannelPending);
-	check_added_monitors!(acceptor_node, 1);
-	let _ev = get_event!(acceptor_node, Event::ChannelPending);
-
-	// Simulate confirmation of the funding tx
-	confirm_transaction(&initiator_node, &broadcasted_funding_tx);
-	let channel_ready_message = get_event_msg!(
-		initiator_node,
-		MessageSendEvent::SendChannelReady,
-		acceptor_node.node.get_our_node_id()
-	);
-
-	confirm_transaction(&acceptor_node, &broadcasted_funding_tx);
-	let channel_ready_message2 = get_event_msg!(
-		acceptor_node,
-		MessageSendEvent::SendChannelReady,
-		initiator_node.node.get_our_node_id()
-	);
-
-	let _res = acceptor_node
-		.node
-		.handle_channel_ready(initiator_node.node.get_our_node_id(), &channel_ready_message);
-	let _ev = get_event!(acceptor_node, Event::ChannelReady);
-	let _channel_update = get_event_msg!(
-		acceptor_node,
-		MessageSendEvent::SendChannelUpdate,
-		initiator_node.node.get_our_node_id()
-	);
-
-	let _res = initiator_node
-		.node
-		.handle_channel_ready(acceptor_node.node.get_our_node_id(), &channel_ready_message2);
-	let _ev = get_event!(initiator_node, Event::ChannelReady);
-	let _channel_update = get_event_msg!(
-		initiator_node,
-		MessageSendEvent::SendChannelUpdate,
-		acceptor_node.node.get_our_node_id()
-	);
-
-	// check channel capacity and other parameters
-	assert_eq!(initiator_node.node.list_channels().len(), 1);
-	{
-		let channel = &initiator_node.node.list_channels()[0];
-		assert_eq!(channel.channel_id.to_string(), expected_funded_channel_id);
-		assert!(channel.is_usable);
-		assert!(channel.is_channel_ready);
-		assert_eq!(channel.channel_value_satoshis, channel_value_sat);
-		assert_eq!(
-			channel.outbound_capacity_msat,
-			1000 * (channel_value_sat - channel_reserve_amnt_sat)
-		);
-		assert_eq!(channel.funding_txo.unwrap().txid, funding_tx.compute_txid());
-		assert_eq!(channel.confirmations.unwrap(), 10);
-	}
-	// do checks on the acceptor node as well (capacity, etc.)
-	assert_eq!(acceptor_node.node.list_channels().len(), 1);
-	{
-		let channel = &acceptor_node.node.list_channels()[0];
-		assert_eq!(channel.channel_id.to_string(), expected_funded_channel_id);
-		assert!(channel.is_usable);
-		assert!(channel.is_channel_ready);
-		assert_eq!(channel.channel_value_satoshis, channel_value_sat);
-		assert_eq!(channel.outbound_capacity_msat, 0);
-		assert_eq!(channel.funding_txo.unwrap().txid, funding_tx.compute_txid());
-		assert_eq!(channel.confirmations.unwrap(), 10);
-	}
 
 	// ==== Channel is now ready for normal operation
 
 	// === Start of Splicing
-	println!("Start of Splicing ..., channel_id {}", channel_id2);
+	println!("Start of Splicing ..., channel_id {}", channel_id);
 
 	// Amount being added to the channel through the splice-in
 	let splice_in_sats: u64 = 20000;
-	let funding_feerate_perkw = 1024; // TODO
-	let locktime = 0; // TODO
+	let funding_feerate_per_kw = 1024; // TODO
 
 	// Create additional inputs
 	let extra_splice_funding_input_sats = 35_000;
@@ -239,12 +67,12 @@ fn test_v1_splice_in() {
 	let _res = initiator_node
 		.node
 		.splice_channel(
-			&channel_id2,
+			&channel_id,
 			&acceptor_node.node.get_our_node_id(),
 			splice_in_sats as i64,
 			funding_inputs,
-			funding_feerate_perkw,
-			locktime,
+			funding_feerate_per_kw,
+			0, // locktime
 		)
 		.unwrap();
 	// Extract the splice message from node0 to node1
@@ -254,7 +82,7 @@ fn test_v1_splice_in() {
 		acceptor_node.node.get_our_node_id()
 	);
 	assert_eq!(splice_init_msg.funding_contribution_satoshis, splice_in_sats as i64);
-	assert_eq!(splice_init_msg.funding_feerate_perkw, funding_feerate_perkw);
+	assert_eq!(splice_init_msg.funding_feerate_perkw, funding_feerate_per_kw);
 	assert_eq!(splice_init_msg.funding_pubkey.to_string(), expected_initiator_funding_key);
 	assert!(splice_init_msg.require_confirmed_inputs.is_none());
 
@@ -309,7 +137,7 @@ fn test_v1_splice_in() {
 	// TODO(splicing): continue with splice transaction negotiation
 
 	// === Close channel, cooperatively
-	initiator_node.node.close_channel(&channel_id2, &acceptor_node.node.get_our_node_id()).unwrap();
+	initiator_node.node.close_channel(&channel_id, &acceptor_node.node.get_our_node_id()).unwrap();
 	let node0_shutdown_message = get_event_msg!(
 		initiator_node,
 		MessageSendEvent::SendShutdown,