Add RBF replacement tracking with new persisted lookup table

Introduce a new lookup `ReplacedTransactionStore` that maps old/replaced
transaction IDs to their current replacement transaction IDs, enabling
reliable tracking of replaced transactions throughout the replacement chain.

Key changes:
- Add persisted storage for RBF replacement relationships
- Link transactions in replacement trees using payment IDs
- Remove entire replacement chains from persistence when any transaction
  in the tree is confirmed

Author: Camillarhi

src/builder.rs

@@ -55,12 +55,13 @@ use crate::gossip::GossipSource;
 use crate::io::sqlite_store::SqliteStore;
 use crate::io::utils::{
 	read_event_queue, read_external_pathfinding_scores_from_cache, read_network_graph,
-	read_node_metrics, read_output_sweeper, read_payments, read_peer_info, read_scorer,
-	write_node_metrics,
+	read_node_metrics, read_output_sweeper, read_payments, read_peer_info, read_replaced_txs,
+	read_scorer, write_node_metrics,
 };
 use crate::io::vss_store::VssStoreBuilder;
 use crate::io::{
 	self, PAYMENT_INFO_PERSISTENCE_PRIMARY_NAMESPACE, PAYMENT_INFO_PERSISTENCE_SECONDARY_NAMESPACE,
+	REPLACED_TX_PERSISTENCE_PRIMARY_NAMESPACE, REPLACED_TX_PERSISTENCE_SECONDARY_NAMESPACE,
 };
 use crate::liquidity::{
 	LSPS1ClientConfig, LSPS2ClientConfig, LSPS2ServiceConfig, LiquiditySourceBuilder,
@@ -73,7 +74,8 @@ use crate::runtime::Runtime;
 use crate::tx_broadcaster::TransactionBroadcaster;
 use crate::types::{
 	ChainMonitor, ChannelManager, DynStore, DynStoreWrapper, GossipSync, Graph, KeysManager,
-	MessageRouter, OnionMessenger, PaymentStore, PeerManager, Persister, SyncAndAsyncKVStore,
+	MessageRouter, OnionMessenger, PaymentStore, PeerManager, Persister, ReplacedTransactionStore,
+	SyncAndAsyncKVStore,
 };
 use crate::wallet::persist::KVStoreWalletPersister;
 use crate::wallet::Wallet;
@@ -1235,6 +1237,21 @@ fn build_with_store_internal(
 		},
 	};
 
+	let replaced_tx_store = match runtime
+		.block_on(async { read_replaced_txs(&*kv_store, Arc::clone(&logger)).await })
+	{
+		Ok(replaced_txs) => Arc::new(ReplacedTransactionStore::new(
+			replaced_txs,
+			REPLACED_TX_PERSISTENCE_PRIMARY_NAMESPACE.to_string(),
+			REPLACED_TX_PERSISTENCE_SECONDARY_NAMESPACE.to_string(),
+			Arc::clone(&kv_store),
+			Arc::clone(&logger),
+		)),
+		Err(e) => {
+			log_error!(logger, "Failed to read replaced transaction data from store: {}", e);
+			return Err(BuildError::ReadFailed);
+		},
+	};
 	let wallet = Arc::new(Wallet::new(
 		bdk_wallet,
 		wallet_persister,
@@ -1243,6 +1260,7 @@ fn build_with_store_internal(
 		Arc::clone(&payment_store),
 		Arc::clone(&config),
 		Arc::clone(&logger),
+		Arc::clone(&replaced_tx_store),
 	));
 
 	// Initialize the KeysManager

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 replaced transaction information will be persisted under this prefix.
+pub(crate) const REPLACED_TX_PERSISTENCE_PRIMARY_NAMESPACE: &str = "replaced_txs";
+pub(crate) const REPLACED_TX_PERSISTENCE_SECONDARY_NAMESPACE: &str = "";

src/io/utils.rs

@@ -44,6 +44,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::ReplacedOnchainTransactionDetails;
 use crate::peer_store::PeerStore;
 use crate::types::{Broadcaster, DynStore, KeysManager, Sweeper};
 use crate::wallet::ser::{ChangeSetDeserWrapper, ChangeSetSerWrapper};
@@ -620,6 +621,83 @@ pub(crate) fn read_bdk_wallet_change_set(
 	Ok(Some(change_set))
 }
 
+/// Read previously persisted replaced transaction information from the store.
+pub(crate) async fn read_replaced_txs<L: Deref>(
+	kv_store: &DynStore, logger: L,
+) -> Result<Vec<ReplacedOnchainTransactionDetails>, std::io::Error>
+where
+	L::Target: LdkLogger,
+{
+	let mut res = Vec::new();
+
+	let mut stored_keys = KVStore::list(
+		&*kv_store,
+		REPLACED_TX_PERSISTENCE_PRIMARY_NAMESPACE,
+		REPLACED_TX_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,
+				REPLACED_TX_PERSISTENCE_PRIMARY_NAMESPACE,
+				REPLACED_TX_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 ReplacedOnchainTransactionDetails: {}", e);
+				set.abort_all();
+				e
+			})?
+			.map_err(|e| {
+				log_error!(logger, "Failed to read ReplacedOnchainTransactionDetails: {}", 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,
+				REPLACED_TX_PERSISTENCE_PRIMARY_NAMESPACE,
+				REPLACED_TX_PERSISTENCE_SECONDARY_NAMESPACE,
+				&next_key,
+			);
+			set.spawn(fut);
+			debug_assert!(set.len() <= BATCH_SIZE);
+		}
+
+		// Handle result.
+		let payment = ReplacedOnchainTransactionDetails::read(&mut &*reader).map_err(|e| {
+			log_error!(logger, "Failed to deserialize ReplacedOnchainTransactionDetails: {}", e);
+			std::io::Error::new(
+				std::io::ErrorKind::InvalidData,
+				"Failed to deserialize ReplacedOnchainTransactionDetails",
+			)
+		})?;
+		res.push(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;
+mod replaced_transaction_store;
 mod spontaneous;
 pub(crate) mod store;
 mod unified;
 
 pub use bolt11::Bolt11Payment;
 pub use bolt12::Bolt12Payment;
 pub use onchain::OnchainPayment;
+pub use replaced_transaction_store::ReplacedOnchainTransactionDetails;
 pub use spontaneous::SpontaneousPayment;
 pub use store::{
 	ConfirmationStatus, LSPFeeLimits, PaymentDetails, PaymentDirection, PaymentKind, PaymentStatus,

src/payment/replaced_transaction_store.rs

@@ -0,0 +1,77 @@
+// 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;
+use lightning::ln::channelmanager::PaymentId;
+
+use crate::data_store::{StorableObject, StorableObjectId, StorableObjectUpdate};
+
+/// Details of an on-chain transaction that has replaced a previous transaction (e.g., via RBF).
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct ReplacedOnchainTransactionDetails {
+	/// The new transaction ID.
+	pub new_txid: Txid,
+	/// The original transaction ID that was replaced.
+	pub original_txid: Txid,
+	/// The payment ID associated with the transaction.
+	pub payment_id: PaymentId,
+}
+
+impl ReplacedOnchainTransactionDetails {
+	pub(crate) fn new(new_txid: Txid, original_txid: Txid, payment_id: PaymentId) -> Self {
+		Self { new_txid, original_txid, payment_id }
+	}
+}
+
+impl_writeable_tlv_based!(ReplacedOnchainTransactionDetails,{
+	(0, new_txid, required),
+	(2, original_txid, required),
+	(4, payment_id, required),
+});
+
+impl StorableObjectId for Txid {
+	fn encode_to_hex_str(&self) -> String {
+		self.to_string()
+	}
+}
+impl StorableObject for ReplacedOnchainTransactionDetails {
+	type Id = Txid;
+	type Update = ReplacedOnchainTransactionDetailsUpdate;
+
+	fn id(&self) -> Self::Id {
+		self.new_txid
+	}
+
+	fn update(&mut self, _update: &Self::Update) -> bool {
+		// We don't update, we delete on confirmation
+		false
+	}
+
+	fn to_update(&self) -> Self::Update {
+		self.into()
+	}
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) struct ReplacedOnchainTransactionDetailsUpdate {
+	pub id: Txid,
+}
+
+impl From<&ReplacedOnchainTransactionDetails> for ReplacedOnchainTransactionDetailsUpdate {
+	fn from(value: &ReplacedOnchainTransactionDetails) -> Self {
+		Self { id: value.new_txid }
+	}
+}
+
+impl StorableObjectUpdate<ReplacedOnchainTransactionDetails>
+	for ReplacedOnchainTransactionDetailsUpdate
+{
+	fn id(&self) -> <ReplacedOnchainTransactionDetails as StorableObject>::Id {
+		self.id
+	}
+}

src/types.rs

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