Rename PendingPaymentDetails and add payment hash

Author: jurvis

lightning/src/ln/channelmanager.rs

@@ -1206,22 +1206,31 @@ impl ChannelDetails {
 
 /// Used to express the status of payments that are currently pending resolution.
 #[derive(Debug, PartialEq)]
-pub enum PendingPaymentDetails {
+pub enum RecentPaymentDetails {
 	/// When a payment is still being sent and awaiting successful delivery.
-	Retryable {
+	Pending {
+		/// Hash of the payment that is currently being sent but has yet to be fulfilled or
+		/// abandoned.
+		payment_hash: PaymentHash,
 		/// Total amount (in msat) across all paths for this payment, not just the amount currently
 		/// inflight.
-		total_msat: u64
+		total_msat: u64,
 	},
 	/// When a pending payment is fulfilled, we continue tracking it until all pending HTLCs have
 	/// been resolved. These payments will only cease being tracked upon receiving or handling
 	/// [`Event::PaymentSent`].
-	Fulfilled,
+	Fulfilled {
+		/// Hash of the payment that was claimed.
+		payment_hash: Option<PaymentHash>,
+	},
 	/// After a payment is explicitly abandoned by calling [`ChannelManager::abandon_payment`], they
 	/// are marked as abandoned until an [`Event::PaymentFailed`] event is generated. A payment
 	/// could also be marked as abandoned if pathfinding fails repeatedly and we will no longer
 	/// retry sending.
-	Abandoned,
+	Abandoned {
+		/// Hash of the payment that we have given up trying to send.
+		payment_hash: PaymentHash,
+	},
 }
 
 /// If a payment fails to send, it can be in one of several states. This enum is returned as the
@@ -1792,17 +1801,20 @@ impl<M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelManager<M, T, K, F
 	}
 
 	/// Gets a list of payments in ramdom order that are currently pending resolution.
-	pub fn list_pending_payments(&self) -> Vec<PendingPaymentDetails> {
+	pub fn list_pending_payments(&self) -> Vec<RecentPaymentDetails> {
 		self.pending_outbound_payments.lock().unwrap().iter()
 			.filter_map(|(_, pending_outbound_payment)| match pending_outbound_payment {
-				PendingOutboundPayment::Retryable { total_msat, .. } => {
-					Some(PendingPaymentDetails::Retryable { total_msat: *total_msat })
+				PendingOutboundPayment::Retryable { payment_hash, total_msat, .. } => {
+					Some(RecentPaymentDetails::Pending {
+						payment_hash: *payment_hash,
+						total_msat: *total_msat,
+					})
 				},
-				PendingOutboundPayment::Abandoned { .. } => {
-					Some(PendingPaymentDetails::Abandoned)
+				PendingOutboundPayment::Abandoned { payment_hash, .. } => {
+					Some(RecentPaymentDetails::Abandoned { payment_hash: *payment_hash })
 				},
-				PendingOutboundPayment::Fulfilled { .. } => {
-					Some(PendingPaymentDetails::Fulfilled)
+				PendingOutboundPayment::Fulfilled { payment_hash, .. } => {
+					Some(RecentPaymentDetails::Fulfilled { payment_hash: *payment_hash })
 				},
 				PendingOutboundPayment::Legacy { .. } => None
 			})

lightning/src/ln/payment_tests.rs

@@ -16,7 +16,7 @@ use crate::chain::channelmonitor::{ANTI_REORG_DELAY, LATENCY_GRACE_PERIOD_BLOCKS
 use crate::chain::transaction::OutPoint;
 use crate::chain::keysinterface::KeysInterface;
 use crate::ln::channel::EXPIRE_PREV_CONFIG_TICKS;
-use crate::ln::channelmanager::{self, BREAKDOWN_TIMEOUT, ChannelManager, MPP_TIMEOUT_TICKS, MIN_CLTV_EXPIRY_DELTA, PaymentId, PaymentSendFailure, IDEMPOTENCY_TIMEOUT_TICKS, PendingPaymentDetails};
+use crate::ln::channelmanager::{self, BREAKDOWN_TIMEOUT, ChannelManager, MPP_TIMEOUT_TICKS, MIN_CLTV_EXPIRY_DELTA, PaymentId, PaymentSendFailure, IDEMPOTENCY_TIMEOUT_TICKS, RecentPaymentDetails};
 use crate::ln::msgs;
 use crate::ln::msgs::ChannelMessageHandler;
 use crate::routing::router::{PaymentParameters, get_route};
@@ -1257,7 +1257,11 @@ fn test_trivial_inflight_htlc_tracking(){
 	let (_, _, chan_2_id, _) = create_announced_chan_between_nodes(&nodes, 1, 2, channelmanager::provided_init_features(), channelmanager::provided_init_features());
 
 	// Send and claim the payment. Inflight HTLCs should be empty.
-	send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 500000);
+	let (route, payment_hash, payment_preimage, payment_secret) = get_route_and_payment_hash!(nodes[0], nodes[2], 500000);
+	nodes[0].node.send_payment(&route, payment_hash, &Some(payment_secret), PaymentId(payment_hash.0)).unwrap();
+	check_added_monitors!(nodes[0], 1);
+	pass_along_route(&nodes[0], &[&vec!(&nodes[1], &nodes[2])[..]], 500000, payment_hash, payment_secret);
+	claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], payment_preimage);
 	{
 		let inflight_htlcs = node_chanmgrs[0].compute_inflight_htlcs();
 
@@ -1282,7 +1286,7 @@ fn test_trivial_inflight_htlc_tracking(){
 
 		let pending_payments = nodes[0].node.list_pending_payments();
 		assert_eq!(pending_payments.len(), 1);
-		assert_eq!(pending_payments[0], PendingPaymentDetails::Fulfilled);
+		assert_eq!(pending_payments[0], RecentPaymentDetails::Fulfilled { payment_hash: Some(payment_hash) });
 	}
 
 	// Remove fulfilled payment
@@ -1291,7 +1295,7 @@ fn test_trivial_inflight_htlc_tracking(){
 	}
 
 	// Send the payment, but do not claim it. Our inflight HTLCs should contain the pending payment.
-	let (payment_preimage, _,  _) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 500000);
+	let (payment_preimage, payment_hash,  _) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 500000);
 	{
 		let inflight_htlcs = node_chanmgrs[0].compute_inflight_htlcs();
 
@@ -1317,7 +1321,7 @@ fn test_trivial_inflight_htlc_tracking(){
 
 		let pending_payments = nodes[0].node.list_pending_payments();
 		assert_eq!(pending_payments.len(), 1);
-		assert_eq!(pending_payments[0], PendingPaymentDetails::Retryable { total_msat: 500000 });
+		assert_eq!(pending_payments[0], RecentPaymentDetails::Pending { payment_hash, total_msat: 500000 });
 	}
 
 	// Now, let's claim the payment. This should result in the used liquidity to return `None`.