Add channel open operations benchmark

Add a channel-open benchmark that measures the open_channel call while
leaving chain confirmation cleanup outside the timed section.

AI-assisted-by: OpenAI Codex

Author: benthecarman

benches/operations.rs

@@ -13,11 +13,13 @@ use std::time::{Duration, Instant};
 
 use bitcoin::Amount;
 use common::{
-	expect_event, generate_blocks_and_wait, premine_and_distribute_funds, random_config,
-	setup_bitcoind_and_electrsd, setup_node, store_bench_configs, wait_for_payment_success,
+	expect_channel_pending_event, expect_channel_ready_event, expect_event,
+	generate_blocks_and_wait, open_channel_no_wait, premine_and_distribute_funds, random_config,
+	setup_bitcoind_and_electrsd, setup_node, setup_two_nodes_with_store, store_bench_configs,
+	wait_for_payment_success,
 };
 use criterion::{criterion_group, criterion_main, Criterion};
-use electrsd::corepc_node::Node as BitcoinD;
+use electrsd::corepc_node::{Client as BitcoindClient, Node as BitcoinD};
 use ldk_node::{Event, Node};
 use lightning::ln::channelmanager::PaymentId;
 use lightning_invoice::{Bolt11InvoiceDescription, Description};
@@ -26,6 +28,7 @@ use crate::common::{open_channel_push_amt, TestChainSource, TestStoreType};
 
 fn operations_benchmark(c: &mut Criterion) {
 	forwarding_benchmark(c);
+	channel_open_benchmark(c);
 }
 
 fn forwarding_benchmark(c: &mut Criterion) {
@@ -73,6 +76,72 @@ fn benchmark_runtime() -> tokio::runtime::Runtime {
 	builder.build().unwrap()
 }
 
+fn channel_open_benchmark(c: &mut Criterion) {
+	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
+	let chain_source = TestChainSource::BitcoindRpcSync(&bitcoind);
+	let runtime = benchmark_runtime();
+
+	let mut group = c.benchmark_group("channel_open");
+	group.sample_size(10);
+
+	for store_config in store_bench_configs() {
+		if !should_register_bench("channel_open", store_config.name) {
+			continue;
+		}
+		let (node_a, node_b) =
+			setup_two_nodes_with_store(&chain_source, false, true, false, store_config.store_type);
+		let node_a = Arc::new(node_a);
+		let node_b = Arc::new(node_b);
+
+		// connect nodes
+		node_a
+			.connect(
+				node_b.node_id(),
+				node_b.listening_addresses().unwrap().first().unwrap().clone(),
+				true,
+			)
+			.unwrap();
+
+		runtime.block_on(async {
+			let address_a = node_a.onchain_payment().new_address().unwrap();
+			premine_and_distribute_funds(
+				&bitcoind.client,
+				&electrsd.client,
+				vec![address_a],
+				Amount::from_sat(35_000_000),
+			)
+			.await;
+			node_a.sync_wallets().unwrap();
+		});
+
+		let node_a = Arc::clone(&node_a);
+		let node_b = Arc::clone(&node_b);
+		let bitcoind_client = &bitcoind.client;
+		let electrsd_ref = &electrsd;
+
+		group.bench_function(store_config.name, |b| {
+			b.to_async(&runtime).iter_custom(|iter| {
+				let node_a = Arc::clone(&node_a);
+				let node_b = Arc::clone(&node_b);
+
+				async move {
+					let mut total = Duration::ZERO;
+					for _ in 0..iter {
+						total += open_channel(
+							Arc::clone(&node_a),
+							Arc::clone(&node_b),
+							bitcoind_client,
+							electrsd_ref,
+						)
+						.await;
+					}
+					total
+				}
+			});
+		});
+	}
+}
+
 /// Returns whether the benchmark identified by `group/name` matches the CLI filters.
 ///
 /// Criterion applies its own filters after benchmark registration, but these benches do expensive
@@ -249,6 +318,25 @@ async fn wait_for_forwarding_path(nodes: &[Arc<Node>]) {
 	panic!("Timed out waiting for forwarding path readiness");
 }
 
+async fn open_channel(
+	node_a: Arc<Node>, node_b: Arc<Node>, bitcoind: &BitcoindClient, electrsd: &electrsd::ElectrsD,
+) -> Duration {
+	let start = Instant::now();
+	let funding_txo = open_channel_no_wait(&node_a, &node_b, 100_000, None, false).await;
+	let duration = start.elapsed();
+
+	common::wait_for_tx(&electrsd.client, funding_txo.txid).await;
+
+	generate_blocks_and_wait(bitcoind, &electrsd.client, 6).await;
+	node_a.sync_wallets().unwrap();
+	node_b.sync_wallets().unwrap();
+
+	expect_channel_ready_event!(node_b, node_a.node_id());
+	expect_channel_ready_event!(node_a, node_b.node_id());
+
+	duration
+}
+
 fn drain_events(node: &Node) {
 	while node.next_event().is_some() {
 		node.event_handled().unwrap();