ln_init: various bug fixes for large networks

Author: pinheadmz

resources/scenarios/ln_framework/ln.py

@@ -89,9 +89,11 @@ def to_dict(self):
     def to_lnd_chanpolicy(self, capacity):
         # LND requires a 1% reserve
         reserve = ((capacity * 99) // 100) * 1000
+        # "min htlc amount of 0 mSAT is below min htlc parameter of 1 mSAT"
+        min_htlc = 1
         return {
             "time_lock_delta": self.cltv_expiry_delta,
-            "min_htlc_msat": self.htlc_minimum_msat,
+            "min_htlc_msat": max(self.htlc_minimum_msat, min_htlc),
             "base_fee_msat": self.fee_base_msat,
             "fee_rate_ppm": self.fee_proportional_millionths,
             "max_htlc_msat": min(self.htlc_maximum_msat, reserve),
@@ -357,8 +359,12 @@ def uri(self):
 
     def connect(self, target_uri):
         pk, host = target_uri.split("@")
-        res = self.post("/v1/peers", data={"addr": {"pubkey": pk, "host": host}})
-        return json.loads(res)
+        response = self.post("/v1/peers", data={"addr": {"pubkey": pk, "host": host}})
+        res = json.loads(response)
+        if "status" in res and "initiated" in res["status"]:
+            return {}
+        else:
+            return res
 
     def channel(self, pk, capacity, push_amt, fee_rate):
         b64_pk = self.hex_to_b64(pk)
@@ -372,6 +378,8 @@ def channel(self, pk, capacity, push_amt, fee_rate):
             },
         )
         res = json.loads(response)
+        if "result" not in res:
+            raise Exception(res)
         res["txid"] = self.b64_to_hex(
             res["result"]["chan_pending"]["txid"], reverse=True
         )

resources/scenarios/ln_init.py

@@ -256,10 +256,9 @@ def open_channel(self, ch, fee_rate):
                 src = self.lns[ch["source"]]
                 tgt_uri = ln_uris[ch["target"]]
                 tgt_pk, _ = tgt_uri.split("@")
-                self.log.info(
-                    f"Sending channel open from {ch['source']} -> {ch['target']} with fee_rate={fee_rate}"
-                )
+                log = f"  {ch['source']} -> {ch['target']}\n  {ch['id']} fee: {fee_rate}"
                 while True:
+                    self.log.info(f"Sending channel open:\n{log}")
                     try:
                         res = src.channel(
                             pk=tgt_pk,
@@ -268,20 +267,11 @@ def open_channel(self, ch, fee_rate):
                             fee_rate=fee_rate,
                         )
                         ch["txid"] = res["txid"]
-                        self.log.info(
-                            f"Channel open {ch['source']} -> {ch['target']}\n  "
-                            + f"outpoint={res['outpoint']}\n  "
-                            + f"expected channel id: {ch['id']}"
-                        )
+                        ch["outpoint"] = res["outpoint"]
+                        self.log.info(f"Channel open success:\n{log}\n  outpoint: {res['outpoint']}")
                         break
                     except Exception as e:
-                        ch["txid"] = "N/A"
-                        self.log.info(
-                            "Couldn't open channel:\n  "
-                            + f"From {ch['source']} -> {ch['target']} fee_rate={fee_rate}\n  "
-                            + f"{e}\n"
-                            + "Retrying in 5 seconds..."
-                        )
+                        self.log.info(f"Couldn't open channel:\n{log}\n  {e}\n  Retrying in 5 seconds...")
                         sleep(5)
 
             channels = sorted(ch_by_block[target_block], key=lambda ch: ch["id"]["index"])
@@ -301,6 +291,11 @@ def open_channel(self, ch, fee_rate):
                 ch_threads.append(t)
 
             all(thread.join() is None for thread in ch_threads)
+            for ch in channels:
+                if ch["outpoint"][-2:] != ":0":
+                    self.log.error(f"Channel open outpoint not tx output index 0\n  {ch}")
+                    raise Exception("Channel determinism ruined, abort!")
+
             self.log.info(f"Waiting for {len(channels)} channel opens in mempool...")
             self.wait_until(
                 lambda channels=channels: self.nodes[0].getmempoolinfo()["size"] >= len(channels),
@@ -369,6 +364,7 @@ def update_policy(self, ln, txid_hex, policy, capacity):
                             f" Failed updates: {res['failed_updates']}\n txid: {txid_hex}\n policy:{policy}\n retrying in 5 seconds..."
                         )
                         sleep(5)
+                        continue
                     break
                 except Exception as e:
                     self.log.info(f"Couldn't update channel policy for {ln.name} because {e}, retrying in 5 seconds...")