Fix stock LDK public channel announcements

src/test/interoperability/ldk-node/src/main.rs

@@ -36,6 +36,9 @@ fn main() {
     builder
         .set_listening_addresses(vec![listening_address])
         .unwrap();
+    builder
+        .set_node_alias("stock-ldk-test".to_string())
+        .unwrap();
     let entropy = NodeEntropy::from_seed_path(format!("{storage_dir}/keys_seed")).unwrap();
     let node = builder.build(entropy).unwrap();
     node.start().unwrap();
@@ -57,6 +60,19 @@ fn main() {
                     .unwrap();
                 respond("OPENING");
             }
+            "open-announced" => {
+                let peer_id = PublicKey::from_str(parts.next().unwrap()).unwrap();
+                let peer_address = SocketAddress::from_str(parts.next().unwrap()).unwrap();
+                node.open_announced_channel(
+                    peer_id,
+                    peer_address,
+                    CHANNEL_CAPACITY_SAT,
+                    None,
+                    None,
+                )
+                .unwrap();
+                respond("OPENING");
+            }
             "channels" => {
                 let channels = node.list_channels();
                 let ready = channels.iter().filter(|c| c.is_channel_ready).count();

src/test/interoperability/ldk.rs

@@ -83,6 +83,40 @@ async fn stock_ldk_opens_pays_both_ways_and_closes() {
     exercise_channel(node1_addr, &mut stock, false).await;
 }
 
+#[serial_test::serial]
+#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
+#[traced_test]
+// run with `cargo test -- --ignored interoperability`, needs to build the stock ldk-node fixture
+#[ignore]
+async fn stock_ldk_opens_announced_channel_and_keeps_it_usable() {
+    initialize();
+
+    let test_dir_node1 = format!("{TEST_DIR_BASE}node1");
+    let test_dir_stock = format!("{TEST_DIR_BASE}stock");
+    let (node1_addr, _) = start_node(&test_dir_node1, NODE1_PEER_PORT, false).await;
+    fund_and_create_utxos(node1_addr, None).await;
+    let node1_pubkey = node_info(node1_addr).await.pubkey;
+
+    let (mut stock, stock_address) = StockLdkNode::start(&test_dir_stock, NODE2_PEER_PORT);
+    fund_wallet(stock_address, 100_000_000);
+    wait_for_stock_funds(&mut stock).await;
+    stock.open_announced_channel(&node1_pubkey, NODE1_PEER_PORT);
+    wait_for_stock_channel_ready(&mut stock).await;
+    wait_for_usable_channels(node1_addr, 1).await;
+
+    for _ in 0..8 {
+        mine(false);
+        tokio::time::sleep(std::time::Duration::from_millis(250)).await;
+    }
+    let channels = list_channels(node1_addr).await;
+    assert_eq!(channels.len(), 1);
+    assert!(channels[0].public);
+    assert!(channels[0].ready);
+    assert!(channels[0].is_usable);
+
+    exercise_channel(node1_addr, &mut stock, false).await;
+}
+
 #[serial_test::serial]
 #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
 #[traced_test]

src/test/interoperability/mod.rs

@@ -88,6 +88,11 @@ impl StockLdkNode {
         assert_eq!(self.command(&command), "OPENING");
     }
 
+    fn open_announced_channel(&mut self, peer_pubkey: &str, peer_port: u16) {
+        let command = format!("open-announced {peer_pubkey} 127.0.0.1:{peer_port}");
+        assert_eq!(self.command(&command), "OPENING");
+    }
+
     /// Number of channels the stock node has, and how many of them are ready
     fn channels(&mut self) -> (usize, usize) {
         let response = self.command("channels");