Include input weights together with inputs (not separate param)

Author: optout21

lightning/src/ln/channel.rs

@@ -4559,7 +4559,7 @@ fn get_v2_channel_reserve_satoshis(channel_value_satoshis: u64, dust_limit_satos
 /// input_count: Number of contributed inputs.
 /// witness_weight: The witness weight for contributed inputs.
 #[allow(dead_code)] // TODO(dual_funding): Remove once V2 channels is enabled.
-fn estimate_funding_transaction_fee(
+fn estimate_v2_funding_transaction_fee(
 	is_initiator: bool, input_count: usize, witness_weight: Weight,
 	funding_feerate_sat_per_1000_weight: u32,
 ) -> u64 {
@@ -4590,7 +4590,7 @@ pub(super) fn calculate_our_funding_satoshis(
 	total_witness_weight: Weight, funding_feerate_sat_per_1000_weight: u32,
 	holder_dust_limit_satoshis: u64,
 ) -> Result<u64, APIError> {
-	let estimated_fee = estimate_funding_transaction_fee(is_initiator, funding_inputs.len(), total_witness_weight, funding_feerate_sat_per_1000_weight);
+	let estimated_fee = estimate_v2_funding_transaction_fee(is_initiator, funding_inputs.len(), total_witness_weight, funding_feerate_sat_per_1000_weight);
 
 	let mut total_input_satoshis = 0u64;
 	for (idx, input) in funding_inputs.iter().enumerate() {
@@ -8219,10 +8219,11 @@ impl<SP: Deref> FundedChannel<SP> where
 	}
 
 	/// Initiate splicing.
-	/// - witness_weight: The witness weight for contributed inputs.
+	/// - our_funding_inputs: the inputs we contribute to the new funding transaction.
+	///   Includes the witness weight for this input (e.g. P2WPKH_WITNESS_WEIGHT=109 for typical P2WPKH inputs).
 	#[cfg(splicing)]
 	pub fn splice_channel(&mut self, our_funding_contribution_satoshis: i64,
-		our_funding_inputs: Vec<(TxIn, Transaction)>, witness_weight: Weight,
+		our_funding_inputs: Vec<(TxIn, Transaction, Weight)>,
 		funding_feerate_per_kw: u32, locktime: u32,
 	) -> Result<msgs::SpliceInit, ChannelError> {
 		// Check if a splice has been initiated already.
@@ -8261,16 +8262,17 @@ impl<SP: Deref> FundedChannel<SP> where
 		// Pre-check that inputs are sufficient to cover our contribution.
 		// Note: fees are not taken into account here.
 		let sum_input: u64 = our_funding_inputs.iter().map(
-			|(txin, tx)| tx.output.get(txin.previous_output.vout as usize).map(|tx| tx.value.to_sat()).unwrap_or(0)
+			|(txin, tx, _)| tx.output.get(txin.previous_output.vout as usize).map(|tx| tx.value.to_sat()).unwrap_or(0)
 		).sum();
 
 		// The +1 is to include the input of the old funding
 		let funding_input_count = our_funding_inputs.len() + 1;
 		// Input witness weight, extended with weight for spending old funding
 		let total_witness_weight = Weight::from_wu(
-			witness_weight.to_wu().saturating_add(FUNDING_TRANSACTION_WITNESS_WEIGHT)
+			our_funding_inputs.iter().map(|(_, _, w)| w.to_wu()).sum::<u64>()
+			.saturating_add(FUNDING_TRANSACTION_WITNESS_WEIGHT)
 		);
-		let estimated_fee = estimate_funding_transaction_fee(true, funding_input_count, total_witness_weight, funding_feerate_per_kw);
+		let estimated_fee = estimate_v2_funding_transaction_fee(true, funding_input_count, total_witness_weight, funding_feerate_per_kw);
 		let available_input = sum_input.saturating_sub(estimated_fee);
 
 		if (available_input as i64) < our_funding_contribution_satoshis {
@@ -9504,6 +9506,7 @@ impl<SP: Deref> PendingV2Channel<SP> where SP::Target: SignerProvider {
 
 	/// Creates a new dual-funded channel from a remote side's request for one.
 	/// Assumes chain_hash has already been checked and corresponds with what we expect!
+	/// TODO(dual_funding): Include witness weight info with the inputs.
 	#[allow(dead_code)] // TODO(dual_funding): Remove once V2 channels is enabled.
 	pub fn new_inbound<ES: Deref, F: Deref, L: Deref>(
 		fee_estimator: &LowerBoundedFeeEstimator<F>, entropy_source: &ES, signer_provider: &SP,
@@ -12496,6 +12499,43 @@ mod tests {
 		assert!(node_a_chan.check_get_channel_ready(0, &&logger).is_some());
 	}
 
+
+	#[test]
+	fn test_estimate_v2_funding_transaction_fee() {
+		use crate::ln::channel::estimate_v2_funding_transaction_fee;
+		use bitcoin::Weight;
+
+		// 2 inputs with weight 300, initiator, 2000 sat/kw feerate
+		assert_eq!(
+			estimate_v2_funding_transaction_fee(true, 2, Weight::from_wu(300), 2000),
+			1668
+		);
+
+		// higher feerate
+		assert_eq!(
+			estimate_v2_funding_transaction_fee(true, 2, Weight::from_wu(300), 3000),
+			2502
+		);
+
+		// only 1 input
+		assert_eq!(
+			estimate_v2_funding_transaction_fee(true, 1, Weight::from_wu(300), 2000),
+			1348
+		);
+
+		// 0 input weight
+		assert_eq!(
+			estimate_v2_funding_transaction_fee(true, 1, Weight::from_wu(0), 2000),
+			748
+		);
+
+		// not initiator
+		assert_eq!(
+			estimate_v2_funding_transaction_fee(false, 1, Weight::from_wu(0), 2000),
+			320
+		);
+	}
+
 	#[cfg(all(test, splicing))]
 	fn get_pre_and_post(pre_channel_value: u64, our_funding_contribution: i64, their_funding_contribution: i64) -> (u64, u64) {
 		use crate::ln::channel::PendingSplice;

lightning/src/ln/channelmanager.rs

@@ -4238,11 +4238,11 @@ where
 	/// Note: Currently only splice-in is supported (increase in channel capacity), splice-out is not.
 	/// - our_funding_contribution_satoshis: the amount contributed by us to the channel. This will increase our channel balance.
 	/// - our_funding_inputs: the funding inputs provided by us. If our contribution is positive, our funding inputs must cover at least that amount.
-	/// - witness_weight: The witness weight for contributed inputs.
+	///   Includes the witness weight for this input (e.g. P2WPKH_WITNESS_WEIGHT=109 for typical P2WPKH inputs).
 	#[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)>, witness_weight: Weight,
+		our_funding_inputs: Vec<(TxIn, Transaction, Weight)>,
 		funding_feerate_per_kw: u32, locktime: u32,
 	) -> Result<(), APIError> {
 		let per_peer_state = self.per_peer_state.read().unwrap();
@@ -4257,7 +4257,7 @@ where
 		match peer_state.channel_by_id.entry(*channel_id) {
 			hash_map::Entry::Occupied(mut chan_phase_entry) => {
 				if let Some(chan) = chan_phase_entry.get_mut().as_funded_mut() {
-					let msg = chan.splice_channel(our_funding_contribution_satoshis, our_funding_inputs, witness_weight, funding_feerate_per_kw, locktime)
+					let msg = chan.splice_channel(our_funding_contribution_satoshis, our_funding_inputs, funding_feerate_per_kw, locktime)
 						.map_err(|err| APIError::APIMisuseError {
 							err: format!(
 								"Cannot initiate Splicing, {}, channel ID {}", err, channel_id

lightning/src/ln/dual_funding_tests.rs

@@ -26,7 +26,7 @@ use {
 	crate::ln::msgs::{CommitmentSigned, TxAddInput, TxAddOutput, TxComplete},
 	crate::ln::types::ChannelId,
 	crate::prelude::*,
-	crate::sign::{ChannelSigner as _, P2WPKH_WITNESS_WEIGHT},
+	crate::sign::ChannelSigner as _,
 	crate::util::ser::TransactionU16LenLimited,
 	crate::util::test_utils,
 	bitcoin::Weight,
@@ -51,13 +51,16 @@ fn do_test_v2_channel_establishment(
 	let logger_a = test_utils::TestLogger::with_id("node a".to_owned());
 
 	// Create a funding input for the new channel along with its previous transaction.
-	let (initiator_funding_inputs, total_weight) = create_dual_funding_utxos_with_prev_txs(
+	let initiator_funding_inputs = create_dual_funding_utxos_with_prev_txs(
 		&nodes[0],
 		&[session.initiator_input_value_satoshis],
-	)
-	.into_iter()
-	.map(|(txin, tx)| (txin, TransactionU16LenLimited::new(tx).unwrap()))
-	.collect();
+	);
+	let total_weight =
+		Weight::from_wu(initiator_funding_inputs.iter().map(|(_, _, w)| w.to_wu()).sum());
+	let initiator_funding_inputs: Vec<_> = initiator_funding_inputs
+		.into_iter()
+		.map(|(txin, tx, _)| (txin, TransactionU16LenLimited::new(tx).unwrap()))
+		.collect();
 
 	// Alice creates a dual-funded channel as initiator.
 	let funding_feerate = node_cfgs[0]

lightning/src/ln/functional_test_utils.rs

@@ -1250,7 +1250,7 @@ fn internal_create_funding_transaction<'a, 'b, 'c>(node: &Node<'a, 'b, 'c>,
 /// 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)>, Weight) {
+) -> Vec<(TxIn, Transaction, Weight)> {
 	// Ensure we have unique transactions per node by using the locktime.
 	let tx = Transaction {
 		version: TxVersion::TWO,
@@ -1274,11 +1274,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),
+		));
 	}
-	let total_weight = Weight::from_wu(utxo_values_in_satoshis.len() as u64 * P2WPKH_WITNESS_WEIGHT);
 
-	(inputs, total_weight)
+	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

@@ -231,7 +231,7 @@ fn test_v1_splice_in() {
 
 	// Create additional inputs
 	let extra_splice_funding_input_sats = 35_000;
-	let (funding_inputs, total_weight) = create_dual_funding_utxos_with_prev_txs(
+	let funding_inputs = create_dual_funding_utxos_with_prev_txs(
 		&initiator_node,
 		&[extra_splice_funding_input_sats],
 	);
@@ -243,7 +243,6 @@ fn test_v1_splice_in() {
 			&acceptor_node.node.get_our_node_id(),
 			splice_in_sats as i64,
 			funding_inputs,
-			total_weight,
 			funding_feerate_per_kw,
 			locktime,
 		)