Reduce test slowness and flakiness

- Use exponential backoff (50ms→1s) in wait_for_condition instead of
  fixed 1s polling, preserving the same total timeout budget
- Make wait_for_tx_broadcast async to avoid blocking the tokio runtime
- Replace hardcoded sleep(5) and sleep(1) sync waits with
  wallet.sync_ln_wallet() for deterministic synchronization
- Batch initial 101-block generation into 2 RPC calls instead of 101

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: benthecarman

orange-sdk/tests/integration_tests.rs

@@ -441,9 +441,9 @@ async fn test_receive_onchain() {
 		// a rebalance should be initiated, we need to mine the channel opening transaction
 		// for it to be confirmed and reflected in the wallet's history
 		generate_blocks(&bitcoind, &electrsd, 6).await;
-		tokio::time::sleep(Duration::from_secs(5)).await; // wait for sync
+		wallet.sync_ln_wallet().unwrap();
 		generate_blocks(&bitcoind, &electrsd, 6).await; // confirm the channel opening transaction
-		tokio::time::sleep(Duration::from_secs(5)).await; // wait for sync
+		wallet.sync_ln_wallet().unwrap();
 
 		//  wait for rebalance to be initiated
 		println!("waiting for channel opened event");
@@ -553,7 +553,7 @@ async fn test_receive_to_onchain_with_channel() {
 
 		// confirm splice
 		generate_blocks(&bitcoind, &electrsd, 6).await;
-		tokio::time::sleep(Duration::from_secs(5)).await;
+		wallet.sync_ln_wallet().unwrap();
 
 		let event = wait_next_event(&wallet).await;
 		match event {
@@ -563,8 +563,6 @@ async fn test_receive_to_onchain_with_channel() {
 			ev => panic!("Expected ChannelOpened event, got {ev:?}"),
 		}
 
-		wallet.sync_ln_wallet().unwrap();
-
 		let txs = wallet.list_transactions().await.unwrap();
 		assert_eq!(txs.len(), 2);
 		let tx = txs.into_iter().last().unwrap();
@@ -839,14 +837,9 @@ async fn test_pay_onchain_from_self_custody() {
 		let info = PaymentInfo::build(instr, Some(send_amount)).unwrap();
 		wallet.pay(&info).await.unwrap();
 
-		// sleep for a second to wait for proper broadcast
-		tokio::time::sleep(Duration::from_secs(1)).await;
-
 		// confirm the tx
 		generate_blocks(&bitcoind, &electrsd, 6).await;
-
-		// sleep for a second to wait for sync
-		tokio::time::sleep(Duration::from_secs(1)).await;
+		wallet.sync_ln_wallet().unwrap();
 
 		// wait for payment to complete
 		test_utils::wait_for_condition("on-chain payment completion", || async {
@@ -945,14 +938,9 @@ async fn test_pay_onchain_from_channel() {
 		let info = PaymentInfo::build(instr, Some(send_amount)).unwrap();
 		wallet.pay(&info).await.unwrap();
 
-		// sleep for a second to wait for proper broadcast
-		tokio::time::sleep(Duration::from_secs(1)).await;
-
 		// confirm the tx
 		generate_blocks(&bitcoind, &electrsd, 6).await;
-
-		// sleep for a second to wait for sync
-		tokio::time::sleep(Duration::from_secs(1)).await;
+		wallet.sync_ln_wallet().unwrap();
 
 		// wait for payment to complete
 		test_utils::wait_for_condition("on-chain payment completion", || async {

orange-sdk/tests/test_utils.rs

@@ -33,21 +33,30 @@ use std::sync::Arc;
 use std::time::Duration;
 use uuid::Uuid;
 
-/// Waits for an async condition to be true, polling at a specified interval until a timeout.
+/// Waits for an async condition to be true, polling with exponential backoff until a timeout.
 pub async fn wait_for_condition<F, Fut>(condition_name: &str, mut condition: F)
 where
 	F: FnMut() -> Fut,
 	Fut: Future<Output = bool>,
 {
-	// longer timeout if running in CI as things can be slower there
-	let iterations = if std::env::var("CI").is_ok() { 120 } else { 20 };
-	for _ in 0..iterations {
+	let timeout = if std::env::var("CI").is_ok() {
+		Duration::from_secs(120)
+	} else {
+		Duration::from_secs(20)
+	};
+	let start = tokio::time::Instant::now();
+	let mut delay = Duration::from_millis(50);
+	loop {
 		if condition().await {
 			return;
 		}
-		tokio::time::sleep(Duration::from_secs(1)).await;
+		if start.elapsed() >= timeout {
+			panic!("Timeout waiting for condition: {condition_name}");
+		}
+		tokio::time::sleep(delay).await;
+		// Exponential backoff, cap at 1 second
+		delay = (delay * 2).min(Duration::from_secs(1));
 	}
-	panic!("Timeout waiting for condition: {condition_name}");
 }
 
 /// Waits for the next event from the wallet, polling every second for up to 20 seconds.
@@ -84,11 +93,11 @@ async fn create_bitcoind(uuid: Uuid) -> (Arc<Bitcoind>, Arc<ElectrsD>) {
 		ElectrsD::with_conf(electrsd::downloaded_exe_path().unwrap(), &bitcoind, &electrsd_conf)
 			.unwrap_or_else(|_| panic!("Failed to start electrsd for test {uuid}"));
 
-	// mine 101 blocks to get some spendable funds, split it up into multiple calls
+	// mine 101 blocks to get some spendable funds, split it up into batches
 	// to avoid potentially hitting RPC timeouts on slower CI systems
 	let address = bitcoind.client.new_address().unwrap();
-	for _ in 0..101 {
-		let _block_hashes = bitcoind.client.generate_to_address(1, &address).unwrap();
+	for batch_size in [50, 51] {
+		let _block_hashes = bitcoind.client.generate_to_address(batch_size, &address).unwrap();
 	}
 
 	wait_for_block(&electrsd.client, 101).await;
@@ -305,7 +314,7 @@ async fn build_test_nodes() -> TestParams {
 
 	// open a channel from payer to LSP
 	third_party.open_channel(lsp.node_id(), lsp_listen.clone(), 10_000_000, None, None).unwrap();
-	wait_for_tx_broadcast(&bitcoind);
+	wait_for_tx_broadcast(&bitcoind).await;
 	generate_blocks(&bitcoind, &electrsd, 6).await;
 
 	// wait for channel ready (needs blocking wait as we are not in async context here)
@@ -457,7 +466,7 @@ async fn build_test_nodes() -> TestParams {
 					None,
 				)
 				.unwrap();
-			wait_for_tx_broadcast(&bitcoind_clone);
+			wait_for_tx_broadcast(&bitcoind_clone).await;
 			generate_blocks(&bitcoind_clone, &electrsd, 6).await;
 
 			// wait for sync/channel ready
@@ -542,14 +551,24 @@ pub async fn open_channel_from_lsp(wallet: &orange_sdk::Wallet, payer: Arc<Node>
 	recv_amt
 }
 
-fn wait_for_tx_broadcast(bitcoind: &Bitcoind) {
-	let iterations = if std::env::var("CI").is_ok() { 120 } else { 10 };
-	for _ in 0..iterations {
+async fn wait_for_tx_broadcast(bitcoind: &Bitcoind) {
+	let timeout = if std::env::var("CI").is_ok() {
+		Duration::from_secs(30)
+	} else {
+		Duration::from_millis(2500)
+	};
+	let start = tokio::time::Instant::now();
+	let mut delay = Duration::from_millis(50);
+	loop {
 		let num_txs = bitcoind.client.get_mempool_info().unwrap().size;
 		if num_txs > 0 {
 			break;
 		}
-		std::thread::sleep(Duration::from_millis(250));
+		if start.elapsed() >= timeout {
+			panic!("Timeout waiting for tx broadcast");
+		}
+		tokio::time::sleep(delay).await;
+		delay = (delay * 2).min(Duration::from_millis(500));
 	}
 }