mycomesh-consumer 0.1.52 → 0.2.0

package/README.md

@@ -1,141 +1,33 @@
 # mycomesh-consumer
 
-Native Node.js Consumer for the MycoMesh Settlement V8 Relay network. It runs
-on the user's machine with no Docker, Python runtime, Compose file, or public
-Gateway dependency.
+The MycoMesh V11 Consumer. One deposit custodied by the settlement contract
+pays any Provider on the network; every request is signed by a local payment
+key and sealed end to end, so Relays forward ciphertext only.
 
-## Install
-
-Requirements: Node.js 20 or newer. The package contains only the small
-cryptographic dependencies needed for V8 EIP-712 payment-key authorizations;
-Codex is an independent client.
+Requires Node.js 20 or newer. No Docker or Python.
 
 ```sh
 npm install --global mycomesh-consumer
-mycomesh-consumer
-```
-
-The default remains the public V8-compatible network for existing installs.
-The pinned V10 fixed-budget committee is a controlled testnet and must be
-selected explicitly:
-
-```sh
-mycomesh-consumer --v10-controlled-test
-```
-
-This option uses the manifest and private testnet CA shipped in the package,
-pins both test Relays, and requires the wallet to fund an active fixed budget
-channel. It is not a production network and does not enable token rewards or
-independent arbitration.
-
-For a checkout:
-
-```sh
-npm install --global ./packages/mycomesh-cli
-```
-
-The command starts the Consumer API on `127.0.0.1:8110`, prints and optionally
-opens the local credentials page, and stays available for any
-OpenAI-compatible client. It does not start or configure Codex.
-
-The page starts with a wallet signature check. The selected wallet must match
-the local payment key's active on-chain grant before the API key/export and
-inference are enabled. It exposes only the local API URL, payment key/export,
-prepaid balance, key operations, and local consumption history. It has no
-conversation or request-session UI. The payment key is generated once and stored at
-`~/.mycomesh/consumer/payment-key` with mode `0600`; set
-`MYCOMESH_CONSUMER_DATA_DIR` to choose another directory.
-
-## Connect a client
-
-The default command is already service-only. Sign in on the local page first,
-then load the export block into a shell and use Codex or another compatible
-client:
-
-```sh
-mycomesh-consumer --no-browser
-```
-
-Open the printed setup URL, sign in, and use **Copy export** on the local page.
-Paste the export into the client terminal, then run `codex`. An unauthenticated
-request to `/credentials` is rejected even after the wallet is unlocked.
-
-The optional convenience wrapper is explicit:
-
-```sh
-mycomesh-consumer --codex
-```
-
-Use `--no-browser` on a headless machine. Stop the process without deleting
-the key or history with `mycomesh-consumer --stop`. A full reset is explicit:
-
-```sh
-MYCOMESH_CONFIRM_RESET=RESET mycomesh-consumer --reset-local
-```
-
-The local API is OpenAI-compatible:
-
-```sh
-export OPENAI_BASE_URL=http://127.0.0.1:8110/v1
-export OPENAI_API_KEY='myco_sk_...'
-mycomesh responses --input 'hello' --model gpt-5.5
-```
-
-The browser's export block is the canonical way to obtain both values after
-wallet verification. `--codex` waits for that verification before launching
-Codex.
-
-## Temporary sharing
-
-The local page can create one time-limited HTTPS API URL and an independent
-`myco_share_...` key for testing an OpenAI-compatible client outside the
-Consumer machine. Install `cloudflared`, choose a lifetime, and click **Start
-sharing**. The public endpoint exposes only models, Responses, Chat
-Completions, and Codex search routes; it does not expose the dashboard or the
-payment key. Stopping the share, reaching its expiry, or restarting the
-Consumer invalidates the temporary key.
-
-## Relay scheduling and V8 payments
-
-The Consumer checks each configured Relay's selected protocol health (V8 by
-default, or V10 when explicitly selected) and automatically tries the next
-Relay after a health, timeout, or retryable HTTP failure. A single
-request ID is preserved across failover. Each attempt carries a fresh V8
-EIP-712 payment authorization signed by the persisted key; the Relay resolves
-the key address to its on-chain grant and settles the signed receipt. A wallet
-signature unlocks each Consumer process once; inference has no per-request
-wallet signature or Consumer-managed conversation state.
-
-Configure multiple Relay origins and an optional outbound proxy:
-
-```sh
-export MYCOMESH_V8_RELAY_URLS='https://relay-a.example,https://relay-b.example'
-mycomesh-consumer --proxy http://127.0.0.1:10792
-```
-
-The default Relay is `https://bridge.mycomesh.xyz`. The V8 deployment and RPC
-defaults are embedded in the package; `MYCOMESH_CONSUMER_NETWORK_CONFIG` and
-`MYCOMESH_CONSUMER_SETTLEMENT_RPC_URLS` can override them for another network.
-For the controlled V10 path, use `--v10-controlled-test` or provide an
-equivalent manifest with `--network-config` and `--controlled-test`.
-
-## Stateless request CLI
-
-The package also keeps the stateless API commands:
-
-```sh
-mycomesh health
-mycomesh models
-mycomesh responses --input 'Summarize this' --max-output-tokens 500
-mycomesh chat --message 'Explain this function'
-```
-
-Use `--json @file`, `--json -`, or piped JSON for complete OpenAI-shaped
-requests. `--stream` returns buffered-compatible SSE events from the Relay.
-
-## Development
-
-```sh
-cd packages/mycomesh-cli
-npm test
-```
+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)
+```
+
+- `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.
+- `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 "..."`
+  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
+`networks/mycomesh-v11-sepolia.json`; use `--network FILE` for another.

package/bin/mycomesh-consumer.mjs

@@ -1,10 +1,7 @@
 #!/usr/bin/env node
+import { main } from "../src/cli.mjs";
 
-import { isApiInvocation } from "../src/consumer.mjs";
-
-const argv = process.argv.slice(2);
-const { main } = isApiInvocation(argv)
-  ? await import("../src/cli.mjs")
-  : await import("../src/consumer.mjs");
-
-process.exitCode = await main(argv);
+main().then((code) => { if (typeof code === "number") process.exitCode = code; }).catch((error) => {
+  process.stderr.write(`mycomesh-consumer: ${error.message}\n`);
+  process.exitCode = 1;
+});

package/networks/mycomesh-v11-sepolia.json

@@ -0,0 +1,27 @@
+{
+  "schema": "mycomesh.v11.network.v1",
+  "network_id": "mycomesh-v11-sepolia",
+  "chain_id": 11155111,
+  "settlement": "0xd46b7efb1e650e83cdeb4a36fdfef33499e54842",
+  "stablecoin": "0xbce27efad4191277167fe76819581a97959048cf",
+  "registry": "0x0ff3210e8e8abf5f5bfa73a39e60db7416b6c8c7",
+  "deployment_block": 11809185,
+  "rpc_urls": [
+    "https://ethereum-sepolia-rpc.publicnode.com",
+    "https://rpc.sepolia.ethpandaops.io",
+    "https://sepolia.gateway.tenderly.co"
+  ],
+  "tls_ca_file": "mycomesh-testnet-ca.crt",
+  "relays": [
+    {
+      "url": "https://136.0.3.126:10443",
+      "signer": "0x58fb2f217f3065d67cdde9d5231aa9388cf72297",
+      "link": "136.0.3.126:10991"
+    },
+    {
+      "url": "https://166.88.96.60:10443",
+      "signer": "0x2211e0288ef46a7b4ea03a5022f4a96f146d8c9d",
+      "link": "166.88.96.60:10991"
+    }
+  ]
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mycomesh-consumer",
-  "version": "0.1.52",
-  "description": "Native Node.js MycoMesh Consumer and OpenAI-compatible request CLI.",
+  "version": "0.2.0",
+  "description": "MycoMesh V11 Consumer: a custodied deposit, relay-blind encrypted requests to any Provider, and a local OpenAI-compatible endpoint.",
   "repository": {
     "type": "git",
     "url": "https://github.com/Charleslzp/mycomesh"
@@ -11,37 +11,24 @@
   },
   "type": "module",
   "bin": {
-    "mycomesh": "bin/mycomesh.mjs",
     "mycomesh-consumer": "bin/mycomesh-consumer.mjs"
   },
   "files": [
-    "bin/mycomesh.mjs",
     "bin/mycomesh-consumer.mjs",
-    "src/cli.mjs",
-    "src/consumer.mjs",
-    "src/consumer-runtime.mjs",
-    "src/consumer-reserved.mjs",
-    "src/consumer-request-journal.mjs",
-    "src/consumer-discovery.mjs",
-    "src/release.mjs",
-    "src/consumer-sessions.mjs",
-    "src/consumer-history.mjs",
-    "README.md",
-    "networks/v10-controlled-test.json",
-    "networks/v10-controlled-test.ca.crt",
-    "networks/v10-dynamic-20260926.json",
-    "networks/v10-dynamic-20260926.ca.crt"
+    "src/*.mjs",
+    "networks/mycomesh-v11-sepolia.json",
+    "networks/mycomesh-testnet-ca.crt",
+    "README.md"
   ],
   "engines": {
     "node": ">=20"
   },
   "dependencies": {
     "@noble/curves": "1.9.1",
-    "@noble/hashes": "1.8.0",
-    "undici": "6.28.0"
+    "@noble/hashes": "1.8.0"
   },
   "scripts": {
-    "test": "node --test"
+    "test": "node --test test/*.test.mjs"
   },
   "license": "UNLICENSED"
 }

package/src/chain.mjs

@@ -0,0 +1,52 @@
+// Minimal JSON-RPC for Consumer setup and balance reads, with endpoint failover.
+import { addressOf, encodeCall, signLegacyTransaction } from "./eip712.mjs";
+
+export async function rpcCall(urls, method, params, { timeoutMs = 15000 } = {}) {
+  let last;
+  for (const url of [].concat(urls)) {
+    try {
+      const response = await fetch(url, {
+        method: "POST", headers: { "content-type": "application/json" },
+        body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params }), signal: AbortSignal.timeout(timeoutMs),
+      });
+      const body = await response.json();
+      if (body.error) throw Object.assign(new Error(`${method}: ${JSON.stringify(body.error).slice(0, 300)}`), { answered: true });
+      return body.result;
+    } catch (error) {
+      if (error.answered) throw error;
+      last = error;
+    }
+  }
+  throw new Error(`${method}: no RPC endpoint answered (${last?.message || "unknown"})`);
+}
+
+export const quantity = (value) => BigInt(value);
+
+export async function ethCallWord(urls, to, data) {
+  return BigInt(await rpcCall(urls, "eth_call", [{ to, data }, "latest"]));
+}
+
+export async function availableBalance(network, owner) {
+  return ethCallWord(network.rpc_urls, network.settlement, encodeCall("availableBalance(address)", [["address", owner]]));
+}
+
+export async function sendTransaction(urls, privateKey, { to, data, gasLimit }) {
+  const from = addressOf(privateKey);
+  const [chainId, nonce, gasPrice] = await Promise.all([
+    rpcCall(urls, "eth_chainId", []), rpcCall(urls, "eth_getTransactionCount", [from, "pending"]), rpcCall(urls, "eth_gasPrice", []),
+  ]);
+  const limit = gasLimit ?? (quantity(await rpcCall(urls, "eth_estimateGas", [{ from, to, data }])) * 12n / 10n + 10000n);
+  const raw = signLegacyTransaction(privateKey, {
+    nonce: quantity(nonce), gasPrice: quantity(gasPrice) * 12n / 10n, gasLimit: limit, to, data, chainId: quantity(chainId),
+  });
+  const hash = await rpcCall(urls, "eth_sendRawTransaction", [raw]);
+  for (let i = 0; i < 180; i += 1) {
+    const receipt = await rpcCall(urls, "eth_getTransactionReceipt", [hash]);
+    if (receipt) {
+      if (receipt.status !== "0x1") throw new Error(`transaction ${hash} reverted`);
+      return receipt;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+  }
+  throw new Error(`transaction ${hash} was not mined in time`);
+}