Remove channel_value_satoshis from SignerProvider

Now that channel_value_satoshis has been moved to
ChannelTransactionParameters, it no longer needs to be used when
deriving a signer. This is a breaking API change, though InMemorySigner
did not make use of channel_value_satoshis when being derived.

Author: jkczyz

fuzz/src/chanmon_consistency.rs

@@ -354,16 +354,12 @@ impl SignerProvider for KeyProvider {
 	#[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] {
 		let id = self.rand_bytes_id.fetch_add(1, atomic::Ordering::Relaxed) as u8;
 		[id; 32]
 	}
 
-	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 {
 		let secp_ctx = Secp256k1::signing_only();
 		let id = channel_keys_id[0];
 		#[rustfmt::skip]
@@ -375,7 +371,6 @@ impl SignerProvider for KeyProvider {
 			SecretKey::from_slice(&[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, self.node_secret[31]]).unwrap(),
 			SecretKey::from_slice(&[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, self.node_secret[31]]).unwrap(),
 			[id, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, self.node_secret[31]],
-			channel_value_satoshis,
 			channel_keys_id,
 			channel_keys_id,
 		);

fuzz/src/full_stack.rs

@@ -426,19 +426,15 @@ impl SignerProvider for KeyProvider {
 	#[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] {
 		let ctr = self.counter.fetch_add(1, Ordering::Relaxed) as u8;
 		self.signer_state
 			.borrow_mut()
 			.insert(ctr, (inbound, Arc::new(Mutex::new(EnforcementState::new()))));
 		[ctr; 32]
 	}
 
-	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 {
 		let secp_ctx = Secp256k1::signing_only();
 		let ctr = channel_keys_id[0];
 		let (inbound, state) = self.signer_state.borrow().get(&ctr).unwrap().clone();
@@ -475,7 +471,6 @@ impl SignerProvider for KeyProvider {
 						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 						0, 0, 0, 0, 0, 6, ctr,
 					],
-					channel_value_satoshis,
 					channel_keys_id,
 					channel_keys_id,
 				)
@@ -511,7 +506,6 @@ impl SignerProvider for KeyProvider {
 						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 						0, 0, 0, 0, 0, 12, ctr,
 					],
-					channel_value_satoshis,
 					channel_keys_id,
 					channel_keys_id,
 				)

fuzz/src/onion_message.rs

@@ -253,15 +253,11 @@ impl SignerProvider for KeyProvider {
 	#[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!()
 	}
 

lightning/src/chain/channelmonitor.rs

@@ -5401,7 +5401,6 @@ mod tests {
 			SecretKey::from_slice(&[41; 32]).unwrap(),
 			SecretKey::from_slice(&[41; 32]).unwrap(),
 			[41; 32],
-			0,
 			[0; 32],
 			[0; 32],
 		);
@@ -5654,7 +5653,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

@@ -383,7 +383,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));
@@ -1314,7 +1314,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

@@ -1944,8 +1944,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

@@ -2119,7 +2119,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,
@@ -2407,8 +2407,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 {
@@ -9004,8 +9004,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(
@@ -9561,8 +9561,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));
@@ -10615,7 +10615,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 {
 			return Err(DecodeError::InvalidValue);
@@ -10970,11 +10970,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()
 		}
 
@@ -11597,7 +11597,7 @@ mod tests {
 		let logger : Arc<dyn Logger> = Arc::new(test_utils::TestLogger::new());
 		let secp_ctx = Secp256k1::new();
 
-		let mut signer = InMemorySigner::new(
+		let signer = InMemorySigner::new(
 			&secp_ctx,
 			SecretKey::from_slice(&<Vec<u8>>::from_hex("30ff4956bbdd3222d44cc5e8a1261dab1e07957bdac5ae88fe3261ef321f3749").unwrap()[..]).unwrap(),
 			SecretKey::from_slice(&<Vec<u8>>::from_hex("0fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap()[..]).unwrap(),
@@ -11607,7 +11607,6 @@ mod tests {
 
 			// These aren't set in the test vectors:
 			[0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff],
-			10_000_000,
 			[0; 32],
 			[0; 32],
 		);

lightning/src/sign/mod.rs

@@ -709,10 +709,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)
 	}
 }
 
@@ -949,19 +946,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;
 
 	/// Get a script pubkey which we send funds to when claiming on-chain contestable outputs.
 	///
@@ -1014,8 +1007,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.
@@ -1031,7 +1022,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
 	}
 }
@@ -1046,7 +1036,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()),
 		}
@@ -1058,8 +1047,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,
@@ -1076,7 +1064,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),
@@ -1831,9 +1818,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);
@@ -1885,7 +1870,6 @@ impl KeysManager {
 			delayed_payment_base_key,
 			htlc_base_key,
 			commitment_seed,
-			channel_value_satoshis,
 			params.clone(),
 			prng_seed,
 		)
@@ -1917,10 +1901,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(
@@ -1937,10 +1918,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,
 						));
 					}
@@ -2109,9 +2087,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
@@ -2127,10 +2103,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 get_destination_script(&self, _channel_keys_id: [u8; 32]) -> Result<ScriptBuf, ()> {
@@ -2250,16 +2224,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 get_destination_script(&self, channel_keys_id: [u8; 32]) -> Result<ScriptBuf, ()> {
@@ -2303,10 +2273,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.