Track reorged on-chain payments as pending

Move affected on-chain payments back to pending when BDK reports that
their transaction is unconfirmed again.

This keeps payment history aligned with wallet events after a reorg. It
does not update payment records directly from disconnected-block
notifications.

Co-Authored-By: HAL 9000

Author: tnull

src/payment/pending_payment_store.rs

@@ -11,7 +11,7 @@ use lightning::ln::channelmanager::PaymentId;
 
 use crate::data_store::{StorableObject, StorableObjectUpdate};
 use crate::payment::store::PaymentDetailsUpdate;
-use crate::payment::PaymentDetails;
+use crate::payment::{PaymentDetails, PaymentKind};
 
 /// Represents a pending payment
 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -68,6 +68,12 @@ impl StorableObject for PendingPaymentDetails {
 			}
 		}
 
+		if let PaymentKind::Onchain { txid, .. } = &self.details.kind {
+			let conflicts_len = self.conflicting_txids.len();
+			self.conflicting_txids.retain(|conflicting_txid| conflicting_txid != txid);
+			updated |= self.conflicting_txids.len() != conflicts_len;
+		}
+
 		updated
 	}
 
@@ -92,3 +98,50 @@ impl From<&PendingPaymentDetails> for PendingPaymentDetailsUpdate {
 		Self { id: value.id(), payment_update: Some(value.details.to_update()), conflicting_txids }
 	}
 }
+
+#[cfg(test)]
+mod tests {
+	use bitcoin::hashes::Hash;
+
+	use super::*;
+	use crate::payment::{ConfirmationStatus, PaymentDirection, PaymentKind, PaymentStatus};
+
+	fn test_txid(byte: u8) -> Txid {
+		Txid::from_byte_array([byte; 32])
+	}
+
+	fn pending_onchain_payment(payment_id: PaymentId, txid: Txid) -> PaymentDetails {
+		PaymentDetails::new(
+			payment_id,
+			PaymentKind::Onchain { txid, status: ConfirmationStatus::Unconfirmed },
+			Some(1_000),
+			Some(100),
+			PaymentDirection::Outbound,
+			PaymentStatus::Pending,
+		)
+	}
+
+	#[test]
+	fn pending_onchain_conflicts_exclude_current_txid_after_txid_rotation() {
+		let original_txid = test_txid(1);
+		let replacement_txid = test_txid(2);
+		let payment_id = PaymentId(original_txid.to_byte_array());
+
+		let mut pending_payment = PendingPaymentDetails::new(
+			pending_onchain_payment(payment_id, replacement_txid),
+			vec![original_txid],
+		);
+		let update = PendingPaymentDetails::new(
+			pending_onchain_payment(payment_id, original_txid),
+			Vec::new(),
+		)
+		.to_update();
+
+		assert!(pending_payment.update(update));
+		assert_eq!(
+			pending_payment.conflicting_txids,
+			Vec::<Txid>::new(),
+			"current txid must not remain in its own conflict list"
+		);
+	}
+}

src/wallet/mod.rs

@@ -345,7 +345,7 @@ impl Wallet {
 						}
 					}
 				},
-				WalletEvent::TxUnconfirmed { txid, tx, old_block_time: None } => {
+				WalletEvent::TxUnconfirmed { txid, tx, .. } => {
 					let payment_id = self
 						.find_payment_by_txid(txid)
 						.unwrap_or_else(|| PaymentId(txid.to_byte_array()));

tests/integration_tests_rust.rs

@@ -21,10 +21,11 @@ use common::{
 	expect_channel_pending_event, expect_channel_ready_event, expect_channel_ready_events,
 	expect_event, expect_payment_claimable_event, expect_payment_received_event,
 	expect_payment_successful_event, expect_splice_negotiated_event, generate_blocks_and_wait,
-	generate_listening_addresses, open_channel, open_channel_push_amt, open_channel_with_all,
-	premine_and_distribute_funds, premine_blocks, prepare_rbf, random_chain_source, random_config,
-	setup_bitcoind_and_electrsd, setup_builder, setup_node, setup_two_nodes, splice_in_with_all,
-	wait_for_tx, TestChainSource, TestConfig, TestStoreType, TestSyncStore,
+	generate_listening_addresses, invalidate_blocks, open_channel, open_channel_push_amt,
+	open_channel_with_all, premine_and_distribute_funds, premine_blocks, prepare_rbf,
+	random_chain_source, random_config, setup_bitcoind_and_electrsd, setup_builder, setup_node,
+	setup_two_nodes, splice_in_with_all, wait_for_block, wait_for_tx, TestChainSource, TestConfig,
+	TestStoreType, TestSyncStore,
 };
 use electrsd::corepc_node::Node as BitcoinD;
 use electrsd::ElectrsD;
@@ -42,6 +43,7 @@ use lightning::routing::router::RouteParametersConfig;
 use lightning_invoice::{Bolt11InvoiceDescription, Description};
 use lightning_types::payment::{PaymentHash, PaymentPreimage};
 use log::LevelFilter;
+use serde_json::json;
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
 async fn channel_full_cycle() {
@@ -672,6 +674,74 @@ async fn onchain_send_receive() {
 	assert_eq!(node_b_payments.len(), 5);
 }
 
+#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
+async fn reorged_onchain_payment_returns_to_unconfirmed() {
+	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
+	let chain_source = random_chain_source(&bitcoind, &electrsd);
+	let (node_a, node_b) = setup_two_nodes(&chain_source, false, true, false);
+
+	let addr_a = node_a.onchain_payment().new_address().unwrap();
+	let addr_b = node_b.onchain_payment().new_address().unwrap();
+	let premine_amount_sat = 500_000;
+	premine_and_distribute_funds(
+		&bitcoind.client,
+		&electrsd.client,
+		vec![addr_b],
+		Amount::from_sat(premine_amount_sat),
+	)
+	.await;
+
+	node_a.sync_wallets().unwrap();
+	node_b.sync_wallets().unwrap();
+
+	let amount_to_send_sats = 100_000;
+	let txid =
+		node_b.onchain_payment().send_to_address(&addr_a, amount_to_send_sats, None).unwrap();
+	wait_for_tx(&electrsd.client, txid).await;
+
+	generate_blocks_and_wait(&bitcoind.client, &electrsd.client, 1).await;
+	node_a.sync_wallets().unwrap();
+	node_b.sync_wallets().unwrap();
+
+	let payment_id = PaymentId(txid.to_byte_array());
+	for node in [&node_a, &node_b] {
+		let payment = node.payment(&payment_id).unwrap();
+		assert_eq!(payment.status, PaymentStatus::Pending);
+		match payment.kind {
+			PaymentKind::Onchain { status, .. } => {
+				assert!(matches!(status, ConfirmationStatus::Confirmed { .. }));
+			},
+			_ => panic!("Unexpected payment kind"),
+		}
+	}
+
+	let original_height =
+		bitcoind.client.get_blockchain_info().expect("failed to get blockchain info").blocks;
+	invalidate_blocks(&bitcoind.client, 1);
+	let replacement_address = bitcoind.client.new_address().expect("failed to get new address");
+	for _ in 0..2 {
+		let _res: serde_json::Value = bitcoind
+			.client
+			.call("generateblock", &[json!(replacement_address.to_string()), json!([])])
+			.expect("failed to generate empty block");
+	}
+	wait_for_block(&electrsd.client, original_height as usize + 1).await;
+
+	node_a.sync_wallets().unwrap();
+	node_b.sync_wallets().unwrap();
+
+	for node in [&node_a, &node_b] {
+		let payment = node.payment(&payment_id).unwrap();
+		assert_eq!(payment.status, PaymentStatus::Pending);
+		match payment.kind {
+			PaymentKind::Onchain { status, .. } => {
+				assert!(matches!(status, ConfirmationStatus::Unconfirmed));
+			},
+			_ => panic!("Unexpected payment kind"),
+		}
+	}
+}
+
 #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
 async fn onchain_send_all_retains_reserve() {
 	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();