mycomesh-consumer 0.3.0 → 0.4.0

package/README.md

@@ -8,26 +8,32 @@ Requires Node.js 20 or newer. No Docker or Python.
 
 ```sh
 npm install --global mycomesh-consumer
-mycomesh-consumer init
-mycomesh-consumer setup --owner-key-file owner.key --faucet 100000000 --deposit 100000000
-mycomesh-consumer request "What is MycoMesh?"
-mycomesh-consumer serve          # http://127.0.0.1:8110/v1 (responses, chat/completions, models; streaming)
+mycomesh-consumer init            # payment key + password-protected owner wallet
+mycomesh-consumer setup --deposit 20000000
+mycomesh-consumer request --stream "What is MycoMesh?"
+mycomesh-consumer serve           # http://127.0.0.1:8110/v1 (responses, chat/completions, models; live streaming)
 ```
 
-- `init` creates the payment key in `~/.mycomesh/v11` (it never leaves the machine).
-- `setup` uses the owner account (which needs Sepolia ETH for gas) to deposit
-  tUSDC and authorize the payment key up to `--max-per-request` units per request.
-  `--faucet UNITS` first mints testnet tUSDC to the owner.
-- `balance --owner-key-file owner.key` shows the deposit.
+- `init` creates the payment key and an owner wallet in `~/.mycomesh/v11`. The wallet is an
+  Ethereum V3 keystore (MetaMask can import it) protected by a password from
+  `MYCOMESH_WALLET_PASSWORD` or a terminal prompt; `--owner-key-file` uses your own key instead.
+- `setup --deposit UNITS` deposits tUSDC and authorizes the payment key up to `--max-per-request`
+  units per request. On the testnet it first tops the wallet up from the faucet (gas ETH and tUSDC);
+  `faucet` does that on its own.
+- `balance` shows the deposit.
 - `request "..." [--model gpt-5.5] [--provider SIGNER]` prints the verified answer,
   the fee and the settlement key.
-- `serve` runs a local OpenAI-compatible endpoint for Codex and other clients;
-  set `MYCOMESH_CONSUMER_API_KEY` to require a bearer token.
-- `dispute <settlement-key|last> --owner-key-file owner.key --statement "..."`
+- `serve` runs the local web console at `http://127.0.0.1:8110/` (chat, wallet, deposit and
+  withdrawal, request history and disputes, network status) and an OpenAI-compatible endpoint for
+  Codex and other clients; set `MYCOMESH_CONSUMER_API_KEY` to require a bearer token. Only pages from
+  this machine can call it: other websites and DNS-rebinding hosts are refused.
+- `withdraw [UNITS]` requests a withdrawal; run it again after the delay to receive the funds.
+- `dispute <settlement-key|last> --statement "..."`
   reveals a recorded request and response to a randomly drawn Provider-AI jury
   within the 24-hour dispute window. The 1 tUSDC reporter bond is returned and a
   bounty paid when fraud is confirmed.
 
 Each response is decrypted locally and checked against the Provider-signed
-receipt before it is shown. The bundled network manifest is
+receipt before it is shown; streamed text is checked against it too. Relays come from the bundled
+manifest and the on-chain Relay directory. The bundled network manifest is
 `networks/mycomesh-v11-sepolia.json`; use `--network FILE` for another.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mycomesh-consumer",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "MycoMesh V11 Consumer: a custodied deposit, relay-blind encrypted requests to any Provider, and a local OpenAI-compatible endpoint.",
   "repository": {
     "type": "git",
@@ -16,6 +16,7 @@
   "files": [
     "bin/mycomesh-consumer.mjs",
     "src/*.mjs",
+    "src/web/*.html",
     "networks/mycomesh-v11-sepolia.json",
     "networks/mycomesh-testnet-ca.crt",
     "README.md"

package/src/account.mjs

@@ -0,0 +1,93 @@
+// Consumer account operations shared by the CLI and the local web console.
+import { addressOf, encodeCall } from "./eip712.mjs";
+import { rpcCall, sendTransaction } from "./chain.mjs";
+import { directoryRelays, httpJson } from "./consumer.mjs";
+import { buildEvidence, evidenceHash, openDisputeCall, reportId } from "./disputes.mjs";
+
+export const STATUSES = ["none", "pending", "disputed", "released", "confirmed", "dismissed", "timed_out", "jury_unavailable", "voided"];
+
+async function words(network, to, signature, pairs = []) {
+  const raw = (await rpcCall(network.rpc_urls, "eth_call", [{ to, data: encodeCall(signature, pairs) }, "latest"])).slice(2);
+  return Array.from({ length: raw.length / 64 }, (_, i) => BigInt(`0x${raw.slice(i * 64, i * 64 + 64)}`));
+}
+
+/** Balances of the owner wallet and the payment key's grant; amounts are strings of base units. */
+export async function walletStatus(network, owner, key) {
+  const [eth, [tokens], [deposit], withdrawal, grant, params] = await Promise.all([
+    rpcCall(network.rpc_urls, "eth_getBalance", [owner, "latest"]),
+    words(network, network.stablecoin, "balanceOf(address)", [["address", owner]]),
+    words(network, network.settlement, "availableBalance(address)", [["address", owner]]),
+    words(network, network.settlement, "withdrawals(address)", [["address", owner]]),
+    key ? words(network, network.settlement, "keyGrants(address)", [["address", key]]) : Promise.resolve(null),
+    words(network, network.settlement, "params()"),
+  ]);
+  return {
+    owner, key, eth_wei: BigInt(eth).toString(), wallet_tokens: tokens.toString(), deposit: deposit.toString(),
+    withdrawal: { amount: withdrawal[0].toString(), available_at: Number(withdrawal[1]) },
+    grant: grant && { active: Boolean(grant[3]) && `0x${grant[0].toString(16).padStart(40, "0")}` === owner.toLowerCase(),
+      max_per_request: grant[1].toString() },
+    dispute_window: Number(params[0]), reporter_bond: params[3].toString(), faucet: Boolean(network.faucet_url),
+  };
+}
+
+export async function faucet(network, address) {
+  if (!network.faucet_url) throw new Error("this network has no faucet");
+  const reply = await httpJson(`${network.faucet_url}/v11/faucet`, { method: "POST", body: { address }, ca: network.tls_ca, timeoutMs: 400_000 });
+  if (reply.status !== 200) throw new Error(`faucet: ${reply.body?.error || reply.status}`);
+  return reply.body;
+}
+
+/** Deposit and grant the payment key; on testnets, top the wallet up from the faucet first. */
+export async function setup(network, { ownerPrivate, key, deposit, limit, forceFaucet = false, log = () => {} }) {
+  const owner = addressOf(ownerPrivate);
+  const status = await walletStatus(network, owner, key);
+  if (network.faucet_url && (forceFaucet || BigInt(status.eth_wei) < 2_000_000_000_000_000n || BigInt(status.wallet_tokens) < deposit)) {
+    log(`funding ${owner} from the testnet faucet...`);
+    await faucet(network, owner);
+  }
+  const send = (to, data) => sendTransaction(network.rpc_urls, ownerPrivate, { to, data });
+  await send(network.stablecoin, encodeCall("approve(address,uint256)", [["address", network.settlement], ["uint", deposit]]));
+  await send(network.settlement, encodeCall("deposit(uint256)", [["uint", deposit]]));
+  if (!status.grant?.active || BigInt(status.grant.max_per_request) !== limit) {
+    await send(network.settlement, encodeCall("registerKey(address,uint256,uint64)", [["address", key], ["uint", limit], ["uint", 0]]));
+  }
+  return { owner, key, deposit: deposit.toString(), max_per_request: limit.toString() };
+}
+
+/** Withdrawals take two steps: request (funds stop backing requests), then withdraw after the delay. */
+export async function requestWithdrawal(network, ownerPrivate, amount) {
+  await sendTransaction(network.rpc_urls, ownerPrivate, { to: network.settlement,
+    data: encodeCall("requestWithdrawal(uint256)", [["uint", amount]]) });
+}
+
+export async function completeWithdrawal(network, ownerPrivate) {
+  await sendTransaction(network.rpc_urls, ownerPrivate, { to: network.settlement, data: encodeCall("withdraw()", []) });
+}
+
+export async function settlementStatus(network, key) {
+  const fields = await words(network, network.settlement, "settlementInfo(bytes32)", [["bytes32", key]]);
+  return { status: STATUSES[Number(fields[14])] || "unknown", release_at: Number(fields[13]), fee: fields[10].toString() };
+}
+
+/** Commit the evidence on-chain (with the reporter bond), then hand it to every Relay's dispute desk. */
+export async function dispute(network, ownerPrivate, record, { reasonCode, statement }) {
+  const evidence = buildEvidence(record, { reasonCode, statement });
+  const digest = evidenceHash(evidence);
+  const [bond] = (await words(network, network.settlement, "params()")).slice(3, 4);
+  if (bond > 0n) {
+    await sendTransaction(network.rpc_urls, ownerPrivate, { to: network.stablecoin,
+      data: encodeCall("approve(address,uint256)", [["address", network.settlement], ["uint", bond]]) });
+  }
+  await sendTransaction(network.rpc_urls, ownerPrivate, { to: network.settlement, data: openDisputeCall(record.settlement_key, digest) });
+  let relays = network.relays;
+  try { relays = [...relays, ...await directoryRelays(network)]; } catch {}
+  const accepted = [];
+  for (const relay of relays) {
+    try {
+      const reply = await httpJson(`${relay.url}/v11/evidence`, { method: "POST", body: evidence, ca: network.tls_ca, timeoutMs: 30_000 });
+      if (reply.status === 200) accepted.push(relay.url);
+    } catch {}
+  }
+  return { settlement_key: record.settlement_key, evidence_hash: digest,
+    report_id: reportId(record.settlement_key, addressOf(ownerPrivate), digest), relays_accepted: accepted };
+}

package/src/cli.mjs

@@ -5,11 +5,12 @@ import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { parseArgs } from "node:util";
-import { addressOf, encodeCall, settlementKey } from "./eip712.mjs";
-import { availableBalance, rpcCall, sendTransaction } from "./chain.mjs";
-import { Consumer, directoryRelays, httpJson, loadNetwork, serveConsumer } from "./consumer.mjs";
+import { addressOf, settlementKey } from "./eip712.mjs";
+import { availableBalance } from "./chain.mjs";
+import { completeWithdrawal, dispute, faucet, requestWithdrawal, setup, walletStatus } from "./account.mjs";
+import { Consumer, loadNetwork, serveConsumer } from "./consumer.mjs";
 import { createWallet, ownerAddress, ownerKey, walletAddress } from "./wallet.mjs";
-import { buildEvidence, evidenceHash, loadRequest, openDisputeCall, reportId } from "./disputes.mjs";
+import { loadRequest } from "./disputes.mjs";
 
 const DEFAULT_NETWORK = join(dirname(fileURLToPath(import.meta.url)), "../networks/mycomesh-v11-sepolia.json");
 
@@ -23,9 +24,10 @@ const USAGE = `Usage: mycomesh-consumer <command> [options]
                            deposit into the settlement contract and authorize the payment key
                            (on testnets, tops the wallet up from the faucet first)
   balance [--owner ADDR]   show the custodied deposit
+  withdraw [UNITS]         request a withdrawal of the deposit; run again after the delay to receive it
   request "prompt" [--stream]
                            send one request and print the verified answer
-  serve [--port 8110]      run the local OpenAI-compatible endpoint with streaming (default)
+  serve [--port 8110]      run the local web console and OpenAI-compatible endpoint (default)
   dispute <settlement-key|last> [--reason CODE] [--statement TEXT]
                            reveal a recorded request and response to a Provider-AI jury
                            (within 24 hours; the reporter bond is returned if fraud is confirmed)
@@ -88,38 +90,37 @@ export async function main(argv = process.argv.slice(2), { stdout = process.stdo
     return 0;
   }
   const network = loadNetwork(values.network || process.env.MYCOMESH_NETWORK || DEFAULT_NETWORK);
-  const faucet = async (address) => {
-    if (!network.faucet_url) throw new Error("this network has no faucet");
-    const reply = await httpJson(`${network.faucet_url}/v11/faucet`, { method: "POST", body: { address }, ca: network.tls_ca, timeoutMs: 400_000 });
-    if (reply.status !== 200) throw new Error(`faucet: ${reply.body?.error || reply.status}`);
-    return reply.body;
-  };
   if (command === "faucet") {
     const address = values.owner || ownerAddress(values["owner-key-file"], dir) || walletAddress(await createWallet(dir));
-    stdout.write(`${JSON.stringify(await faucet(address))}\n`);
+    stdout.write(`${JSON.stringify(await faucet(network, address))}\n`);
     return 0;
   }
   if (command === "setup") {
     const keyPrivate = paymentKey(dir);
     if (!values.deposit) throw new Error("--deposit UNITS is required");
     if (!values["owner-key-file"]) await createWallet(dir);
-    const address = ownerAddress(values["owner-key-file"], dir);
-    const deposit = BigInt(values.deposit);
-    const limit = BigInt(values["max-per-request"] || values["max-fee"]);
-    const eth = BigInt(await rpcCall(network.rpc_urls, "eth_getBalance", [address, "latest"]));
-    const tokens = BigInt(await rpcCall(network.rpc_urls, "eth_call", [{ to: network.stablecoin,
-      data: encodeCall("balanceOf(address)", [["address", address]]) }, "latest"]));
-    if (network.faucet_url && (values.faucet || eth < 2_000_000_000_000_000n || tokens < deposit)) {
-      stdout.write(`funding ${address} from the testnet faucet...\n`);
-      await faucet(address);
-    }
+    const result = await setup(network, {
+      ownerPrivate: await ownerKey(values["owner-key-file"], dir), key: addressOf(keyPrivate), deposit: BigInt(values.deposit),
+      limit: BigInt(values["max-per-request"] || values["max-fee"]), forceFaucet: values.faucet,
+      log: (line) => stdout.write(`${line}\n`),
+    });
+    stdout.write(`deposited ${result.deposit} and authorized ${result.key} up to ${result.max_per_request} per request\n`);
+    return 0;
+  }
+  if (command === "withdraw") {
     const owner = await ownerKey(values["owner-key-file"], dir);
-    await sendTransaction(network.rpc_urls, owner, { to: network.stablecoin,
-      data: encodeCall("approve(address,uint256)", [["address", network.settlement], ["uint", deposit]]) });
-    await sendTransaction(network.rpc_urls, owner, { to: network.settlement, data: encodeCall("deposit(uint256)", [["uint", deposit]]) });
-    await sendTransaction(network.rpc_urls, owner, { to: network.settlement,
-      data: encodeCall("registerKey(address,uint256,uint64)", [["address", addressOf(keyPrivate)], ["uint", limit], ["uint", 0]]) });
-    stdout.write(`deposited ${deposit} and authorized ${addressOf(keyPrivate)} up to ${limit} per request\n`);
+    const status = await walletStatus(network, addressOf(owner), null);
+    if (BigInt(status.withdrawal.amount) > 0n) {
+      if (status.withdrawal.available_at > Math.floor(Date.now() / 1000)) {
+        throw new Error(`the withdrawal of ${status.withdrawal.amount} unlocks at ${new Date(status.withdrawal.available_at * 1000).toISOString()}`);
+      }
+      await completeWithdrawal(network, owner);
+      stdout.write(`withdrew ${status.withdrawal.amount}\n`);
+      return 0;
+    }
+    const amount = BigInt(rest[0] || status.deposit);
+    await requestWithdrawal(network, owner, amount);
+    stdout.write(`requested a withdrawal of ${amount}; run \`withdraw\` again after the delay\n`);
     return 0;
   }
   if (command === "balance") {
@@ -130,29 +131,10 @@ export async function main(argv = process.argv.slice(2), { stdout = process.stdo
   }
   if (command === "dispute") {
     const owner = await ownerKey(values["owner-key-file"], dir);
-    const record = loadRequest(dir, rest[0] || "last");
-    const evidence = buildEvidence(record, { reasonCode: values.reason, statement: values.statement || rest.slice(1).join(" ") });
-    const digest = evidenceHash(evidence);
-    // The reporter bond comes from the owner's wallet and is returned when fraud is confirmed.
-    const params = await rpcCall(network.rpc_urls, "eth_call", [{ to: network.settlement, data: encodeCall("params()", []) }, "latest"]);
-    const bond = BigInt(`0x${params.slice(2 + 64 * 3, 2 + 64 * 4)}`);
-    if (bond > 0n) {
-      await sendTransaction(network.rpc_urls, owner, { to: network.stablecoin,
-        data: encodeCall("approve(address,uint256)", [["address", network.settlement], ["uint", bond]]) });
-    }
-    await sendTransaction(network.rpc_urls, owner, { to: network.settlement, data: openDisputeCall(record.settlement_key, digest) });
-    const accepted = [];
-    let relays = network.relays;
-    try { relays = [...relays, ...await directoryRelays(network)]; } catch {}
-    for (const relay of relays) {
-      try {
-        const reply = await httpJson(`${relay.url}/v11/evidence`, { method: "POST", body: evidence, ca: network.tls_ca, timeoutMs: 30_000 });
-        if (reply.status === 200) accepted.push(relay.url);
-      } catch {}
-    }
-    stdout.write(`${JSON.stringify({ settlement_key: record.settlement_key, evidence_hash: digest,
-      report_id: reportId(record.settlement_key, addressOf(owner), digest), relays_accepted: accepted })}\n`);
-    return accepted.length ? 0 : 2;
+    const result = await dispute(network, owner, loadRequest(dir, rest[0] || "last"),
+      { reasonCode: values.reason, statement: values.statement || rest.slice(1).join(" ") });
+    stdout.write(`${JSON.stringify(result)}\n`);
+    return result.relays_accepted.length ? 0 : 2;
   }
   const keyPrivate = paymentKey(dir);
   const consumer = new Consumer({ network, keyPrivate, maxFee: Number(values["max-fee"]), journalDir: dir });
@@ -169,9 +151,11 @@ export async function main(argv = process.argv.slice(2), { stdout = process.stdo
     return 0;
   }
   if (command === "serve") {
-    const server = await serveConsumer(consumer, { host: values.host, port: Number(values.port), apiKey: process.env.MYCOMESH_CONSUMER_API_KEY });
+    const server = await serveConsumer(consumer, { host: values.host, port: Number(values.port),
+      apiKey: process.env.MYCOMESH_CONSUMER_API_KEY, dataDir: dir });
     const { port } = server.address();
     stdout.write(`MycoMesh V11 Consumer on http://${values.host}:${port}/v1 (payment key ${consumer.key})\n`);
+    stdout.write(`Web console: http://127.0.0.1:${port}/\n`);
     return new Promise(() => {});
   }
   throw new Error(`unknown command ${command}\n${USAGE}`);

package/src/console.mjs

@@ -0,0 +1,86 @@
+// The local web console: the Bitcoin-node model, a UI served by this machine to this machine.
+// The browser only ever talks to 127.0.0.1; this process reaches the network and verifies everything.
+import { readFileSync } from "node:fs";
+import { addressOf } from "./eip712.mjs";
+import { completeWithdrawal, dispute, faucet, requestWithdrawal, settlementStatus, setup, walletStatus } from "./account.mjs";
+import { listRequests, loadRequest } from "./disputes.mjs";
+import { outputText } from "./protocol.mjs";
+import { createWallet, ownerAddress, unlockWallet, walletAddress } from "./wallet.mjs";
+
+const PAGE = new URL("./web/console.html", import.meta.url);
+
+/**
+ * Only this machine's own pages may call the local node: reject other Host
+ * names (DNS rebinding) and cross-site Origins (a web page spending the deposit).
+ */
+export function localRequestAllowed(req, port) {
+  const allowed = new Set([`127.0.0.1:${port}`, `localhost:${port}`, `[::1]:${port}`]);
+  if (!allowed.has(String(req.headers.host || ""))) return false;
+  const origin = req.headers.origin;
+  return !origin || allowed.has(origin.replace(/^http:\/\//, ""));
+}
+
+export function consoleRoutes({ consumer, dataDir }) {
+  const network = consumer.network;
+  const owner = () => ownerAddress(undefined, dataDir);
+  const withWallet = (body) => unlockWallet(dataDir, body.password);
+  const units = (value, name) => {
+    if (!/^[0-9]+$/.test(String(value ?? ""))) throw Object.assign(new Error(`${name} must be a whole number of base units`), { status: 400 });
+    return BigInt(value);
+  };
+  return {
+    "GET /": () => ({ type: "text/html; charset=utf-8", body: readFileSync(PAGE, "utf8") }),
+    "GET /api/status": async () => {
+      const address = owner();
+      return {
+        network: { id: network.network_id, chain_id: network.chain_id, settlement: network.settlement, faucet: Boolean(network.faucet_url) },
+        payment_key: consumer.key, max_fee: String(consumer.maxFee),
+        wallet: address ? await walletStatus(network, address, consumer.key) : null,
+      };
+    },
+    "GET /api/network": async () => {
+      const relays = [];
+      for (const relay of await consumer.relays()) {
+        let health = null; let providers = [];
+        try { health = (await consumer.fetchJson(`${relay.url}/health`, { ca: network.tls_ca, timeoutMs: 5_000 })).body; } catch {}
+        try { providers = await consumer.providers(relay); } catch {}
+        relays.push({ url: relay.url, signer: relay.signer, healthy: Boolean(health?.ok), providers: providers.map((p) => ({
+          signer: p.provider_signer, models: p.models, prices: p.prices, capacity: p.capacity })) });
+      }
+      return { relays };
+    },
+    "GET /api/history": async () => {
+      const entries = listRequests(dataDir, outputText, 50);
+      await Promise.all(entries.map(async (entry) => {
+        try { Object.assign(entry, await settlementStatus(network, entry.settlement_key)); } catch { entry.status = "unknown"; }
+      }));
+      return { entries };
+    },
+    "POST /api/wallet": async (body) => ({ owner: walletAddress(await createWallet(dataDir, body.password)) }),
+    "POST /api/faucet": async () => {
+      const address = owner();
+      if (!address) throw Object.assign(new Error("create the wallet first"), { status: 400 });
+      return faucet(network, address);
+    },
+    "POST /api/setup": async (body) => setup(network, {
+      ownerPrivate: withWallet(body), key: consumer.key, deposit: units(body.deposit, "deposit"),
+      limit: units(body.max_per_request ?? consumer.maxFee, "max_per_request"),
+    }),
+    "POST /api/withdraw": async (body) => {
+      const ownerPrivate = withWallet(body);
+      const status = await walletStatus(network, addressOf(ownerPrivate), null);
+      if (BigInt(status.withdrawal.amount) > 0n) {
+        if (status.withdrawal.available_at > Math.floor(Date.now() / 1000)) {
+          throw Object.assign(new Error("the pending withdrawal is still locked"), { status: 409 });
+        }
+        await completeWithdrawal(network, ownerPrivate);
+        return { withdrawn: status.withdrawal.amount };
+      }
+      const amount = body.amount ? units(body.amount, "amount") : BigInt(status.deposit);
+      await requestWithdrawal(network, ownerPrivate, amount);
+      return { requested: amount.toString() };
+    },
+    "POST /api/dispute": async (body) => dispute(network, withWallet(body), loadRequest(dataDir, String(body.settlement_key)),
+      { reasonCode: String(body.reason_code || "unrelated_response"), statement: String(body.statement || "") }),
+  };
+}

package/src/consumer.mjs

@@ -9,6 +9,7 @@ import { rpcCall } from "./chain.mjs";
 import { openDelta, openResponse, outputText, prepareRequest, verifiedProvider } from "./protocol.mjs";
 import { recordRequest } from "./disputes.mjs";
 import { chatStream, responseStream } from "./sse.mjs";
+import { consoleRoutes, localRequestAllowed } from "./console.mjs";
 
 const PROVIDER_CACHE_MS = 30_000;
 const RELAY_CACHE_MS = 300_000;
@@ -241,7 +242,8 @@ async function readJson(req) {
 }
 
 /** Local OpenAI-compatible endpoint; nothing leaves this machine unsealed except pricing and routing. */
-export function serveConsumer(consumer, { host = "127.0.0.1", port = 8110, apiKey } = {}) {
+export function serveConsumer(consumer, { host = "127.0.0.1", port = 8110, apiKey, dataDir } = {}) {
+  const routes = dataDir ? consoleRoutes({ consumer, dataDir }) : {};
   const server = createServer(async (req, res) => {
     let writer = null;
     const send = (status, body, type = "application/json") => {
@@ -249,8 +251,17 @@ export function serveConsumer(consumer, { host = "127.0.0.1", port = 8110, apiKe
       res.end(type === "application/json" ? JSON.stringify(body) : body);
     };
     try {
-      if (apiKey && req.headers.authorization !== `Bearer ${apiKey}`) return send(401, openaiError("invalid API key", "unauthorized"));
+      if (!localRequestAllowed(req, server.address().port)) return send(403, openaiError("only this machine may use the local node", "forbidden"));
       const path = new URL(req.url, "http://localhost").pathname.replace(/^\/v1\/v1\//, "/v1/");
+      const route = routes[`${req.method} ${path}`];
+      if (route) {
+        if (req.method === "POST" && !String(req.headers["content-type"] || "").startsWith("application/json")) {
+          return send(415, { error: "JSON body required" });
+        }
+        const result = await route(req.method === "POST" ? await readJson(req) : {});
+        return result?.type ? send(200, result.body, result.type) : send(200, result);
+      }
+      if (apiKey && req.headers.authorization !== `Bearer ${apiKey}`) return send(401, openaiError("invalid API key", "unauthorized"));
       if (req.method === "GET" && path === "/health") return send(200, { ok: true, protocol: 11, key: consumer.key });
       if (req.method === "GET" && path === "/v1/models") {
         return send(200, { object: "list", data: (await consumer.models()).map((id) => ({ id, object: "model", owned_by: "mycomesh" })) });
@@ -284,6 +295,10 @@ export function serveConsumer(consumer, { host = "127.0.0.1", port = 8110, apiKe
       return res.end();
     } catch (error) {
       if (res.headersSent) { writer?.fail(error.message); return res.end(); }
+      if (error.message === "wrong wallet password") return send(401, { error: error.message });
+      if (error.status && error.status < 500 && !error.dispatched && routes[`${req.method} ${new URL(req.url, "http://x").pathname}`]) {
+        return send(error.status, { error: error.message });
+      }
       const status = error.code === "outcome_unknown" ? 504 : (error.status && error.status < 500 ? error.status : 502);
       return send(status, openaiError(error.message, error.code || "request_failed"));
     }

package/src/disputes.mjs

@@ -1,5 +1,5 @@
 // V11 Consumer disputes: keep each request's plaintexts locally, reveal them as evidence on demand.
-import { chmodSync, mkdirSync, readdirSync, readFileSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { chmodSync, existsSync, mkdirSync, readdirSync, readFileSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { canonicalJson } from "./secure-envelope.mjs";
 import { encodeCall, encodeWords, hex, keccak, settlementKey } from "./eip712.mjs";
@@ -52,3 +52,31 @@ export const reportId = (key, reporter, digest) =>
   hex(keccak(encodeWords([["bytes32", key], ["address", reporter], ["bytes32", digest]])));
 
 export const openDisputeCall = (key, digest) => encodeCall("openDispute(bytes32,bytes32)", [["bytes32", key], ["bytes32", digest]]);
+
+function preview(document) {
+  const content = document.endpoint === "chat" ? (document.messages || []).filter((m) => m.role === "user").at(-1)?.content : document.input;
+  const text = typeof content === "string" ? content : Array.isArray(content)
+    ? content.map((part) => (typeof part === "string" ? part : part?.text ?? part?.content ?? "")).join(" ") : JSON.stringify(content ?? "");
+  return String(text).slice(0, 400);
+}
+
+/** Recorded requests, newest first, with short previews (the plaintexts never leave this machine). */
+export function listRequests(dir, outputText, limit = 100) {
+  const folder = journal(dir);
+  if (!existsSync(folder)) return [];
+  return readdirSync(folder).filter((name) => name.endsWith(".json"))
+    .map((name) => JSON.parse(readFileSync(join(folder, name), "utf8")))
+    .sort((a, b) => b.recorded_at - a.recorded_at).slice(0, limit)
+    .map((record) => {
+      let request = {}; let response = {};
+      try { request = JSON.parse(Buffer.from(record.request, "base64").toString("utf8")); } catch {}
+      try { response = JSON.parse(Buffer.from(record.response, "base64").toString("utf8")); } catch {}
+      const { authorization, receipt } = record.signed_receipt;
+      return {
+        settlement_key: record.settlement_key, recorded_at: record.recorded_at, relay_url: record.relay_url,
+        model: request.model, endpoint: request.endpoint, prompt: preview(request),
+        answer: String(outputText(response.output)).slice(0, 600), fee: String(receipt.actual_fee),
+        input_tokens: receipt.input_tokens, output_tokens: receipt.output_tokens, provider: authorization.provider_signer,
+      };
+    });
+}

package/src/wallet.mjs

@@ -76,11 +76,12 @@ export async function password(prompt, { confirm = false } = {}) {
 
 export const walletPath = (dir) => join(dir, "owner-wallet.json");
 
-export async function createWallet(dir) {
+export async function createWallet(dir, secret) {
   const path = walletPath(dir);
   if (existsSync(path)) return JSON.parse(readFileSync(path, "utf8"));
+  if (secret !== undefined && String(secret).length < 8) throw new Error("use a wallet password of at least 8 characters");
   const keystore = encryptKeystore(`0x${randomBytes(32).toString("hex")}`,
-    await password("New wallet password (protects your deposit): ", { confirm: true }));
+    secret ?? await password("New wallet password (protects your deposit): ", { confirm: true }));
   writeFileSync(path, `${JSON.stringify(keystore, null, 2)}\n`, { mode: 0o600 });
   chmodSync(path, 0o600);
   return keystore;
@@ -104,3 +105,10 @@ export function ownerAddress(file, dir) {
   if (/^(0x)?[0-9a-fA-F]{64}$/.test(text)) return addressOf(text.startsWith("0x") ? text : `0x${text}`);
   return walletAddress(JSON.parse(text));
 }
+
+/** Unlock this machine's wallet with a password given by the local console. */
+export function unlockWallet(dir, secret) {
+  const path = walletPath(dir);
+  if (!existsSync(path)) throw new Error("no owner wallet yet");
+  return decryptKeystore(JSON.parse(readFileSync(path, "utf8")), String(secret ?? ""));
+}

package/src/web/console.html

@@ -0,0 +1,282 @@
+<!doctype html>
+<html lang="zh-CN">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>MycoMesh 本地节点</title>
+<style>
+  :root { --bg:#0f1115; --panel:#171a21; --line:#262b36; --text:#e6e8ee; --dim:#8b93a7; --accent:#5fd4a4; --warn:#f2b35b; --bad:#f07178; }
+  * { box-sizing:border-box; }
+  body { margin:0; font:14px/1.55 -apple-system,BlinkMacSystemFont,"PingFang SC","Noto Sans SC","Segoe UI",sans-serif; background:var(--bg); color:var(--text); }
+  header { display:flex; align-items:center; gap:16px; padding:14px 24px; border-bottom:1px solid var(--line); }
+  header h1 { font-size:16px; margin:0; letter-spacing:.3px; }
+  header h1 span { color:var(--accent); }
+  .badge { padding:2px 10px; border:1px solid var(--line); border-radius:999px; color:var(--dim); font-size:12px; }
+  .badge.ok { color:var(--accent); border-color:#2e5a49; }
+  nav { display:flex; gap:4px; padding:0 20px; border-bottom:1px solid var(--line); }
+  nav button { background:none; border:0; color:var(--dim); padding:12px 14px; cursor:pointer; font-size:14px; border-bottom:2px solid transparent; }
+  nav button.active { color:var(--text); border-bottom-color:var(--accent); }
+  main { max-width:1080px; margin:0 auto; padding:24px; }
+  section { display:none; } section.active { display:block; }
+  .cards { display:grid; grid-template-columns:repeat(auto-fit,minmax(200px,1fr)); gap:12px; margin-bottom:20px; }
+  .card { background:var(--panel); border:1px solid var(--line); border-radius:10px; padding:14px 16px; }
+  .card .label { color:var(--dim); font-size:12px; } .card .value { font-size:20px; margin-top:4px; font-variant-numeric:tabular-nums; }
+  .row { display:flex; gap:10px; flex-wrap:wrap; align-items:center; margin:10px 0; }
+  input, select, textarea { background:#0c0e12; color:var(--text); border:1px solid var(--line); border-radius:8px; padding:9px 11px; font:inherit; }
+  textarea { width:100%; resize:vertical; min-height:70px; }
+  button.primary, button.ghost { border-radius:8px; padding:9px 16px; cursor:pointer; font:inherit; }
+  button.primary { background:var(--accent); color:#06231a; border:0; font-weight:600; }
+  button.ghost { background:none; color:var(--text); border:1px solid var(--line); }
+  button:disabled { opacity:.5; cursor:default; }
+  h2 { font-size:15px; margin:24px 0 8px; }
+  .muted { color:var(--dim); } .mono { font-family:ui-monospace,SFMono-Regular,Menlo,monospace; font-size:12px; }
+  table { width:100%; border-collapse:collapse; } th, td { text-align:left; padding:9px 8px; border-bottom:1px solid var(--line); vertical-align:top; }
+  th { color:var(--dim); font-weight:500; font-size:12px; }
+  .chip { display:inline-block; padding:1px 8px; border-radius:999px; font-size:12px; border:1px solid var(--line); }
+  .chip.pending { color:var(--warn); } .chip.released { color:var(--accent); } .chip.disputed, .chip.confirmed { color:var(--bad); }
+  #chat { display:flex; flex-direction:column; gap:12px; min-height:320px; margin-bottom:14px; }
+  .msg { max-width:80%; padding:10px 14px; border-radius:12px; white-space:pre-wrap; word-wrap:break-word; }
+  .msg.user { align-self:flex-end; background:#1f3a31; } .msg.assistant { align-self:flex-start; background:var(--panel); border:1px solid var(--line); }
+  .msg.error { align-self:flex-start; color:var(--bad); border:1px solid #5a2e33; }
+  #toast { position:fixed; right:20px; bottom:20px; max-width:420px; padding:12px 16px; border-radius:10px; background:var(--panel); border:1px solid var(--line); display:none; }
+  dialog { background:var(--panel); color:var(--text); border:1px solid var(--line); border-radius:12px; padding:20px; width:min(440px,92vw); }
+  dialog::backdrop { background:rgba(0,0,0,.55); } dialog label { display:block; margin:10px 0 4px; color:var(--dim); font-size:12px; }
+  dialog input, dialog textarea { width:100%; }
+</style>
+</head>
+<body>
+<header>
+  <h1><span>●</span> MycoMesh 本地节点</h1>
+  <span class="badge" id="net">连接中…</span>
+  <span class="badge" id="relays">Relay —</span>
+  <span class="muted mono" id="paykey" style="margin-left:auto"></span>
+</header>
+<nav>
+  <button data-tab="chat" class="active">对话</button>
+  <button data-tab="wallet">钱包</button>
+  <button data-tab="history">记录</button>
+  <button data-tab="network">网络</button>
+</nav>
+<main>
+  <section id="tab-chat" class="active">
+    <div class="row"><label class="muted">模型</label><select id="model"></select>
+      <button class="ghost" id="clear">新对话</button><span class="muted" id="chat-hint"></span></div>
+    <div id="chat"></div>
+    <textarea id="prompt" placeholder="输入问题，Enter 发送，Shift+Enter 换行。请求在本机加密，Relay 看不到内容。"></textarea>
+    <div class="row"><button class="primary" id="send">发送</button><span class="muted">每个回答都会在本机解密，并与 Provider 签名的收据核对后才显示。</span></div>
+  </section>
+
+  <section id="tab-wallet">
+    <div id="no-wallet" style="display:none">
+      <h2>创建钱包</h2>
+      <p class="muted">钱包文件是标准的以太坊加密 keystore，保存在本机，可以导入 MetaMask。密码只用于解锁，不会保存或上传。</p>
+      <div class="row"><input type="password" id="new-pw" placeholder="钱包密码（至少 8 位）"><input type="password" id="new-pw2" placeholder="再输入一次">
+        <button class="primary" id="create-wallet">创建</button></div>
+    </div>
+    <div id="has-wallet" style="display:none">
+      <div class="cards">
+        <div class="card"><div class="label">托管押金</div><div class="value" id="deposit">—</div></div>
+        <div class="card"><div class="label">钱包里的 tUSDC</div><div class="value" id="tokens">—</div></div>
+        <div class="card"><div class="label">gas（ETH）</div><div class="value" id="eth">—</div></div>
+        <div class="card"><div class="label">单次请求上限</div><div class="value" id="grant">—</div></div>
+      </div>
+      <p class="muted">钱包地址 <span class="mono" id="owner"></span></p>
+      <h2>存入押金</h2>
+      <p class="muted">押金由结算合约托管，只能用于你本机签名授权的请求。测试网上，余额不足时会先自动从水龙头领取。</p>
+      <div class="row"><input id="dep-amount" placeholder="金额（tUSDC）" value="20" size="10">
+        <input id="dep-limit" placeholder="单次上限（tUSDC）" value="2" size="12">
+        <button class="primary" id="deposit-btn">存入</button>
+        <button class="ghost" id="faucet-btn">领取测试币</button></div>
+      <h2>取回押金</h2>
+      <p class="muted" id="withdraw-hint">先申请，等待期结束后再次点击即可到账。</p>
+      <div class="row"><input id="wd-amount" placeholder="金额（留空为全部）" size="16"><button class="ghost" id="withdraw-btn">取回</button></div>
+    </div>
+  </section>
+
+  <section id="tab-history">
+    <p class="muted">最近 3 天在本机记录的请求。明文只保存在这台机器上；24 小时争议窗口内可以把它公开给随机抽选的 Provider-AI 陪审团。</p>
+    <table><thead><tr><th>时间</th><th>问题</th><th>回答</th><th>费用</th><th>状态</th><th></th></tr></thead><tbody id="history"></tbody></table>
+  </section>
+
+  <section id="tab-network">
+    <p class="muted">Relay 来自内置清单和链上 Relay 目录，本机逐个核对签名身份。价格单位：每 1000 个 token 的 tUSDC。</p>
+    <div id="network"></div>
+  </section>
+</main>
+
+<dialog id="dialog"><form method="dialog" id="dialog-form">
+  <h3 id="dialog-title" style="margin-top:0"></h3><div id="dialog-body"></div>
+  <label>钱包密码</label><input type="password" id="dialog-pw" required>
+  <div class="row" style="justify-content:flex-end"><button class="ghost" value="cancel" formnovalidate>取消</button><button class="primary" value="ok">确认</button></div>
+</form></dialog>
+<div id="toast"></div>
+
+<script>
+const $ = (id) => document.getElementById(id);
+const USDC = 1_000_000;
+const fmt = (units) => (Number(units) / USDC).toLocaleString("zh-CN", { maximumFractionDigits: 6 });
+const toUnits = (text) => String(Math.round(Number(text) * USDC));
+const short = (value) => value ? `${value.slice(0, 8)}…${value.slice(-6)}` : "";
+const STATUS = { pending: "托管中", released: "已结算", disputed: "争议中", confirmed: "欺诈确认·已退款", dismissed: "争议驳回",
+  timed_out: "陪审超时·已放款", jury_unavailable: "无陪审·已退款", voided: "已作废", none: "待上链", unknown: "未知" };
+
+function toast(text, bad = false) {
+  const box = $("toast"); box.textContent = text; box.style.display = "block"; box.style.color = bad ? "var(--bad)" : "var(--text)";
+  clearTimeout(toast.timer); toast.timer = setTimeout(() => { box.style.display = "none"; }, 6000);
+}
+async function api(path, body) {
+  const response = await fetch(path, body === undefined ? {} : { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body) });
+  const data = await response.json().catch(() => ({}));
+  if (!response.ok) throw new Error(typeof data.error === "string" ? data.error : data.error?.message || `HTTP ${response.status}`);
+  return data;
+}
+function ask(title, bodyHtml = "") {
+  return new Promise((resolve) => {
+    $("dialog-title").textContent = title; $("dialog-body").innerHTML = bodyHtml; $("dialog-pw").value = "";
+    $("dialog").onclose = () => resolve($("dialog").returnValue === "ok" ? { password: $("dialog-pw").value, form: $("dialog-body") } : null);
+    $("dialog").showModal();
+  });
+}
+async function busy(button, work) {
+  button.disabled = true; const label = button.textContent; button.textContent = "处理中…";
+  try { await work(); } catch (error) { toast(error.message, true); } finally { button.disabled = false; button.textContent = label; }
+}
+
+document.querySelectorAll("nav button").forEach((button) => button.onclick = () => {
+  history.replaceState(null, "", `#${button.dataset.tab}`);
+  document.querySelectorAll("nav button").forEach((b) => b.classList.toggle("active", b === button));
+  document.querySelectorAll("section").forEach((s) => s.classList.toggle("active", s.id === `tab-${button.dataset.tab}`));
+  ({ wallet: refreshWallet, history: refreshHistory, network: refreshNetwork })[button.dataset.tab]?.();
+});
+
+// ---------------- wallet ----------------
+let status = null;
+async function refreshWallet() {
+  status = await api("/api/status");
+  $("net").textContent = `${status.network.id} · 链 ${status.network.chain_id}`; $("net").className = "badge ok";
+  $("paykey").textContent = `付款 key ${short(status.payment_key)}`;
+  $("no-wallet").style.display = status.wallet ? "none" : "block"; $("has-wallet").style.display = status.wallet ? "block" : "none";
+  $("faucet-btn").style.display = status.network.faucet ? "" : "none";
+  const w = status.wallet; if (!w) return;
+  $("owner").textContent = w.owner; $("deposit").textContent = fmt(w.deposit); $("tokens").textContent = fmt(w.wallet_tokens);
+  $("eth").textContent = (Number(w.eth_wei) / 1e18).toFixed(4); $("grant").textContent = w.grant?.active ? fmt(w.grant.max_per_request) : "未授权";
+  const pending = BigInt(w.withdrawal.amount);
+  $("withdraw-hint").textContent = pending > 0n
+    ? (w.withdrawal.available_at * 1000 > Date.now() ? `已申请取回 ${fmt(w.withdrawal.amount)}，${new Date(w.withdrawal.available_at * 1000).toLocaleString()} 之后可到账。`
+      : `已申请的 ${fmt(w.withdrawal.amount)} 可以到账了，点击“取回”。`) : "先申请，等待期结束后再次点击即可到账。";
+  $("chat-hint").textContent = BigInt(w.deposit) === 0n || !w.grant?.active ? "还没有押金：先到“钱包”存入。" : `押金 ${fmt(w.deposit)} tUSDC`;
+}
+$("create-wallet").onclick = () => busy($("create-wallet"), async () => {
+  if ($("new-pw").value !== $("new-pw2").value) throw new Error("两次输入的密码不一致");
+  await api("/api/wallet", { password: $("new-pw").value }); toast("钱包已创建"); await refreshWallet();
+});
+$("faucet-btn").onclick = () => busy($("faucet-btn"), async () => { await api("/api/faucet", {}); toast("已领取测试 ETH 和 tUSDC"); await refreshWallet(); });
+$("deposit-btn").onclick = async () => {
+  const answer = await ask(`存入 ${$("dep-amount").value} tUSDC`, `<p class="muted">单次请求上限 ${$("dep-limit").value} tUSDC。需要几笔链上交易，约 1 分钟。</p>`);
+  if (!answer) return;
+  await busy($("deposit-btn"), async () => {
+    await api("/api/setup", { password: answer.password, deposit: toUnits($("dep-amount").value), max_per_request: toUnits($("dep-limit").value) });
+    toast("押金已存入"); await refreshWallet();
+  });
+};
+$("withdraw-btn").onclick = async () => {
+  const answer = await ask("取回押金"); if (!answer) return;
+  await busy($("withdraw-btn"), async () => {
+    const amount = $("wd-amount").value.trim();
+    const result = await api("/api/withdraw", { password: answer.password, ...(amount ? { amount: toUnits(amount) } : {}) });
+    toast(result.withdrawn ? `已取回 ${fmt(result.withdrawn)} tUSDC` : `已申请取回 ${fmt(result.requested)} tUSDC`); await refreshWallet();
+  });
+};
+
+// ---------------- chat ----------------
+let conversation = [];
+function bubble(role, text) { const div = document.createElement("div"); div.className = `msg ${role}`; div.textContent = text; $("chat").append(div); div.scrollIntoView({ block: "end" }); return div; }
+$("clear").onclick = () => { conversation = []; $("chat").innerHTML = ""; };
+$("prompt").onkeydown = (event) => { if (event.key === "Enter" && !event.shiftKey) { event.preventDefault(); $("send").click(); } };
+$("send").onclick = async () => {
+  const text = $("prompt").value.trim(); if (!text) return;
+  $("prompt").value = ""; conversation.push({ role: "user", content: text }); bubble("user", text);
+  const out = bubble("assistant", "…"); let answer = ""; $("send").disabled = true;
+  try {
+    const response = await fetch("/v1/chat/completions", { method: "POST", headers: { "content-type": "application/json" },
+      body: JSON.stringify({ model: $("model").value, stream: true, messages: conversation }) });
+    if (!response.ok) { const data = await response.json().catch(() => ({})); throw new Error(data.error?.message || `HTTP ${response.status}`); }
+    const reader = response.body.getReader(); const decoder = new TextDecoder(); let buffer = "";
+    for (;;) {
+      const { value, done } = await reader.read(); if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let index;
+      while ((index = buffer.indexOf("\n\n")) >= 0) {
+        const event = buffer.slice(0, index); buffer = buffer.slice(index + 2);
+        const data = event.replace(/^data: /, ""); if (!data || data === "[DONE]") continue;
+        const chunk = JSON.parse(data);
+        if (chunk.error) throw new Error(chunk.error.message);
+        const delta = chunk.choices?.[0]?.delta?.content; if (delta) { answer += delta; out.textContent = answer; out.scrollIntoView({ block: "end" }); }
+      }
+    }
+    conversation.push({ role: "assistant", content: answer });
+  } catch (error) { out.className = "msg error"; out.textContent = error.message; conversation.pop(); }
+  finally { $("send").disabled = false; }
+};
+async function loadModels() {
+  const data = await fetch("/v1/models").then((r) => r.json());
+  $("model").innerHTML = data.data.map((m) => `<option>${m.id}</option>`).join("") || "<option>gpt-5.5</option>";
+}
+
+// ---------------- history ----------------
+async function refreshHistory() {
+  const { entries } = await api("/api/history");
+  const now = Date.now() / 1000;
+  $("history").innerHTML = entries.length ? "" : `<tr><td colspan="6" class="muted">还没有请求。</td></tr>`;
+  for (const entry of entries) {
+    const row = document.createElement("tr");
+    const cells = [new Date(entry.recorded_at * 1000).toLocaleString(), entry.prompt, entry.answer, `${fmt(entry.fee)}`];
+    cells.forEach((text, i) => {
+      const td = document.createElement("td");
+      td.textContent = (i === 1 || i === 2) && text.length > 140 ? `${text.slice(0, 140)}…` : text;
+      if (i === 1 || i === 2) { td.style.maxWidth = "280px"; td.title = text; }
+      row.append(td);
+    });
+    const state = document.createElement("td"); state.innerHTML = `<span class="chip ${entry.status}">${STATUS[entry.status] || entry.status}</span>`; row.append(state);
+    const action = document.createElement("td");
+    if (entry.status === "pending" && entry.release_at > now) {
+      const button = document.createElement("button"); button.className = "ghost"; button.textContent = "争议";
+      button.onclick = async () => {
+        const answer = await ask("发起争议", `<p class="muted">会公开这次的问题和回答给随机抽选的 Provider-AI 陪审团，并锁定 1 tUSDC 保证金；确认欺诈后退款并返还保证金。</p>
+          <label>说明</label><textarea id="statement" placeholder="例如：回答与问题完全无关"></textarea>`);
+        if (!answer) return;
+        await busy(button, async () => {
+          const result = await api("/api/dispute", { password: answer.password, settlement_key: entry.settlement_key, statement: answer.form.querySelector("#statement").value });
+          toast(`争议已提交，${result.relays_accepted.length} 个 Relay 接收了证据`); await refreshHistory();
+        });
+      };
+      action.append(button);
+    }
+    row.append(action); $("history").append(row);
+  }
+}
+
+// ---------------- network ----------------
+async function refreshNetwork() {
+  const { relays } = await api("/api/network");
+  $("relays").textContent = `Relay ${relays.filter((r) => r.healthy).length}/${relays.length}`;
+  $("relays").className = relays.some((r) => r.healthy) ? "badge ok" : "badge";
+  $("network").innerHTML = "";
+  for (const relay of relays) {
+    const card = document.createElement("div"); card.className = "card"; card.style.marginBottom = "12px";
+    card.innerHTML = `<div class="row" style="margin:0"><strong>${relay.url}</strong><span class="chip ${relay.healthy ? "released" : "disputed"}">${relay.healthy ? "在线" : "离线"}</span>
+      <span class="muted mono">签名 ${short(relay.signer)}</span></div>
+      <table style="margin-top:8px"><thead><tr><th>Provider</th><th>模型</th><th>输入</th><th>输出</th><th>最低</th></tr></thead><tbody>${relay.providers.map((p) =>
+        `<tr><td class="mono">${short(p.signer)}</td><td>${p.models.join(", ")}</td><td>${fmt(p.prices.input_per_1k)}</td><td>${fmt(p.prices.output_per_1k)}</td><td>${fmt(p.prices.minimum_fee)}</td></tr>`).join("")
+        || `<tr><td colspan="5" class="muted">没有已连接的 Provider</td></tr>`}</tbody></table>`;
+    $("network").append(card);
+  }
+}
+
+refreshWallet().catch((error) => toast(error.message, true));
+refreshNetwork().catch(() => {});
+loadModels().catch(() => {});
+document.querySelector(`nav button[data-tab="${location.hash.slice(1)}"]`)?.click();
+</script>
+</body>
+</html>