Include channel_value_satoshis in ChannelTransactionParameters

Since channel_value_satoshis is needed by the signer and may change for
each new FundingScope, included it in ChannelTransactionParameters so it
can be passed to each signer call in the upcoming commits.

Author: jkczyz

lightning/src/chain/channelmonitor.rs

@@ -5421,7 +5421,8 @@ mod tests {
 				selected_contest_delay: 67,
 			}),
 			funding_outpoint: Some(funding_outpoint),
-			channel_type_features: ChannelTypeFeatures::only_static_remote_key()
+			channel_type_features: ChannelTypeFeatures::only_static_remote_key(),
+			channel_value_satoshis: 0,
 		};
 		// Prune with one old state and a holder commitment tx holding a few overlaps with the
 		// old state.
@@ -5430,11 +5431,11 @@ mod tests {
 		let monitor = ChannelMonitor::new(Secp256k1::new(), keys,
 			Some(ShutdownScript::new_p2wpkh_from_pubkey(shutdown_pubkey).into_inner()), 0, &ScriptBuf::new(),
 			(OutPoint { txid: Txid::from_slice(&[43; 32]).unwrap(), index: 0 }, ScriptBuf::new()),
-			&channel_parameters, true, ScriptBuf::new(), 46, 0, HolderCommitmentTransaction::dummy(&mut Vec::new()),
+			&channel_parameters, true, ScriptBuf::new(), 46, 0, HolderCommitmentTransaction::dummy(0, &mut Vec::new()),
 			best_block, dummy_key, channel_id);
 
 		let mut htlcs = preimages_slice_to_htlcs!(preimages[0..10]);
-		let dummy_commitment_tx = HolderCommitmentTransaction::dummy(&mut htlcs);
+		let dummy_commitment_tx = HolderCommitmentTransaction::dummy(0, &mut htlcs);
 
 		monitor.provide_latest_holder_commitment_tx(dummy_commitment_tx.clone(),
 			htlcs.into_iter().map(|(htlc, _)| (htlc, Some(dummy_sig), None)).collect()).unwrap();
@@ -5473,7 +5474,7 @@ mod tests {
 		// Now update holder commitment tx info, pruning only element 18 as we still care about the
 		// previous commitment tx's preimages too
 		let mut htlcs = preimages_slice_to_htlcs!(preimages[0..5]);
-		let dummy_commitment_tx = HolderCommitmentTransaction::dummy(&mut htlcs);
+		let dummy_commitment_tx = HolderCommitmentTransaction::dummy(0, &mut htlcs);
 		monitor.provide_latest_holder_commitment_tx(dummy_commitment_tx.clone(),
 			htlcs.into_iter().map(|(htlc, _)| (htlc, Some(dummy_sig), None)).collect()).unwrap();
 		secret[0..32].clone_from_slice(&<Vec<u8>>::from_hex("2273e227a5b7449b6e70f1fb4652864038b1cbf9cd7c043a7d6456b7fc275ad8").unwrap());
@@ -5484,7 +5485,7 @@ mod tests {
 
 		// But if we do it again, we'll prune 5-10
 		let mut htlcs = preimages_slice_to_htlcs!(preimages[0..3]);
-		let dummy_commitment_tx = HolderCommitmentTransaction::dummy(&mut htlcs);
+		let dummy_commitment_tx = HolderCommitmentTransaction::dummy(0, &mut htlcs);
 		monitor.provide_latest_holder_commitment_tx(dummy_commitment_tx,
 			htlcs.into_iter().map(|(htlc, _)| (htlc, Some(dummy_sig), None)).collect()).unwrap();
 		secret[0..32].clone_from_slice(&<Vec<u8>>::from_hex("27cddaa5624534cb6cb9d7da077cf2b22ab21e9b506fd4998a51d54502e99116").unwrap());
@@ -5673,14 +5674,15 @@ mod tests {
 				selected_contest_delay: 67,
 			}),
 			funding_outpoint: Some(funding_outpoint),
-			channel_type_features: ChannelTypeFeatures::only_static_remote_key()
+			channel_type_features: ChannelTypeFeatures::only_static_remote_key(),
+			channel_value_satoshis: 0,
 		};
 		let shutdown_pubkey = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
 		let best_block = BestBlock::from_network(Network::Testnet);
 		let monitor = ChannelMonitor::new(Secp256k1::new(), keys,
 			Some(ShutdownScript::new_p2wpkh_from_pubkey(shutdown_pubkey).into_inner()), 0, &ScriptBuf::new(),
 			(OutPoint { txid: Txid::from_slice(&[43; 32]).unwrap(), index: 0 }, ScriptBuf::new()),
-			&channel_parameters, true, ScriptBuf::new(), 46, 0, HolderCommitmentTransaction::dummy(&mut Vec::new()),
+			&channel_parameters, true, ScriptBuf::new(), 46, 0, HolderCommitmentTransaction::dummy(0, &mut Vec::new()),
 			best_block, dummy_key, channel_id);
 
 		let chan_id = monitor.inner.lock().unwrap().channel_id();

lightning/src/chain/onchaintx.rs

@@ -368,7 +368,7 @@ impl<'a, 'b, ES: EntropySource, SP: SignerProvider> ReadableArgs<(&'a ES, &'b SP
 		let prev_holder_commitment = Readable::read(reader)?;
 		let _prev_holder_htlc_sigs: Option<Vec<Option<(usize, Signature)>>> = Readable::read(reader)?;
 
-		let channel_parameters = Readable::read(reader)?;
+		let channel_parameters = ReadableArgs::<u64>::read(reader, channel_value_satoshis)?;
 
 		// Read the serialized signer bytes, but don't deserialize them, as we'll obtain our signer
 		// by re-deriving the private key material.
@@ -1355,6 +1355,7 @@ mod tests {
 			}),
 			funding_outpoint: Some(funding_outpoint),
 			channel_type_features: ChannelTypeFeatures::only_static_remote_key(),
+			channel_value_satoshis: 0,
 		};
 
 		// Create an OnchainTxHandler for a commitment containing HTLCs with CLTV expiries of 0, 1,
@@ -1374,7 +1375,7 @@ mod tests {
 				(),
 			));
 		}
-		let holder_commit = HolderCommitmentTransaction::dummy(&mut htlcs);
+		let holder_commit = HolderCommitmentTransaction::dummy(1000000, &mut htlcs);
 		let mut tx_handler = OnchainTxHandler::new(
 			1000000,
 			[0; 32],

lightning/src/events/bump_transaction.rs

@@ -956,7 +956,7 @@ mod tests {
 				channel_derivation_parameters: ChannelDerivationParameters {
 					value_satoshis: 42_000_000,
 					keys_id: [42; 32],
-					transaction_parameters: ChannelTransactionParameters::test_dummy(),
+					transaction_parameters: ChannelTransactionParameters::test_dummy(42_000_000),
 				},
 				outpoint: OutPoint { txid: Txid::from_byte_array([42; 32]), vout: 0 },
 			},

lightning/src/ln/chan_utils.rs

@@ -30,7 +30,7 @@ use crate::chain::package::WEIGHT_REVOKED_OUTPUT;
 use crate::sign::EntropySource;
 use crate::types::payment::{PaymentHash, PaymentPreimage};
 use crate::ln::msgs::DecodeError;
-use crate::util::ser::{Readable, RequiredWrapper, Writeable, Writer};
+use crate::util::ser::{Readable, ReadableArgs, RequiredWrapper, Writeable, Writer};
 use crate::util::transaction_utils;
 
 use bitcoin::locktime::absolute::LockTime;
@@ -882,7 +882,9 @@ pub struct ChannelTransactionParameters {
 	pub funding_outpoint: Option<chain::transaction::OutPoint>,
 	/// This channel's type, as negotiated during channel open. For old objects where this field
 	/// wasn't serialized, it will default to static_remote_key at deserialization.
-	pub channel_type_features: ChannelTypeFeatures
+	pub channel_type_features: ChannelTypeFeatures,
+	/// The value locked in the channel, denominated in satoshis.
+	pub channel_value_satoshis: u64,
 }
 
 /// Late-bound per-channel counterparty data used to build transactions.
@@ -930,7 +932,7 @@ impl ChannelTransactionParameters {
 	}
 
 	#[cfg(test)]
-	pub fn test_dummy() -> Self {
+	pub fn test_dummy(channel_value_satoshis: u64) -> Self {
 		let dummy_keys = ChannelPublicKeys {
 			funding_pubkey: PublicKey::from_slice(&[2; 33]).unwrap(),
 			revocation_basepoint: PublicKey::from_slice(&[2; 33]).unwrap().into(),
@@ -950,6 +952,7 @@ impl ChannelTransactionParameters {
 				txid: Txid::from_byte_array([42; 32]), index: 0
 			}),
 			channel_type_features: ChannelTypeFeatures::empty(),
+			channel_value_satoshis,
 		}
 	}
 }
@@ -970,20 +973,22 @@ impl Writeable for ChannelTransactionParameters {
 			(8, self.funding_outpoint, option),
 			(10, legacy_deserialization_prevention_marker, option),
 			(11, self.channel_type_features, required),
+			(13, self.channel_value_satoshis, required),
 		});
 		Ok(())
 	}
 }
 
-impl Readable for ChannelTransactionParameters {
-	fn read<R: io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
+impl ReadableArgs<u64> for ChannelTransactionParameters {
+	fn read<R: io::Read>(reader: &mut R, read_args: u64) -> Result<Self, DecodeError> {
 		let mut holder_pubkeys = RequiredWrapper(None);
 		let mut holder_selected_contest_delay = RequiredWrapper(None);
 		let mut is_outbound_from_holder = RequiredWrapper(None);
 		let mut counterparty_parameters = None;
 		let mut funding_outpoint = None;
 		let mut _legacy_deserialization_prevention_marker: Option<()> = None;
 		let mut channel_type_features = None;
+		let mut channel_value_satoshis = None;
 
 		read_tlv_fields!(reader, {
 			(0, holder_pubkeys, required),
@@ -993,8 +998,14 @@ impl Readable for ChannelTransactionParameters {
 			(8, funding_outpoint, option),
 			(10, _legacy_deserialization_prevention_marker, option),
 			(11, channel_type_features, option),
+			(13, channel_value_satoshis, option),
 		});
 
+		let channel_value_satoshis = channel_value_satoshis.unwrap_or(read_args);
+		if channel_value_satoshis != read_args {
+			return Err(DecodeError::InvalidValue);
+		}
+
 		let mut additional_features = ChannelTypeFeatures::empty();
 		additional_features.set_anchors_nonzero_fee_htlc_tx_required();
 		chain::package::verify_channel_type_features(&channel_type_features, Some(&additional_features))?;
@@ -1005,7 +1016,8 @@ impl Readable for ChannelTransactionParameters {
 			is_outbound_from_holder: is_outbound_from_holder.0.unwrap(),
 			counterparty_parameters,
 			funding_outpoint,
-			channel_type_features: channel_type_features.unwrap_or(ChannelTypeFeatures::only_static_remote_key())
+			channel_type_features: channel_type_features.unwrap_or(ChannelTypeFeatures::only_static_remote_key()),
+			channel_value_satoshis,
 		})
 	}
 }
@@ -1105,7 +1117,7 @@ impl_writeable_tlv_based!(HolderCommitmentTransaction, {
 
 impl HolderCommitmentTransaction {
 	#[cfg(test)]
-	pub fn dummy(htlcs: &mut Vec<(HTLCOutputInCommitment, ())>) -> Self {
+	pub fn dummy(channel_value_satoshis: u64, htlcs: &mut Vec<(HTLCOutputInCommitment, ())>) -> Self {
 		let secp_ctx = Secp256k1::new();
 		let dummy_key = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
 		let dummy_sig = sign(&secp_ctx, &secp256k1::Message::from_digest([42; 32]), &SecretKey::from_slice(&[42; 32]).unwrap());
@@ -1131,6 +1143,7 @@ impl HolderCommitmentTransaction {
 			counterparty_parameters: Some(CounterpartyChannelTransactionParameters { pubkeys: channel_pubkeys.clone(), selected_contest_delay: 0 }),
 			funding_outpoint: Some(chain::transaction::OutPoint { txid: Txid::all_zeros(), index: 0 }),
 			channel_type_features: ChannelTypeFeatures::only_static_remote_key(),
+			channel_value_satoshis,
 		};
 		let mut counterparty_htlc_sigs = Vec::new();
 		for _ in 0..htlcs.len() {
@@ -1942,6 +1955,7 @@ mod tests {
 				counterparty_parameters: Some(CounterpartyChannelTransactionParameters { pubkeys: counterparty_pubkeys.clone(), selected_contest_delay: 0 }),
 				funding_outpoint: Some(chain::transaction::OutPoint { txid: Txid::all_zeros(), index: 0 }),
 				channel_type_features: ChannelTypeFeatures::only_static_remote_key(),
+				channel_value_satoshis: 3000,
 			};
 			let htlcs_with_aux = Vec::new();
 

lightning/src/ln/channel.rs

@@ -2597,7 +2597,8 @@ impl<SP: Deref> ChannelContext<SP> where SP::Target: SignerProvider {
 					pubkeys: counterparty_pubkeys,
 				}),
 				funding_outpoint: None,
-				channel_type_features: channel_type.clone()
+				channel_type_features: channel_type.clone(),
+				channel_value_satoshis,
 			},
 			funding_transaction: None,
 		};
@@ -2832,7 +2833,8 @@ impl<SP: Deref> ChannelContext<SP> where SP::Target: SignerProvider {
 				is_outbound_from_holder: true,
 				counterparty_parameters: None,
 				funding_outpoint: None,
-				channel_type_features: channel_type.clone()
+				channel_type_features: channel_type.clone(),
+				channel_value_satoshis,
 			},
 			funding_transaction: None,
 		};
@@ -10512,7 +10514,7 @@ impl<'a, 'b, 'c, ES: Deref, SP: Deref> ReadableArgs<(&'a ES, &'b SP, u32, &'c Ch
 			_ => return Err(DecodeError::InvalidValue),
 		};
 
-		let mut channel_parameters: ChannelTransactionParameters = Readable::read(reader)?;
+		let mut channel_parameters: ChannelTransactionParameters = ReadableArgs::<u64>::read(reader, channel_value_satoshis)?;
 		let funding_transaction: Option<Transaction> = Readable::read(reader)?;
 
 		let counterparty_cur_commitment_point = Readable::read(reader)?;
@@ -10657,6 +10659,8 @@ impl<'a, 'b, 'c, ES: Deref, SP: Deref> ReadableArgs<(&'a ES, &'b SP, u32, &'c Ch
 		// ChannelTransactionParameters may have had an empty features set upon deserialization.
 		// To account for that, we're proactively setting/overriding the field here.
 		channel_parameters.channel_type_features = chan_features.clone();
+		// ChannelTransactionParameters::channel_value_satoshis defaults to 0 prior to version 0.2.
+		channel_parameters.channel_value_satoshis = channel_value_satoshis;
 
 		let mut secp_ctx = Secp256k1::new();
 		secp_ctx.seeded_randomize(&entropy_source.get_secure_random_bytes());

lightning/src/ln/dual_funding_tests.rs

@@ -171,6 +171,7 @@ fn do_test_v2_channel_establishment(session: V2ChannelEstablishmentTestSession)
 		is_outbound_from_holder: true,
 		funding_outpoint,
 		channel_type_features,
+		channel_value_satoshis: funding_satoshis,
 	};
 
 	channel

lightning/src/sign/mod.rs

@@ -58,7 +58,7 @@ use crate::ln::msgs::{UnsignedChannelAnnouncement, UnsignedGossipMessage};
 use crate::ln::script::ShutdownScript;
 use crate::offers::invoice::UnsignedBolt12Invoice;
 use crate::types::payment::PaymentPreimage;
-use crate::util::ser::Writeable;
+use crate::util::ser::{ReadableArgs, Writeable};
 use crate::util::transaction_utils;
 
 use crate::crypto::chacha20::ChaCha20;
@@ -127,7 +127,7 @@ impl_writeable_tlv_based!(DelayedPaymentOutputDescriptor, {
 	(8, revocation_pubkey, required),
 	(10, channel_keys_id, required),
 	(12, channel_value_satoshis, required),
-	(13, channel_transaction_parameters, option),
+	(13, channel_transaction_parameters, (option: ReadableArgs, channel_value_satoshis.0.unwrap())),
 });
 
 pub(crate) const P2WPKH_WITNESS_WEIGHT: u64 = 1 /* num stack items */ +
@@ -196,7 +196,7 @@ impl_writeable_tlv_based!(StaticPaymentOutputDescriptor, {
 	(2, output, required),
 	(4, channel_keys_id, required),
 	(6, channel_value_satoshis, required),
-	(7, channel_transaction_parameters, option),
+	(7, channel_transaction_parameters, (option: ReadableArgs, channel_value_satoshis.0.unwrap())),
 });
 
 /// Describes the necessary information to spend a spendable output.
@@ -562,7 +562,7 @@ pub struct ChannelDerivationParameters {
 impl_writeable_tlv_based!(ChannelDerivationParameters, {
 	(0, value_satoshis, required),
 	(2, keys_id, required),
-	(4, transaction_parameters, required),
+	(4, transaction_parameters, (required: ReadableArgs, value_satoshis.0.unwrap())),
 });
 
 /// A descriptor used to sign for a commitment transaction's HTLC output.

lightning/src/util/ser_macros.rs

@@ -29,6 +29,9 @@ macro_rules! _encode_tlv {
 		BigSize($field.serialized_length() as u64).write($stream)?;
 		$field.write($stream)?;
 	};
+	($stream: expr, $type: expr, $field: expr, (required: $trait: ident $(, $read_arg: expr)?) $(, $self: ident)?) => {
+		$crate::_encode_tlv!($stream, $type, $field, required);
+	};
 	($stream: expr, $type: expr, $field: expr, required_vec $(, $self: ident)?) => {
 		$crate::_encode_tlv!($stream, $type, $crate::util::ser::WithoutLength(&$field), required);
 	};
@@ -185,6 +188,9 @@ macro_rules! _get_varint_length_prefixed_tlv_length {
 			.expect("No in-memory data may fail to serialize");
 		$len.0 += field_len;
 	};
+	($len: expr, $type: expr, $field: expr, (required: $trait: ident $(, $read_arg: expr)?) $(, $self: ident)?) => {
+		$crate::_get_varint_length_prefixed_tlv_length!($len, $type, $field, required);
+	};
 	($len: expr, $type: expr, $field: expr, required_vec $(, $self: ident)?) => {
 		let field = $crate::util::ser::WithoutLength(&$field);
 		$crate::_get_varint_length_prefixed_tlv_length!($len, $type, field, required);
@@ -801,6 +807,9 @@ macro_rules! _init_tlv_based_struct_field {
 	($field: ident, required) => {
 		$field.0.unwrap()
 	};
+	($field: ident, (required: $trait: ident $(, $read_arg: expr)?)) => {
+		$crate::_init_tlv_based_struct_field!($field, required)
+	};
 	($field: ident, required_vec) => {
 		$field
 	};