Remove channel_value_satoshis from SignerProvider

Author: jkczyz

lightning/src/chain/channelmonitor.rs

@@ -5391,7 +5391,6 @@ mod tests {
 			SecretKey::from_slice(&[41; 32]).unwrap(),
 			SecretKey::from_slice(&[41; 32]).unwrap(),
 			[41; 32],
-			0,
 			[0; 32],
 			[0; 32],
 		);
@@ -5644,7 +5643,6 @@ mod tests {
 			SecretKey::from_slice(&[41; 32]).unwrap(),
 			SecretKey::from_slice(&[41; 32]).unwrap(),
 			[41; 32],
-			0,
 			[0; 32],
 			[0; 32],
 		);

lightning/src/chain/onchaintx.rs

@@ -386,7 +386,7 @@ impl<'a, 'b, ES: EntropySource, SP: SignerProvider> ReadableArgs<(&'a ES, &'b SP
 			bytes_read += bytes_to_read;
 		}
 
-		let signer = signer_provider.derive_channel_signer(channel_value_satoshis, channel_keys_id);
+		let signer = signer_provider.derive_channel_signer(channel_keys_id);
 
 		let pending_claim_requests_len: u64 = Readable::read(reader)?;
 		let mut pending_claim_requests = hash_map_with_capacity(cmp::min(pending_claim_requests_len as usize, MAX_ALLOC_SIZE / 128));
@@ -1317,7 +1317,6 @@ mod tests {
 			SecretKey::from_slice(&[41; 32]).unwrap(),
 			SecretKey::from_slice(&[41; 32]).unwrap(),
 			[41; 32],
-			0,
 			[0; 32],
 			[0; 32],
 		);

lightning/src/events/bump_transaction.rs

@@ -97,10 +97,7 @@ impl AnchorDescriptor {
 	where
 		SP::Target: SignerProvider<EcdsaSigner= S>
 	{
-		signer_provider.derive_channel_signer(
-			self.channel_derivation_parameters.value_satoshis,
-			self.channel_derivation_parameters.keys_id,
-		)
+		signer_provider.derive_channel_signer(self.channel_derivation_parameters.keys_id)
 	}
 }
 

lightning/src/ln/chan_utils.rs

@@ -1938,8 +1938,8 @@ mod tests {
 			let seed = [42; 32];
 			let network = Network::Testnet;
 			let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
-			let signer = keys_provider.derive_channel_signer(3000, keys_provider.generate_channel_keys_id(false, 1_000_000, 0));
-			let counterparty_signer = keys_provider.derive_channel_signer(3000, keys_provider.generate_channel_keys_id(true, 1_000_000, 1));
+			let signer = keys_provider.derive_channel_signer(keys_provider.generate_channel_keys_id(false, 0));
+			let counterparty_signer = keys_provider.derive_channel_signer(keys_provider.generate_channel_keys_id(true, 1));
 			let delayed_payment_base = &signer.pubkeys().delayed_payment_basepoint;
 			let per_commitment_secret = SecretKey::from_slice(&<Vec<u8>>::from_hex("1f1e1d1c1b1a191817161514131211100f0e0d0c0b0a09080706050403020100").unwrap()[..]).unwrap();
 			let per_commitment_point = PublicKey::from_secret_key(&secp_ctx, &per_commitment_secret);

lightning/src/ln/channel.rs

@@ -2056,7 +2056,7 @@ trait InitialRemoteCommitmentReceiver<SP: Deref> where SP::Target: SignerProvide
 		let funding_txo_script = funding_redeemscript.to_p2wsh();
 		let obscure_factor = get_commitment_transaction_number_obscure_factor(&funding.get_holder_pubkeys().payment_point, &funding.get_counterparty_pubkeys().payment_point, funding.is_outbound());
 		let shutdown_script = context.shutdown_scriptpubkey.clone().map(|script| script.into_inner());
-		let monitor_signer = signer_provider.derive_channel_signer(funding.get_value_satoshis(), context.channel_keys_id);
+		let monitor_signer = signer_provider.derive_channel_signer(context.channel_keys_id);
 		// TODO(RBF): When implementing RBF, the funding_txo passed here must only update
 		// ChannelMonitorImp::first_confirmed_funding_txo during channel establishment, not splicing
 		let channel_monitor = ChannelMonitor::new(context.secp_ctx.clone(), monitor_signer,
@@ -2350,8 +2350,8 @@ impl<SP: Deref> ChannelContext<SP> where SP::Target: SignerProvider {
 
 		let channel_value_satoshis = our_funding_satoshis.saturating_add(open_channel_fields.funding_satoshis);
 
-		let channel_keys_id = signer_provider.generate_channel_keys_id(true, channel_value_satoshis, user_id);
-		let holder_signer = signer_provider.derive_channel_signer(channel_value_satoshis, channel_keys_id);
+		let channel_keys_id = signer_provider.generate_channel_keys_id(true, user_id);
+		let holder_signer = signer_provider.derive_channel_signer(channel_keys_id);
 		let pubkeys = holder_signer.pubkeys().clone();
 
 		if config.channel_handshake_config.our_to_self_delay < BREAKDOWN_TIMEOUT {
@@ -8642,8 +8642,8 @@ impl<SP: Deref> OutboundV1Channel<SP> where SP::Target: SignerProvider {
 				implemention limit dust_limit_satoshis {}", holder_selected_channel_reserve_satoshis) });
 		}
 
-		let channel_keys_id = signer_provider.generate_channel_keys_id(false, channel_value_satoshis, user_id);
-		let holder_signer = signer_provider.derive_channel_signer(channel_value_satoshis, channel_keys_id);
+		let channel_keys_id = signer_provider.generate_channel_keys_id(false, user_id);
+		let holder_signer = signer_provider.derive_channel_signer(channel_keys_id);
 		let pubkeys = holder_signer.pubkeys().clone();
 
 		let (funding, context) = ChannelContext::new_for_outbound_channel(
@@ -9195,8 +9195,8 @@ impl<SP: Deref> PendingV2Channel<SP> where SP::Target: SignerProvider {
 	      F::Target: FeeEstimator,
 	      L::Target: Logger,
 	{
-		let channel_keys_id = signer_provider.generate_channel_keys_id(false, funding_satoshis, user_id);
-		let holder_signer = signer_provider.derive_channel_signer(funding_satoshis, channel_keys_id);
+		let channel_keys_id = signer_provider.generate_channel_keys_id(false, user_id);
+		let holder_signer = signer_provider.derive_channel_signer(channel_keys_id);
 		let pubkeys = holder_signer.pubkeys().clone();
 
 		let temporary_channel_id = Some(ChannelId::temporary_v2_from_revocation_basepoint(&pubkeys.revocation_basepoint));
@@ -10259,7 +10259,7 @@ impl<'a, 'b, 'c, ES: Deref, SP: Deref> ReadableArgs<(&'a ES, &'b SP, u32, &'c Ch
 		});
 
 		let (channel_keys_id, holder_signer) = if let Some(channel_keys_id) = channel_keys_id {
-			let holder_signer = signer_provider.derive_channel_signer(channel_value_satoshis, channel_keys_id);
+			let holder_signer = signer_provider.derive_channel_signer(channel_keys_id);
 			(channel_keys_id, holder_signer)
 		} else {
 			// `keys_data` can be `None` if we had corrupted data.
@@ -10609,11 +10609,11 @@ mod tests {
 		#[cfg(taproot)]
 		type TaprootSigner = InMemorySigner;
 
-		fn generate_channel_keys_id(&self, _inbound: bool, _channel_value_satoshis: u64, _user_channel_id: u128) -> [u8; 32] {
+		fn generate_channel_keys_id(&self, _inbound: bool, _user_channel_id: u128) -> [u8; 32] {
 			self.signer.channel_keys_id()
 		}
 
-		fn derive_channel_signer(&self, _channel_value_satoshis: u64, _channel_keys_id: [u8; 32]) -> Self::EcdsaSigner {
+		fn derive_channel_signer(&self, _channel_keys_id: [u8; 32]) -> Self::EcdsaSigner {
 			self.signer.clone()
 		}
 

lightning/src/sign/mod.rs

@@ -711,10 +711,7 @@ impl HTLCDescriptor {
 	where
 		SP::Target: SignerProvider<EcdsaSigner = S>,
 	{
-		signer_provider.derive_channel_signer(
-			self.channel_derivation_parameters.value_satoshis,
-			self.channel_derivation_parameters.keys_id,
-		)
+		signer_provider.derive_channel_signer(self.channel_derivation_parameters.keys_id)
 	}
 }
 
@@ -950,19 +947,15 @@ pub trait SignerProvider {
 	/// `channel_keys_id`.
 	///
 	/// This method must return a different value each time it is called.
-	fn generate_channel_keys_id(
-		&self, inbound: bool, channel_value_satoshis: u64, user_channel_id: u128,
-	) -> [u8; 32];
+	fn generate_channel_keys_id(&self, inbound: bool, user_channel_id: u128) -> [u8; 32];
 
 	/// Derives the private key material backing a `Signer`.
 	///
 	/// To derive a new `Signer`, a fresh `channel_keys_id` should be obtained through
 	/// [`SignerProvider::generate_channel_keys_id`]. Otherwise, an existing `Signer` can be
 	/// re-derived from its `channel_keys_id`, which can be obtained through its trait method
 	/// [`ChannelSigner::channel_keys_id`].
-	fn derive_channel_signer(
-		&self, channel_value_satoshis: u64, channel_keys_id: [u8; 32],
-	) -> Self::EcdsaSigner;
+	fn derive_channel_signer(&self, channel_keys_id: [u8; 32]) -> Self::EcdsaSigner;
 
 	/// Reads a [`Signer`] for this [`SignerProvider`] from the given input stream.
 	/// This is only called during deserialization of other objects which contain
@@ -1030,8 +1023,6 @@ pub struct InMemorySigner {
 	pub commitment_seed: [u8; 32],
 	/// Holder public keys and basepoints.
 	pub(crate) holder_channel_pubkeys: ChannelPublicKeys,
-	/// The total value of this channel.
-	channel_value_satoshis: u64,
 	/// Key derivation parameters.
 	channel_keys_id: [u8; 32],
 	/// A source of random bytes.
@@ -1047,7 +1038,6 @@ impl PartialEq for InMemorySigner {
 			&& self.htlc_base_key == other.htlc_base_key
 			&& self.commitment_seed == other.commitment_seed
 			&& self.holder_channel_pubkeys == other.holder_channel_pubkeys
-			&& self.channel_value_satoshis == other.channel_value_satoshis
 			&& self.channel_keys_id == other.channel_keys_id
 	}
 }
@@ -1062,7 +1052,6 @@ impl Clone for InMemorySigner {
 			htlc_base_key: self.htlc_base_key.clone(),
 			commitment_seed: self.commitment_seed.clone(),
 			holder_channel_pubkeys: self.holder_channel_pubkeys.clone(),
-			channel_value_satoshis: self.channel_value_satoshis,
 			channel_keys_id: self.channel_keys_id,
 			entropy_source: RandomBytes::new(self.get_secure_random_bytes()),
 		}
@@ -1074,8 +1063,7 @@ impl InMemorySigner {
 	pub fn new<C: Signing>(
 		secp_ctx: &Secp256k1<C>, funding_key: SecretKey, revocation_base_key: SecretKey,
 		payment_key: SecretKey, delayed_payment_base_key: SecretKey, htlc_base_key: SecretKey,
-		commitment_seed: [u8; 32], channel_value_satoshis: u64, channel_keys_id: [u8; 32],
-		rand_bytes_unique_start: [u8; 32],
+		commitment_seed: [u8; 32], channel_keys_id: [u8; 32], rand_bytes_unique_start: [u8; 32],
 	) -> InMemorySigner {
 		let holder_channel_pubkeys = InMemorySigner::make_holder_keys(
 			secp_ctx,
@@ -1092,7 +1080,6 @@ impl InMemorySigner {
 			delayed_payment_base_key,
 			htlc_base_key,
 			commitment_seed,
-			channel_value_satoshis,
 			holder_channel_pubkeys,
 			channel_keys_id,
 			entropy_source: RandomBytes::new(rand_bytes_unique_start),
@@ -1734,7 +1721,7 @@ impl Writeable for InMemorySigner {
 		self.htlc_base_key.write(writer)?;
 		self.commitment_seed.write(writer)?;
 		None::<ChannelTransactionParameters>.write(writer)?;
-		self.channel_value_satoshis.write(writer)?;
+		0u64.write(writer)?;
 		self.channel_keys_id.write(writer)?;
 
 		write_tlv_fields!(writer, {});
@@ -1758,7 +1745,7 @@ where
 		let commitment_seed = Readable::read(reader)?;
 		let _counterparty_channel_data: Option<ChannelTransactionParameters> =
 			Readable::read(reader)?;
-		let channel_value_satoshis = Readable::read(reader)?;
+		let _channel_value_satoshis: u64 = Readable::read(reader)?;
 		let secp_ctx = Secp256k1::signing_only();
 		let holder_channel_pubkeys = InMemorySigner::make_holder_keys(
 			&secp_ctx,
@@ -1779,7 +1766,6 @@ where
 			delayed_payment_base_key,
 			htlc_base_key,
 			commitment_seed,
-			channel_value_satoshis,
 			holder_channel_pubkeys,
 			channel_keys_id: keys_id,
 			entropy_source: RandomBytes::new(entropy_source.get_secure_random_bytes()),
@@ -1918,9 +1904,7 @@ impl KeysManager {
 	}
 
 	/// Derive an old [`EcdsaChannelSigner`] containing per-channel secrets based on a key derivation parameters.
-	pub fn derive_channel_keys(
-		&self, channel_value_satoshis: u64, params: &[u8; 32],
-	) -> InMemorySigner {
+	pub fn derive_channel_keys(&self, params: &[u8; 32]) -> InMemorySigner {
 		let chan_id = u64::from_be_bytes(params[0..8].try_into().unwrap());
 		let mut unique_start = Sha256::engine();
 		unique_start.input(params);
@@ -1972,7 +1956,6 @@ impl KeysManager {
 			delayed_payment_base_key,
 			htlc_base_key,
 			commitment_seed,
-			channel_value_satoshis,
 			params.clone(),
 			prng_seed,
 		)
@@ -2004,10 +1987,7 @@ impl KeysManager {
 					if keys_cache.is_none()
 						|| keys_cache.as_ref().unwrap().1 != descriptor.channel_keys_id
 					{
-						let signer = self.derive_channel_keys(
-							descriptor.channel_value_satoshis,
-							&descriptor.channel_keys_id,
-						);
+						let signer = self.derive_channel_keys(&descriptor.channel_keys_id);
 						keys_cache = Some((signer, descriptor.channel_keys_id));
 					}
 					let witness = keys_cache.as_ref().unwrap().0.sign_counterparty_payment_input(
@@ -2024,10 +2004,7 @@ impl KeysManager {
 						|| keys_cache.as_ref().unwrap().1 != descriptor.channel_keys_id
 					{
 						keys_cache = Some((
-							self.derive_channel_keys(
-								descriptor.channel_value_satoshis,
-								&descriptor.channel_keys_id,
-							),
+							self.derive_channel_keys(&descriptor.channel_keys_id),
 							descriptor.channel_keys_id,
 						));
 					}
@@ -2196,9 +2173,7 @@ impl SignerProvider for KeysManager {
 	#[cfg(taproot)]
 	type TaprootSigner = InMemorySigner;
 
-	fn generate_channel_keys_id(
-		&self, _inbound: bool, _channel_value_satoshis: u64, user_channel_id: u128,
-	) -> [u8; 32] {
+	fn generate_channel_keys_id(&self, _inbound: bool, user_channel_id: u128) -> [u8; 32] {
 		let child_idx = self.channel_child_index.fetch_add(1, Ordering::AcqRel);
 		// `child_idx` is the only thing guaranteed to make each channel unique without a restart
 		// (though `user_channel_id` should help, depending on user behavior). If it manages to
@@ -2214,10 +2189,8 @@ impl SignerProvider for KeysManager {
 		id
 	}
 
-	fn derive_channel_signer(
-		&self, channel_value_satoshis: u64, channel_keys_id: [u8; 32],
-	) -> Self::EcdsaSigner {
-		self.derive_channel_keys(channel_value_satoshis, &channel_keys_id)
+	fn derive_channel_signer(&self, channel_keys_id: [u8; 32]) -> Self::EcdsaSigner {
+		self.derive_channel_keys(&channel_keys_id)
 	}
 
 	fn read_chan_signer(&self, reader: &[u8]) -> Result<Self::EcdsaSigner, DecodeError> {
@@ -2341,16 +2314,12 @@ impl SignerProvider for PhantomKeysManager {
 	#[cfg(taproot)]
 	type TaprootSigner = InMemorySigner;
 
-	fn generate_channel_keys_id(
-		&self, inbound: bool, channel_value_satoshis: u64, user_channel_id: u128,
-	) -> [u8; 32] {
-		self.inner.generate_channel_keys_id(inbound, channel_value_satoshis, user_channel_id)
+	fn generate_channel_keys_id(&self, inbound: bool, user_channel_id: u128) -> [u8; 32] {
+		self.inner.generate_channel_keys_id(inbound, user_channel_id)
 	}
 
-	fn derive_channel_signer(
-		&self, channel_value_satoshis: u64, channel_keys_id: [u8; 32],
-	) -> Self::EcdsaSigner {
-		self.inner.derive_channel_signer(channel_value_satoshis, channel_keys_id)
+	fn derive_channel_signer(&self, channel_keys_id: [u8; 32]) -> Self::EcdsaSigner {
+		self.inner.derive_channel_signer(channel_keys_id)
 	}
 
 	fn read_chan_signer(&self, reader: &[u8]) -> Result<Self::EcdsaSigner, DecodeError> {
@@ -2398,10 +2367,8 @@ impl PhantomKeysManager {
 	}
 
 	/// See [`KeysManager::derive_channel_keys`] for documentation on this method.
-	pub fn derive_channel_keys(
-		&self, channel_value_satoshis: u64, params: &[u8; 32],
-	) -> InMemorySigner {
-		self.inner.derive_channel_keys(channel_value_satoshis, params)
+	pub fn derive_channel_keys(&self, params: &[u8; 32]) -> InMemorySigner {
+		self.inner.derive_channel_keys(params)
 	}
 
 	/// Gets the "node_id" secret key used to sign gossip announcements, decode onion data, etc.

lightning/src/util/test_utils.rs

@@ -358,15 +358,11 @@ impl SignerProvider for OnlyReadsKeysInterface {
 	#[cfg(taproot)]
 	type TaprootSigner = TestChannelSigner;
 
-	fn generate_channel_keys_id(
-		&self, _inbound: bool, _channel_value_satoshis: u64, _user_channel_id: u128,
-	) -> [u8; 32] {
+	fn generate_channel_keys_id(&self, _inbound: bool, _user_channel_id: u128) -> [u8; 32] {
 		unreachable!();
 	}
 
-	fn derive_channel_signer(
-		&self, _channel_value_satoshis: u64, _channel_keys_id: [u8; 32],
-	) -> Self::EcdsaSigner {
+	fn derive_channel_signer(&self, _channel_keys_id: [u8; 32]) -> Self::EcdsaSigner {
 		unreachable!();
 	}
 
@@ -1554,16 +1550,12 @@ impl SignerProvider for TestKeysInterface {
 	#[cfg(taproot)]
 	type TaprootSigner = TestChannelSigner;
 
-	fn generate_channel_keys_id(
-		&self, inbound: bool, channel_value_satoshis: u64, user_channel_id: u128,
-	) -> [u8; 32] {
-		self.backing.generate_channel_keys_id(inbound, channel_value_satoshis, user_channel_id)
+	fn generate_channel_keys_id(&self, inbound: bool, user_channel_id: u128) -> [u8; 32] {
+		self.backing.generate_channel_keys_id(inbound, user_channel_id)
 	}
 
-	fn derive_channel_signer(
-		&self, channel_value_satoshis: u64, channel_keys_id: [u8; 32],
-	) -> TestChannelSigner {
-		let keys = self.backing.derive_channel_signer(channel_value_satoshis, channel_keys_id);
+	fn derive_channel_signer(&self, channel_keys_id: [u8; 32]) -> TestChannelSigner {
+		let keys = self.backing.derive_channel_signer(channel_keys_id);
 		let state = self.make_enforcement_state_cell(keys.commitment_seed);
 		let signer =
 			TestChannelSigner::new_with_revoked(keys, state, self.disable_revocation_policy_check);
@@ -1629,10 +1621,8 @@ impl TestKeysInterface {
 		self
 	}
 
-	pub fn derive_channel_keys(
-		&self, channel_value_satoshis: u64, id: &[u8; 32],
-	) -> TestChannelSigner {
-		self.derive_channel_signer(channel_value_satoshis, *id)
+	pub fn derive_channel_keys(&self, id: &[u8; 32]) -> TestChannelSigner {
+		self.derive_channel_signer(*id)
 	}
 
 	fn make_enforcement_state_cell(