rpc: add graph import-json to recreate a graph from lnd description

Author: pinheadmz

Diff for: docs/warcli.md

@@ -105,6 +105,18 @@ options:
 | bitcoin_conf | Path   |            |           |
 | random       | Bool   |            | False     |
 
+### `warcli graph import-json`
+Create a cycle graph with nodes imported from lnd `describegraph` JSON file,
+    and additionally include 7 extra random outbounds per node. Include lightning
+    channels and their policies as well.
+    Returns XML file as string with or without --outfile option.
+
+options:
+| name    | type   | required   | default   |
+|---------|--------|------------|-----------|
+| infile  | Path   | yes        |           |
+| outfile | Path   |            |           |
+
 ### `warcli graph validate`
 Validate a \<graph file> against the schema.
 

Diff for: src/cli/graph.py

@@ -36,6 +36,19 @@ def create(number: int, outfile: Path, version: str, bitcoin_conf: Path, random:
     )
 
 
+@graph.command()
+@click.argument("infile", type=click.Path())
+@click.option("--outfile", type=click.Path())
+def import_json(infile: Path, outfile: Path):
+    """
+    Create a cycle graph with nodes imported from lnd `describegraph` JSON file,
+    and additionally include 7 extra random outbounds per node. Include lightning
+    channels and their policies as well.
+    Returns XML file as string with or without --outfile option.
+    """
+    print(rpc_call("graph_import", {"infile": str(infile), "outfile": str(outfile) if outfile else ""}))
+
+
 @graph.command()
 @click.argument("graph", type=click.Path())
 def validate(graph: Path):

Diff for: src/warnet/server.py

@@ -26,6 +26,7 @@
 from flask_jsonrpc.app import JSONRPC
 from flask_jsonrpc.exceptions import ServerError
 from warnet.utils import (
+    DEFAULT_TAG,
     create_cycle_graph,
     gen_config_dir,
     validate_graph_schema,
@@ -170,6 +171,7 @@ def setup_rpc(self):
         self.jsonrpc.register(self.network_export)
         # Graph
         self.jsonrpc.register(self.graph_generate)
+        self.jsonrpc.register(self.graph_import)
         self.jsonrpc.register(self.graph_validate)
         # Debug
         self.jsonrpc.register(self.generate_deployment)
@@ -529,6 +531,74 @@ def graph_generate(
             self.logger.error(msg)
             raise ServerError(message=msg) from e
 
+    def graph_import(
+        self,
+        infile: str,
+        outfile: str
+    ) -> str:
+        with open(infile) as f:
+            json_graph = json.loads(f.read())
+
+        # Start with a connected L1 graph with the right amount of tanks
+        graph = create_cycle_graph(len(json_graph["nodes"]), version=DEFAULT_TAG, bitcoin_conf=None, random_version=False)
+
+        # Initialize all the tanks with basic LN node configurations
+        for index, n in enumerate(graph.nodes()):
+            graph.nodes[n]["bitcoin_config"] = f"-uacomment=tank{index:06}"
+            graph.nodes[n]["ln"] = "lnd"
+            graph.nodes[n]["ln_cb_image"] = "pinheadmz/circuitbreaker:278737d"
+            graph.nodes[n]["ln_config"] = "--protocol.wumbo-channels"
+
+        # Save a map of LN pubkey -> Tank index
+        ln_ids = {}
+        for index, node in enumerate(json_graph["nodes"]):
+            ln_ids[node["id"]] = index
+
+        # Offset for edge IDs
+        # Note create_cycle_graph() creates L1 edges all with the same id "0"
+        L1_edges = len(graph.edges)
+
+        # Insert LN channels
+        # Ensure channels are in order by channel ID like lnd describegraph output
+        sorted_edges = sorted(json_graph["edges"], key=lambda chan: int(chan['channel_id']))
+        for ln_index, channel in enumerate(sorted_edges):
+            src = ln_ids[channel["node1_pub"]]
+            tgt = ln_ids[channel["node2_pub"]]
+            cap = int(channel["capacity"])
+            push = cap // 2
+            openp = f"--local_amt={cap} --push_amt={push}"
+            srcp = ""
+            tgtp = ""
+            if channel["node1_policy"]:
+                srcp += f" --base_fee_msat={channel['node1_policy']['fee_base_msat']}"
+                srcp += f" --fee_rate_ppm={channel['node1_policy']['fee_rate_milli_msat']}"
+                srcp += f" --time_lock_delta={channel['node1_policy']['time_lock_delta']}"
+                srcp += f" --min_htlc_msat={channel['node1_policy']['min_htlc']}"
+                srcp += f" --max_htlc_msat={push * 1000}"
+            if channel["node2_policy"]:
+                tgtp += f" --base_fee_msat={channel['node2_policy']['fee_base_msat']}"
+                tgtp += f" --fee_rate_ppm={channel['node2_policy']['fee_rate_milli_msat']}"
+                tgtp += f" --time_lock_delta={channel['node2_policy']['time_lock_delta']}"
+                tgtp += f" --min_htlc_msat={channel['node2_policy']['min_htlc']}"
+                tgtp += f" --max_htlc_msat={push * 1000}"
+
+            graph.add_edge(
+                src,
+                tgt,
+                key = ln_index+L1_edges,
+                channel_open = openp,
+                source_policy = srcp,
+                target_policy = tgtp)
+
+        if outfile:
+            file_path = Path(outfile)
+            nx.write_graphml(graph, file_path, named_key_ids=True)
+            return f"Generated graph written to file: {outfile}"
+        bio = BytesIO()
+        nx.write_graphml(graph, bio, named_key_ids=True)
+        xml_data = bio.getvalue()
+        return xml_data.decode("utf-8")
+
     def graph_validate(self, graph_path: str) -> str:
         with open(graph_path) as f:
             graph = nx.parse_graphml(f.read(), node_type=int, force_multigraph=True)

Diff for: src/warnet/utils.py

@@ -389,8 +389,9 @@ def set_execute_permission(file_path):
 
 def create_cycle_graph(n: int, version: str, bitcoin_conf: str | None, random_version: bool):
     try:
-        # Use nx.DiGraph() as base otherwise edges not always made in specific directions
-        graph = nx.generators.cycle_graph(n, nx.DiGraph())
+        # Use nx.MultiDiGraph() so we get directed edges (source->target)
+        # and still allow parallel edges (L1 p2p connections + LN channels)
+        graph = nx.generators.cycle_graph(n, nx.MultiDiGraph())
     except TypeError as e:
         msg = f"Failed to create graph: {e}"
         logger.error(msg)