WIP switch to PaymentId fully

.. will require Payment metadata store

Author: tnull

bindings/ldk_node.udl

@@ -214,9 +214,9 @@ interface Bolt11Payment {
 	[Throws=NodeError]
 	void send_probes_using_amount([ByRef]Bolt11Invoice invoice, u64 amount_msat, RouteParametersConfig? route_parameters);
 	[Throws=NodeError]
-	void claim_for_hash(PaymentHash payment_hash, u64 claimable_amount_msat, PaymentPreimage preimage);
+	void claim_for_id(PaymentId payment_id, u64 claimable_amount_msat, PaymentPreimage preimage);
 	[Throws=NodeError]
-	void fail_for_hash(PaymentHash payment_hash);
+	void fail_for_id(PaymentId payment_id);
 	[Throws=NodeError]
 	Bolt11Invoice receive(u64 amount_msat, [ByRef]Bolt11InvoiceDescription description, u32 expiry_secs);
 	[Throws=NodeError]

src/event.rs

@@ -635,9 +635,10 @@ where
 				claim_deadline,
 				onion_fields,
 				counterparty_skimmed_fee_msat,
+				payment_id,
 				..
 			} => {
-				let payment_id = PaymentId(payment_hash.0);
+				let payment_id = payment_id.unwrap_or(PaymentId(payment_hash.0));
 				if let Some(info) = self.payment_store.get(&payment_id) {
 					if info.direction == PaymentDirection::Outbound {
 						log_info!(
@@ -744,46 +745,6 @@ where
 							_ => debug_assert!(false, "We only expect the counterparty to get away with withholding fees for JIT payments."),
 						}
 					}
-
-					// If this is known by the store but ChannelManager doesn't know the preimage,
-					// the payment has been registered via `_for_hash` variants and needs to be manually claimed via
-					// user interaction.
-					match info.kind {
-						PaymentKind::Bolt11 { preimage, .. }
-						| PaymentKind::Bolt11Jit { preimage, .. } => {
-							if purpose.preimage().is_none() {
-								debug_assert!(
-									preimage.is_none(),
-									"We would have registered the preimage if we knew"
-								);
-
-								let custom_records = onion_fields
-									.map(|cf| {
-										cf.custom_tlvs().into_iter().map(|tlv| tlv.into()).collect()
-									})
-									.unwrap_or_default();
-								let event = Event::PaymentClaimable {
-									payment_id,
-									payment_hash,
-									claimable_amount_msat: amount_msat,
-									claim_deadline,
-									custom_records,
-								};
-								match self.event_queue.add_event(event).await {
-									Ok(_) => return Ok(()),
-									Err(e) => {
-										log_error!(
-											self.logger,
-											"Failed to push to event queue: {}",
-											e
-										);
-										return Err(ReplayEvent());
-									},
-								};
-							}
-						},
-						_ => {},
-					}
 				}
 
 				log_info!(
@@ -793,7 +754,46 @@ where
 					amount_msat,
 				);
 				let payment_preimage = match purpose {
-					PaymentPurpose::Bolt11InvoicePayment { payment_preimage, .. } => {
+					PaymentPurpose::Bolt11InvoicePayment {
+						payment_preimage,
+						payment_secret,
+						..
+					} => {
+						let kind = PaymentKind::Bolt11 {
+							hash: payment_hash,
+							preimage: payment_preimage,
+							secret: Some(payment_secret),
+						};
+
+						let payment = PaymentDetails::new(
+							payment_id,
+							kind,
+							Some(amount_msat),
+							None,
+							PaymentDirection::Inbound,
+							PaymentStatus::Pending,
+						);
+
+						match self.payment_store.insert(payment) {
+							Ok(false) => (),
+							Ok(true) => {
+								log_error!(
+									self.logger,
+									"Bolt11InvoicePayment with ID {} was previously known",
+									payment_id,
+								);
+								debug_assert!(false);
+							},
+							Err(e) => {
+								log_error!(
+									self.logger,
+									"Failed to insert payment with ID {}: {}",
+									payment_id,
+									e
+								);
+								debug_assert!(false);
+							},
+						}
 						payment_preimage
 					},
 					PaymentPurpose::Bolt12OfferPayment {
@@ -892,25 +892,47 @@ where
 				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.",
+					// If ChannelManager doesn't know the preimage the payment  needs to be
+					// manually claimed via user interaction.
+					//if purpose.preimage().is_none() {
+					let custom_records = onion_fields
+						.map(|cf| cf.custom_tlvs().into_iter().map(|tlv| tlv.into()).collect())
+						.unwrap_or_default();
+					let event = Event::PaymentClaimable {
 						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)
+						payment_hash,
+						claimable_amount_msat: amount_msat,
+						claim_deadline,
+						custom_records,
 					};
-					match self.payment_store.update(&update) {
+					match self.event_queue.add_event(event).await {
 						Ok(_) => return Ok(()),
 						Err(e) => {
-							log_error!(self.logger, "Failed to access payment store: {}", e);
+							log_error!(self.logger, "Failed to push to event queue: {}", e);
 							return Err(ReplayEvent());
 						},
 					};
+					//}
+
+					//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)
+					//};
+					//match self.payment_store.update(&update) {
+					//	Ok(_) => return Ok(()),
+					//	Err(e) => {
+					//		log_error!(self.logger, "Failed to access payment store: {}", e);
+					//		return Err(ReplayEvent());
+					//	},
+					//};
 				}
 			},
 			LdkEvent::PaymentClaimed {
@@ -921,9 +943,9 @@ where
 				htlcs: _,
 				sender_intended_total_msat: _,
 				onion_fields,
-				payment_id: _,
+				payment_id,
 			} => {
-				let payment_id = PaymentId(payment_hash.0);
+				let payment_id = payment_id.unwrap_or(PaymentId(payment_hash.0));
 				log_info!(
 					self.logger,
 					"Claimed payment with ID {} from payment hash {} of {}msat.",