@arp-protocol/cli 0.0.0-stage → 0.0.1

package/dist/chunks/node-init-4v2m2vj0.js

@@ -0,0 +1,255 @@
+#!/usr/bin/env node
+import {
+  resolveNodeKey
+} from "./cli-zpft011j.js";
+import"./cli-tyey74p3.js";
+import {
+  asEndpointBinding,
+  endpointBindingDocument,
+  normaliseEndpoint,
+  parseAgentRegistry,
+  validateHandshakeRequest
+} from "./cli-74hv4etk.js";
+import"./cli-c8568g4c.js";
+import"./cli-v446mw5v.js";
+import {
+  isHex
+} from "./cli-0hqxver6.js";
+import"./cli-d3dy7cxe.js";
+import"./cli-3kbbwfbp.js";
+import"./cli-g5zvr10v.js";
+
+// src/node-init.ts
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+// ../node/src/register.ts
+async function post(fetchLike, url, body) {
+  const response = await fetchLike(url, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  let parsed = null;
+  try {
+    parsed = await response.json();
+  } catch {
+    parsed = null;
+  }
+  return { status: response.status, ok: response.ok, body: parsed };
+}
+function refusal(status, body) {
+  if (typeof body === "object" && body !== null) {
+    const { error, reason } = body;
+    if (typeof error === "string")
+      return typeof reason === "string" ? `${error}: ${reason}` : error;
+  }
+  return `HTTP ${status}`;
+}
+function isChallenge(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const record = value;
+  return typeof record["nonce"] === "string" && typeof record["message"] === "string" && typeof record["owner"] === "string" && typeof record["nodeAddress"] === "string";
+}
+async function register(options) {
+  const fetchLike = options.fetch ?? fetch;
+  const base = options.directoryUrl.replace(/\/$/, "");
+  const request = {
+    ...options.agent,
+    nodePublicKey: options.node.publicKey,
+    endpoint: options.endpoint
+  };
+  const valid = validateHandshakeRequest(request);
+  if (!valid.ok) {
+    return {
+      ok: false,
+      step: "request",
+      reason: valid.error.code === "malformed" ? valid.error.reason : valid.error.code
+    };
+  }
+  let answer;
+  try {
+    answer = await post(fetchLike, `${base}/challenge`, request);
+  } catch (error) {
+    return {
+      ok: false,
+      step: "challenge",
+      reason: error instanceof Error ? error.message : String(error)
+    };
+  }
+  if (!answer.ok)
+    return { ok: false, step: "challenge", reason: refusal(answer.status, answer.body) };
+  if (!isChallenge(answer.body))
+    return { ok: false, step: "challenge", reason: "not a challenge" };
+  const challenge = answer.body;
+  if (challenge.nodeAddress.toLowerCase() !== options.node.address.toLowerCase()) {
+    return { ok: false, step: "challenge", reason: "the challenge names another node key" };
+  }
+  let ownerSignature;
+  try {
+    ownerSignature = await options.signAsOwner(challenge);
+  } catch (error) {
+    return {
+      ok: false,
+      step: "owner",
+      reason: error instanceof Error ? error.message : String(error)
+    };
+  }
+  if (!isHex(ownerSignature))
+    return { ok: false, step: "owner", reason: "the signature is not hex" };
+  const nodeSignature = await options.node.signMessage({ message: challenge.message });
+  let done;
+  try {
+    done = await post(fetchLike, `${base}/complete`, {
+      nonce: challenge.nonce,
+      ownerSignature,
+      nodeSignature
+    });
+  } catch (error) {
+    return {
+      ok: false,
+      step: "complete",
+      reason: error instanceof Error ? error.message : String(error)
+    };
+  }
+  if (!done.ok)
+    return { ok: false, step: "complete", reason: refusal(done.status, done.body) };
+  const binding = asEndpointBinding(done.body);
+  if (binding === null || binding.message !== challenge.message) {
+    return { ok: false, step: "complete", reason: "the directory did not return this binding" };
+  }
+  return { ok: true, binding, challenge };
+}
+
+// src/node-init.ts
+var NODE_INIT_EXIT = { ok: 0, usage: 2, refused: 3, failed: 6 };
+var VALUE_FLAGS = {
+  "--agent-registry": "agentRegistry",
+  "--agent-id": "agentId",
+  "--endpoint": "endpoint",
+  "--directory": "directory"
+};
+function parseNodeInitFlags(args) {
+  const flags = {
+    agentRegistry: null,
+    agentId: null,
+    endpoint: null,
+    directory: null,
+    noInput: false
+  };
+  for (let i = 0;i < args.length; i += 1) {
+    const arg = args[i] ?? "";
+    if (arg === "--node")
+      continue;
+    if (arg === "--no-input") {
+      flags.noInput = true;
+      continue;
+    }
+    const [name, inline] = arg.includes("=") ? [arg.slice(0, arg.indexOf("=")), arg.slice(arg.indexOf("=") + 1)] : [arg, null];
+    if (name in VALUE_FLAGS) {
+      const value = inline ?? args[i + 1];
+      if (inline === null)
+        i += 1;
+      if (value === undefined || value.length === 0 || value.startsWith("--")) {
+        return new Error(`${name} needs a value`);
+      }
+      flags[VALUE_FLAGS[name]] = value;
+      continue;
+    }
+    return new Error(`unknown option '${arg}' for init --node`);
+  }
+  return flags;
+}
+function writePrivate(path, text) {
+  mkdirSync(dirname(path), { recursive: true, mode: 448 });
+  writeFileSync(path, text, { mode: 384 });
+}
+async function nodeInit(flags, io) {
+  const agentRegistry = flags.agentRegistry ?? io.env["AGENT_REGISTRY"] ?? null;
+  const agentId = flags.agentId ?? io.env["AGENT_ID"] ?? null;
+  const endpointRaw = flags.endpoint ?? io.env["ARP_NODE_PUBLIC_URL"] ?? null;
+  const directory = flags.directory ?? io.env["ARP_DIRECTORY_URL"] ?? null;
+  const missing = [];
+  if (agentRegistry === null)
+    missing.push("--agent-registry (or AGENT_REGISTRY)");
+  if (agentId === null)
+    missing.push("--agent-id (or AGENT_ID)");
+  if (endpointRaw === null)
+    missing.push("--endpoint (or ARP_NODE_PUBLIC_URL)");
+  if (directory === null)
+    missing.push("--directory (or ARP_DIRECTORY_URL)");
+  if (missing.length > 0 || agentRegistry === null || agentId === null || endpointRaw === null || directory === null) {
+    io.err(`arp init --node: missing ${missing.join(", ")}`);
+    return NODE_INIT_EXIT.usage;
+  }
+  if (parseAgentRegistry(agentRegistry) === null || !/^(0|[1-9][0-9]*)$/.test(agentId)) {
+    io.err("arp init --node: the agent is eip155:<chainId>:<registry> plus a decimal token id");
+    return NODE_INIT_EXIT.usage;
+  }
+  const endpoint = normaliseEndpoint(endpointRaw);
+  if (endpoint === null) {
+    io.err(`arp init --node: the endpoint must be the tunnel's https URL, got ${endpointRaw}`);
+    return NODE_INIT_EXIT.usage;
+  }
+  if (flags.noInput || !io.interactive) {
+    io.err("arp init --node: the owner signs the handshake in their wallet, which needs a terminal");
+    return NODE_INIT_EXIT.refused;
+  }
+  let key;
+  try {
+    key = resolveNodeKey(io.env, { home: io.home });
+  } catch (error) {
+    io.err(`arp init --node: ${error instanceof Error ? error.message : String(error)}`);
+    return NODE_INIT_EXIT.failed;
+  }
+  io.err(`node key   ${key.account.address}  (${key.source === "env" ? "AGENT_PRIVATE_KEY" : key.path})`);
+  const messagePath = join(io.home, ".arp", "handshake-message.txt");
+  const result = await register({
+    directoryUrl: directory,
+    agent: { agentRegistry, agentId },
+    endpoint,
+    node: key.account,
+    ...io.fetch === undefined ? {} : { fetch: io.fetch },
+    async signAsOwner(challenge) {
+      writePrivate(messagePath, challenge.message);
+      io.err("");
+      io.err(`Sign this message as ${challenge.owner}, the token's owner, before ${challenge.expiresAt}:`);
+      io.err("");
+      for (const line of challenge.message.split(`
+`))
+        io.err(`  ${line}`);
+      io.err("");
+      io.err(`It is also in ${messagePath}. With Foundry, for example:`);
+      io.err(`  cast wallet sign --interactive "$(cat ${messagePath})"`);
+      io.err("");
+      const answer = (await io.readLine("owner signature (0x…): ")).trim();
+      if (!isHex(answer) || answer.length < 132)
+        throw new Error("that is not a signature");
+      return answer;
+    }
+  });
+  if (!result.ok) {
+    io.err(`arp init --node: ${result.step} refused: ${result.reason}`);
+    return NODE_INIT_EXIT.failed;
+  }
+  const bindingPath = join(io.home, ".arp", "node-binding.json");
+  const documentPath = join(io.home, ".arp", "node-binding.document.json");
+  writePrivate(bindingPath, `${JSON.stringify(result.binding, null, 2)}
+`);
+  writePrivate(documentPath, endpointBindingDocument(result.binding));
+  io.out(`bound      node ${result.binding.nodeAddress} to agent ${agentId} of ${agentRegistry}`);
+  io.out(`endpoint   ${result.binding.endpoint}`);
+  io.out(`saved      ${bindingPath}`);
+  io.out(`document   ${documentPath}`);
+  io.out("");
+  io.out("Next: pin the document to IPFS, then write the binding on Intuition testnet with");
+  io.out("`prepareEndpointBinding`. This command signs no transaction.");
+  io.out("A transfer of the token voids the binding until you run this again.");
+  return NODE_INIT_EXIT.ok;
+}
+export {
+  parseNodeInitFlags,
+  nodeInit,
+  NODE_INIT_EXIT
+};

package/dist/chunks/secp256k1-j2w0pmjr.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import {
+  encodeToCurve,
+  hashToCurve,
+  schnorr,
+  secp256k1,
+  secp256k1_hasher
+} from "./cli-d3dy7cxe.js";
+import"./cli-3kbbwfbp.js";
+import"./cli-g5zvr10v.js";
+export {
+  secp256k1_hasher,
+  secp256k1,
+  schnorr,
+  hashToCurve,
+  encodeToCurve
+};