Handle on-chain CBF reorgs in wallet payment tracking

Author: febyeji

src/chain/cbf.rs

@@ -598,10 +598,11 @@ impl CbfChainSource {
 			vec![&*channel_manager, &*chain_monitor, &*output_sweeper];
 
 		// Process any queued reorg events before the regular sync.
-		// A reorg invalidates our last synced height since blocks may have changed.
+		// A reorg invalidates our last synced heights since blocks may have changed.
 		let pending_reorgs = std::mem::take(&mut *self.reorg_queue.lock().unwrap());
 		if !pending_reorgs.is_empty() {
 			*self.last_lightning_synced_height.lock().unwrap() = None;
+			*self.last_onchain_synced_height.lock().unwrap() = None;
 		}
 		for reorg in &pending_reorgs {
 			let reorg_set: HashSet<BlockHash> = reorg.reorganized.iter().copied().collect();

src/wallet/mod.rs

@@ -318,23 +318,61 @@ impl Wallet {
 
 					for mut payment in pending_payments {
 						match payment.details.kind {
-							PaymentKind::Onchain {
-								status: ConfirmationStatus::Confirmed { height, .. },
-								..
-							} => {
+							PaymentKind::Onchain { txid, .. } => {
+								let current_confirmation_status = locked_wallet
+									.tx_details(txid)
+									.map(|tx_details| match tx_details.chain_position {
+										bdk_chain::ChainPosition::Confirmed { anchor, .. } => {
+											ConfirmationStatus::Confirmed {
+												block_hash: anchor.block_id.hash,
+												height: anchor.block_id.height,
+												timestamp: anchor.confirmation_time,
+											}
+										},
+										bdk_chain::ChainPosition::Unconfirmed { .. } => {
+											ConfirmationStatus::Unconfirmed
+										},
+									});
 								let payment_id = payment.details.id;
-								if new_tip.height >= height + ANTI_REORG_DELAY - 1 {
-									payment.details.status = PaymentStatus::Succeeded;
-									self.payment_store.insert_or_update(payment.details)?;
-									self.pending_payment_store.remove(&payment_id)?;
+								match current_confirmation_status {
+									Some(ConfirmationStatus::Confirmed {
+										block_hash,
+										height,
+										timestamp,
+									}) => {
+										payment.details.kind = PaymentKind::Onchain {
+											txid,
+											status: ConfirmationStatus::Confirmed {
+												block_hash,
+												height,
+												timestamp,
+											},
+										};
+										if new_tip.height >= height + ANTI_REORG_DELAY - 1 {
+											payment.details.status = PaymentStatus::Succeeded;
+											self.payment_store.insert_or_update(payment.details)?;
+											self.pending_payment_store.remove(&payment_id)?;
+										} else {
+											self.payment_store
+												.insert_or_update(payment.details.clone())?;
+											self.pending_payment_store.insert_or_update(payment)?;
+										}
+									},
+									Some(ConfirmationStatus::Unconfirmed) | None => {
+										payment.details.kind = PaymentKind::Onchain {
+											txid,
+											status: ConfirmationStatus::Unconfirmed,
+										};
+										payment.details.status = PaymentStatus::Pending;
+										if payment.details.direction == PaymentDirection::Outbound {
+											unconfirmed_outbound_txids.push(txid);
+										}
+										self.payment_store
+											.insert_or_update(payment.details.clone())?;
+										self.pending_payment_store.insert_or_update(payment)?;
+									},
 								}
 							},
-							PaymentKind::Onchain {
-								txid,
-								status: ConfirmationStatus::Unconfirmed,
-							} if payment.details.direction == PaymentDirection::Outbound => {
-								unconfirmed_outbound_txids.push(txid);
-							},
 							_ => {},
 						}
 					}

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_pending_event, generate_blocks_and_wait,
-	open_channel, open_channel_push_amt, open_channel_with_all, premine_and_distribute_funds,
-	premine_blocks, prepare_rbf, random_chain_source, random_config, random_listening_addresses,
-	setup_bitcoind_and_electrsd, setup_builder, setup_node, setup_two_nodes, splice_in_with_all,
-	wait_for_cbf_sync, wait_for_tx, TestChainSource, TestStoreType, TestSyncStore,
+	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,
+	random_listening_addresses, setup_bitcoind_and_electrsd, setup_builder, setup_node,
+	setup_two_nodes, splice_in_with_all, wait_for_block, wait_for_cbf_sync, wait_for_tx,
+	TestChainSource, TestStoreType, TestSyncStore,
 };
 use ldk_node::config::{AsyncPaymentsRole, EsploraSyncConfig};
 use ldk_node::entropy::NodeEntropy;
@@ -2877,3 +2878,101 @@ async fn repeated_manual_sync_cbf() {
 
 	node.stop().unwrap();
 }
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
+async fn onchain_wallet_sync_cbf_after_reorg() {
+	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
+	let chain_source = TestChainSource::Cbf(&bitcoind);
+	let node = setup_node(&chain_source, random_config(true));
+
+	let first_addr = node.onchain_payment().new_address().unwrap();
+	let first_amount_sat = 100_000;
+	premine_and_distribute_funds(
+		&bitcoind.client,
+		&electrsd.client,
+		vec![first_addr],
+		Amount::from_sat(first_amount_sat),
+	)
+	.await;
+
+	wait_for_cbf_sync(&node).await;
+	assert_eq!(node.list_balances().spendable_onchain_balance_sats, first_amount_sat);
+
+	// Advance the tip so the reorg happens below our synced checkpoint.
+	generate_blocks_and_wait(&bitcoind.client, &electrsd.client, 2).await;
+	wait_for_cbf_sync(&node).await;
+
+	// Replace the last two blocks with a different branch that has no wallet activity.
+	invalidate_blocks(&bitcoind.client, 2);
+	generate_blocks_and_wait(&bitcoind.client, &electrsd.client, 2).await;
+	wait_for_cbf_sync(&node).await;
+
+	let second_addr = node.onchain_payment().new_address().unwrap();
+	let second_amount_sat = 50_000;
+	distribute_funds_unconfirmed(
+		&bitcoind.client,
+		&electrsd.client,
+		vec![second_addr],
+		Amount::from_sat(second_amount_sat),
+	)
+	.await;
+	generate_blocks_and_wait(&bitcoind.client, &electrsd.client, 1).await;
+	wait_for_cbf_sync(&node).await;
+
+	assert_eq!(
+		node.list_balances().spendable_onchain_balance_sats,
+		first_amount_sat + second_amount_sat
+	);
+	assert_eq!(
+		node.list_payments_with_filter(|p| {
+			p.direction == PaymentDirection::Inbound
+				&& matches!(p.kind, PaymentKind::Onchain { .. })
+		})
+		.len(),
+		2
+	);
+
+	node.stop().unwrap();
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
+async fn onchain_wallet_sync_cbf_reorgs_out_confirmed_receive() {
+	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
+	let chain_source = TestChainSource::Cbf(&bitcoind);
+	let node = setup_node(&chain_source, random_config(true));
+
+	let addr = node.onchain_payment().new_address().unwrap();
+	premine_blocks(&bitcoind.client, &electrsd.client).await;
+	let cur_height = bitcoind.client.get_blockchain_info().unwrap().blocks as usize;
+	let reward_block_hash =
+		bitcoind.client.generate_to_address(1, &addr).unwrap().0.pop().unwrap().parse().unwrap();
+	wait_for_block(&electrsd.client, cur_height + 1).await;
+	let reward_block = bitcoind.client.get_block(reward_block_hash).unwrap();
+	let txid = reward_block.txdata[0].compute_txid();
+	wait_for_cbf_sync(&node).await;
+	assert_eq!(node.list_balances().total_onchain_balance_sats, 5_000_000_000);
+	assert_eq!(node.list_balances().spendable_onchain_balance_sats, 0);
+
+	let payment_id = PaymentId(txid.to_byte_array());
+	let payment = node.payment(&payment_id).unwrap();
+	assert_eq!(payment.status, PaymentStatus::Pending);
+	match payment.kind {
+		PaymentKind::Onchain { status: ConfirmationStatus::Confirmed { .. }, .. } => {},
+		other => panic!("Unexpected payment state before reorg: {:?}", other),
+	}
+
+	invalidate_blocks(&bitcoind.client, 1);
+	generate_blocks_and_wait(&bitcoind.client, &electrsd.client, 2).await;
+	wait_for_cbf_sync(&node).await;
+
+	assert_eq!(node.list_balances().total_onchain_balance_sats, 0);
+	assert_eq!(node.list_balances().spendable_onchain_balance_sats, 0);
+	let payment = node.payment(&payment_id).unwrap();
+	assert_eq!(payment.status, PaymentStatus::Pending);
+	match payment.kind {
+		PaymentKind::Onchain { status: ConfirmationStatus::Unconfirmed, .. } => {},
+		other => panic!("Unexpected payment state after reorg: {:?}", other),
+	}
+
+	node.stop().unwrap();
+}