test(cbf): strengthen wait_for_cbf_sync with state verification

The old wait_for_cbf_sync only checked that the onchain sync timestamp
advanced, which could false-pass when the timestamp updated but wallet
state was still stale. The new version verifies both onchain and
lightning wallet syncs completed, and accepts a check closure so callers
can assert concrete wallet state (e.g. balance, payment existence).

Also simplifies CbfSyncConfig in test setup to use Default (which
already sets required_peers: 1 and reasonable timeouts).

Author: febyeji

tests/common/mod.rs

@@ -516,19 +516,7 @@ pub(crate) fn setup_node(chain_source: &TestChainSource, config: TestConfig) ->
 		TestChainSource::Cbf(bitcoind) => {
 			let p2p_socket = bitcoind.params.p2p_socket.expect("P2P must be enabled for CBF");
 			let peer_addr = format!("{}", p2p_socket);
-			let timeouts_config = SyncTimeoutsConfig {
-				onchain_wallet_sync_timeout_secs: 3,
-				lightning_wallet_sync_timeout_secs: 3,
-				fee_rate_cache_update_timeout_secs: 3,
-				tx_broadcast_timeout_secs: 3,
-				per_request_timeout_secs: 3,
-			};
-			let sync_config = CbfSyncConfig {
-				background_sync_config: None,
-				timeouts_config,
-				required_peers: 1,
-				..Default::default()
-			};
+			let sync_config = CbfSyncConfig { background_sync_config: None, ..Default::default() };
 			builder.set_chain_source_cbf(vec![peer_addr], Some(sync_config), None);
 		},
 	}
@@ -658,13 +646,27 @@ pub(crate) async fn wait_for_outpoint_spend<E: ElectrumApi>(electrs: &E, outpoin
 	.await;
 }
 
-pub(crate) async fn wait_for_cbf_sync(node: &TestNode) {
-	let before = node.status().latest_onchain_wallet_sync_timestamp;
+/// Wait for a CBF sync cycle to complete successfully.
+///
+/// Unlike the old version which only checked that the onchain sync timestamp
+/// advanced, this also verifies that both the onchain *and* lightning wallet
+/// syncs completed, and calls a user-supplied `check` closure after each
+/// successful sync so the caller can verify concrete wallet state (e.g.
+/// balance). This prevents false passes where the timestamp advances but
+/// the wallet state is still stale.
+pub(crate) async fn wait_for_cbf_sync<F>(node: &TestNode, check: F)
+where
+	F: Fn() -> bool,
+{
+	let before_onchain = node.status().latest_onchain_wallet_sync_timestamp;
+	let before_lightning = node.status().latest_lightning_wallet_sync_timestamp;
 	let mut delay = Duration::from_millis(200);
 	for _ in 0..30 {
 		if node.sync_wallets().is_ok() {
-			let after = node.status().latest_onchain_wallet_sync_timestamp;
-			if after > before {
+			let status = node.status();
+			let onchain_synced = status.latest_onchain_wallet_sync_timestamp > before_onchain;
+			let lightning_synced = status.latest_lightning_wallet_sync_timestamp > before_lightning;
+			if onchain_synced && lightning_synced && check() {
 				return;
 			}
 		}

tests/integration_tests_rust.rs

@@ -24,7 +24,7 @@ use common::{
 	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,
 	random_listening_addresses, setup_bitcoind_and_electrsd, setup_builder, setup_node,
-	setup_two_nodes, splice_in_with_all, skip_if_cbf, wait_for_cbf_sync, wait_for_tx,
+	setup_two_nodes, skip_if_cbf, splice_in_with_all, wait_for_cbf_sync, wait_for_tx,
 	TestChainSource, TestStoreType, TestSyncStore,
 };
 use electrsd::corepc_node::Node as BitcoinD;
@@ -2995,7 +2995,8 @@ async fn fee_rate_estimation_after_manual_sync_cbf() {
 	)
 	.await;
 
-	wait_for_cbf_sync(&node).await;
+	wait_for_cbf_sync(&node, || node.status().latest_fee_rate_cache_update_timestamp.is_some())
+		.await;
 	let first_fee_update = node.status().latest_fee_rate_cache_update_timestamp;
 	assert!(first_fee_update.is_some());
 
@@ -3025,7 +3026,10 @@ async fn repeated_manual_sync_cbf() {
 	)
 	.await;
 
-	wait_for_cbf_sync(&node).await;
+	wait_for_cbf_sync(&node, || {
+		node.list_balances().spendable_onchain_balance_sats == premine_amount_sat
+	})
+	.await;
 	assert_eq!(node.list_balances().spendable_onchain_balance_sats, premine_amount_sat);
 
 	// Regression: the second manual sync must not block forever.
@@ -3070,7 +3074,10 @@ async fn start_stop_reinit_cbf() {
 	)
 	.await;
 
-	wait_for_cbf_sync(&node).await;
+	wait_for_cbf_sync(&node, || {
+		node.list_balances().spendable_onchain_balance_sats == expected_amount.to_sat()
+	})
+	.await;
 	assert_eq!(node.list_balances().spendable_onchain_balance_sats, expected_amount.to_sat());
 
 	node.stop().unwrap();
@@ -3098,7 +3105,11 @@ async fn start_stop_reinit_cbf() {
 		expected_amount.to_sat()
 	);
 
-	wait_for_cbf_sync(&reinitialized_node).await;
+	wait_for_cbf_sync(&reinitialized_node, || {
+		reinitialized_node.list_balances().spendable_onchain_balance_sats
+			== expected_amount.to_sat()
+	})
+	.await;
 	assert_eq!(
 		reinitialized_node.list_balances().spendable_onchain_balance_sats,
 		expected_amount.to_sat()
@@ -3128,7 +3139,10 @@ async fn onchain_wallet_recovery_cbf() {
 	)
 	.await;
 
-	wait_for_cbf_sync(&original_node).await;
+	wait_for_cbf_sync(&original_node, || {
+		original_node.list_balances().spendable_onchain_balance_sats == premine_amount_sat
+	})
+	.await;
 	assert_eq!(original_node.list_balances().spendable_onchain_balance_sats, premine_amount_sat);
 
 	let addr_2 = original_node.onchain_payment().new_address().unwrap();
@@ -3144,7 +3158,10 @@ async fn onchain_wallet_recovery_cbf() {
 
 	generate_blocks_and_wait(&bitcoind.client, &electrsd.client, 1).await;
 
-	wait_for_cbf_sync(&original_node).await;
+	wait_for_cbf_sync(&original_node, || {
+		original_node.list_balances().spendable_onchain_balance_sats == premine_amount_sat * 2
+	})
+	.await;
 	assert_eq!(
 		original_node.list_balances().spendable_onchain_balance_sats,
 		premine_amount_sat * 2
@@ -3159,7 +3176,10 @@ async fn onchain_wallet_recovery_cbf() {
 	recovered_config.recovery_mode = true;
 	let recovered_node = setup_node(&chain_source, recovered_config);
 
-	wait_for_cbf_sync(&recovered_node).await;
+	wait_for_cbf_sync(&recovered_node, || {
+		recovered_node.list_balances().spendable_onchain_balance_sats == premine_amount_sat * 2
+	})
+	.await;
 	assert_eq!(
 		recovered_node.list_balances().spendable_onchain_balance_sats,
 		premine_amount_sat * 2
@@ -3182,7 +3202,10 @@ async fn onchain_wallet_recovery_cbf() {
 
 	generate_blocks_and_wait(&bitcoind.client, &electrsd.client, 1).await;
 
-	wait_for_cbf_sync(&recovered_node).await;
+	wait_for_cbf_sync(&recovered_node, || {
+		recovered_node.list_balances().spendable_onchain_balance_sats == premine_amount_sat * 3
+	})
+	.await;
 	assert_eq!(
 		recovered_node.list_balances().spendable_onchain_balance_sats,
 		premine_amount_sat * 3
@@ -3209,7 +3232,10 @@ async fn onchain_send_receive_cbf() {
 	)
 	.await;
 
-	wait_for_cbf_sync(&node_a).await;
+	wait_for_cbf_sync(&node_a, || {
+		node_a.list_balances().spendable_onchain_balance_sats == premine_amount_sat
+	})
+	.await;
 	node_b.sync_wallets().unwrap();
 	assert_eq!(node_a.list_balances().spendable_onchain_balance_sats, premine_amount_sat);
 	assert_eq!(node_b.list_balances().spendable_onchain_balance_sats, premine_amount_sat);
@@ -3240,7 +3266,7 @@ async fn onchain_send_receive_cbf() {
 
 	// Mine the transaction so CBF can see it.
 	generate_blocks_and_wait(&bitcoind.client, &electrsd.client, 6).await;
-	wait_for_cbf_sync(&node_a).await;
+	wait_for_cbf_sync(&node_a, || node_a.payment(&PaymentId(txid.to_byte_array())).is_some()).await;
 	node_b.sync_wallets().unwrap();
 
 	let payment_id = PaymentId(txid.to_byte_array());
@@ -3285,7 +3311,7 @@ async fn onchain_send_receive_cbf() {
 	wait_for_tx(&electrsd.client, txid).await;
 
 	generate_blocks_and_wait(&bitcoind.client, &electrsd.client, 6).await;
-	wait_for_cbf_sync(&node_a).await;
+	wait_for_cbf_sync(&node_a, || node_a.list_balances().spendable_onchain_balance_sats == 0).await;
 	node_b.sync_wallets().unwrap();
 
 	assert_eq!(node_a.list_balances().spendable_onchain_balance_sats, 0);