@toon-protocol/rig 2.12.0 → 2.13.0

package/dist/cli/rig.js

@@ -21,14 +21,16 @@ import {
 } from "../chunk-EEUHZNWS.js";
 import {
   DEFAULT_KEYSTORE_PASSWORD,
+  MinaZkAppStore,
   MissingIdentityError,
+  TOPOLOGY_CACHE_FILENAME,
   clientConfigPath,
   clientKeystorePath,
   linkKeystoreInClientConfig,
   readClientConfigFile,
   resolveAccountIndex,
   resolveIdentity
-} from "../chunk-GZUDRNOK.js";
+} from "../chunk-FFQXFV4W.js";
 import {
   ChannelMapStore,
   channelStatus,
@@ -40,6 +42,9 @@ import {
   MAX_OBJECT_SIZE,
   flooredUploadFee
 } from "../chunk-35ALWUDJ.js";
+import {
+  minaPresetForChain
+} from "../chunk-ACTH6ISJ.js";
 import {
   COMMENT_KIND,
   authorizedStatusAuthors,
@@ -1074,7 +1079,7 @@ function loadPaidSession(deps, relayUrl) {
   });
 }
 var defaultLoadStandalone = async (options) => {
-  const mod = await import("../standalone-mode-U3OOSVOB.js");
+  const mod = await import("../standalone-mode-D2YSANBJ.js");
   return mod.createStandaloneContext(options);
 };
 function identityReport(ctx) {
@@ -1941,6 +1946,9 @@ async function runChain(args, deps) {
 }
 
 // src/cli/channel.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join3 } from "path";
 import { parseArgs as parseArgs5 } from "util";
 var CHANNEL_USAGE = `Usage: rig channel <subcommand>
 
@@ -1963,6 +1971,17 @@ Subcommands:
                    apex); --deposit adds that much extra collateral after the
                    open/resume. On-chain: asks for confirmation (--yes skips).
 
+  deploy-zkapp [--graphql-url <url>]
+                   deploy a dedicated Mina PaymentChannel zkApp for THIS
+                   identity (the zkApp is single-pair; Mina channels open on
+                   an identity-owned deployment). Normally automatic \u2014 the
+                   Mina open path deploys one when needed \u2014 this explicit
+                   form pre-deploys it (compile \u22481-3 min, inclusion \u22483-6 min).
+                   On-chain: costs the 1 MINA account-creation fee + tx fee
+                   from the wallet's MINA. The zkApp key is saved under
+                   TOON_CLIENT_HOME/keys/. Asks for confirmation (--yes
+                   skips).
+
   close <channelId>
                    close a recorded channel \u2014 an on-chain tx that starts the
                    settlement challenge window (the peer's settlementTimeout).
@@ -1986,6 +2005,8 @@ async function runChannel(args, deps) {
       return runChannelList(rest, deps);
     case "open":
       return runChannelOpen(rest, deps);
+    case "deploy-zkapp":
+      return runChannelDeployZkApp(rest, deps);
     case "close":
       return runChannelWithdrawStep(rest, deps, "close");
     case "settle":
@@ -2178,6 +2199,9 @@ async function runChannelOpen(args, deps) {
       io2.out(
         "If a live channel is already recorded for this peer it is RESUMED (no on-chain spend); otherwise an on-chain channel open locks the peer-negotiated initial deposit from your wallet (plus gas)."
       );
+      io2.out(
+        "On a Mina chain a first open may also deploy a dedicated PaymentChannel zkApp for this identity (~1.1 MINA + fees; compile \u22481-3 min, inclusion \u22483-6 min \u2014 progress is printed)."
+      );
     }
     const gate = await confirmOnChain(
       io2,
@@ -2236,6 +2260,160 @@ async function runChannelOpen(args, deps) {
     await stopQuietly(ctx);
   }
 }
+async function runChannelDeployZkApp(args, deps) {
+  const { io: io2, env } = deps;
+  let graphqlFlag;
+  let yes = false;
+  let json = false;
+  try {
+    const { values } = parseArgs5({
+      args,
+      options: {
+        "graphql-url": { type: "string" },
+        yes: { type: "boolean", default: false },
+        json: { type: "boolean", default: false },
+        help: { type: "boolean", short: "h", default: false }
+      }
+    });
+    if (values.help) {
+      io2.out(CHANNEL_USAGE);
+      return 0;
+    }
+    graphqlFlag = values["graphql-url"];
+    yes = values.yes ?? false;
+    json = values.json ?? false;
+  } catch (err) {
+    io2.err(err instanceof Error ? err.message : String(err));
+    io2.err(CHANNEL_USAGE);
+    return 2;
+  }
+  try {
+    const dir = env["TOON_CLIENT_HOME"] ?? join3(homedir3(), ".toon-client");
+    let file = {};
+    try {
+      file = JSON.parse(readFileSync3(join3(dir, "config.json"), "utf8"));
+    } catch {
+    }
+    const pinned = env["TOON_CLIENT_CHAIN"] ?? file.chain;
+    const chain = pinned !== void 0 && pinned.startsWith("mina:") ? pinned : "mina:devnet";
+    const graphqlUrl = graphqlFlag ?? file.minaChannel?.graphqlUrl ?? minaPresetForChain(chain)?.graphqlUrl;
+    if (!graphqlUrl) {
+      throw new Error(
+        `no Mina GraphQL endpoint for ${chain} \u2014 pass --graphql-url or set minaChannel.graphqlUrl in the client config`
+      );
+    }
+    const resolved = await resolveIdentity({
+      env,
+      cwd: deps.cwd,
+      warn: (line) => io2.err(line)
+    });
+    const identity = {
+      pubkey: resolved.pubkey,
+      source: resolved.source,
+      sourceLabel: resolved.sourceLabel
+    };
+    const store = MinaZkAppStore.forHome(dir);
+    const existing = store.lookup(resolved.pubkey, chain);
+    if (existing) {
+      if (json) {
+        io2.emitJson({
+          command: "channel deploy-zkapp",
+          identity,
+          executed: false,
+          plan: { chain, graphqlUrl },
+          result: {
+            zkAppAddress: existing.zkAppAddress,
+            deployTxHash: existing.deployTxHash ?? null,
+            vkHash: existing.vkHash ?? null,
+            storePath: store.filePath
+          },
+          hint: "a zkApp is already recorded for this identity/chain \u2014 the open path reuses it"
+        });
+        return 0;
+      }
+      io2.out(
+        `A Mina zkApp is already recorded for this identity on ${chain}: ` + existing.zkAppAddress
+      );
+      io2.out(`The open path reuses it (record: ${store.filePath}).`);
+      return 0;
+    }
+    const plan = { chain, graphqlUrl };
+    if (!json) {
+      io2.out("Mina zkApp deploy plan:");
+      io2.out(`  chain       ${chain}`);
+      io2.out(`  graphql     ${graphqlUrl}`);
+      io2.out(renderIdentityLine(identity));
+      io2.out(
+        "Deploys a dedicated PaymentChannel zkApp for this identity \u2014 on-chain: the 1 MINA account-creation fee + a 0.1 MINA tx fee from your wallet. Compile \u22481-3 min; inclusion \u22483-6 min."
+      );
+    }
+    const gate = await confirmOnChain(
+      io2,
+      { yes, json },
+      "Proceed with the on-chain zkApp deploy? [y/N] "
+    );
+    if (gate === "json-plan") {
+      io2.emitJson({
+        command: "channel deploy-zkapp",
+        identity,
+        executed: false,
+        plan,
+        hint: "plan only \u2014 re-run with --yes to deploy (on-chain: ~1.1 MINA + fees)"
+      });
+      return 0;
+    }
+    if (gate !== "proceed") return gate;
+    const client = await import("@toon-protocol/client");
+    const derived = await client.deriveFullIdentity(
+      resolved.mnemonic,
+      resolved.accountIndex
+    );
+    if (!derived.mina.privateKey) {
+      throw new Error(
+        "no Mina key derived \u2014 the optional `mina-signer` dependency is not installed"
+      );
+    }
+    const record = await client.deployMinaChannelZkApp({
+      graphqlUrl,
+      payerPrivateKey: derived.mina.privateKey,
+      onProgress: (line) => io2.err(`rig: mina: ${line}`)
+    });
+    store.save({
+      identity: resolved.pubkey,
+      chain,
+      zkAppAddress: record.zkAppAddress,
+      zkAppPrivateKey: record.zkAppPrivateKey,
+      feePayer: record.feePayer,
+      ...record.deployTxHash !== void 0 ? { deployTxHash: record.deployTxHash } : {},
+      ...record.vkHash !== void 0 ? { vkHash: record.vkHash } : {},
+      deployedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      source: "rig channel deploy-zkapp (npm @toon-protocol/mina-zkapp build)"
+    });
+    if (json) {
+      io2.emitJson({
+        command: "channel deploy-zkapp",
+        identity,
+        executed: true,
+        plan,
+        result: {
+          zkAppAddress: record.zkAppAddress,
+          deployTxHash: record.deployTxHash ?? null,
+          vkHash: record.vkHash ?? null,
+          storePath: store.filePath
+        }
+      });
+      return 0;
+    }
+    io2.out(`Deployed Mina PaymentChannel zkApp ${record.zkAppAddress}.`);
+    if (record.deployTxHash) io2.out(`  deploy tx   ${record.deployTxHash}`);
+    if (record.vkHash) io2.out(`  vk hash     ${record.vkHash}`);
+    io2.out(`  record      ${store.filePath} (holds the zkApp key \u2014 back it up)`);
+    io2.out("The next Mina channel open/push finds and reuses this zkApp.");
+    return 0;
+  } catch (err) {
+    return emitCliError(io2, json, "channel deploy-zkapp", err);
+  }
+}
 function withdrawPrecheck(step, channelId, watermark, nowSec) {
   const status = channelStatus(watermark, nowSec);
   if (status === "settled") {
@@ -2405,7 +2583,7 @@ async function stopQuietly(ctx) {
 
 // src/cli/clone.ts
 import { mkdtemp, mkdir, readdir, rename, rm, rmdir } from "fs/promises";
-import { basename, dirname as dirname2, join as join3, resolve } from "path";
+import { basename, dirname as dirname2, join as join4, resolve } from "path";
 import { parseArgs as parseArgs6 } from "util";
 var CLONE_USAGE = `Usage: rig clone <relay-url> <owner>/<repo-id> [dir] [options]
 
@@ -2576,7 +2754,7 @@ async function runClone(args, deps) {
     }
     const parent = dirname2(dest);
     await mkdir(parent, { recursive: true });
-    tempDir = await mkdtemp(join3(parent, `.${basename(dest)}.rig-clone-`));
+    tempDir = await mkdtemp(join4(parent, `.${basename(dest)}.rig-clone-`));
     await runGit(tempDir, [
       "init",
       "--quiet",
@@ -3822,8 +4000,288 @@ async function warnIfNotMaintainer(deps, args) {
   }
 }
 
-// src/cli/fetch.ts
+// src/cli/entry.ts
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync4, unlinkSync, writeFileSync as writeFileSync3 } from "fs";
+import { homedir as homedir4 } from "os";
+import { dirname as dirname3, join as join5 } from "path";
 import { parseArgs as parseArgs9 } from "util";
+var SANDBOX_BTP_URL = "wss://proxy.sandbox.devnet.toonprotocol.dev:443";
+var SANDBOX_RELAY_URL = "wss://relay-ws.sandbox.devnet.toonprotocol.dev";
+var ENTRY_USAGE = `Usage: rig entry [apex | sandbox | <wss-url>] [options]
+
+Choose which network entry node (payment ingress + relay) rig talks to. Free:
+only the local config file is touched.
+
+  rig entry               show the effective entry endpoints and their source
+  rig entry apex          revert to the default apex: clears the btpUrl/
+                          relayUrl override so core's genesis seed (or a live
+                          announce) applies \u2014 settles evm | sol | mina
+  rig entry sandbox       the devnet sandbox entry (Mina USDC ONLY \u2014 the
+                          cross-currency multihop demo path):
+                            btp    ${SANDBOX_BTP_URL}
+                            relay  ${SANDBOX_RELAY_URL}
+  rig entry <wss-url>     an explicit BTP endpoint (ws:// or wss://); pass
+                          --relay <url> to also set the relay
+
+Switching entries deletes the cached topology (the next paid command
+re-discovers the new entry's announce) and leaves existing payment channels
+behind \u2014 channels are per-entry-peer; the next paid command opens or resumes
+one with the new peer.
+
+NOTE for repos: the relay a repo publishes to is its git \`origin\` remote,
+which OVERRIDES the config relayUrl. After switching entries, point the repo
+too: \`rig remote add origin <relay-url>\` (or use a fresh repo).
+
+Options:
+  --relay <url>        with <wss-url>: also set the relay URL
+  --json               machine-readable envelope
+  -h, --help           show this help`;
+function configPathFor2(env) {
+  const dir = env["TOON_CLIENT_HOME"] ?? join5(homedir4(), ".toon-client");
+  return join5(dir, "config.json");
+}
+function readEntryConfig(configPath) {
+  try {
+    return JSON.parse(readFileSync4(configPath, "utf8"));
+  } catch (err) {
+    if (err.code === "ENOENT") return {};
+    throw new Error(
+      `failed to read client config at ${configPath}: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+function writeEntryConfig(configPath, file) {
+  mkdirSync3(dirname3(configPath), { recursive: true });
+  writeFileSync3(configPath, `${JSON.stringify(file, null, 2)}
+`, "utf8");
+}
+async function loadGenesisSeedDefault() {
+  try {
+    const { loadGenesisSeed } = await import("../network-bootstrap-3X2GXNJB.js");
+    return loadGenesisSeed();
+  } catch {
+    return void 0;
+  }
+}
+function classifyEntry(btpUrl, seedBtp, btpSource) {
+  if (btpUrl === null) return null;
+  if (btpUrl === SANDBOX_BTP_URL) return "sandbox";
+  if (btpSource === "genesis-seed" || btpUrl === seedBtp) return "apex";
+  return "custom";
+}
+async function runEntry(args, deps) {
+  const { io: io2, env } = deps;
+  let positionals;
+  let relayFlag;
+  let json = false;
+  try {
+    const parsed = parseArgs9({
+      args,
+      allowPositionals: true,
+      options: {
+        relay: { type: "string" },
+        json: { type: "boolean", default: false },
+        help: { type: "boolean", short: "h", default: false }
+      }
+    });
+    if (parsed.values.help) {
+      io2.out(ENTRY_USAGE);
+      return 0;
+    }
+    positionals = parsed.positionals;
+    relayFlag = parsed.values.relay;
+    json = parsed.values.json ?? false;
+  } catch (err) {
+    io2.err(err instanceof Error ? err.message : String(err));
+    io2.err(ENTRY_USAGE);
+    return 2;
+  }
+  if (positionals.length > 1) {
+    io2.err(
+      `rig entry takes at most one argument, got ${positionals.length}: ${positionals.join(" ")}`
+    );
+    io2.err(ENTRY_USAGE);
+    return 2;
+  }
+  const target = positionals[0];
+  let mutation;
+  if (target !== void 0) {
+    if (target === "apex") {
+      if (relayFlag !== void 0) {
+        io2.err("--relay only applies to an explicit <wss-url> entry");
+        io2.err(ENTRY_USAGE);
+        return 2;
+      }
+      mutation = { kind: "apex" };
+    } else if (target === "sandbox") {
+      if (relayFlag !== void 0) {
+        io2.err("--relay only applies to an explicit <wss-url> entry");
+        io2.err(ENTRY_USAGE);
+        return 2;
+      }
+      mutation = { kind: "sandbox" };
+    } else if (/^wss?:\/\/.+/.test(target)) {
+      if (relayFlag !== void 0 && !/^wss?:\/\/.+/.test(relayFlag)) {
+        io2.err(
+          `--relay must be a ws(s) URL, got ${JSON.stringify(relayFlag)}`
+        );
+        io2.err(ENTRY_USAGE);
+        return 2;
+      }
+      mutation = {
+        kind: "url",
+        btpUrl: target,
+        ...relayFlag !== void 0 ? { relayUrl: relayFlag } : {}
+      };
+    } else {
+      io2.err(
+        `unknown entry ${JSON.stringify(target)} \u2014 expected \`apex\`, \`sandbox\`, or a ws(s):// URL`
+      );
+      io2.err(ENTRY_USAGE);
+      return 2;
+    }
+  }
+  try {
+    const configPath = configPathFor2(env);
+    const file = readEntryConfig(configPath);
+    const seed = await (deps.loadGenesisSeed ?? loadGenesisSeedDefault)();
+    const effective = () => {
+      const btpExplicit = env["TOON_CLIENT_PROXY_URL"] ?? env["TOON_CLIENT_BTP_URL"] ?? file.proxyUrl ?? file.btpUrl;
+      const btpFromEnv = env["TOON_CLIENT_PROXY_URL"] ?? env["TOON_CLIENT_BTP_URL"];
+      const relayExplicit = env["TOON_CLIENT_RELAY_URL"] ?? file.relayUrl;
+      return {
+        btpUrl: btpExplicit ?? seed?.btpEndpoint ?? null,
+        btpSource: btpExplicit ? btpFromEnv ? "env" : "config" : seed?.btpEndpoint ? "genesis-seed" : null,
+        relayUrl: relayExplicit ?? seed?.relayUrl ?? null,
+        relaySource: env["TOON_CLIENT_RELAY_URL"] ? "env" : file.relayUrl ? "config" : seed?.relayUrl ? "genesis-seed" : null
+      };
+    };
+    if (mutation === void 0) {
+      const state2 = effective();
+      const entry = classifyEntry(state2.btpUrl, seed?.btpEndpoint, state2.btpSource);
+      if (json) {
+        io2.emitJson({
+          command: "entry",
+          entry,
+          btpUrl: state2.btpUrl,
+          btpSource: state2.btpSource,
+          relayUrl: state2.relayUrl,
+          relaySource: state2.relaySource,
+          configPath
+        });
+        return 0;
+      }
+      const label = (source) => source === "env" ? "env" : source === "config" ? `config (${configPath})` : source === "genesis-seed" ? "default apex \u2014 genesis seed" : "not configured";
+      io2.out(
+        `Entry: ${entry ?? "(none)"}${entry === "sandbox" ? " (Mina USDC only \u2014 multihop demo path)" : ""}`
+      );
+      io2.out(`  btp    ${state2.btpUrl ?? "(none)"}  [${label(state2.btpSource)}]`);
+      io2.out(`  relay  ${state2.relayUrl ?? "(none)"}  [${label(state2.relaySource)}]`);
+      io2.out(
+        "Switch with `rig entry apex`, `rig entry sandbox`, or `rig entry <wss-url>`."
+      );
+      return 0;
+    }
+    const warnings = [];
+    for (const envVar of [
+      "TOON_CLIENT_BTP_URL",
+      "TOON_CLIENT_PROXY_URL",
+      "TOON_CLIENT_RELAY_URL"
+    ]) {
+      if (env[envVar] !== void 0) {
+        warnings.push(
+          `${envVar}=${env[envVar]} is set in the environment and overrides the config value you just wrote \u2014 unset it for this entry to take effect.`
+        );
+      }
+    }
+    warnings.push(
+      "Payment channels are per-entry-peer: existing channels (see `rig channels`) are not used with the new entry \u2014 the next paid command opens or resumes a channel with the new peer."
+    );
+    const hadProxyUrl = file.proxyUrl !== void 0;
+    let wroteBtp;
+    let wroteRelay;
+    if (mutation.kind === "apex") {
+      wroteBtp = null;
+      wroteRelay = null;
+      delete file.btpUrl;
+      delete file.relayUrl;
+      delete file.proxyUrl;
+    } else if (mutation.kind === "sandbox") {
+      wroteBtp = SANDBOX_BTP_URL;
+      wroteRelay = SANDBOX_RELAY_URL;
+      file.btpUrl = SANDBOX_BTP_URL;
+      file.relayUrl = SANDBOX_RELAY_URL;
+      delete file.proxyUrl;
+    } else {
+      wroteBtp = mutation.btpUrl;
+      wroteRelay = mutation.relayUrl ?? null;
+      file.btpUrl = mutation.btpUrl;
+      if (mutation.relayUrl !== void 0) file.relayUrl = mutation.relayUrl;
+      delete file.proxyUrl;
+    }
+    if (hadProxyUrl) {
+      warnings.push(
+        "Removed the legacy `proxyUrl` config field \u2014 it outranks `btpUrl` and would have silently kept the old entry."
+      );
+    }
+    writeEntryConfig(configPath, file);
+    let clearedTopologyCache = false;
+    try {
+      unlinkSync(join5(dirname3(configPath), TOPOLOGY_CACHE_FILENAME));
+      clearedTopologyCache = true;
+    } catch {
+    }
+    if (mutation.kind === "sandbox") {
+      const effectiveChain = env["TOON_CLIENT_CHAIN"] ?? file.chain ?? file.supportedChains?.[0];
+      if (effectiveChain === void 0 || !effectiveChain.startsWith("mina")) {
+        warnings.push(
+          "The sandbox entry settles ONLY mina:devnet \u2014 run `rig chain set mina` " + (effectiveChain !== void 0 ? `(currently ${effectiveChain}).` : "to pin it.")
+        );
+      }
+      warnings.push(
+        `Repos publish to their git \`origin\` relay, which OVERRIDES the config relayUrl \u2014 for the sandbox demo run \`rig remote add origin ${SANDBOX_RELAY_URL}\` in the repo (or use a fresh repo).`
+      );
+    }
+    const state = effective();
+    if (json) {
+      io2.emitJson({
+        command: "entry",
+        entry: mutation.kind === "url" ? "custom" : mutation.kind,
+        btpUrl: state.btpUrl,
+        btpSource: state.btpSource,
+        relayUrl: state.relayUrl,
+        relaySource: state.relaySource,
+        wrote: { btpUrl: wroteBtp, relayUrl: wroteRelay },
+        clearedTopologyCache,
+        configPath,
+        ...warnings.length ? { warnings } : {}
+      });
+      return 0;
+    }
+    if (mutation.kind === "apex") {
+      io2.out("Entry reverted to the default apex (cleared btpUrl/relayUrl/proxyUrl).");
+      io2.out(`  btp    ${state.btpUrl ?? "(genesis seed unavailable)"}`);
+      io2.out(`  relay  ${state.relayUrl ?? "(genesis seed unavailable)"}`);
+    } else if (mutation.kind === "sandbox") {
+      io2.out("Entry set to the devnet sandbox (Mina USDC only \u2014 multihop demo path).");
+      io2.out(`  btp    ${SANDBOX_BTP_URL}`);
+      io2.out(`  relay  ${SANDBOX_RELAY_URL}`);
+    } else {
+      io2.out(`Entry set to ${mutation.btpUrl}.`);
+      if (mutation.relayUrl !== void 0) io2.out(`  relay  ${mutation.relayUrl}`);
+    }
+    io2.out(
+      `Saved to ${configPath}.` + (clearedTopologyCache ? " Cleared the cached topology." : "")
+    );
+    for (const w of warnings) io2.err(`warning: ${w}`);
+    return 0;
+  } catch (err) {
+    return emitCliError(io2, json, "entry", err);
+  }
+}
+
+// src/cli/fetch.ts
+import { parseArgs as parseArgs10 } from "util";
 var FETCH_USAGE = `Usage: rig fetch [remote] [options]
 
 Fetch from a TOON remote \u2014 FREE (relay reads + Arweave gateway downloads; no
@@ -3877,7 +4335,7 @@ async function runFetch(args, deps) {
   let ownerFlag;
   let concurrency;
   try {
-    const { values, positionals } = parseArgs9({
+    const { values, positionals } = parseArgs10({
       args,
       options: {
         json: { type: "boolean", default: false },
@@ -4042,10 +4500,10 @@ async function runFetch(args, deps) {
 }
 
 // src/cli/fund.ts
-import { readFileSync as readFileSync3 } from "fs";
-import { homedir as homedir3 } from "os";
-import { join as join4 } from "path";
-import { parseArgs as parseArgs10 } from "util";
+import { readFileSync as readFileSync5 } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join6 } from "path";
+import { parseArgs as parseArgs11 } from "util";
 var DEVNET_FAUCET_URL = "https://faucet.devnet.toonprotocol.dev";
 var CHAINS = ["evm", "solana", "mina"];
 var CHAIN_ALIASES = {
@@ -4083,7 +4541,9 @@ The identity comes from RIG_MNEMONIC (env or a project .env) or the
 faucetUrl config field, or the deployed devnet faucet when the network is
 devnet \u2014 including when a configured *.devnet.toonprotocol.dev origin infers
 it (a devnet relay/proxy/btp endpoint, or the git origin remote from
-\`rig remote add origin <devnet relay>\`). The faucet drips a FIXED amount per
+\`rig remote add origin <devnet relay>\`). A completely fresh install with NO
+origin configured anywhere infers devnet from the built-in genesis seed, so a
+bare \`rig fund\` works with zero config. The faucet drips a FIXED amount per
 chain (there is no --amount). On a network without a faucet, prints the wallet
 address(es) to fund externally instead.
 
@@ -4120,6 +4580,44 @@ function sharedDevnetOrigin(env, file, originRelays = []) {
   }
   return void 0;
 }
+async function loadGenesisSeedDefault2() {
+  try {
+    const { loadGenesisSeed } = await import("../network-bootstrap-3X2GXNJB.js");
+    return loadGenesisSeed();
+  } catch {
+    return void 0;
+  }
+}
+async function resolveEffectiveNetwork(opts) {
+  const { env, cwd } = opts;
+  const file = opts.file ?? readFundConfig(env).file;
+  const network = env["TOON_CLIENT_NETWORK"] ?? file.network;
+  const canInfer = network === void 0 || network === "custom";
+  const originRelays = canInfer ? await resolveOriginRelays(cwd) : [];
+  let devnetOrigin = sharedDevnetOrigin(env, file, originRelays);
+  let seededOrigin = false;
+  if (devnetOrigin === void 0 && canInfer) {
+    const anyConfiguredOrigin = [
+      env["TOON_CLIENT_RELAY_URL"] ?? file.relayUrl,
+      env["TOON_CLIENT_PROXY_URL"] ?? file.proxyUrl,
+      env["TOON_CLIENT_BTP_URL"] ?? file.btpUrl,
+      ...originRelays
+    ].some((url) => url !== void 0);
+    if (!anyConfiguredOrigin) {
+      const seed = await (opts.loadGenesisSeed ?? loadGenesisSeedDefault2)();
+      devnetOrigin = devnetHost(seed?.relayUrl) ?? devnetHost(seed?.btpEndpoint);
+      seededOrigin = devnetOrigin !== void 0;
+    }
+  }
+  const inferredDevnet = devnetOrigin !== void 0 && canInfer;
+  return {
+    network,
+    effectiveNetwork: inferredDevnet ? "devnet" : network,
+    devnetOrigin,
+    seededOrigin,
+    inferredDevnet
+  };
+}
 async function resolveOriginRelays(cwd) {
   let repoRoot;
   try {
@@ -4149,11 +4647,11 @@ function noFaucetGuidance(network, devnetOrigin) {
   return `${head}. If you meant the shared devnet, set TOON_CLIENT_NETWORK=devnet and re-run \`rig fund\` \u2014 no faucet URL is needed there. If this is a self-hosted network with its own faucet, set TOON_CLIENT_FAUCET_URL (or the faucetUrl config field). ${external}`;
 }
 function readFundConfig(env) {
-  const dir = env["TOON_CLIENT_HOME"] ?? join4(homedir3(), ".toon-client");
-  const configPath = join4(dir, "config.json");
+  const dir = env["TOON_CLIENT_HOME"] ?? join6(homedir5(), ".toon-client");
+  const configPath = join6(dir, "config.json");
   try {
     return {
-      file: JSON.parse(readFileSync3(configPath, "utf8")),
+      file: JSON.parse(readFileSync5(configPath, "utf8")),
       configPath
     };
   } catch (err) {
@@ -4171,7 +4669,7 @@ async function runFund(args, deps) {
   let addressFlag;
   let json = false;
   try {
-    const { values, positionals } = parseArgs10({
+    const { values, positionals } = parseArgs11({
       args,
       allowPositionals: true,
       options: {
@@ -4213,11 +4711,12 @@ async function runFund(args, deps) {
     const { file } = readFundConfig(env);
     const targetChains = resolvedChain === void 0 || resolvedChain === "all" ? [...CHAINS] : [resolvedChain];
     const network = env["TOON_CLIENT_NETWORK"] ?? file.network;
-    const canInfer = network === void 0 || network === "custom";
-    const originRelays = canInfer ? await resolveOriginRelays(deps.cwd) : [];
-    const devnetOrigin = sharedDevnetOrigin(env, file, originRelays);
-    const inferredDevnet = devnetOrigin !== void 0 && (network === void 0 || network === "custom");
-    const effectiveNetwork = inferredDevnet ? "devnet" : network;
+    const { devnetOrigin, seededOrigin, inferredDevnet, effectiveNetwork } = await resolveEffectiveNetwork({
+      env,
+      cwd: deps.cwd,
+      file,
+      ...deps.loadGenesisSeed ? { loadGenesisSeed: deps.loadGenesisSeed } : {}
+    });
     const faucetUrl = env["TOON_CLIENT_FAUCET_URL"] ?? file.faucetUrl ?? (effectiveNetwork === "devnet" ? DEVNET_FAUCET_URL : void 0);
     const resolved = await resolveIdentity({
       env,
@@ -4268,7 +4767,7 @@ async function runFund(args, deps) {
     };
     if (!json && inferredDevnet) {
       io2.out(
-        `Inferred network 'devnet' from the configured origin ${devnetOrigin} (network was ${JSON.stringify(network ?? "custom")}). Set TOON_CLIENT_NETWORK explicitly to override.`
+        seededOrigin ? `Inferred network 'devnet' from the built-in genesis seed ${devnetOrigin} (nothing configured \u2014 fresh install). Set TOON_CLIENT_NETWORK explicitly to override.` : `Inferred network 'devnet' from the configured origin ${devnetOrigin} (network was ${JSON.stringify(network ?? "custom")}). Set TOON_CLIENT_NETWORK explicitly to override.`
       );
     }
     if (!json) {
@@ -4321,7 +4820,9 @@ async function runFund(args, deps) {
         network: effectiveNetwork ?? null,
         faucetUrl,
         results,
-        ...inferredDevnet ? { inferredDevnetFrom: devnetOrigin } : {}
+        ...inferredDevnet ? {
+          inferredDevnetFrom: seededOrigin ? `${devnetOrigin} (genesis seed)` : devnetOrigin
+        } : {}
       });
       return allFunded ? 0 : 1;
     }
@@ -4393,10 +4894,10 @@ var runGitPassthrough = (argv2, options = {}) => {
 };
 
 // src/cli/identity-cmd.ts
-import { existsSync, mkdirSync as mkdirSync3 } from "fs";
-import { dirname as dirname3 } from "path";
+import { existsSync, mkdirSync as mkdirSync4 } from "fs";
+import { dirname as dirname4 } from "path";
 import { createInterface } from "readline/promises";
-import { parseArgs as parseArgs11 } from "util";
+import { parseArgs as parseArgs12 } from "util";
 async function loadKeyOps() {
   return await import("@toon-protocol/client");
 }
@@ -4445,7 +4946,7 @@ async function prepareKeystoreTarget(input) {
   const envPassword = input.env["TOON_CLIENT_KEYSTORE_PASSWORD"]?.trim() || void 0;
   const autoPassword = envPassword === void 0;
   const password = envPassword ?? DEFAULT_KEYSTORE_PASSWORD;
-  mkdirSync3(dirname3(keystorePath), { recursive: true });
+  mkdirSync4(dirname4(keystorePath), { recursive: true });
   return { keystorePath, password, autoPassword, existing, keyOps };
 }
 function readAccountIndex(env) {
@@ -4567,7 +5068,7 @@ async function runIdentity(args, deps) {
   }
 }
 function parseMintArgs(args, verb) {
-  const { values, positionals } = parseArgs11({
+  const { values, positionals } = parseArgs12({
     args,
     options: {
       force: { type: "boolean", default: false },
@@ -4672,7 +5173,7 @@ async function runIdentityShow(args, deps) {
   let json = false;
   let help = false;
   try {
-    const parsed = parseArgs11({
+    const parsed = parseArgs12({
       args,
       options: {
         json: { type: "boolean", default: false },
@@ -4781,7 +5282,7 @@ async function defaultReadSecretLine(prompt, isInteractive) {
 
 // src/cli/init.ts
 import { basename as basename2 } from "path";
-import { parseArgs as parseArgs12 } from "util";
+import { parseArgs as parseArgs13 } from "util";
 
 // src/cli/git-author.ts
 var PROFILE_KIND = 0;
@@ -4899,7 +5400,7 @@ Options:
   --json               machine-readable report
   -h, --help           show this help`;
 function parseInitArgs(args) {
-  const { values, positionals } = parseArgs12({
+  const { values, positionals } = parseArgs13({
     args,
     options: {
       "repo-id": { type: "string" },
@@ -5132,7 +5633,7 @@ async function runInit(args, deps) {
 }
 
 // src/cli/maintainers.ts
-import { parseArgs as parseArgs13 } from "util";
+import { parseArgs as parseArgs14 } from "util";
 var HEX64_RE3 = /^[0-9a-f]{64}$/;
 var WS_URL_RE4 = /^wss?:\/\//i;
 var MAINTAINERS_USAGE = `Usage: rig maintainers <list|add|remove> [<pubkey>] [options]
@@ -5237,7 +5738,7 @@ async function runList2(args, deps) {
   const { io: io2 } = deps;
   let flags;
   try {
-    const { values, positionals } = parseArgs13({
+    const { values, positionals } = parseArgs14({
       args,
       options: MAINT_OPTIONS,
       allowPositionals: true
@@ -5304,7 +5805,7 @@ async function runMutate(op, args, deps) {
   let flags;
   let pubkey;
   try {
-    const { values, positionals } = parseArgs13({
+    const { values, positionals } = parseArgs14({
       args,
       options: MAINT_OPTIONS,
       allowPositionals: true
@@ -5453,7 +5954,7 @@ async function runMutate(op, args, deps) {
 
 // src/cli/name.ts
 import { randomUUID } from "crypto";
-import { parseArgs as parseArgs14 } from "util";
+import { parseArgs as parseArgs15 } from "util";
 var ARIO_DECIMALS = 6;
 function renderMario(mario) {
   return `${mario.toString()} mARIO (~${formatUnits(mario.toString(), ARIO_DECIMALS)} ARIO)`;
@@ -5857,6 +6358,7 @@ var defaultGasStationClient = {
     };
   }
 };
+var DEVNET_DVM_URL = "https://dvm.devnet.toonprotocol.dev";
 var NAME_USAGE = `Usage: rig name <buy|set|status> <name> [options]
 
 ArNS naming for Arweave-served artifacts. A name registered on the ar.io
@@ -5909,12 +6411,18 @@ Options:
                        unverified.
   --process-id <id>    explicit ArNS registry program id \u2014 a Solana program
                        address (overrides --network; or RIG_ARIO_PROCESS_ID)
-  --via <dvm-url>      buy only: broker the purchase through a store DVM's
-                       kind:5095 job endpoint (or RIG_ARNS_DVM_URL). The DVM
-                       pays the mARIO; you own the name via your spawned ANT.
-                       Direct backend targeting stubs the job payment
-                       (dev/e2e) \u2014 the paid path runs the same job through
-                       the connector payment proxy.
+  --via <dvm-url>      broker buy/set through a store DVM's job endpoint (or
+                       RIG_ARNS_DVM_URL). The DVM pays the mARIO; you own the
+                       name via your spawned ANT. Direct backend targeting
+                       stubs the job payment (dev/e2e) \u2014 the paid path runs
+                       the same job through the connector payment proxy.
+                       DEVNET DEFAULT: with --network devnet and the TOON
+                       network on devnet too, buy/set default to the deployed
+                       devnet store DVM (${DEVNET_DVM_URL})
+                       unless --direct opts out.
+  --direct             force the direct wallet-paid path: never default (or
+                       read RIG_ARNS_DVM_URL as) a --via DVM. Mutually
+                       exclusive with an explicit --via.
   --yes                skip the confirmation (required when not a TTY) for
                        buy/set
   --json               machine-readable envelope; for buy/set without --yes it
@@ -5960,7 +6468,7 @@ async function resolveNameContext(deps, network, processId, mode) {
   return { identity, solanaAddress, network, processId, sdk, nostrSecretKey };
 }
 function parseNameFlags(args, env) {
-  const { values, positionals } = parseArgs14({
+  const { values, positionals } = parseArgs15({
     args,
     allowPositionals: true,
     options: {
@@ -5971,6 +6479,7 @@ function parseNameFlags(args, env) {
       network: { type: "string" },
       "process-id": { type: "string" },
       via: { type: "string" },
+      direct: { type: "boolean", default: false },
       "tx-id": { type: "string" },
       yes: { type: "boolean", default: false },
       json: { type: "boolean", default: false },
@@ -5984,6 +6493,7 @@ function parseNameFlags(args, env) {
         permabuy: false,
         ttl: 0,
         network: "mainnet",
+        direct: false,
         yes: false,
         json: false
       }
@@ -6017,7 +6527,12 @@ function parseNameFlags(args, env) {
     );
   }
   const processId = values["process-id"] ?? env["RIG_ARIO_PROCESS_ID"];
-  const viaRaw = values.via ?? env["RIG_ARNS_DVM_URL"];
+  if (values.direct && values.via !== void 0) {
+    throw new Error(
+      "--direct and --via are mutually exclusive: --direct forces the wallet-paid path, --via brokers through a DVM"
+    );
+  }
+  const viaRaw = values.direct ? void 0 : values.via ?? env["RIG_ARNS_DVM_URL"];
   let via;
   if (viaRaw !== void 0) {
     if (!/^https?:\/\/.+/.test(viaRaw)) {
@@ -6037,6 +6552,7 @@ function parseNameFlags(args, env) {
       network: networkRaw,
       ...processId !== void 0 ? { processId } : {},
       ...via !== void 0 ? { via } : {},
+      direct: values.direct ?? false,
       ...values["tx-id"] !== void 0 ? { txId: values["tx-id"] } : {},
       yes: values.yes ?? false,
       json: values.json ?? false
@@ -6427,6 +6943,20 @@ async function runName(args, deps) {
     io2.err(NAME_USAGE);
     return 2;
   }
+  if ((sub === "buy" || sub === "set") && !flags.direct && flags.via === void 0 && flags.network === "devnet") {
+    let toonDevnet = false;
+    try {
+      const resolved = await (deps.resolveToonNetwork ?? resolveEffectiveNetwork)({ env: deps.env, cwd: deps.cwd });
+      toonDevnet = resolved.effectiveNetwork === "devnet";
+    } catch {
+    }
+    if (toonDevnet) {
+      flags = { ...flags, via: DEVNET_DVM_URL };
+      io2.err(
+        `Brokering via the devnet store DVM ${DEVNET_DVM_URL} (no --via given; pass --direct for a wallet-paid ${sub}).`
+      );
+    }
+  }
   try {
     if (sub === "buy") return await runBuy(name, flags, deps);
     if (sub === "status") return await runStatus(name, flags, deps);
@@ -6450,7 +6980,7 @@ async function runName(args, deps) {
 }
 
 // src/cli/site.ts
-import { parseArgs as parseArgs15 } from "util";
+import { parseArgs as parseArgs16 } from "util";
 
 // src/arweave-manifest.ts
 var DEFAULT_INDEX = "index.html";
@@ -6469,22 +6999,22 @@ function buildArweaveManifest(entries, indexPath = DEFAULT_INDEX, fallbackTxId)
 }
 
 // src/cli/site-record.ts
-import { mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
-import { homedir as homedir4 } from "os";
-import { join as join5 } from "path";
+import { mkdirSync as mkdirSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
+import { homedir as homedir6 } from "os";
+import { join as join7 } from "path";
 var SITE_MANIFEST_FILENAME = "site-manifests.json";
 function storeDir2(env) {
-  return env["TOON_CLIENT_HOME"] ?? join5(homedir4(), ".toon-client");
+  return env["TOON_CLIENT_HOME"] ?? join7(homedir6(), ".toon-client");
 }
 function storePath2(env) {
-  return join5(storeDir2(env), SITE_MANIFEST_FILENAME);
+  return join7(storeDir2(env), SITE_MANIFEST_FILENAME);
 }
 function keyOf(repoId, ref) {
   return `${repoId}\0${ref}`;
 }
 function readFile2(env) {
   try {
-    const parsed = JSON.parse(readFileSync4(storePath2(env), "utf8"));
+    const parsed = JSON.parse(readFileSync6(storePath2(env), "utf8"));
     if (parsed && typeof parsed === "object") return parsed;
     return {};
   } catch {
@@ -6496,10 +7026,10 @@ function readSiteRecord(env, repoId, ref) {
 }
 function writeSiteRecord(env, record) {
   const dir = storeDir2(env);
-  mkdirSync4(dir, { recursive: true });
+  mkdirSync5(dir, { recursive: true });
   const file = readFile2(env);
   file[keyOf(record.repoId, record.ref)] = record;
-  writeFileSync3(storePath2(env), `${JSON.stringify(file, null, 2)}
+  writeFileSync4(storePath2(env), `${JSON.stringify(file, null, 2)}
 `, "utf8");
 }
 
@@ -6541,7 +7071,7 @@ Options (publish):
                        estimate (nothing uploaded)
   -h, --help           show this help`;
 function parseSiteArgs(args) {
-  const { values, positionals } = parseArgs15({
+  const { values, positionals } = parseArgs16({
     args,
     options: {
       index: { type: "string" },
@@ -6951,15 +7481,23 @@ Commands rig owns:
                              (free \u2014 chain reads and local state only)
   chain [set <c>|unset]      choose which chain/USDC settles paid writes
                              (evm|sol|mina); free \u2014 reads/writes local config
+  entry [apex|sandbox|url]   choose the network entry node (payment ingress +
+                             relay): apex settles evm|sol|mina, sandbox is the
+                             Mina-only multihop demo path; free \u2014 writes local
+                             config and clears the cached topology
   name buy <name>            ArNS naming (#367): buy points a human name at an
   name set <name> <txId>     Arweave txId, owned + paid by this identity's
   name status <name>         Solana key. buy spends mARIO on Solana via the
                              ar.io registry (NOT ILP); status is free. Needs
                              the optional \`@ar.io/sdk\` dependency
   channel list               show the payment channels paid commands hold
-                             (free \u2014 reads local state)
+                             (free \u2014 reads local state; \`rig channels\` is a
+                             shorthand for \`rig channel list\`)
   channel open               explicitly open (or resume) the channel for a
                              peer; --deposit adds collateral (on-chain)
+  channel deploy-zkapp       pre-deploy this identity's dedicated Mina
+                             PaymentChannel zkApp (on-chain; the Mina open
+                             path otherwise does this automatically)
   channel close <channelId>  start the settlement challenge window (on-chain)
   channel settle <channelId> release collateral after the window (on-chain)
 
@@ -7022,12 +7560,19 @@ async function dispatch(argv2, deps) {
       return runMaintainers(rest, deps);
     case "channel":
       return runChannel(rest, deps);
+    case "channels":
+      return runChannel(
+        rest[0] !== void 0 && !rest[0].startsWith("-") ? rest : ["list", ...rest],
+        deps
+      );
     case "fund":
       return runFund(rest, deps);
     case "balance":
       return runBalance(rest, deps);
     case "chain":
       return runChain(rest, deps);
+    case "entry":
+      return runEntry(rest, deps);
     case "name":
       return runName(rest, deps);
     case "help":
@@ -7105,8 +7650,11 @@ var RIG_OWNED_VERBS = /* @__PURE__ */ new Set([
   "pr",
   "maintainers",
   "channel",
+  "channels",
   "fund",
   "balance",
+  "chain",
+  "entry",
   "name"
 ]);
 function isJsonInvocation(argv2) {