LN: pass updatechanpolicy args from graphml file to ln node

Author: pinheadmz

src/scenarios/ln_init.py

@@ -46,7 +46,7 @@ def run_test(self):
         # 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".
-        opening_txs = []
+        chan_pts = []
         ln_edges = []
         for edge in self.warnet.graph.edges(data=True):
             (src, dst, data) = edge
@@ -55,15 +55,15 @@ def run_test(self):
                 assert src_node is not None
                 assert self.warnet.get_ln_node_from_tank(dst) is not None
                 ln_edges.append(edge)
-                tx = src_node.open_channel_to_tank(dst, data["source-policy"])["funding_txid"]
-                opening_txs.append(tx)
+                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 tx in opening_txs:
-                if tx not in mp:
+            for chan_pt in chan_pts:
+                if chan_pt[:64] not in mp:
                     all_set = False
             if all_set:
                 break
@@ -84,8 +84,14 @@ def run_test(self):
                 break
             sleep(2)
 
-        self.log.info(f"Warnet LN ready with {len(recv_addrs)} nodes and {len(ln_edges)} channels.")
+        self.log.info("Updating channel policies")
+        for i, edge in enumerate(ln_edges):
+            (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"])
 
+        self.log.info(f"Warnet LN ready with {len(recv_addrs)} nodes and {len(ln_edges)} channels.")
 
 if __name__ == "__main__":
     LNInit().main()

src/warnet/lnnode.py

@@ -73,11 +73,21 @@ def get_wallet_balance(self):
         res = self.lncli("walletbalance")
         return res
 
+    # returns the channel point in the form txid:output_index
     def open_channel_to_tank(self, index: int, policy: str) -> str:
         tank = self.warnet.tanks[index]
         [pubkey, host] = tank.lnnode.getURI().split("@")
-        res = self.lncli(f"openchannel --node_key={pubkey} --connect={host} {policy}")
-        return res
+        txid = self.lncli(f"openchannel --node_key={pubkey} --connect={host} {policy}")["funding_txid"]
+        # Why doesn't LND return the output index as well?
+        # Do they charge by the RPC call or something?!
+        pending = self.lncli("pendingchannels")
+        for chan in pending["pending_open_channels"]:
+            if txid in chan["channel"]["channel_point"]:
+                return chan["channel"]["channel_point"]
+        raise Exception(f"Opened channel with txid {txid} not found in pending channels")
+
+    def update_channel_policy(self, chan_point: str, policy: str) -> str:
+        return self.lncli(f"updatechanpolicy --chan_point={chan_point} {policy}")
 
     def connect_to_tank(self, index):
         tank = self.warnet.tanks[index]

test/data/ln.graphml

@@ -7,6 +7,7 @@
   <key attr.name="ln_cb_image"    attr.type="string" for="node" id="ln_cb_image"/>
   <key attr.name="ln_config"      attr.type="string" for="node" id="ln_config"/>
   <key attr.name="source-policy"  attr.type="string" for="edge" id="source-policy"/>
+  <key attr.name="target-policy"  attr.type="string" for="edge" id="target-policy"/>
   <key attr.name="collect_logs"   attr.type="boolean" for="node" id="collect_logs"/>
   <key attr.name="image"          attr.type="string" for="node" id="image"/>
   <graph edgedefault="directed">
@@ -23,13 +24,13 @@
         <data key="ln">lnd</data>
         <data key="ln_cb_image">pinheadmz/circuitbreaker:278737d</data>
         <data key="collect_logs">true</data>
-        <data key="ln_config">--bitcoin.timelockdelta=20</data>
     </node>
     <node id="2">
         <data key="version">26.0</data>
         <data key="bitcoin_config">-uacomment=w2</data>
         <data key="ln">lnd</data>
         <data key="ln_cb_image">pinheadmz/circuitbreaker:278737d</data>
+        <data key="ln_config">--bitcoin.timelockdelta=33</data>
     </node>
     <node id="3">
         <data key="version">26.0</data>
@@ -42,6 +43,7 @@
     <!-- LN channels -->
     <edge id="5" source="0" target="1">
         <data key="source-policy">--local_amt=100000</data>
+        <data key="target-policy">--base_fee_msat=2200 --fee_rate_ppm=13 --time_lock_delta=20</data>
     </edge>
     <edge id="6" source="1" target="2">
         <data key="source-policy">--local_amt=100000 --push_amt=50000 --base_fee_msat=5500 --fee_rate_ppm=3</data>

test/ln_test.py

@@ -45,17 +45,17 @@ def get_cb_forwards(index):
 base.wait_for_all_scenarios()
 
 print("\nEnsuring node-level channel policy settings")
-chans = json.loads(base.warcli("lncli 1 describegraph"))["edges"]
-for chan in chans:
-    # node_1 or node_2 is tank 1 with its non-default --bitcoin.timelockdelta=20
-    if chan["node1_policy"]["time_lock_delta"] != 20:
-        assert chan["node2_policy"]["time_lock_delta"] == 20
+chan_id = json.loads(base.warcli("lncli 2 listchannels"))["channels"][0]["chan_id"]
+chan = json.loads(base.warcli(f"lncli 2 getchaninfo {chan_id}"))
+# node_1 or node_2 is tank 2 with its non-default --bitcoin.timelockdelta=33
+if chan["node1_policy"]["time_lock_delta"] != 33:
+    assert chan["node2_policy"]["time_lock_delta"] == 33
 
 print("\nEnsuring no circuit breaker forwards yet")
 assert len(get_cb_forwards(1)["forwards"]) == 0
 
 print("\nTest LN payment from 0 -> 2")
-inv = json.loads(base.warcli("lncli 2 addinvoice --amt=1234"))["payment_request"]
+inv = json.loads(base.warcli("lncli 2 addinvoice --amt=2000"))["payment_request"]
 
 print(f"\nGot invoice from node 2: {inv}")
 print("\nPaying invoice from node 0...")
@@ -71,11 +71,32 @@ def check_invoices():
         return False
 base.wait_for_predicate(check_invoices)
 
-print("\nEnsuring channel-level channel policy settings")
+print("\nEnsuring channel-level channel policy settings: source")
 payment = json.loads(base.warcli("lncli 0 listpayments"))["payments"][0]
-assert payment["fee_msat"] == "5503"
+assert payment["fee_msat"] == "5506"
 
 print("\nEnsuring circuit breaker tracked payment")
 assert len(get_cb_forwards(1)["forwards"]) == 1
 
+print("\nTest LN payment from 2 -> 0")
+inv = json.loads(base.warcli("lncli 0 addinvoice --amt=1000"))["payment_request"]
+
+print(f"\nGot invoice from node 0: {inv}")
+print("\nPaying invoice from node 2...")
+print(base.warcli(f"lncli 2 payinvoice -f {inv}"))
+
+print("Waiting for payment success")
+def check_invoices():
+    invs = json.loads(base.warcli("lncli 0 listinvoices"))["invoices"]
+    if len(invs) > 0 and invs[0]["state"] == "SETTLED":
+        print("\nSettled!")
+        return True
+    else:
+        return False
+base.wait_for_predicate(check_invoices)
+
+print("\nEnsuring channel-level channel policy settings: target")
+payment = json.loads(base.warcli("lncli 2 listpayments"))["payments"][0]
+assert payment["fee_msat"] == "2213"
+
 base.stop_server()