Merge pull request #4 from 0KnowledgeNetwork/feature/networks

feat: init commands for networks

Author: xendarboh

.github/workflows/docker.yml

@@ -7,8 +7,8 @@ on:
   push:
     branches:
       - main
-    paths:
-      - ".github/workflows/docker.yml"
+    paths-ignore:
+      - '**/*.md'
     tags:
       - "v*"
 

Dockerfile

@@ -27,6 +27,11 @@ RUN pnpm run build
 # Stage 2: Production image
 FROM base AS runner
 
+# install deps used by scripts
+RUN apk add --no-cache \
+  bash \
+  netcat-openbsd
+
 COPY --from=builder /app/appchain/packages/chain/dist /app/appchain/packages/chain/dist
 COPY --from=builder /app/appchain/packages/chain/package.json /app/appchain/packages/chain/
 COPY --from=builder /app/appchain/package.json /app/appchain/pnpm-lock.yaml /app/appchain/
@@ -36,4 +41,6 @@ COPY --from=builder /app/appchain-agent/dist ./dist
 COPY --from=builder /app/appchain-agent/package.json /app/appchain-agent/pnpm-lock.yaml ./
 RUN --mount=type=cache,id=pnpm,target=${PNPM_HOME}/store pnpm install --prod --frozen-lockfile
 
+COPY bin ./bin
+
 USER node

bin/network-init.sh

@@ -0,0 +1,55 @@
+#!/bin/bash
+
+test -z "${2}" && echo "USAGE: ${0} <network_id> <file://build.yml> [data dir]" && exit 1
+
+network_id=${1}
+network_build=${2}
+dir=${3:-/tmp}
+socket=${dir}/appchain.sock
+
+cat <<EOF
+Initialize Network:
+  data directory: '${dir}'
+  network id: '${network_id}'
+  network build file: '${network_build}'
+EOF
+
+mkdir -p "${dir}"
+
+node \
+  --experimental-specifier-resolution=node \
+  --experimental-vm-modules \
+  --experimental-wasm-modules \
+  --experimental-wasm-threads \
+  --no-warnings \
+  dist/index.js \
+  --admin \
+  --debug \
+  --ipfs \
+  --ipfs-data ${dir}/ipfs \
+  --key ${dir}/admin.key \
+  --listen \
+  --nonce \
+  --socket ${socket} \
+  --tx-status-retries 0 \
+  &
+PID=$!
+
+# Wait for the socket to exist
+while [ ! -S ${socket} ]; do sleep 1; done
+
+appchain () {
+  echo "$@" | tee >(cat >&2) | nc -U -q 0 ${socket}
+  sleep 0.2s
+}
+
+appchain admin setAdmin
+appchain nodes setRegistrationStake 0
+appchain nodes openRegistration
+appchain networks register ${network_id} ${network_build}
+sleep 1s # avoid nonce collision from slower register command (IPFS)
+appchain networks setActive ${network_id}
+
+kill ${PID}
+
+rm -f ${socket}

clients/go/chainbridge/chainbridge.go

@@ -51,6 +51,11 @@ type CommandResponse struct {
 	TX     string      `cbor:"tx,omitempty"`
 }
 
+type Network struct {
+	Identifier string `cbor:"identifier"`
+	Parameters []byte `cbor:"parameters"`
+}
+
 type Node struct {
 	Administrator string `cbor:"administrator"`
 	Identifier    string `cbor:"identifier"`
@@ -65,11 +70,14 @@ var (
 	ErrNoData = errors.New("ChainBridge: no data")
 
 	// command response errors returned by the appchain
-	Err_nodes_alreadyRegistered = "Node already registered"
+	Err_networks_alreadyRegistered = "Network already registered"
+	Err_nodes_alreadyRegistered    = "Node already registered"
 )
 
 // appchain-agent commands; cuz compile errors are better than runtime errors
 var (
+	Cmd_networks_getNetwork         = "networks getNetwork %s"
+	Cmd_networks_register           = "networks register %s"
 	Cmd_nodes_getNode               = "nodes getNode %s"
 	Cmd_nodes_register              = "nodes register %s %d %d"
 	Cmd_pki_getDocucment            = "pki getDocument %d"

clients/go/cmd/client/main.go

@@ -24,6 +24,42 @@ func sendCommand(command string, payload []byte) {
 	}
 }
 
+func networkRegistration() {
+	network1 := chainbridge.Network{
+		Identifier: "0x000",
+		Parameters: []byte("pA: 1\npB: 2\npC: 3\n"),
+	}
+	log.Printf("Network in: %+v", network1)
+
+	// register the network
+	command := fmt.Sprintf(
+		chainbridge.Cmd_networks_register,
+		network1.Identifier,
+	)
+	response, err := chBridge.Command(command, network1.Parameters)
+	log.Printf("Response (%s): %+v\n", command, response)
+	if err != nil {
+		log.Printf("ChainBridge command error: %v", err)
+	}
+	if response.Error != "" {
+		log.Printf("ChainBridge response error: %v", response.Error)
+	}
+
+	// retrieve the network
+	command = fmt.Sprintf(chainbridge.Cmd_networks_getNetwork, network1.Identifier)
+	response, err = chBridge.Command(command, nil)
+	if err != nil {
+		log.Printf("ChainBridge command error: %v", err)
+	} else {
+		log.Printf("Response (%s): %+v\n", command, response)
+	}
+	var network2 chainbridge.Network
+	if err := chBridge.DataUnmarshal(response, &network2); err != nil {
+		log.Printf("ChainBridge data error: %v", err)
+	}
+	log.Printf("Network out: %+v", network2)
+}
+
 func nodeRegistration() {
 	node1 := chainbridge.Node{
 		Identifier:    "node-5000",
@@ -35,7 +71,7 @@ func nodeRegistration() {
 
 	// register the node
 	command := fmt.Sprintf(
-		"nodes register %s %d %d",
+		chainbridge.Cmd_nodes_register,
 		node1.Identifier,
 		chainbridge.Bool2int(node1.IsGatewayNode),
 		chainbridge.Bool2int(node1.IsServiceNode))
@@ -49,7 +85,7 @@ func nodeRegistration() {
 	}
 
 	// retrieve the node
-	command = fmt.Sprintf("nodes getNode %s", node1.Identifier)
+	command = fmt.Sprintf(chainbridge.Cmd_nodes_getNode, node1.Identifier)
 	response, err = chBridge.Command(command, nil)
 	if err != nil {
 		log.Printf("ChainBridge command error: %v", err)
@@ -89,7 +125,7 @@ func pkiMixDescriptor() {
 	id := "node-5000"
 
 	// send encoded data as payload to IPFS and the appchain
-	command := fmt.Sprintf("pki setMixDescriptor %d %s", epoch, id)
+	command := fmt.Sprintf(chainbridge.Cmd_pki_setMixDescriptor, epoch, id)
 	response, err := chBridge.Command(command, enc)
 	log.Printf("Response (%s): %+v\n", command, response)
 	if err != nil {
@@ -100,7 +136,7 @@ func pkiMixDescriptor() {
 	}
 
 	// retrieve the stored data
-	command = fmt.Sprintf("pki getMixDescriptor %d %s", epoch, id)
+	command = fmt.Sprintf(chainbridge.Cmd_pki_getMixDescriptor, epoch, id)
 	response, err = chBridge.Command(command, nil)
 	if err != nil {
 		log.Printf("ChainBridge command error: %v", err)
@@ -122,8 +158,7 @@ func pkiMixDescriptor() {
 }
 
 func getGenesisEpoch() uint64 {
-	command := "pki getGenesisEpoch"
-	response, err := chBridge.Command(command, nil)
+	response, err := chBridge.Command(chainbridge.Cmd_pki_getGenesisEpoch, nil)
 	if err != nil {
 		log.Printf("ChainBridge command error: %v", err)
 	}
@@ -186,6 +221,7 @@ func main() {
 	}
 	wg.Wait()
 
+	networkRegistration()
 	nodeRegistration()
 
 	log.Printf("genesisEpoch: %d", getGenesisEpoch())

package.json

@@ -8,7 +8,7 @@
   "scripts": {
     "lint": "eslint .",
     "build": "tsc -p tsconfig.json",
-    "agent": "node --experimental-specifier-resolution=node --experimental-vm-modules --experimental-wasm-modules --experimental-wasm-threads dist/index.js"
+    "agent": "node --experimental-specifier-resolution=node --experimental-vm-modules --experimental-wasm-modules --experimental-wasm-threads --no-warnings dist/index.js"
   },
   "devDependencies": {
     "@types/node": "^22.4.1",

src/index.ts

@@ -16,6 +16,7 @@ import {
   Balance,
   CID,
   MixDescriptor,
+  Network,
   Node,
   TreasuryId,
   client,
@@ -60,6 +61,19 @@ const getPrivateKeyFromFile = async (path: string): Promise<PrivateKey> => {
   }
 };
 
+const getBytesFromFile = async (path: string): Promise<Uint8Array> => {
+  const f = path.replace(/^file:\/\//, "");
+  return await fs.readFile(f);
+};
+
+const putBytesToFile = async (
+  path: string,
+  data: Uint8Array,
+): Promise<void> => {
+  const f = path.replace(/^file:\/\//, "");
+  return await fs.writeFile(f, data);
+};
+
 const program = new Command();
 program.name("cli").description("appchain cli");
 
@@ -130,6 +144,7 @@ console.log("opts", opts);
 await client.start();
 const admin = client.runtime.resolve("Admin");
 const faucet = client.runtime.resolve("Faucet");
+const networks = client.runtime.resolve("Networks");
 const nodes = client.runtime.resolve("Nodes");
 const pki = client.runtime.resolve("Pki");
 const token = client.runtime.resolve("Token");
@@ -303,6 +318,104 @@ const executeCommand = async (
       });
   }
 
+  const commandNetworks = program
+    .command("networks")
+    .description("networks commands");
+  commandNetworks
+    .command("register <identifier> [file://]")
+    .description("register a network <parameters := file:// OR payload>")
+    .action(async (identifier: string, file?: string) => {
+      if (!ipfsNode) return callback(responses.IPFS_NOT_STARTED);
+
+      // get network parameters from file or payload
+      const _payload = file ? await getBytesFromFile(file) : payload;
+      if (!_payload) return callback(responses.PAYLOAD_UNDEFINED);
+
+      const parametersCID = await ipfsNode.putBytes(_payload);
+
+      const r = await txer(async () => {
+        await networks.register(
+          new Network({
+            identifier: CircuitString.fromString(identifier),
+            parametersCID: CID.fromString(parametersCID),
+          }),
+        );
+      });
+
+      const debug = { identifier, cid: parametersCID, tx: r.tx };
+      callback({ id, ...r }, debug);
+    });
+  commandNetworks
+    .command("getActive")
+    .description("get the identifier of the active network(s)")
+    .action(async () => {
+      const nid = (await client.query.runtime.Networks.activeNetwork.get()) as
+        | Field
+        | undefined;
+      if (!nid) return callback(responses.RECORD_NOT_FOUND);
+
+      // retrieve the string form of the network identifier
+      const n = await client.query.runtime.Networks.networks.get(nid);
+      if (!n) return callback(responses.RECORD_NOT_FOUND);
+
+      callback({ id, status: SUCCESS, data: n.identifier.toString() });
+    });
+  commandNetworks
+    .command("getNetwork <identifier> [file://]")
+    .description(
+      'get network by id; "_" for active, optionally save params to file',
+    )
+    .action(async (identifier: string, file?: string) => {
+      if (!ipfsNode) return callback(responses.IPFS_NOT_STARTED);
+
+      var networkID: Field;
+      if (identifier === "_") {
+        const nid =
+          (await client.query.runtime.Networks.activeNetwork.get()) as
+            | Field
+            | undefined;
+        if (!nid) return callback(responses.RECORD_NOT_FOUND);
+        networkID = nid;
+      } else {
+        networkID = Network.getID(CircuitString.fromString(identifier));
+      }
+
+      const network = (await client.query.runtime.Networks.networks.get(
+        networkID,
+      )) as Network | undefined;
+      if (!network) return callback(responses.RECORD_NOT_FOUND);
+
+      const cid = network.parametersCID.toString();
+      const parameters = await ipfsNode.getBytes(cid);
+      if (file) await putBytesToFile(file, parameters);
+
+      const { parametersCID, ...rest } = Network.toObject(network);
+      const data = {
+        parameters,
+        ...rest,
+      };
+
+      const debug = { identifier, cid, network: rest };
+      callback(
+        {
+          id,
+          status: SUCCESS,
+          data: opts.socketFormat === "cbor" ? cbor.encode(data) : data,
+        },
+        debug,
+      );
+    });
+  commandNetworks
+    .command("setActive <identifier>")
+    .description("set the active network")
+    .action(async (identifier: string) => {
+      const networkID = Network.getID(CircuitString.fromString(identifier));
+      const r = await txer(async () => {
+        await networks.setActiveNetwork(networkID);
+      });
+      callback({ id, ...r });
+    });
+
   const commandNodes = program.command("nodes").description("nodes commands");
   commandNodes
     .command("isRegistrationOpen")