sets receiver_node_id to the phantom node pubkey when phantom_shared_secret is found on the claimable_htlcs

Author: tee8z

lightning-invoice/src/utils.rs

@@ -1081,7 +1081,7 @@ mod test {
 		nodes[fwd_idx].node.process_pending_htlc_forwards();
 
 		let payment_preimage_opt = if user_generated_pmt_hash { None } else { Some(payment_preimage) };
-		expect_payment_received!(&nodes[fwd_idx], payment_hash, payment_secret, payment_amt, payment_preimage_opt);
+		expect_payment_received!(&nodes[fwd_idx], payment_hash, payment_secret, payment_amt, payment_preimage_opt, route.paths[0].last().unwrap().pubkey);
 		do_claim_payment_along_route(&nodes[0], &vec!(&vec!(&nodes[fwd_idx])[..]), false, payment_preimage);
 		let events = nodes[0].node.get_and_clear_pending_events();
 		assert_eq!(events.len(), 2);

lightning/src/ln/channelmanager.rs

@@ -3484,9 +3484,15 @@ impl<M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelManager<M, T, K, F
 												log_bytes!(payment_hash.0), total_value, $payment_data.total_msat);
 											fail_htlc!(claimable_htlc, payment_hash);
 										} else if total_value == $payment_data.total_msat {
+											let phantom_shared_secret = claimable_htlc.prev_hop.phantom_shared_secret;
 											htlcs.push(claimable_htlc);
+											let mut receiver_node_id = self.our_network_pubkey;
+											if phantom_shared_secret.is_some(){
+												receiver_node_id = self.keys_manager.get_node_id(Recipient::PhantomNode)
+													.expect("Failed to get node_id for phantom node recipient");
+											}
 											new_events.push(events::Event::PaymentReceived {
-												receiver_node_id: Some(self.our_network_pubkey),
+												receiver_node_id: Some(receiver_node_id),
 												payment_hash,
 												purpose: purpose(),
 												amount_msat: total_value,
@@ -3527,9 +3533,16 @@ impl<M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelManager<M, T, K, F
 												match channel_state.claimable_htlcs.entry(payment_hash) {
 													hash_map::Entry::Vacant(e) => {
 														let purpose = events::PaymentPurpose::SpontaneousPayment(preimage);
+														let phantom_shared_secret = &claimable_htlc.prev_hop.phantom_shared_secret.clone();
 														e.insert((purpose.clone(), vec![claimable_htlc]));
+														let mut receiver_node_id = Some(self.our_network_pubkey);
+														if phantom_shared_secret.is_some(){
+															let phantom_pubkey = self.keys_manager.get_node_id(Recipient::PhantomNode)
+																				.expect("Failed to get node_id for phantom node recipient");
+															receiver_node_id = Some(phantom_pubkey)
+														}
 														new_events.push(events::Event::PaymentReceived {
-															receiver_node_id: Some(self.our_network_pubkey),
+															receiver_node_id,
 															payment_hash,
 															amount_msat: outgoing_amt_msat,
 															purpose,
@@ -4196,6 +4209,7 @@ impl<M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelManager<M, T, K, F
 			let mut claimed_any_htlcs = false;
 			let mut channel_state_lock = self.channel_state.lock().unwrap();
 			let channel_state = &mut *channel_state_lock;
+			let mut receiver_node_id = Some(self.our_network_pubkey);
 			for htlc in sources.iter() {
 				let chan_id = match self.short_to_chan_info.read().unwrap().get(&htlc.prev_hop.short_channel_id) {
 					Some((_cp_id, chan_id)) => chan_id.clone(),
@@ -4227,6 +4241,12 @@ impl<M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelManager<M, T, K, F
 						break;
 					}
 				}
+				let phantom_shared_secret = htlc.prev_hop.phantom_shared_secret;
+				if phantom_shared_secret.is_some(){
+					let phantom_pubkey = self.keys_manager.get_node_id(Recipient::PhantomNode)
+										.expect("Failed to get node_id for phantom node recipient");
+					receiver_node_id = Some(phantom_pubkey)
+				}
 
 				claimable_amt_msat += htlc.value;
 			}
@@ -4276,7 +4296,7 @@ impl<M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelManager<M, T, K, F
 
 			if claimed_any_htlcs {
 				self.pending_events.lock().unwrap().push(events::Event::PaymentClaimed {
-					receiver_node_id: Some(self.our_network_pubkey),
+					receiver_node_id,
 					payment_hash,
 					purpose: payment_purpose,
 					amount_msat: claimable_amt_msat,
@@ -7490,6 +7510,13 @@ impl<'a, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref>
 				if let Some((payment_purpose, claimable_htlcs)) = claimable_htlcs.remove(&payment_hash) {
 					log_info!(args.logger, "Re-claiming HTLCs with payment hash {} as we've released the preimage to a ChannelMonitor!", log_bytes!(payment_hash.0));
 					let mut claimable_amt_msat = 0;
+					let mut receiver_node_id = Some(our_network_pubkey);
+					let phantom_shared_secret = claimable_htlcs[0].prev_hop.phantom_shared_secret;
+					if phantom_shared_secret.is_some(){
+						let phantom_pubkey = args.keys_manager.get_node_id(Recipient::PhantomNode)
+										.expect("Failed to get node_id for phantom node recipient");
+						receiver_node_id = Some(phantom_pubkey)
+					}
 					for claimable_htlc in claimable_htlcs {
 						claimable_amt_msat += claimable_htlc.value;
 
@@ -7517,7 +7544,7 @@ impl<'a, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref>
 						}
 					}
 					pending_events_read.push(events::Event::PaymentClaimed {
-						receiver_node_id: Some(our_network_pubkey),
+						receiver_node_id,
 						payment_hash,
 						purpose: payment_purpose,
 						amount_msat: claimable_amt_msat,

lightning/src/ln/functional_test_utils.rs

@@ -1433,21 +1433,22 @@ macro_rules! expect_pending_htlcs_forwardable_from_events {
 		}
 	}}
 }
-
+// expect_payment_received!(&nodes[fwd_idx], payment_hash, payment_secret, payment_amt, payment_preimage_opt);
 #[macro_export]
 #[cfg(any(test, feature = "_bench_unstable", feature = "_test_utils"))]
 macro_rules! expect_payment_received {
 	($node: expr, $expected_payment_hash: expr, $expected_payment_secret: expr, $expected_recv_value: expr) => {
-		expect_payment_received!($node, $expected_payment_hash, $expected_payment_secret, $expected_recv_value, None)
+		expect_payment_received!($node, $expected_payment_hash, $expected_payment_secret, $expected_recv_value, None, $node.node.get_our_node_id())
 	};
-	($node: expr, $expected_payment_hash: expr, $expected_payment_secret: expr, $expected_recv_value: expr, $expected_payment_preimage: expr) => {
+	($node: expr, $expected_payment_hash: expr, $expected_payment_secret: expr, $expected_recv_value: expr, $expected_payment_preimage: expr, $expected_receiver_node_id: expr) => {
 		let events = $node.node.get_and_clear_pending_events();
 		assert_eq!(events.len(), 1);
 		match events[0] {
 			$crate::util::events::Event::PaymentReceived { ref payment_hash, ref purpose, amount_msat, receiver_node_id } => {
 				assert_eq!($expected_payment_hash, *payment_hash);
 				assert_eq!($expected_recv_value, amount_msat);
-				assert_eq!($node.node.get_our_node_id(), receiver_node_id.unwrap());
+				assert_eq!($expected_receiver_node_id, receiver_node_id.unwrap());
+
 				match purpose {
 					$crate::util::events::PaymentPurpose::InvoicePayment { payment_preimage, payment_secret, .. } => {
 						assert_eq!(&$expected_payment_preimage, payment_preimage);

lightning/src/ln/onion_route_tests.rs

@@ -1229,7 +1229,7 @@ fn test_phantom_failure_reject_payment() {
 	nodes[1].node.process_pending_htlc_forwards();
 	expect_pending_htlcs_forwardable_ignore!(nodes[1]);
 	nodes[1].node.process_pending_htlc_forwards();
-	expect_payment_received!(nodes[1], payment_hash, payment_secret, recv_amt_msat);
+	expect_payment_received!(nodes[1], payment_hash, payment_secret, recv_amt_msat, None, route.paths[0].last().unwrap().pubkey);
 	nodes[1].node.fail_htlc_backwards(&payment_hash);
 	expect_pending_htlcs_forwardable_and_htlc_handling_failed_ignore!(nodes[1], vec![HTLCDestination::FailedPayment { payment_hash }]);
 	nodes[1].node.process_pending_htlc_forwards();

lightning/src/util/events.rs

@@ -342,7 +342,11 @@ pub enum Event {
 	/// [`ChannelManager::claim_funds`]: crate::ln::channelmanager::ChannelManager::claim_funds
 	/// [`ChannelManager::fail_htlc_backwards`]: crate::ln::channelmanager::ChannelManager::fail_htlc_backwards
 	PaymentReceived {
-		/// The node that received the payment
+		/// The node that received the payment.
+		/// This is useful to identify payments which were received via [phantom node payments].
+		/// This field will always be filled in when the event was generated by LDK versions 0.0.113 and above.
+		/// 
+		/// [phantom node payments]: chain::keysinterface::PhantomKeysManager
 		receiver_node_id: Option<PublicKey>,
 		/// The hash for which the preimage should be handed to the ChannelManager. Note that LDK will
 		/// not stop you from registering duplicate payment hashes for inbound payments.
@@ -368,7 +372,11 @@ pub enum Event {
 	///
 	/// [`ChannelManager::claim_funds`]: crate::ln::channelmanager::ChannelManager::claim_funds
 	PaymentClaimed {
-		/// The node that received the payment
+		/// The node that received the payment.
+		/// This is useful to identify payments which were received via [phantom node payments].
+		/// This field will always be filled in when the event was generated by LDK versions 0.0.113 and above.
+		/// 
+		/// [phantom node payments]: chain::keysinterface::PhantomKeysManager
 		receiver_node_id: Option<PublicKey>,
 		/// The payment hash of the claimed payment. Note that LDK will not stop you from
 		/// registering duplicate payment hashes for inbound payments.
@@ -743,7 +751,7 @@ impl Writeable for Event {
 				// We never write out FundingGenerationReady events as, upon disconnection, peers
 				// drop any channels which have not yet exchanged funding_signed.
 			},
-			&Event::PaymentReceived { ref payment_hash, ref amount_msat, ref purpose, receiver_node_id } => {
+			&Event::PaymentReceived { ref payment_hash, ref amount_msat, ref purpose, ref receiver_node_id } => {
 				1u8.write(writer)?;
 				let mut payment_secret = None;
 				let payment_preimage;
@@ -859,7 +867,7 @@ impl Writeable for Event {
 				// We never write the OpenChannelRequest events as, upon disconnection, peers
 				// drop any channels which have not yet exchanged funding_signed.
 			},
-			&Event::PaymentClaimed { ref payment_hash, ref amount_msat, ref purpose, receiver_node_id } => {
+			&Event::PaymentClaimed { ref payment_hash, ref amount_msat, ref purpose, ref receiver_node_id } => {
 				19u8.write(writer)?;
 				write_tlv_fields!(writer, {
 					(0, payment_hash, required),