Add KeysInterface::get_node_id method

Useful since we're working on getting rid of KeysInterface::get_node_secret to
complete support for remote signing.

Will be used in upcoming work to check whether an outbound onion message
blinded path has our node id as the introduction node id

Author: valentinewallace

fuzz/src/chanmon_consistency.rs

@@ -167,6 +167,11 @@ impl KeysInterface for KeyProvider {
 		Ok(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, 1, self.node_id]).unwrap())
 	}
 
+	fn get_node_id(&self, _recipient: Recipient) -> Result<PublicKey, ()> {
+		let secp_ctx = Secp256k1::signing_only();
+		Ok(PublicKey::from_secret_key(&secp_ctx, &self.get_node_secret(Recipient::Node).unwrap()))
+	}
+
 	fn ecdh(&self, recipient: Recipient, other_key: &PublicKey, tweak: Option<&Scalar>) -> Result<SharedSecret, ()> {
 		let mut node_secret = self.get_node_secret(recipient)?;
 		if let Some(tweak) = tweak {

fuzz/src/full_stack.rs

@@ -272,6 +272,11 @@ impl KeysInterface for KeyProvider {
 		Ok(self.node_secret.clone())
 	}
 
+	fn get_node_id(&self, _recipient: Recipient) -> Result<PublicKey, ()> {
+		let secp_ctx = Secp256k1::signing_only();
+		Ok(PublicKey::from_secret_key(&secp_ctx, &self.node_secret))
+	}
+
 	fn ecdh(&self, recipient: Recipient, other_key: &PublicKey, tweak: Option<&Scalar>) -> Result<SharedSecret, ()> {
 		let mut node_secret = self.get_node_secret(recipient)?;
 		if let Some(tweak) = tweak {

fuzz/src/onion_message.rs

@@ -1,7 +1,7 @@
 // Imports that need to be added manually
 use bitcoin::bech32::u5;
 use bitcoin::blockdata::script::Script;
-use bitcoin::secp256k1::{PublicKey, Scalar, SecretKey};
+use bitcoin::secp256k1::{PublicKey, Scalar, Secp256k1, SecretKey};
 use bitcoin::secp256k1::ecdh::SharedSecret;
 use bitcoin::secp256k1::ecdsa::RecoverableSignature;
 
@@ -67,6 +67,11 @@ impl KeysInterface for KeyProvider {
 		Ok(self.node_secret.clone())
 	}
 
+	fn get_node_id(&self, _recipient: Recipient) -> Result<PublicKey, ()> {
+		let secp_ctx = Secp256k1::signing_only();
+		Ok(PublicKey::from_secret_key(&secp_ctx, &self.get_node_secret(Recipient::Node).unwrap()))
+	}
+
 	fn ecdh(&self, recipient: Recipient, other_key: &PublicKey, tweak: Option<&Scalar>) -> Result<SharedSecret, ()> {
 		let mut node_secret = self.get_node_secret(recipient)?;
 		if let Some(tweak) = tweak {

lightning/src/chain/keysinterface.rs

@@ -405,6 +405,11 @@ pub trait KeysInterface {
 	/// This method must return the same value each time it is called with a given `Recipient`
 	/// parameter.
 	fn get_node_secret(&self, recipient: Recipient) -> Result<SecretKey, ()>;
+	/// Get node id based on the provided [`Recipient`].
+	///
+	/// This method must return the same value each time it is called with a given `Recipient`
+	/// parameter.
+	fn get_node_id(&self, recipient: Recipient) -> Result<PublicKey, ()>;
 	/// Gets the ECDH shared secret of our [`node secret`] and `other_key`, multiplying by `tweak` if
 	/// one is provided. Note that this tweak can be applied to `other_key` instead of our node
 	/// secret, though this is less efficient.
@@ -853,6 +858,7 @@ impl ReadableArgs<SecretKey> for InMemorySigner {
 pub struct KeysManager {
 	secp_ctx: Secp256k1<secp256k1::All>,
 	node_secret: SecretKey,
+	node_id: PublicKey,
 	inbound_payment_key: KeyMaterial,
 	destination_script: Script,
 	shutdown_pubkey: PublicKey,
@@ -894,6 +900,7 @@ impl KeysManager {
 		match ExtendedPrivKey::new_master(Network::Testnet, seed) {
 			Ok(master_key) => {
 				let node_secret = master_key.ckd_priv(&secp_ctx, ChildNumber::from_hardened_idx(0).unwrap()).expect("Your RNG is busted").private_key;
+				let node_id = PublicKey::from_secret_key(&secp_ctx, &node_secret);
 				let destination_script = match master_key.ckd_priv(&secp_ctx, ChildNumber::from_hardened_idx(1).unwrap()) {
 					Ok(destination_key) => {
 						let wpubkey_hash = WPubkeyHash::hash(&ExtendedPubKey::from_priv(&secp_ctx, &destination_key).to_pub().to_bytes());
@@ -921,6 +928,7 @@ impl KeysManager {
 				let mut res = KeysManager {
 					secp_ctx,
 					node_secret,
+					node_id,
 					inbound_payment_key: KeyMaterial(inbound_pmt_key_bytes),
 
 					destination_script,
@@ -1140,6 +1148,13 @@ impl KeysInterface for KeysManager {
 		}
 	}
 
+	fn get_node_id(&self, recipient: Recipient) -> Result<PublicKey, ()> {
+		match recipient {
+			Recipient::Node => Ok(self.node_id.clone()),
+			Recipient::PhantomNode => Err(())
+		}
+	}
+
 	fn ecdh(&self, recipient: Recipient, other_key: &PublicKey, tweak: Option<&Scalar>) -> Result<SharedSecret, ()> {
 		let mut node_secret = self.get_node_secret(recipient)?;
 		if let Some(tweak) = tweak {
@@ -1220,6 +1235,7 @@ pub struct PhantomKeysManager {
 	inner: KeysManager,
 	inbound_payment_key: KeyMaterial,
 	phantom_secret: SecretKey,
+	phantom_node_id: PublicKey,
 }
 
 impl KeysInterface for PhantomKeysManager {
@@ -1232,6 +1248,13 @@ impl KeysInterface for PhantomKeysManager {
 		}
 	}
 
+	fn get_node_id(&self, recipient: Recipient) -> Result<PublicKey, ()> {
+		match recipient {
+			Recipient::Node => self.inner.get_node_id(Recipient::Node),
+			Recipient::PhantomNode => Ok(self.phantom_node_id.clone()),
+		}
+	}
+
 	fn ecdh(&self, recipient: Recipient, other_key: &PublicKey, tweak: Option<&Scalar>) -> Result<SharedSecret, ()> {
 		let mut node_secret = self.get_node_secret(recipient)?;
 		if let Some(tweak) = tweak {
@@ -1285,10 +1308,13 @@ impl PhantomKeysManager {
 	pub fn new(seed: &[u8; 32], starting_time_secs: u64, starting_time_nanos: u32, cross_node_seed: &[u8; 32]) -> Self {
 		let inner = KeysManager::new(seed, starting_time_secs, starting_time_nanos);
 		let (inbound_key, phantom_key) = hkdf_extract_expand_twice(b"LDK Inbound and Phantom Payment Key Expansion", cross_node_seed);
+		let phantom_secret = SecretKey::from_slice(&phantom_key).unwrap();
+		let phantom_node_id = PublicKey::from_secret_key(&inner.secp_ctx, &phantom_secret);
 		Self {
 			inner,
 			inbound_payment_key: KeyMaterial(inbound_key),
-			phantom_secret: SecretKey::from_slice(&phantom_key).unwrap(),
+			phantom_secret,
+			phantom_node_id,
 		}
 	}
 

lightning/src/ln/channel.rs

@@ -6710,6 +6710,7 @@ mod tests {
 		type Signer = InMemorySigner;
 
 		fn get_node_secret(&self, _recipient: Recipient) -> Result<SecretKey, ()> { panic!(); }
+		fn get_node_id(&self, _recipient: Recipient) -> Result<PublicKey, ()> { panic!(); }
 		fn ecdh(&self, _recipient: Recipient, _other_key: &PublicKey, _tweak: Option<&Scalar>) -> Result<SharedSecret, ()> { panic!(); }
 		fn get_inbound_payment_key_material(&self) -> KeyMaterial { panic!(); }
 		fn get_destination_script(&self) -> Script {

lightning/src/util/test_utils.rs

@@ -76,6 +76,7 @@ impl keysinterface::KeysInterface for OnlyReadsKeysInterface {
 	type Signer = EnforcingSigner;
 
 	fn get_node_secret(&self, _recipient: Recipient) -> Result<SecretKey, ()> { unreachable!(); }
+	fn get_node_id(&self, _recipient: Recipient) -> Result<PublicKey, ()> { unreachable!(); }
 	fn ecdh(&self, _recipient: Recipient, _other_key: &PublicKey, _tweak: Option<&Scalar>) -> Result<SharedSecret, ()> { unreachable!(); }
 	fn get_inbound_payment_key_material(&self) -> KeyMaterial { unreachable!(); }
 	fn get_destination_script(&self) -> Script { unreachable!(); }
@@ -608,6 +609,9 @@ impl keysinterface::KeysInterface for TestKeysInterface {
 	fn get_node_secret(&self, recipient: Recipient) -> Result<SecretKey, ()> {
 		self.backing.get_node_secret(recipient)
 	}
+	fn get_node_id(&self, recipient: Recipient) -> Result<PublicKey, ()> {
+		self.backing.get_node_id(recipient)
+	}
 	fn ecdh(&self, recipient: Recipient, other_key: &PublicKey, tweak: Option<&Scalar>) -> Result<SharedSecret, ()> {
 		self.backing.ecdh(recipient, other_key, tweak)
 	}