Add payment_hash to PaymentSent #999

Author: galderz

lightning/src/ln/chanmon_update_fail_tests.rs

@@ -213,7 +213,7 @@ fn do_test_simple_monitor_temporary_update_fail(disconnect: bool, persister_fail
 		_ => panic!("Unexpected event"),
 	}
 
-	claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1, 1_000_000);
+	claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1, payment_hash_1, 1_000_000);
 
 	// Now set it to failed again...
 	let (_, payment_hash_2) = get_payment_preimage_hash!(&nodes[0]);
@@ -286,7 +286,7 @@ fn do_test_monitor_temporary_update_fail(disconnect_count: usize) {
 	let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known()).2;
 	let logger = test_utils::TestLogger::new();
 
-	let (payment_preimage_1, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
+	let (payment_preimage_1, payment_hash_1) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
 
 	// Now try to send a second payment which will fail to send
 	let (payment_preimage_2, payment_hash_2) = get_payment_preimage_hash!(nodes[0]);
@@ -322,8 +322,9 @@ fn do_test_monitor_temporary_update_fail(disconnect_count: usize) {
 				let events_3 = nodes[0].node.get_and_clear_pending_events();
 				assert_eq!(events_3.len(), 1);
 				match events_3[0] {
-					Event::PaymentSent { ref payment_preimage } => {
+					Event::PaymentSent { ref payment_preimage, ref payment_hash } => {
 						assert_eq!(*payment_preimage, payment_preimage_1);
+						assert_eq!(*payment_hash, payment_hash_1);
 					},
 					_ => panic!("Unexpected event"),
 				}
@@ -414,8 +415,9 @@ fn do_test_monitor_temporary_update_fail(disconnect_count: usize) {
 			let events_3 = nodes[0].node.get_and_clear_pending_events();
 			assert_eq!(events_3.len(), 1);
 			match events_3[0] {
-				Event::PaymentSent { ref payment_preimage } => {
+				Event::PaymentSent { ref payment_preimage, ref payment_hash } => {
 					assert_eq!(*payment_preimage, payment_preimage_1);
+					assert_eq!(*payment_hash, payment_hash_1);
 				},
 				_ => panic!("Unexpected event"),
 			}
@@ -581,7 +583,7 @@ fn do_test_monitor_temporary_update_fail(disconnect_count: usize) {
 		_ => panic!("Unexpected event"),
 	}
 
-	claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2, 1_000_000);
+	claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2, payment_hash_2, 1_000_000);
 }
 
 #[test]
@@ -695,7 +697,7 @@ fn test_monitor_update_fail_cs() {
 		_ => panic!("Unexpected event"),
 	};
 
-	claim_payment(&nodes[0], &[&nodes[1]], payment_preimage, 1_000_000);
+	claim_payment(&nodes[0], &[&nodes[1]], payment_preimage, our_payment_hash, 1_000_000);
 }
 
 #[test]
@@ -746,7 +748,7 @@ fn test_monitor_update_fail_no_rebroadcast() {
 		_ => panic!("Unexpected event"),
 	}
 
-	claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1, 1_000_000);
+	claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1, our_payment_hash, 1_000_000);
 }
 
 #[test]
@@ -824,8 +826,8 @@ fn test_monitor_update_raa_while_paused() {
 	expect_pending_htlcs_forwardable!(nodes[1]);
 	expect_payment_received!(nodes[1], our_payment_hash_1, 1000000);
 
-	claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1, 1_000_000);
-	claim_payment(&nodes[1], &[&nodes[0]], payment_preimage_2, 1_000_000);
+	claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1, our_payment_hash_1, 1_000_000);
+	claim_payment(&nodes[1], &[&nodes[0]], payment_preimage_2, our_payment_hash_2, 1_000_000);
 }
 
 fn do_test_monitor_update_fail_raa(test_ignore_second_cs: bool) {
@@ -1078,10 +1080,10 @@ fn do_test_monitor_update_fail_raa(test_ignore_second_cs: bool) {
 			Event::PaymentReceived { payment_hash, .. } => assert_eq!(payment_hash, payment_hash_4.unwrap()),
 			_ => panic!("Unexpected event"),
 		};
-		claim_payment(&nodes[2], &[&nodes[1], &nodes[0]], payment_preimage_4.unwrap(), 1_000_000);
+		claim_payment(&nodes[2], &[&nodes[1], &nodes[0]], payment_preimage_4.unwrap(), payment_hash_4.unwrap(), 1_000_000);
 	}
 
-	claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage_2, 1_000_000);
+	claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage_2, payment_hash_2, 1_000_000);
 }
 
 #[test]
@@ -1288,9 +1290,9 @@ fn raa_no_response_awaiting_raa_state() {
 	expect_pending_htlcs_forwardable!(nodes[1]);
 	expect_payment_received!(nodes[1], payment_hash_3, 1000000);
 
-	claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1, 1_000_000);
-	claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2, 1_000_000);
-	claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_3, 1_000_000);
+	claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1, payment_hash_1, 1_000_000);
+	claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2, payment_hash_2, 1_000_000);
+	claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_3, payment_hash_3, 1_000_000);
 }
 
 #[test]
@@ -1309,7 +1311,7 @@ fn claim_while_disconnected_monitor_update_fail() {
 	let logger = test_utils::TestLogger::new();
 
 	// Forward a payment for B to claim
-	let (payment_preimage_1, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
+	let (payment_preimage_1, payment_hash_1) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
 
 	nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
 	nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
@@ -1410,13 +1412,14 @@ fn claim_while_disconnected_monitor_update_fail() {
 	let events = nodes[0].node.get_and_clear_pending_events();
 	assert_eq!(events.len(), 1);
 	match events[0] {
-		Event::PaymentSent { ref payment_preimage } => {
+		Event::PaymentSent { ref payment_preimage, ref payment_hash } => {
 			assert_eq!(*payment_preimage, payment_preimage_1);
+			assert_eq!(*payment_hash, payment_hash_1);
 		},
 		_ => panic!("Unexpected event"),
 	}
 
-	claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2, 1_000_000);
+	claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2, payment_hash_2, 1_000_000);
 }
 
 #[test]
@@ -1484,7 +1487,7 @@ fn monitor_failed_no_reestablish_response() {
 	expect_pending_htlcs_forwardable!(nodes[1]);
 	expect_payment_received!(nodes[1], payment_hash_1, 1000000);
 
-	claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1, 1_000_000);
+	claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1, payment_hash_1, 1_000_000);
 }
 
 #[test]
@@ -1585,8 +1588,8 @@ fn first_message_on_recv_ordering() {
 	expect_pending_htlcs_forwardable!(nodes[1]);
 	expect_payment_received!(nodes[1], payment_hash_2, 1000000);
 
-	claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1, 1_000_000);
-	claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2, 1_000_000);
+	claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1, payment_hash_1, 1_000_000);
+	claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2, payment_hash_2, 1_000_000);
 }
 
 #[test]
@@ -1741,7 +1744,7 @@ fn test_monitor_update_on_pending_forwards() {
 	nodes[0].node.process_pending_htlc_forwards();
 	expect_payment_received!(nodes[0], payment_hash_2, 1000000);
 
-	claim_payment(&nodes[2], &[&nodes[1], &nodes[0]], payment_preimage_2, 1_000_000);
+	claim_payment(&nodes[2], &[&nodes[1], &nodes[0]], payment_preimage_2, payment_hash_2, 1_000_000);
 }
 
 #[test]
@@ -1758,7 +1761,7 @@ fn monitor_update_claim_fail_no_response() {
 	let logger = test_utils::TestLogger::new();
 
 	// Forward a payment for B to claim
-	let (payment_preimage_1, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
+	let (payment_preimage_1, payment_hash_1) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
 
 	// Now start forwarding a second payment, skipping the last RAA so B is in AwaitingRAA
 	let (payment_preimage_2, payment_hash_2) = get_payment_preimage_hash!(nodes[0]);
@@ -1800,13 +1803,14 @@ fn monitor_update_claim_fail_no_response() {
 	let events = nodes[0].node.get_and_clear_pending_events();
 	assert_eq!(events.len(), 1);
 	match events[0] {
-		Event::PaymentSent { ref payment_preimage } => {
+		Event::PaymentSent { ref payment_preimage, ref payment_hash } => {
 			assert_eq!(*payment_preimage, payment_preimage_1);
+			assert_eq!(*payment_hash, payment_hash_1);
 		},
 		_ => panic!("Unexpected event"),
 	}
 
-	claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2, 1_000_000);
+	claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2, payment_hash_2, 1_000_000);
 }
 
 // confirm_a_first and restore_b_before_conf are wholly unrelated to earlier bools and
@@ -1970,5 +1974,5 @@ fn test_path_paused_mpp() {
 	assert_eq!(events.len(), 1);
 	pass_along_path(&nodes[0], &[&nodes[2], &nodes[3]], 200_000, payment_hash.clone(), Some(payment_secret), events.pop().unwrap(), true);
 
-	claim_payment_along_route_with_secret(&nodes[0], &[&[&nodes[1], &nodes[3]], &[&nodes[2], &nodes[3]]], false, payment_preimage, Some(payment_secret), 200_000);
+	claim_payment_along_route_with_secret(&nodes[0], &[&[&nodes[1], &nodes[3]], &[&nodes[2], &nodes[3]]], false, payment_preimage, payment_hash, Some(payment_secret), 200_000);
 }

lightning/src/ln/channelmanager.rs

@@ -2145,13 +2145,14 @@ impl<ChanSigner: ChannelKeys, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref>
 		} else { unreachable!(); }
 	}
 
-	fn claim_funds_internal(&self, mut channel_state_lock: MutexGuard<ChannelHolder<ChanSigner>>, source: HTLCSource, payment_preimage: PaymentPreimage) {
+	fn claim_funds_internal(&self, mut channel_state_lock: MutexGuard<ChannelHolder<ChanSigner>>, source: HTLCSource, payment_preimage: PaymentPreimage, payment_hash: PaymentHash) {
 		match source {
 			HTLCSource::OutboundRoute { .. } => {
 				mem::drop(channel_state_lock);
 				let mut pending_events = self.pending_events.lock().unwrap();
 				pending_events.push(events::Event::PaymentSent {
-					payment_preimage
+					payment_preimage,
+				    payment_hash
 				});
 			},
 			HTLCSource::PreviousHopData(hop_data) => {
@@ -2630,7 +2631,8 @@ impl<ChanSigner: ChannelKeys, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref>
 				hash_map::Entry::Vacant(_) => return Err(MsgHandleErrInternal::send_err_msg_no_close("Failed to find corresponding channel".to_owned(), msg.channel_id))
 			}
 		};
-		self.claim_funds_internal(channel_lock, htlc_source, msg.payment_preimage.clone());
+		let payment_hash = PaymentHash(Sha256::hash(&msg.payment_preimage.0).into_inner());
+		self.claim_funds_internal(channel_lock, htlc_source, msg.payment_preimage.clone(), payment_hash);
 		Ok(())
 	}
 
@@ -3018,7 +3020,7 @@ impl<ChanSigner: ChannelKeys, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref>
 					MonitorEvent::HTLCEvent(htlc_update) => {
 						if let Some(preimage) = htlc_update.payment_preimage {
 							log_trace!(self.logger, "Claiming HTLC with preimage {} from our monitor", log_bytes!(preimage.0));
-							self.claim_funds_internal(self.channel_state.lock().unwrap(), htlc_update.source, preimage);
+							self.claim_funds_internal(self.channel_state.lock().unwrap(), htlc_update.source, preimage, htlc_update.payment_hash.clone());
 						} else {
 							log_trace!(self.logger, "Failing HTLC with hash {} from our monitor", log_bytes!(htlc_update.payment_hash.0));
 							self.fail_htlc_backwards_internal(self.channel_state.lock().unwrap(), htlc_update.source, &htlc_update.payment_hash, HTLCFailReason::Reason { failure_code: 0x4000 | 8, data: Vec::new() });

lightning/src/ln/functional_test_utils.rs

@@ -821,12 +821,13 @@ macro_rules! expect_payment_received {
 }
 
 macro_rules! expect_payment_sent {
-	($node: expr, $expected_payment_preimage: expr) => {
+	($node: expr, $expected_payment_preimage: expr, $expected_payment_hash: expr) => {
 		let events = $node.node.get_and_clear_pending_events();
 		assert_eq!(events.len(), 1);
 		match events[0] {
-			Event::PaymentSent { ref payment_preimage } => {
+			Event::PaymentSent { ref payment_preimage, ref payment_hash } => {
 				assert_eq!($expected_payment_preimage, *payment_preimage);
+				assert_eq!($expected_payment_hash, *payment_hash);
 			},
 			_ => panic!("Unexpected event"),
 		}
@@ -921,7 +922,7 @@ pub fn send_along_route<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, route: Route
 	(our_payment_preimage, our_payment_hash)
 }
 
-pub fn claim_payment_along_route_with_secret<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_paths: &[&[&Node<'a, 'b, 'c>]], skip_last: bool, our_payment_preimage: PaymentPreimage, our_payment_secret: Option<PaymentSecret>, expected_amount: u64) {
+pub fn claim_payment_along_route_with_secret<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_paths: &[&[&Node<'a, 'b, 'c>]], skip_last: bool, our_payment_preimage: PaymentPreimage, our_payment_hash: PaymentHash, our_payment_secret: Option<PaymentSecret>, expected_amount: u64) {
 	for path in expected_paths.iter() {
 		assert_eq!(path.last().unwrap().node.get_our_node_id(), expected_paths[0].last().unwrap().node.get_our_node_id());
 	}
@@ -1004,17 +1005,17 @@ pub fn claim_payment_along_route_with_secret<'a, 'b, 'c>(origin_node: &Node<'a,
 
 		if !skip_last {
 			last_update_fulfill_dance!(origin_node, expected_route.first().unwrap());
-			expect_payment_sent!(origin_node, our_payment_preimage);
+			expect_payment_sent!(origin_node, our_payment_preimage, our_payment_hash);
 		}
 	}
 }
 
-pub fn claim_payment_along_route<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_route: &[&Node<'a, 'b, 'c>], skip_last: bool, our_payment_preimage: PaymentPreimage, expected_amount: u64) {
-	claim_payment_along_route_with_secret(origin_node, &[expected_route], skip_last, our_payment_preimage, None, expected_amount);
+pub fn claim_payment_along_route<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_route: &[&Node<'a, 'b, 'c>], skip_last: bool, our_payment_preimage: PaymentPreimage, our_payment_hash: PaymentHash, expected_amount: u64) {
+	claim_payment_along_route_with_secret(origin_node, &[expected_route], skip_last, our_payment_preimage, our_payment_hash, None, expected_amount);
 }
 
-pub fn claim_payment<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_route: &[&Node<'a, 'b, 'c>], our_payment_preimage: PaymentPreimage, expected_amount: u64) {
-	claim_payment_along_route(origin_node, expected_route, false, our_payment_preimage, expected_amount);
+pub fn claim_payment<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_route: &[&Node<'a, 'b, 'c>], our_payment_preimage: PaymentPreimage, our_payment_hash: PaymentHash, expected_amount: u64) {
+	claim_payment_along_route(origin_node, expected_route, false, our_payment_preimage, our_payment_hash, expected_amount);
 }
 
 pub const TEST_FINAL_CLTV: u32 = 32;
@@ -1048,8 +1049,8 @@ pub fn route_over_limit<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_rou
 }
 
 pub fn send_payment<'a, 'b, 'c>(origin: &Node<'a, 'b, 'c>, expected_route: &[&Node<'a, 'b, 'c>], recv_value: u64, expected_value: u64)  {
-	let our_payment_preimage = route_payment(&origin, expected_route, recv_value).0;
-	claim_payment(&origin, expected_route, our_payment_preimage, expected_value);
+	let (our_payment_preimage, our_payment_hash) = route_payment(&origin, expected_route, recv_value);
+	claim_payment(&origin, expected_route, our_payment_preimage, our_payment_hash, expected_value);
 }
 
 pub fn fail_payment_along_route<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_route: &[&Node<'a, 'b, 'c>], skip_last: bool, our_payment_hash: PaymentHash)  {