Add PendingPaymentStore to track pending payments and replaced txids

Track pending payments with their replaced/conflicting transaction IDs
in a separate store. Pending payments are created here on WalletEvent::TxUnconfirmed,
then removed once they reach ANTI_REORG_DELAY confirmations. This avoids
scanning the entire payment store and enables efficient cleanup.

Author: Camillarhi

src/io/mod.rs

@@ -78,3 +78,7 @@ pub(crate) const BDK_WALLET_INDEXER_KEY: &str = "indexer";
 ///
 /// [`StaticInvoice`]: lightning::offers::static_invoice::StaticInvoice
 pub(crate) const STATIC_INVOICE_STORE_PRIMARY_NAMESPACE: &str = "static_invoices";
+
+/// The pending payment information will be persisted under this prefix.
+pub(crate) const PENDING_PAYMENT_INFO_PERSISTENCE_PRIMARY_NAMESPACE: &str = "pending_payments";
+pub(crate) const PENDING_PAYMENT_INFO_PERSISTENCE_SECONDARY_NAMESPACE: &str = "";

src/io/utils.rs

@@ -46,6 +46,7 @@ use crate::io::{
 	NODE_METRICS_KEY, NODE_METRICS_PRIMARY_NAMESPACE, NODE_METRICS_SECONDARY_NAMESPACE,
 };
 use crate::logger::{log_error, LdkLogger, Logger};
+use crate::payment::PendingPaymentDetails;
 use crate::peer_store::PeerStore;
 use crate::types::{Broadcaster, DynStore, KeysManager, Sweeper};
 use crate::wallet::ser::{ChangeSetDeserWrapper, ChangeSetSerWrapper};
@@ -626,6 +627,83 @@ pub(crate) fn read_bdk_wallet_change_set(
 	Ok(Some(change_set))
 }
 
+/// Read previously persisted pending payments information from the store.
+pub(crate) async fn read_pending_payments<L: Deref>(
+	kv_store: &DynStore, logger: L,
+) -> Result<Vec<PendingPaymentDetails>, std::io::Error>
+where
+	L::Target: LdkLogger,
+{
+	let mut res = Vec::new();
+
+	let mut stored_keys = KVStore::list(
+		&*kv_store,
+		PENDING_PAYMENT_INFO_PERSISTENCE_PRIMARY_NAMESPACE,
+		PENDING_PAYMENT_INFO_PERSISTENCE_SECONDARY_NAMESPACE,
+	)
+	.await?;
+
+	const BATCH_SIZE: usize = 50;
+
+	let mut set = tokio::task::JoinSet::new();
+
+	// Fill JoinSet with tasks if possible
+	while set.len() < BATCH_SIZE && !stored_keys.is_empty() {
+		if let Some(next_key) = stored_keys.pop() {
+			let fut = KVStore::read(
+				&*kv_store,
+				PENDING_PAYMENT_INFO_PERSISTENCE_PRIMARY_NAMESPACE,
+				PENDING_PAYMENT_INFO_PERSISTENCE_SECONDARY_NAMESPACE,
+				&next_key,
+			);
+			set.spawn(fut);
+			debug_assert!(set.len() <= BATCH_SIZE);
+		}
+	}
+
+	while let Some(read_res) = set.join_next().await {
+		// Exit early if we get an IO error.
+		let reader = read_res
+			.map_err(|e| {
+				log_error!(logger, "Failed to read PendingPaymentDetails: {}", e);
+				set.abort_all();
+				e
+			})?
+			.map_err(|e| {
+				log_error!(logger, "Failed to read PendingPaymentDetails: {}", e);
+				set.abort_all();
+				e
+			})?;
+
+		// Refill set for every finished future, if we still have something to do.
+		if let Some(next_key) = stored_keys.pop() {
+			let fut = KVStore::read(
+				&*kv_store,
+				PENDING_PAYMENT_INFO_PERSISTENCE_PRIMARY_NAMESPACE,
+				PENDING_PAYMENT_INFO_PERSISTENCE_SECONDARY_NAMESPACE,
+				&next_key,
+			);
+			set.spawn(fut);
+			debug_assert!(set.len() <= BATCH_SIZE);
+		}
+
+		// Handle result.
+		let pending_payment = PendingPaymentDetails::read(&mut &*reader).map_err(|e| {
+			log_error!(logger, "Failed to deserialize PendingPaymentDetails: {}", e);
+			std::io::Error::new(
+				std::io::ErrorKind::InvalidData,
+				"Failed to deserialize PendingPaymentDetails",
+			)
+		})?;
+		res.push(pending_payment);
+	}
+
+	debug_assert!(set.is_empty());
+	debug_assert!(stored_keys.is_empty());
+
+	Ok(res)
+}
+
 #[cfg(test)]
 mod tests {
 	use super::read_or_generate_seed_file;

src/payment/mod.rs

@@ -11,13 +11,15 @@ pub(crate) mod asynchronous;
 mod bolt11;
 mod bolt12;
 mod onchain;
+pub(crate) mod pending_payment_store;
 mod spontaneous;
 pub(crate) mod store;
 mod unified;
 
 pub use bolt11::Bolt11Payment;
 pub use bolt12::Bolt12Payment;
 pub use onchain::OnchainPayment;
+pub use pending_payment_store::PendingPaymentDetails;
 pub use spontaneous::SpontaneousPayment;
 pub use store::{
 	ConfirmationStatus, LSPFeeLimits, PaymentDetails, PaymentDirection, PaymentKind, PaymentStatus,

src/payment/pending_payment_store.rs

@@ -0,0 +1,93 @@
+// This file is Copyright its original authors, visible in version control history.
+//
+// This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
+// http://opensource.org/licenses/MIT>, at your option. You may not use this file except in
+// accordance with one or both of these licenses.
+
+use bitcoin::Txid;
+use lightning::{impl_writeable_tlv_based, ln::channelmanager::PaymentId};
+
+use crate::{
+	data_store::{StorableObject, StorableObjectUpdate},
+	payment::{store::PaymentDetailsUpdate, PaymentDetails},
+};
+
+/// Represents a pending payment
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct PendingPaymentDetails {
+	/// The full payment details
+	pub details: PaymentDetails,
+	/// Transaction IDs that have replaced or conflict with this payment.
+	pub conflicting_txids: Vec<Txid>,
+}
+
+impl PendingPaymentDetails {
+	pub(crate) fn new(details: PaymentDetails, conflicting_txids: Vec<Txid>) -> Self {
+		Self { details, conflicting_txids }
+	}
+
+	/// Convert to finalized payment for the main payment store
+	pub fn into_payment_details(self) -> PaymentDetails {
+		self.details
+	}
+}
+
+impl_writeable_tlv_based!(PendingPaymentDetails, {
+	(0, details, required),
+	(2, conflicting_txids, optional_vec),
+});
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) struct PendingPaymentDetailsUpdate {
+	pub id: PaymentId,
+	pub payment_update: Option<PaymentDetailsUpdate>,
+	pub conflicting_txids: Option<Vec<Txid>>,
+}
+
+impl StorableObject for PendingPaymentDetails {
+	type Id = PaymentId;
+	type Update = PendingPaymentDetailsUpdate;
+
+	fn id(&self) -> Self::Id {
+		self.details.id
+	}
+
+	fn update(&mut self, update: &Self::Update) -> bool {
+		let mut updated = false;
+
+		// Update the underlying payment details if present
+		if let Some(payment_update) = &update.payment_update {
+			updated |= self.details.update(payment_update);
+		}
+
+		if let Some(new_conflicting_txids) = &update.conflicting_txids {
+			if &self.conflicting_txids != new_conflicting_txids {
+				self.conflicting_txids = new_conflicting_txids.clone();
+				updated = true;
+			}
+		}
+
+		updated
+	}
+
+	fn to_update(&self) -> Self::Update {
+		self.into()
+	}
+}
+
+impl StorableObjectUpdate<PendingPaymentDetails> for PendingPaymentDetailsUpdate {
+	fn id(&self) -> <PendingPaymentDetails as StorableObject>::Id {
+		self.id
+	}
+}
+
+impl From<&PendingPaymentDetails> for PendingPaymentDetailsUpdate {
+	fn from(value: &PendingPaymentDetails) -> Self {
+		Self {
+			id: value.id(),
+			payment_update: Some(value.details.to_update()),
+			conflicting_txids: Some(value.conflicting_txids.clone()),
+		}
+	}
+}

src/types.rs

@@ -39,7 +39,7 @@ use crate::data_store::DataStore;
 use crate::fee_estimator::OnchainFeeEstimator;
 use crate::logger::Logger;
 use crate::message_handler::NodeCustomMessageHandler;
-use crate::payment::PaymentDetails;
+use crate::payment::{PaymentDetails, PendingPaymentDetails};
 use crate::runtime::RuntimeSpawner;
 
 /// A supertrait that requires that a type implements both [`KVStore`] and [`KVStoreSync`] at the
@@ -621,3 +621,5 @@ impl From<&(u64, Vec<u8>)> for CustomTlvRecord {
 		CustomTlvRecord { type_num: tlv.0, value: tlv.1.clone() }
 	}
 }
+
+pub(crate) type PendingPaymentStore = DataStore<PendingPaymentDetails, Arc<Logger>>;