Update the payment store in event handling

.. depending on the payment purpose, we derive the inbound payment ID
and update the status in `PaymentClaimable`/`PaymentClaimed`

Author: tnull

src/event.rs

@@ -435,7 +435,9 @@ where
 			} => {
 				let payment_id = PaymentId(payment_hash.0);
 				if let Some(info) = self.payment_store.get(&payment_id) {
-					if info.status == PaymentStatus::Succeeded {
+					if info.status == PaymentStatus::Succeeded
+						|| matches!(info.kind, PaymentKind::Spontaneous { .. })
+					{
 						log_info!(
 							self.logger,
 							"Refused duplicate inbound payment from payment hash {} of {}msat",
@@ -483,6 +485,7 @@ where
 						self.channel_manager.fail_htlc_backwards(&payment_hash);
 
 						let update = PaymentDetailsUpdate {
+							hash: Some(Some(payment_hash)),
 							status: Some(PaymentStatus::Failed),
 							..PaymentDetailsUpdate::new(payment_id)
 						};
@@ -501,126 +504,56 @@ where
 					amount_msat,
 				);
 				let payment_preimage = match purpose {
-					PaymentPurpose::Bolt11InvoicePayment { payment_preimage, payment_secret } => {
-						if payment_preimage.is_some() {
-							payment_preimage
-						} else {
-							self.channel_manager
-								.get_payment_preimage(payment_hash, payment_secret)
-								.ok()
-						}
-					},
-					PaymentPurpose::Bolt12OfferPayment { .. } => {
-						// TODO: support BOLT12.
-						log_error!(
-							self.logger,
-							"Failed to claim unsupported BOLT12 payment with hash: {}",
-							payment_hash
-						);
-						self.channel_manager.fail_htlc_backwards(&payment_hash);
-						return;
+					PaymentPurpose::Bolt11InvoicePayment { payment_preimage, .. } => {
+						payment_preimage
 					},
-					PaymentPurpose::Bolt12RefundPayment { .. } => {
-						// TODO: support BOLT12.
-						log_error!(
-							self.logger,
-							"Failed to claim unsupported BOLT12 payment with hash: {}",
-							payment_hash
-						);
-						self.channel_manager.fail_htlc_backwards(&payment_hash);
-						return;
-					},
-					PaymentPurpose::SpontaneousPayment(preimage) => Some(preimage),
-				};
-
-				if let Some(preimage) = payment_preimage {
-					self.channel_manager.claim_funds(preimage);
-				} else {
-					log_error!(
-						self.logger,
-						"Failed to claim payment with hash {}: preimage unknown.",
-						hex_utils::to_string(&payment_hash.0),
-					);
-					self.channel_manager.fail_htlc_backwards(&payment_hash);
-
-					let update = PaymentDetailsUpdate {
-						status: Some(PaymentStatus::Failed),
-						..PaymentDetailsUpdate::new(payment_id)
-					};
-					self.payment_store.update(&update).unwrap_or_else(|e| {
-						log_error!(self.logger, "Failed to access payment store: {}", e);
-						panic!("Failed to access payment store");
-					});
-				}
-			},
-			LdkEvent::PaymentClaimed {
-				payment_hash,
-				purpose,
-				amount_msat,
-				receiver_node_id: _,
-				htlcs: _,
-				sender_intended_total_msat: _,
-			} => {
-				log_info!(
-					self.logger,
-					"Claimed payment from payment hash {} of {}msat.",
-					hex_utils::to_string(&payment_hash.0),
-					amount_msat,
-				);
-				let payment_id = PaymentId(payment_hash.0);
-				match purpose {
-					PaymentPurpose::Bolt11InvoicePayment {
+					PaymentPurpose::Bolt12OfferPayment {
 						payment_preimage,
 						payment_secret,
+						payment_context,
 						..
 					} => {
-						let update = PaymentDetailsUpdate {
-							preimage: Some(payment_preimage),
-							secret: Some(Some(payment_secret)),
-							amount_msat: Some(Some(amount_msat)),
-							status: Some(PaymentStatus::Succeeded),
-							..PaymentDetailsUpdate::new(payment_id)
+						let offer_id = payment_context.offer_id;
+						let payment = PaymentDetails {
+							id: payment_id,
+							kind: PaymentKind::Bolt12Offer {
+								hash: Some(payment_hash),
+								preimage: payment_preimage,
+								secret: Some(payment_secret),
+								offer_id,
+							},
+							amount_msat: Some(amount_msat),
+							direction: PaymentDirection::Inbound,
+							status: PaymentStatus::Pending,
 						};
-						match self.payment_store.update(&update) {
-							Ok(true) => (),
-							Ok(false) => {
+
+						match self.payment_store.insert(payment) {
+							Ok(false) => (),
+							Ok(true) => {
 								log_error!(
 									self.logger,
-									"Payment with hash {} couldn't be found in store",
-									hex_utils::to_string(&payment_hash.0)
+									"Bolt12OfferPayment with ID {} was previously known",
+									payment_id,
 								);
 								debug_assert!(false);
 							},
 							Err(e) => {
 								log_error!(
 									self.logger,
-									"Failed to update payment with hash {}: {}",
-									hex_utils::to_string(&payment_hash.0),
+									"Failed to insert payment with ID {}: {}",
+									payment_id,
 									e
 								);
 								debug_assert!(false);
 							},
 						}
+						payment_preimage
 					},
-					PaymentPurpose::Bolt12OfferPayment { .. } => {
-						// TODO: support BOLT12.
-						log_error!(
-							self.logger,
-							"Failed to claim unsupported BOLT12 payment with hash: {}",
-							payment_hash
-						);
-						return;
-					},
-					PaymentPurpose::Bolt12RefundPayment { .. } => {
-						// TODO: support BOLT12.
-						log_error!(
-							self.logger,
-							"Failed to claim unsupported BOLT12 payment with hash: {}",
-							payment_hash
-						);
-						return;
+					PaymentPurpose::Bolt12RefundPayment { payment_preimage, .. } => {
+						payment_preimage
 					},
 					PaymentPurpose::SpontaneousPayment(preimage) => {
+						// Since it's spontaneous, we insert it now into our store.
 						let payment = PaymentDetails {
 							id: payment_id,
 							kind: PaymentKind::Spontaneous {
@@ -629,32 +562,133 @@ where
 							},
 							amount_msat: Some(amount_msat),
 							direction: PaymentDirection::Inbound,
-							status: PaymentStatus::Succeeded,
+							status: PaymentStatus::Pending,
 						};
 
 						match self.payment_store.insert(payment) {
 							Ok(false) => (),
 							Ok(true) => {
 								log_error!(
 									self.logger,
-									"Spontaneous payment with hash {} was previously known",
-									hex_utils::to_string(&payment_hash.0)
+									"Spontaneous payment with ID {} was previously known",
+									payment_id,
 								);
 								debug_assert!(false);
 							},
 							Err(e) => {
 								log_error!(
 									self.logger,
-									"Failed to insert payment with hash {}: {}",
-									hex_utils::to_string(&payment_hash.0),
+									"Failed to insert payment with ID {}: {}",
+									payment_id,
 									e
 								);
 								debug_assert!(false);
 							},
 						}
+
+						Some(preimage)
 					},
 				};
 
+				if let Some(preimage) = payment_preimage {
+					self.channel_manager.claim_funds(preimage);
+				} else {
+					log_error!(
+						self.logger,
+						"Failed to claim payment with ID {}: preimage unknown.",
+						payment_id,
+					);
+					self.channel_manager.fail_htlc_backwards(&payment_hash);
+
+					let update = PaymentDetailsUpdate {
+						hash: Some(Some(payment_hash)),
+						status: Some(PaymentStatus::Failed),
+						..PaymentDetailsUpdate::new(payment_id)
+					};
+					self.payment_store.update(&update).unwrap_or_else(|e| {
+						log_error!(self.logger, "Failed to access payment store: {}", e);
+						panic!("Failed to access payment store");
+					});
+				}
+			},
+			LdkEvent::PaymentClaimed {
+				payment_hash,
+				purpose,
+				amount_msat,
+				receiver_node_id: _,
+				htlcs: _,
+				sender_intended_total_msat: _,
+			} => {
+				let payment_id = PaymentId(payment_hash.0);
+				log_info!(
+					self.logger,
+					"Claimed payment with ID {} from payment hash {} of {}msat.",
+					payment_id,
+					hex_utils::to_string(&payment_hash.0),
+					amount_msat,
+				);
+
+				let update = match purpose {
+					PaymentPurpose::Bolt11InvoicePayment {
+						payment_preimage,
+						payment_secret,
+						..
+					} => PaymentDetailsUpdate {
+						preimage: Some(payment_preimage),
+						secret: Some(Some(payment_secret)),
+						amount_msat: Some(Some(amount_msat)),
+						status: Some(PaymentStatus::Succeeded),
+						..PaymentDetailsUpdate::new(payment_id)
+					},
+					PaymentPurpose::Bolt12OfferPayment {
+						payment_preimage, payment_secret, ..
+					} => PaymentDetailsUpdate {
+						preimage: Some(payment_preimage),
+						secret: Some(Some(payment_secret)),
+						amount_msat: Some(Some(amount_msat)),
+						status: Some(PaymentStatus::Succeeded),
+						..PaymentDetailsUpdate::new(payment_id)
+					},
+					PaymentPurpose::Bolt12RefundPayment {
+						payment_preimage,
+						payment_secret,
+						..
+					} => PaymentDetailsUpdate {
+						preimage: Some(payment_preimage),
+						secret: Some(Some(payment_secret)),
+						amount_msat: Some(Some(amount_msat)),
+						status: Some(PaymentStatus::Succeeded),
+						..PaymentDetailsUpdate::new(payment_id)
+					},
+					PaymentPurpose::SpontaneousPayment(preimage) => PaymentDetailsUpdate {
+						preimage: Some(Some(preimage)),
+						amount_msat: Some(Some(amount_msat)),
+						status: Some(PaymentStatus::Succeeded),
+						..PaymentDetailsUpdate::new(payment_id)
+					},
+				};
+
+				match self.payment_store.update(&update) {
+					Ok(true) => (),
+					Ok(false) => {
+						log_error!(
+							self.logger,
+							"Payment with ID {} couldn't be found in store",
+							payment_id,
+						);
+						debug_assert!(false);
+					},
+					Err(e) => {
+						log_error!(
+							self.logger,
+							"Failed to update payment with ID {}: {}",
+							payment_id,
+							e
+						);
+						panic!("Failed to access payment store");
+					},
+				}
+
 				self.event_queue
 					.add_event(Event::PaymentReceived {
 						payment_id: Some(payment_id),
@@ -681,6 +715,7 @@ where
 				};
 
 				let update = PaymentDetailsUpdate {
+					hash: Some(Some(payment_hash)),
 					preimage: Some(Some(payment_preimage)),
 					status: Some(PaymentStatus::Succeeded),
 					..PaymentDetailsUpdate::new(payment_id)
@@ -727,6 +762,7 @@ where
 				);
 
 				let update = PaymentDetailsUpdate {
+					hash: Some(Some(payment_hash)),
 					status: Some(PaymentStatus::Failed),
 					..PaymentDetailsUpdate::new(payment_id)
 				};

src/payment/store.rs

@@ -357,7 +357,8 @@ where
 						*hash = hash_opt
 					},
 					_ => {
-						// We can omit updating the hash for BOLT11 payments as the payment has will always be known from the beginning.
+						// We can omit updating the hash for BOLT11 payments as the payment hash
+						// will always be known from the beginning.
 					},
 				}
 			}