renamed node_id to our_node_id and make the value optional to not break older versions

Author: tee8z

lightning/src/ln/chanmon_update_fail_tests.rs

@@ -200,10 +200,10 @@ fn do_test_simple_monitor_temporary_update_fail(disconnect: bool) {
 	let events_3 = nodes[1].node.get_and_clear_pending_events();
 	assert_eq!(events_3.len(), 1);
 	match events_3[0] {
-		Event::PaymentReceived { ref payment_hash, ref purpose, amount_msat, node_id } => {
+		Event::PaymentReceived { ref payment_hash, ref purpose, amount_msat, our_node_id } => {
 			assert_eq!(payment_hash_1, *payment_hash);
 			assert_eq!(amount_msat, 1_000_000);
-			assert_eq!(node_id.unwrap(), nodes[1].node.get_our_node_id());
+			assert_eq!(our_node_id.unwrap(), nodes[1].node.get_our_node_id());
 			match &purpose {
 				PaymentPurpose::InvoicePayment { payment_preimage, payment_secret, .. } => {
 					assert!(payment_preimage.is_none());
@@ -569,10 +569,10 @@ fn do_test_monitor_temporary_update_fail(disconnect_count: usize) {
 	let events_5 = nodes[1].node.get_and_clear_pending_events();
 	assert_eq!(events_5.len(), 1);
 	match events_5[0] {
-		Event::PaymentReceived { ref payment_hash, ref purpose, amount_msat, node_id } => {
+		Event::PaymentReceived { ref payment_hash, ref purpose, amount_msat, our_node_id } => {
 			assert_eq!(payment_hash_2, *payment_hash);
 			assert_eq!(amount_msat, 1_000_000);
-			assert_eq!(node_id.unwrap(), nodes[1].node.get_our_node_id());
+			assert_eq!(our_node_id.unwrap(), nodes[1].node.get_our_node_id());
 			match &purpose {
 				PaymentPurpose::InvoicePayment { payment_preimage, payment_secret, .. } => {
 					assert!(payment_preimage.is_none());
@@ -687,10 +687,10 @@ fn test_monitor_update_fail_cs() {
 	let events = nodes[1].node.get_and_clear_pending_events();
 	assert_eq!(events.len(), 1);
 	match events[0] {
-		Event::PaymentReceived { payment_hash, ref purpose, amount_msat, node_id } => {
+		Event::PaymentReceived { payment_hash, ref purpose, amount_msat, our_node_id } => {
 			assert_eq!(payment_hash, our_payment_hash);
 			assert_eq!(amount_msat, 1_000_000);
-			assert_eq!(node_id.unwrap(), nodes[1].node.get_our_node_id());
+			assert_eq!(our_node_id.unwrap(), nodes[1].node.get_our_node_id());
 			match &purpose {
 				PaymentPurpose::InvoicePayment { payment_preimage, payment_secret, .. } => {
 					assert!(payment_preimage.is_none());
@@ -1662,10 +1662,10 @@ fn test_monitor_update_fail_claim() {
 	let events = nodes[0].node.get_and_clear_pending_events();
 	assert_eq!(events.len(), 2);
 	match events[0] {
-		Event::PaymentReceived { ref payment_hash, ref purpose, amount_msat, node_id } => {
+		Event::PaymentReceived { ref payment_hash, ref purpose, amount_msat, our_node_id } => {
 			assert_eq!(payment_hash_2, *payment_hash);
 			assert_eq!(1_000_000, amount_msat);
-			assert_eq!(node_id.unwrap(), nodes[0].node.get_our_node_id());
+			assert_eq!(our_node_id.unwrap(), nodes[0].node.get_our_node_id());
 			match &purpose {
 				PaymentPurpose::InvoicePayment { payment_preimage, payment_secret, .. } => {
 					assert!(payment_preimage.is_none());
@@ -1677,10 +1677,10 @@ fn test_monitor_update_fail_claim() {
 		_ => panic!("Unexpected event"),
 	}
 	match events[1] {
-		Event::PaymentReceived { ref payment_hash, ref purpose, amount_msat, node_id } => {
+		Event::PaymentReceived { ref payment_hash, ref purpose, amount_msat, our_node_id } => {
 			assert_eq!(payment_hash_3, *payment_hash);
 			assert_eq!(1_000_000, amount_msat);
-			assert_eq!(node_id.unwrap(), nodes[0].node.get_our_node_id());
+			assert_eq!(our_node_id.unwrap(), nodes[0].node.get_our_node_id());
 			match &purpose {
 				PaymentPurpose::InvoicePayment { payment_preimage, payment_secret, .. } => {
 					assert!(payment_preimage.is_none());

lightning/src/ln/channelmanager.rs

@@ -3486,7 +3486,7 @@ impl<M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelManager<M, T, K, F
 										} else if total_value == $payment_data.total_msat {
 											htlcs.push(claimable_htlc);
 											new_events.push(events::Event::PaymentReceived {
-												node_id: Some(self.our_network_pubkey),
+												our_node_id: Some(self.our_network_pubkey),
 												payment_hash,
 												purpose: purpose(),
 												amount_msat: total_value,
@@ -3529,7 +3529,7 @@ impl<M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelManager<M, T, K, F
 														let purpose = events::PaymentPurpose::SpontaneousPayment(preimage);
 														e.insert((purpose.clone(), vec![claimable_htlc]));
 														new_events.push(events::Event::PaymentReceived {
-															node_id: Some(self.our_network_pubkey),
+															our_node_id: Some(self.our_network_pubkey),
 															payment_hash,
 															amount_msat: outgoing_amt_msat,
 															purpose,
@@ -4276,7 +4276,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 {
-					node_id: Some(self.our_network_pubkey),
+					our_node_id: Some(self.our_network_pubkey),
 					payment_hash,
 					purpose: payment_purpose,
 					amount_msat: claimable_amt_msat,
@@ -7517,7 +7517,7 @@ impl<'a, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref>
 						}
 					}
 					pending_events_read.push(events::Event::PaymentClaimed {
-						node_id: Some(our_network_pubkey),
+						our_node_id: Some(our_network_pubkey),
 						payment_hash,
 						purpose: payment_purpose,
 						amount_msat: claimable_amt_msat,

lightning/src/ln/functional_test_utils.rs

@@ -1444,10 +1444,10 @@ macro_rules! expect_payment_received {
 		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, node_id } => {
+			$crate::util::events::Event::PaymentReceived {ref payment_hash, ref purpose, amount_msat, our_node_id } => {
 				assert_eq!($expected_payment_hash, *payment_hash);
 				assert_eq!($expected_recv_value, amount_msat);
-				assert_eq!($node.node.get_our_node_id(), node_id.unwrap());
+				assert_eq!($node.node.get_our_node_id(), our_node_id.unwrap());
 				match purpose {
 					$crate::util::events::PaymentPurpose::InvoicePayment { payment_preimage, payment_secret, .. } => {
 						assert_eq!(&$expected_payment_preimage, payment_preimage);
@@ -1739,9 +1739,9 @@ pub fn do_pass_along_path<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_p
 			if payment_received_expected {
 				assert_eq!(events_2.len(), 1);
 				match events_2[0] {
-					Event::PaymentReceived { ref payment_hash, ref purpose, amount_msat, node_id } => {
+					Event::PaymentReceived { ref payment_hash, ref purpose, amount_msat, our_node_id } => {
 						assert_eq!(our_payment_hash, *payment_hash);
-						assert_eq!(node.node.get_our_node_id(), node_id.unwrap());
+						assert_eq!(node.node.get_our_node_id(), our_node_id.unwrap());
 						match &purpose {
 							PaymentPurpose::InvoicePayment { payment_preimage, payment_secret, .. } => {
 								assert_eq!(expected_preimage, *payment_preimage);

lightning/src/ln/functional_tests.rs

@@ -1956,10 +1956,10 @@ fn test_channel_reserve_holding_cell_htlcs() {
 	let events = nodes[2].node.get_and_clear_pending_events();
 	assert_eq!(events.len(), 2);
 	match events[0] {
-		Event::PaymentReceived { ref payment_hash, ref purpose, amount_msat, node_id } => {
+		Event::PaymentReceived { ref payment_hash, ref purpose, amount_msat, our_node_id } => {
 			assert_eq!(our_payment_hash_21, *payment_hash);
 			assert_eq!(recv_value_21, amount_msat);
-			assert_eq!(nodes[2].node.get_our_node_id(), node_id.unwrap());
+			assert_eq!(nodes[2].node.get_our_node_id(), our_node_id.unwrap());
 			match &purpose {
 				PaymentPurpose::InvoicePayment { payment_preimage, payment_secret, .. } => {
 					assert!(payment_preimage.is_none());
@@ -1971,10 +1971,10 @@ fn test_channel_reserve_holding_cell_htlcs() {
 		_ => panic!("Unexpected event"),
 	}
 	match events[1] {
-		Event::PaymentReceived { ref payment_hash, ref purpose, amount_msat, node_id } => {
+		Event::PaymentReceived { ref payment_hash, ref purpose, amount_msat, our_node_id } => {
 			assert_eq!(our_payment_hash_22, *payment_hash);
 			assert_eq!(recv_value_22, amount_msat);
-			assert_eq!(nodes[2].node.get_our_node_id(), node_id.unwrap());
+			assert_eq!(nodes[2].node.get_our_node_id(), our_node_id.unwrap());
 			match &purpose {
 				PaymentPurpose::InvoicePayment { payment_preimage, payment_secret, .. } => {
 					assert!(payment_preimage.is_none());
@@ -3725,10 +3725,10 @@ fn do_test_drop_messages_peer_disconnect(messages_delivered: u8, simulate_broken
 	let events_2 = nodes[1].node.get_and_clear_pending_events();
 	assert_eq!(events_2.len(), 1);
 	match events_2[0] {
-		Event::PaymentReceived { ref payment_hash, ref purpose, amount_msat, node_id } => {
+		Event::PaymentReceived { ref payment_hash, ref purpose, amount_msat, our_node_id } => {
 			assert_eq!(payment_hash_1, *payment_hash);
 			assert_eq!(amount_msat, 1_000_000);
-			assert_eq!(node_id.unwrap(), nodes[1].node.get_our_node_id());
+			assert_eq!(our_node_id.unwrap(), nodes[1].node.get_our_node_id());
 			match &purpose {
 				PaymentPurpose::InvoicePayment { payment_preimage, payment_secret, .. } => {
 					assert!(payment_preimage.is_none());

lightning/src/util/events.rs

@@ -342,8 +342,8 @@ 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 received node, ie whether the node was a phantom node or not.
-		node_id: Option<PublicKey>,
+		/// The node that recieved the payment, ie our node
+		our_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.
 		payment_hash: PaymentHash,
@@ -368,8 +368,8 @@ pub enum Event {
 	///
 	/// [`ChannelManager::claim_funds`]: crate::ln::channelmanager::ChannelManager::claim_funds
 	PaymentClaimed {
-		/// The received node, ie whether the node was a phantom node or not.
-		node_id: Option<PublicKey>,
+		/// The node that recieved the payment, ie our node
+		our_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.
 		payment_hash: PaymentHash,
@@ -743,7 +743,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 node_id, ref payment_hash, ref amount_msat, ref purpose } => {
+			&Event::PaymentReceived { ref payment_hash, ref amount_msat, ref purpose, our_node_id } => {
 				1u8.write(writer)?;
 				let mut payment_secret = None;
 				let payment_preimage;
@@ -762,7 +762,7 @@ impl Writeable for Event {
 					(4, amount_msat, required),
 					(6, 0u64, required), // user_payment_id required for compatibility with 0.0.103 and earlier
 					(8, payment_preimage, option),
-					(10, node_id, required),
+					(10, our_node_id, option),
 				});
 			},
 			&Event::PaymentSent { ref payment_id, ref payment_preimage, ref payment_hash, ref fee_paid_msat } => {
@@ -859,13 +859,13 @@ 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 node_id, ref payment_hash, ref amount_msat, ref purpose } => {
+			&Event::PaymentClaimed { ref payment_hash, ref amount_msat, ref purpose, our_node_id } => {
 				19u8.write(writer)?;
 				write_tlv_fields!(writer, {
 					(0, payment_hash, required),
 					(2, purpose, required),
 					(4, amount_msat, required),
-					(6, node_id, required),
+					(6, our_node_id, option),
 				});
 			},
 			&Event::ProbeSuccessful { ref payment_id, ref payment_hash, ref path } => {
@@ -929,15 +929,15 @@ impl MaybeReadable for Event {
 					let mut payment_preimage = None;
 					let mut payment_secret = None;
 					let mut amount_msat = 0;
-					let mut node_id = None;
+					let mut our_node_id = None;
 					let mut _user_payment_id = None::<u64>; // For compatibility with 0.0.103 and earlier
 					read_tlv_fields!(reader, {
 						(0, payment_hash, required),
 						(2, payment_secret, option),
 						(4, amount_msat, required),
 						(6, _user_payment_id, option),
 						(8, payment_preimage, option),
-						(10, node_id, required),
+						(10, our_node_id, option),
 					});
 					let purpose = match payment_secret {
 						Some(secret) => PaymentPurpose::InvoicePayment {
@@ -948,7 +948,7 @@ impl MaybeReadable for Event {
 						None => return Err(msgs::DecodeError::InvalidValue),
 					};
 					Ok(Some(Event::PaymentReceived {
-						node_id,
+						our_node_id,
 						payment_hash,
 						amount_msat,
 						purpose,
@@ -1126,17 +1126,17 @@ impl MaybeReadable for Event {
 					let mut payment_hash = PaymentHash([0; 32]);
 					let mut purpose = None;
 					let mut amount_msat = 0;
-					let mut node_id = None;
+					let mut our_node_id = None;
 					read_tlv_fields!(reader, {
 						(0, payment_hash, required),
 						(2, purpose, ignorable),
 						(4, amount_msat, required),
-						(6, node_id, required),
+						(6, our_node_id, option),
 					});
 					if purpose.is_none() { return Ok(None); }
 
 					Ok(Some(Event::PaymentClaimed {
-						node_id,
+						our_node_id,
 						payment_hash,
 						purpose: purpose.unwrap(),
 						amount_msat,