f Do updates via ChannelDetailsUpdate

Author: tnull

src/event.rs

@@ -1,6 +1,7 @@
-use crate::{
-	hex_utils, ChannelManager, Config, Error, KeysManager, NetworkGraph, PaymentDetails,
-	PaymentDirection, PaymentStatus, PaymentStore, Wallet,
+use crate::{hex_utils, ChannelManager, Config, Error, KeysManager, NetworkGraph, Wallet};
+
+use crate::payment_store::{
+	PaymentDetails, PaymentDetailsUpdate, PaymentDirection, PaymentStatus, PaymentStore,
 };
 
 use crate::io::{
@@ -338,9 +339,10 @@ where
 							amount_msat,
 						);
 						self.channel_manager.fail_htlc_backwards(&payment_hash);
-						self.payment_store
-							.update(&payment_hash, None, None, None, Some(PaymentStatus::Failed))
-							.expect("Failed to access payment store");
+
+						let mut update = PaymentDetailsUpdate::new(payment_hash);
+						update.status = Some(PaymentStatus::Failed);
+						self.payment_store.update(&update).expect("Failed to access payment store");
 						return;
 					}
 				}
@@ -373,9 +375,10 @@ where
 						hex_utils::to_string(&payment_hash.0),
 					);
 					self.channel_manager.fail_htlc_backwards(&payment_hash);
-					self.payment_store
-						.update(&payment_hash, None, None, None, Some(PaymentStatus::Failed))
-						.expect("Failed to access payment store");
+
+					let mut update = PaymentDetailsUpdate::new(payment_hash);
+					update.status = Some(PaymentStatus::Failed);
+					self.payment_store.update(&update).expect("Failed to access payment store");
 				}
 			}
 			LdkEvent::PaymentClaimed {
@@ -392,13 +395,12 @@ where
 				);
 				match purpose {
 					PaymentPurpose::InvoicePayment { payment_preimage, payment_secret, .. } => {
-						match self.payment_store.update(
-							&payment_hash,
-							Some(payment_preimage),
-							Some(Some(payment_secret)),
-							Some(Some(amount_msat)),
-							Some(PaymentStatus::Succeeded),
-						) {
+						let mut update = PaymentDetailsUpdate::new(payment_hash);
+						update.preimage = Some(payment_preimage);
+						update.secret = Some(Some(payment_secret));
+						update.amount_msat = Some(Some(amount_msat));
+						update.status = Some(PaymentStatus::Succeeded);
+						match self.payment_store.update(&update) {
 							Ok(true) => (),
 							Ok(false) => {
 								log_error!(
@@ -488,9 +490,9 @@ where
 					hex_utils::to_string(&payment_hash.0)
 				);
 
-				self.payment_store
-					.update(&payment_hash, None, None, None, Some(PaymentStatus::Failed))
-					.expect("Failed to access payment store");
+				let mut update = PaymentDetailsUpdate::new(payment_hash);
+				update.status = Some(PaymentStatus::Failed);
+				self.payment_store.update(&update).expect("Failed to access payment store");
 				self.event_queue
 					.add_event(Event::PaymentFailed { payment_hash })
 					.expect("Failed to push to event queue");

src/payment_store.rs

@@ -39,7 +39,7 @@ impl_writeable_tlv_based!(PaymentDetails, {
 });
 
 /// Represents the direction of a payment.
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
 pub enum PaymentDirection {
 	/// The payment is inbound.
 	Inbound,
@@ -53,7 +53,7 @@ impl_writeable_tlv_based_enum!(PaymentDirection,
 );
 
 /// Represents the current status of a payment.
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
 pub enum PaymentStatus {
 	/// The payment is still pending.
 	Pending,
@@ -69,6 +69,29 @@ impl_writeable_tlv_based_enum!(PaymentStatus,
 	(2, Failed) => {};
 );
 
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) struct PaymentDetailsUpdate {
+	pub hash: PaymentHash,
+	pub preimage: Option<Option<PaymentPreimage>>,
+	pub secret: Option<Option<PaymentSecret>>,
+	pub amount_msat: Option<Option<u64>>,
+	pub direction: Option<PaymentDirection>,
+	pub status: Option<PaymentStatus>,
+}
+
+impl PaymentDetailsUpdate {
+	pub fn new(hash: PaymentHash) -> Self {
+		Self {
+			hash,
+			preimage: None,
+			secret: None,
+			amount_msat: None,
+			direction: None,
+			status: None,
+		}
+	}
+}
+
 pub(crate) struct PaymentStore<K: Deref + Clone, L: Deref>
 where
 	K::Target: KVStore,
@@ -122,32 +145,28 @@ where
 		self.payments.lock().unwrap().contains_key(hash)
 	}
 
-	pub(crate) fn update(
-		&self, hash: &PaymentHash, update_preimage: Option<Option<PaymentPreimage>>,
-		update_secret: Option<Option<PaymentSecret>>, update_amount_msat: Option<Option<u64>>,
-		update_status: Option<PaymentStatus>,
-	) -> Result<bool, Error> {
+	pub(crate) fn update(&self, update: &PaymentDetailsUpdate) -> Result<bool, Error> {
 		let mut updated = false;
 		let mut locked_payments = self.payments.lock().unwrap();
 
-		if let Some(payment) = locked_payments.get_mut(hash) {
-			if let Some(preimage_opt) = update_preimage {
+		if let Some(payment) = locked_payments.get_mut(&update.hash) {
+			if let Some(preimage_opt) = update.preimage {
 				payment.preimage = preimage_opt;
 			}
 
-			if let Some(secret_opt) = update_secret {
+			if let Some(secret_opt) = update.secret {
 				payment.secret = secret_opt;
 			}
 
-			if let Some(amount_opt) = update_amount_msat {
+			if let Some(amount_opt) = update.amount_msat {
 				payment.amount_msat = amount_opt;
 			}
 
-			if let Some(status) = update_status {
+			if let Some(status) = update.status {
 				payment.status = status;
 			}
 
-			self.write_info_and_commit(hash, payment)?;
+			self.write_info_and_commit(&update.hash, payment)?;
 			updated = true;
 		}
 
@@ -237,10 +256,9 @@ mod tests {
 		assert_eq!(Ok(true), payment_store.insert(payment));
 		assert!(store.get_and_clear_did_persist());
 
-		assert_eq!(
-			Ok(true),
-			payment_store.update(&hash, None, None, None, Some(PaymentStatus::Succeeded))
-		);
+		let mut update = PaymentDetailsUpdate::new(hash);
+		update.status = Some(PaymentStatus::Succeeded);
+		assert_eq!(Ok(true), payment_store.update(&update));
 		assert!(store.get_and_clear_did_persist());
 
 		assert_eq!(PaymentStatus::Succeeded, payment_store.get(&hash).unwrap().status);