test: demonstrate rgb_send_lock stuck when ChannelPending is blocked

Open a vanilla channel but deliberately skip mining, so the funding TX
stays in the mempool and the ChannelPending event never fires.  On the
current code the lock is held from openchannel until ChannelPending,
which means a second channel open returns 403 indefinitely.

This test fails on the unfixed code and passes once the lock is released
at FundingGenerationReady instead.

Ref: #111

Author: bitwalt

src/test/mod.rs

@@ -1892,6 +1892,7 @@ mod lock_unlock_changepassword;
 mod multi_hop;
 mod multi_open_close;
 mod open_after_double_send;
+mod openchannel_close_before_funding;
 mod openchannel_fail;
 mod openchannel_optional_addr;
 mod openchannel_push_asset_amount;

src/test/openchannel_close_before_funding.rs

@@ -0,0 +1,109 @@
+use super::*;
+
+const TEST_DIR_BASE: &str = "tmp/openchannel_close_before_funding/";
+
+/// Test that the rgb_send_lock is released after FundingGenerationReady completes,
+/// even when the funding transaction has not yet been confirmed on-chain.
+///
+/// Bug scenario: the rgb_send_lock is acquired when the openchannel API is called
+/// and only released when the ChannelPending event fires (which requires the
+/// funding TX to be mined with sufficient confirmations). If mining is delayed
+/// or the channel stalls between FundingGenerationReady and ChannelPending, the
+/// lock stays held indefinitely — blocking all subsequent channel opens, asset
+/// issuance, and on-chain RGB sends.
+///
+/// This test opens a vanilla channel and deliberately does NOT mine afterward.
+/// After FundingGenerationReady has completed (funding TX in the mempool), it
+/// attempts a second channel open to a different peer:
+///
+/// - Without the fix: 403 Forbidden (rgb_send_lock still held).
+/// - With the fix: 200 OK (lock released at FundingGenerationReady).
+///
+/// Ref: https://github.com/RGB-Tools/rgb-lightning-node/issues/111
+#[serial_test::serial]
+#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
+#[traced_test]
+async fn openchannel_lock_released_after_funding_generated() {
+    initialize();
+
+    let test_dir_node1 = format!("{TEST_DIR_BASE}node1");
+    let test_dir_node2 = format!("{TEST_DIR_BASE}node2");
+    let test_dir_node3 = format!("{TEST_DIR_BASE}node3");
+
+    let (node1_addr, _) = start_node(&test_dir_node1, NODE1_PEER_PORT, false).await;
+    let (node2_addr, _) = start_node(&test_dir_node2, NODE2_PEER_PORT, false).await;
+    let (node3_addr, _) = start_node(&test_dir_node3, NODE3_PEER_PORT, false).await;
+
+    // Fund node1 with enough UTXOs for two channel opens
+    fund_and_create_utxos(node1_addr, Some(10)).await;
+
+    let node2_pubkey = node_info(node2_addr).await.pubkey;
+    let node3_pubkey = node_info(node3_addr).await.pubkey;
+
+    // Open a vanilla channel from node1 -> node2.
+    // This sets rgb_send_lock = true and begins the LDK handshake.
+    let payload = OpenChannelRequest {
+        peer_pubkey_and_opt_addr: format!("{node2_pubkey}@127.0.0.1:{NODE2_PEER_PORT}"),
+        capacity_sat: 100_000,
+        push_msat: 0,
+        asset_amount: None,
+        asset_id: None,
+        push_asset_amount: None,
+        public: true,
+        with_anchors: true,
+        fee_base_msat: None,
+        fee_proportional_millionths: None,
+        temporary_channel_id: None,
+    };
+    let res = reqwest::Client::new()
+        .post(format!("http://{node1_addr}/openchannel"))
+        .json(&payload)
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(res.status(), reqwest::StatusCode::OK);
+
+    // Wait for FundingGenerationReady to complete (PSBT creation, signing,
+    // funding_transaction_generated). On localhost this takes a few seconds.
+    //
+    // IMPORTANT: we do NOT mine any blocks, so the funding TX stays in the
+    // mempool and ChannelPending will never fire.
+    tokio::time::sleep(std::time::Duration::from_secs(10)).await;
+
+    // Attempt a second channel from node1 -> node3.
+    //
+    // Without the fix the lock is still held (waiting for ChannelPending, which
+    // needs mining) and this returns 403 Forbidden.
+    //
+    // With the fix the lock was already released at FundingGenerationReady and
+    // this succeeds.
+    let payload2 = OpenChannelRequest {
+        peer_pubkey_and_opt_addr: format!("{node3_pubkey}@127.0.0.1:{NODE3_PEER_PORT}"),
+        capacity_sat: 100_000,
+        push_msat: 0,
+        asset_amount: None,
+        asset_id: None,
+        push_asset_amount: None,
+        public: true,
+        with_anchors: true,
+        fee_base_msat: None,
+        fee_proportional_millionths: None,
+        temporary_channel_id: None,
+    };
+    let res = reqwest::Client::new()
+        .post(format!("http://{node1_addr}/openchannel"))
+        .json(&payload2)
+        .send()
+        .await
+        .unwrap();
+
+    assert_ne!(
+        res.status(),
+        reqwest::StatusCode::FORBIDDEN,
+        "rgb_send_lock is stuck: the node cannot open new channels while \
+         waiting for a previous funding TX to confirm (ChannelPending blocked)"
+    );
+    assert_eq!(res.status(), reqwest::StatusCode::OK);
+
+    shutdown(&[node1_addr, node2_addr, node3_addr]).await;
+}