Set preimages for successful payments

Author: benthecarman

orange-sdk/src/event.rs

@@ -309,6 +309,7 @@ impl Future for EventFuture {
 pub(crate) struct LdkEventHandler {
 	pub(crate) event_queue: Arc<EventQueue>,
 	pub(crate) ldk_node: Arc<ldk_node::Node>,
+	pub(crate) tx_metadata: store::TxMetadataStore,
 	pub(crate) payment_receipt_sender: watch::Sender<()>,
 	pub(crate) channel_pending_sender: watch::Sender<u128>,
 	pub(crate) logger: Arc<Logger>,
@@ -323,10 +324,17 @@ impl LdkEventHandler {
 				payment_preimage,
 				fee_paid_msat,
 			} => {
+				let preimage = payment_preimage.unwrap(); // safe
+				let payment_id = PaymentId::SelfCustodial(payment_id.unwrap().0); // safe
+
+				if self.tx_metadata.set_preimage(payment_id, preimage.0).is_err() {
+					log_error!(self.logger, "Failed to set preimage for payment {payment_id:?}");
+				}
+
 				if let Err(e) = self.event_queue.add_event(Event::PaymentSuccessful {
-					payment_id: PaymentId::SelfCustodial(payment_id.unwrap().0), // safe
+					payment_id,
 					payment_hash,
-					payment_preimage: payment_preimage.unwrap(), // safe
+					payment_preimage: preimage,
 					fee_paid_msat,
 				}) {
 					log_error!(self.logger, "Failed to add PaymentSuccessful event: {e:?}");

orange-sdk/src/lib.rs

@@ -564,6 +564,7 @@ impl Wallet {
 				config,
 				Arc::clone(&store),
 				Arc::clone(&event_queue),
+				tx_metadata.clone(),
 				Arc::clone(&logger),
 			)
 			.await?,

orange-sdk/src/lightning_wallet.rs

@@ -1,7 +1,7 @@
 use crate::bitcoin::OutPoint;
 use crate::event::{EventQueue, LdkEventHandler};
 use crate::logging::Logger;
-use crate::store::TxStatus;
+use crate::store::{TxMetadataStore, TxStatus};
 use crate::{ChainSource, InitFailure, PaymentType, Seed, WalletConfig};
 
 use bitcoin_payment_instructions::PaymentMethod;
@@ -53,7 +53,7 @@ const DEFAULT_INVOICE_EXPIRY_SECS: u32 = 86_400; // 24 hours
 impl LightningWallet {
 	pub(super) async fn init(
 		runtime: Arc<Runtime>, config: WalletConfig, store: Arc<dyn KVStore + Sync + Send>,
-		event_queue: Arc<EventQueue>, logger: Arc<Logger>,
+		event_queue: Arc<EventQueue>, tx_metadata: TxMetadataStore, logger: Arc<Logger>,
 	) -> Result<Self, InitFailure> {
 		log_info!(logger, "Creating LDK node...");
 		let anchor_channels_config = ldk_node::config::AnchorChannelsConfig {
@@ -162,6 +162,7 @@ impl LightningWallet {
 		let ev_handler = Arc::new(LdkEventHandler {
 			event_queue,
 			ldk_node: Arc::clone(&ldk_node),
+			tx_metadata,
 			payment_receipt_sender,
 			channel_pending_sender,
 			logger,

orange-sdk/src/store.rs

@@ -358,6 +358,75 @@ impl TxMetadataStore {
 			Err(())
 		}
 	}
+
+	/// Sets the preimage for an outgoing lightning payment. If the payment already has a preimage,
+	/// this is a no-op and returns Ok(()). If the payment_id does not exist in the store, or if the payment
+	/// is not an outgoing lightning payment, returns Err(()).
+	pub fn set_preimage(&self, payment_id: PaymentId, preimage: [u8; 32]) -> Result<(), ()> {
+		let mut tx_metadata = self.tx_metadata.write().unwrap();
+		if let Some(metadata) = tx_metadata.get_mut(&payment_id) {
+			match metadata.ty {
+				TxType::Payment { ty } => match ty {
+					PaymentType::OutgoingLightningBolt12 { payment_preimage } => {
+						if payment_preimage.is_some() {
+							Ok(())
+						} else {
+							metadata.ty = TxType::Payment {
+								ty: PaymentType::OutgoingLightningBolt12 {
+									payment_preimage: Some(PaymentPreimage(preimage)),
+								},
+							};
+
+							self.store
+								.write(
+									STORE_PRIMARY_KEY,
+									STORE_SECONDARY_KEY,
+									&payment_id.to_string(),
+									&metadata.encode(),
+								)
+								.expect("We do not allow writes to fail");
+							Ok(())
+						}
+					},
+					PaymentType::OutgoingLightningBolt11 { payment_preimage } => {
+						if payment_preimage.is_some() {
+							Ok(())
+						} else {
+							metadata.ty = TxType::Payment {
+								ty: PaymentType::OutgoingLightningBolt11 {
+									payment_preimage: Some(PaymentPreimage(preimage)),
+								},
+							};
+
+							self.store
+								.write(
+									STORE_PRIMARY_KEY,
+									STORE_SECONDARY_KEY,
+									&payment_id.to_string(),
+									&metadata.encode(),
+								)
+								.expect("We do not allow writes to fail");
+							Ok(())
+						}
+					},
+					_ => {
+						eprintln!(
+							"payment_id {payment_id} is not an outgoing lightning payment, cannot set preimage"
+						);
+						Err(())
+					},
+				},
+				_ => {
+					// if we're trying to set a preimage on a non-payment, just continue
+					// this should only happen when we finish a rebalance payment
+					Ok(())
+				},
+			}
+		} else {
+			eprintln!("doesn't exist in metadata store: {payment_id}");
+			Err(())
+		}
+	}
 }
 
 const REBALANCE_ENABLED_KEY: &str = "rebalance_enabled";

orange-sdk/src/trusted_wallet/cashu/mod.rs

@@ -351,12 +351,22 @@ impl TrustedWalletInterface for Cashu {
 									},
 								};
 
+								let payment_preimage =
+									preimage.unwrap_or(PaymentPreimage([0u8; 32]));
+
+								if tx_metadata.set_preimage(payment_id, payment_preimage.0).is_err()
+								{
+									log_error!(
+										logger,
+										"Failed to set preimage for payment {payment_id:?}"
+									);
+								}
+
 								let fee_paid_sat: u64 = res.fee_paid.into();
 								let _ = event_queue.add_event(Event::PaymentSuccessful {
 									payment_id,
 									payment_hash: hash,
-									payment_preimage: preimage
-										.unwrap_or(PaymentPreimage([0u8; 32])),
+									payment_preimage,
 									fee_paid_msat: Some(fee_paid_sat * 1_000), // convert to msats
 								});
 							},

orange-sdk/src/trusted_wallet/dummy.rs

@@ -111,6 +111,12 @@ impl DummyTrustedWallet {
 
 						// Send a PaymentSuccessful event if not a rebalance
 						if !is_rebalance {
+							if tx_metadata
+								.set_preimage(payment_id, payment_preimage.unwrap().0)
+								.is_err()
+							{
+								println!("Failed to set preimage for payment {payment_id:?}");
+							}
 							event_queue
 								.add_event(crate::Event::PaymentSuccessful {
 									payment_id,

orange-sdk/src/trusted_wallet/spark/mod.rs

@@ -342,6 +342,13 @@ impl SparkEventHandler {
 								TrustedError::Other(format!("Invalid payment_hash hex: {e:?}"))
 							})?;
 
+						if self.tx_metadata.set_preimage(payment_id, preimage).is_err() {
+							log_error!(
+								self.logger,
+								"Failed to set preimage for payment {payment_id:?}"
+							);
+						}
+
 						self.event_queue.add_event(Event::PaymentSuccessful {
 							payment_id,
 							payment_hash: PaymentHash(payment_hash),

orange-sdk/tests/integration_tests.rs

@@ -142,6 +142,23 @@ fn test_pay_from_trusted() {
 			wallet.get_balance().await.unwrap().trusted < bal.trusted
 		})
 		.await;
+
+		let txs = wallet.list_transactions().await.unwrap();
+		assert_eq!(txs.len(), 2);
+		let tx = txs.into_iter().find(|t| t.outbound).unwrap();
+
+		assert!(tx.fee.is_some(), "Trusted wallet send should have fees set");
+		assert!(tx.outbound, "Outgoing payment should be outbound");
+		assert_eq!(tx.status, TxStatus::Completed, "Payment should be completed");
+		match tx.payment_type {
+			PaymentType::OutgoingLightningBolt11 { payment_preimage } => {
+				assert!(
+					payment_preimage.is_some_and(|p| p.0 != [0; 32]),
+					"Completed payment should have payment_preimage"
+				);
+			},
+			pt => panic!("Payment type should be OutgoingLightningBolt11, got {pt:?}"),
+		}
 	})
 }
 
@@ -505,6 +522,15 @@ fn run_test_pay_lightning_from_self_custody(amountless: bool) {
 		);
 		assert_eq!(payment.status, TxStatus::Completed, "Payment should be completed");
 		assert_ne!(payment.time_since_epoch, Duration::ZERO, "Time should be set");
+		match payment.payment_type {
+			PaymentType::OutgoingLightningBolt11 { payment_preimage } => {
+				assert!(
+					payment_preimage.is_some_and(|p| p.0 != [0; 32]),
+					"Completed payment should have payment_preimage"
+				);
+			},
+			pt => panic!("Payment type should be OutgoingLightningBolt11, got {pt:?}"),
+		}
 
 		// Validate fee is reasonable
 		let fee_ratio = payment.fee.unwrap().milli_sats() as f64 / amount.milli_sats() as f64;