scenarios: ensure ln_init can handle larger scale networks

Author: pinheadmz

src/scenarios/ln_init.py

@@ -1,4 +1,5 @@
 #!/usr/bin/env python3
+
 from time import sleep
 
 from scenarios.utils import ensure_miner
@@ -15,83 +16,94 @@ def set_test_params(self):
 
     def run_test(self):
         self.log.info("Get LN nodes and wallet addresses")
+        ln_nodes = []
         recv_addrs = []
         for tank in self.warnet.tanks:
             if tank.lnnode is not None:
                 recv_addrs.append(tank.lnnode.getnewaddress())
+                ln_nodes.append(tank.index)
 
         self.log.info("Fund LN wallets")
-        miner = ensure_miner(self.nodes[3])
-        addr = miner.getnewaddress()
-        self.generatetoaddress(self.nodes[3], 110, addr)
+        miner = ensure_miner(self.nodes[0])
+        miner_addr = miner.getnewaddress()
+        # 298 block base
+        self.generatetoaddress(self.nodes[0], 298, miner_addr)
+        # divvy up the goods
+        split = miner.getbalance() // len(recv_addrs)
         for addr in recv_addrs:
-            miner.sendtoaddress(addr, 50)
-        self.generatetoaddress(self.nodes[3], 1, addr)
-
-        self.log.info("Waiting for funds to be spendable")
-        ready = False
-        while not ready:
-            sleep(1)
-            ready = True
+            miner.sendtoaddress(addr, split)
+        # confirm funds in block 299
+        self.generatetoaddress(self.nodes[0], 1, miner_addr)
+
+        self.log.info(f"Waiting for funds to be spendable: {split} BTC each for {len(recv_addrs)} LN nodes")
+
+        def funded_lnnodes():
             for tank in self.warnet.tanks:
                 if tank.lnnode is None:
                     continue
-                bal = tank.lnnode.get_wallet_balance()
-                if int(bal["confirmed_balance"]) >= 50:
-                    continue
-                ready = False
-                break
-
-        self.log.info("Open channels")
-        # TODO: This might belong in Warnet class as connect_ln_edges()
-        #       but that would need to ensure spendable funds first.
-        #       For now we consider this scenario "special".
-        chan_pts = []
-        ln_edges = []
+                if int(tank.lnnode.get_wallet_balance()["confirmed_balance"]) < (split * 100000000):
+                    return False
+            return True
+        self.wait_until(funded_lnnodes, timeout=5*60)
+
+        ln_nodes_uri = ln_nodes.copy()
+        while len(ln_nodes_uri) > 0:
+            self.log.info(f"Waiting for all LN nodes to have URI, LN nodes remaining: {ln_nodes_uri}")
+            for index in ln_nodes_uri:
+                lnnode = self.warnet.tanks[index].lnnode
+                if lnnode.getURI():
+                    ln_nodes_uri.remove(index)
+            sleep(5)
+
+        self.log.info("Adding p2p connections to LN nodes")
+        for edge in self.warnet.graph.edges(data=True):
+            (src, dst, data) = edge
+            # Copy the L1 p2p topology (where applicable) to L2
+            # so we get a more robust p2p graph for lightning
+            if "source-policy" not in data and self.warnet.tanks[src].lnnode and self.warnet.tanks[dst].lnnode:
+                self.warnet.tanks[src].lnnode.connect_to_tank(dst)
+
+        # Start confirming channel opens in block 300
+        self.log.info("Opening channels, one per block")
+        chan_opens = []
         for edge in self.warnet.graph.edges(data=True):
             (src, dst, data) = edge
             if "source-policy" in data:
                 src_node = self.warnet.get_ln_node_from_tank(src)
                 assert src_node is not None
                 assert self.warnet.get_ln_node_from_tank(dst) is not None
-                ln_edges.append(edge)
+                self.log.info(f"opening channel {src}->{dst}")
                 chan_pt = src_node.open_channel_to_tank(dst, data["source-policy"])
-                chan_pts.append(chan_pt)
-
-        self.log.info("Waiting for all channel open txs in mempool")
-        while True:
-            all_set = True
-            mp = self.nodes[3].getrawmempool()
-            for chan_pt in chan_pts:
-                if chan_pt[:64] not in mp:
-                    all_set = False
-            if all_set:
-                break
-            sleep(2)
-
-        self.log.info("Confirming channel opens")
-        self.generatetoaddress(self.nodes[3], 6, addr)
-
-        self.log.info("Waiting for graph gossip sync")
-        while True:
-            all_set = True
-            for tank in self.warnet.tanks:
-                if tank.lnnode is not None:
-                    edges = tank.lnnode.lncli("describegraph")["edges"]
-                    if len(edges) != len(ln_edges):
-                        all_set = False
-            if all_set:
-                break
-            sleep(2)
+                # We can guarantee deterministic short channel IDs as long as
+                # the change output is greater than the channel funding output,
+                # which will then be output 0
+                assert chan_pt[64:] == ":0"
+                chan_opens.append((edge, chan_pt))
+                self.log.info(f"  pending channel point: {chan_pt}")
+                self.wait_until(lambda chan_pt=chan_pt: chan_pt[:64] in self.nodes[0].getrawmempool())
+                self.generatetoaddress(self.nodes[0], 1, miner_addr)
+                assert chan_pt[:64] not in self.nodes[0].getrawmempool()
+                self.log.info(f"  confirmed in block {self.nodes[0].getblockcount()}")
+
+        # Ensure all channel opens are sufficiently confirmed
+        self.generatetoaddress(self.nodes[0], 10, miner_addr)
+        ln_nodes_gossip = ln_nodes.copy()
+        while len(ln_nodes_gossip) > 0:
+            self.log.info(f"Waiting for graph gossip sync, LN nodes remaining: {ln_nodes_gossip}")
+            for index in ln_nodes_gossip:
+                lnnode = self.warnet.tanks[index].lnnode
+                if len(lnnode.lncli("describegraph")["edges"]) == len(chan_opens):
+                    ln_nodes_gossip.remove(index)
+            sleep(5)
 
         self.log.info("Updating channel policies")
-        for i, edge in enumerate(ln_edges):
+        for edge, chan_pt in chan_opens:
             (src, dst, data) = edge
             if "target-policy" in data:
                 target_node = self.warnet.get_ln_node_from_tank(dst)
-                target_node.update_channel_policy(chan_pts[i], data["target-policy"])
+                target_node.update_channel_policy(chan_pt, data["target-policy"])
 
-        self.log.info(f"Warnet LN ready with {len(recv_addrs)} nodes and {len(ln_edges)} channels.")
+        self.log.info(f"Warnet LN ready with {len(recv_addrs)} nodes and {len(chan_opens)} channels.")
 
 if __name__ == "__main__":
     LNInit().main()

src/warnet/lnnode.py

@@ -12,7 +12,8 @@
     "--accept-keysend",
     "--bitcoin.active",
     "--bitcoin.regtest",
-    "--bitcoin.node=bitcoind"
+    "--bitcoin.node=bitcoind",
+    "--maxpendingchannels=64"
 ])
 
 class LNNode:
@@ -67,6 +68,8 @@ def getnewaddress(self):
 
     def getURI(self):
         res = self.lncli("getinfo")
+        if len(res["uris"]) < 1:
+            return None
         return res["uris"][0]
 
     def get_wallet_balance(self):

test/data/ln.graphml

@@ -39,6 +39,7 @@
     <edge id="1" source="0" target="1"></edge>
     <edge id="2" source="1" target="2"></edge>
     <edge id="3" source="2" target="3"></edge>
+    <edge id="4" source="2" target="0"></edge>
     <edge id="4" source="3" target="0"></edge>
     <!-- LN channels -->
     <edge id="5" source="0" target="1">