Apply RBF replacements to the wallet before sync

bump_fee_rbf updated the payment store but not the BDK wallet, so a
second bump before sync failed with InvalidPaymentId (or panicked on
debug). Apply the replacement to the wallet immediately, with a seen-at
after the replaced round.

Once the bump applies the replacement to the wallet, sync no longer
emits TxReplaced for the replaced transaction (BDK derives events from
a before/after diff of the canonical set), so nothing else populates
conflicting_txids after a bump until a later eviction or confirmation
flips the canonical set.

Fixes #1117.

AI assistance: OpenAI Codex, Claude Code.

Author: ram0verflow

src/wallet/mod.rs

@@ -2260,6 +2260,23 @@ impl Wallet {
 			ConfirmationStatus::Unconfirmed,
 		);
 
+		let seen_at = std::time::SystemTime::now()
+			.duration_since(std::time::UNIX_EPOCH)
+			.unwrap_or_default()
+			.as_secs();
+		let previous_seen_at = locked_wallet
+			.tx_details(txid)
+			.and_then(|details| match details.chain_position {
+				bdk_chain::ChainPosition::Unconfirmed { last_seen, .. } => last_seen,
+				_ => None,
+			})
+			.unwrap_or(0);
+		// BDK keeps the conflicting tx with the latest last-seen and breaks ties by txid, so a bump
+		// in the same second as the replaced round must still be seen strictly after it.
+		locked_wallet.apply_unconfirmed_txs([(
+			fee_bumped_tx.clone(),
+			seen_at.max(previous_seen_at.saturating_add(1)),
+		)]);
 		let change_set = locked_wallet.take_staged().unwrap_or_default();
 		drop(locked_wallet);
 		locked_persister.persist_changeset(change_set).await.map_err(|e| {

tests/integration_tests_rust.rs

@@ -4667,6 +4667,43 @@ async fn fs_store_persistence_backwards_compatibility() {
 	node_new.stop().unwrap();
 }
 
+#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
+async fn onchain_fee_bump_rbf_twice_before_sync() {
+	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, false);
+
+	let addr_a = node_a.onchain_payment().new_address().unwrap();
+	let addr_b = node_b.onchain_payment().new_address().unwrap();
+	premine_and_distribute_funds(
+		&bitcoind.client,
+		&electrsd.client,
+		vec![addr_a.clone(), addr_b],
+		Amount::from_sat(500_000),
+	)
+	.await;
+	node_b.sync_wallets().unwrap();
+	let txid = node_b.onchain_payment().send_to_address(&addr_a, 100_000, None).unwrap();
+	wait_for_tx(&electrsd.client, txid).await;
+	node_b.sync_wallets().unwrap();
+	let payment_id = PaymentId(txid.to_byte_array());
+	let first_fee = node_b.payment(&payment_id).unwrap().unwrap().fee_paid_msat.unwrap();
+
+	let first_replacement = node_b.onchain_payment().bump_fee_rbf(payment_id, None).unwrap();
+	let second_replacement = node_b.onchain_payment().bump_fee_rbf(payment_id, None).unwrap();
+	assert_ne!(first_replacement, second_replacement);
+	let payment = node_b.payment(&payment_id).unwrap().unwrap();
+	assert!(payment.fee_paid_msat.unwrap() > first_fee);
+	assert!(
+		matches!(payment.kind, PaymentKind::Onchain { txid, .. } if txid == second_replacement)
+	);
+	wait_for_tx(&electrsd.client, second_replacement).await;
+	node_b.sync_wallets().unwrap();
+	generate_blocks_and_wait(&bitcoind.client, &electrsd.client, 6).await;
+	node_b.sync_wallets().unwrap();
+	assert_eq!(node_b.payment(&payment_id).unwrap().unwrap().status, PaymentStatus::Succeeded);
+}
+
 #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
 async fn onchain_fee_bump_rbf() {
 	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();