@seedhape/local-wallet 0.2.0

package/test/setup-flow.test.mjs

@@ -0,0 +1,47 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
+import { generatePrivateKey } from "viem/accounts";
+import { LocalSessionKeySigner, USDC } from "@seedhape/core";
+
+test("first wallet request starts browser setup once and returns while setup is pending", async () => {
+  process.env.SEEDHAPE_TOKEN = "test-token";
+  const { createServer } = await import("../dist/server.js");
+  const signer = new LocalSessionKeySigner(generatePrivateKey());
+  let finish;
+  let setupCalls = 0;
+  const server = createServer({
+    agentId: "test-agent",
+    address: null,
+    signer: null,
+    asset: USDC["base-sepolia"],
+    absoluteMaxPerPayment: 1_000_000n,
+    setupNeeded: true,
+    finishSetup: () => {
+      setupCalls += 1;
+      return new Promise((resolve) => { finish = resolve; });
+    },
+    fetchImpl: async () => new Response("ok", { status: 200 }),
+  });
+  const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+  await server.connect(serverTransport);
+  const client = new Client({ name: "test", version: "1" });
+  await client.connect(clientTransport);
+  try {
+    const pending1 = await client.callTool({ name: "wallet_status", arguments: {} });
+    const pending2 = await client.callTool({ name: "quote", arguments: { url: "https://example.com/" } });
+    assert.match(pending1.content[0].text, /Finishing setup in your browser/);
+    assert.match(pending2.content[0].text, /Finishing setup in your browser/);
+    assert.equal(setupCalls, 1, "parallel first-use requests share one setup flow");
+
+    finish({ address: signer.address, signer, webBotAuth: null, identity: null });
+    await new Promise((resolve) => setImmediate(resolve));
+    const ready = await client.callTool({ name: "quote", arguments: { url: "https://example.com/" } });
+    assert.match(ready.content[0].text, /does not ask for payment/);
+    assert.equal(setupCalls, 1);
+  } finally {
+    await client.close();
+    delete process.env.SEEDHAPE_TOKEN;
+  }
+});

package/test/web-bot-auth.test.mjs

@@ -0,0 +1,134 @@
+// Web Bot Auth in the local wallet: key generation, registration against a
+// Seedhape-like server, and fresh signatures on every outgoing HTTPS request.
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createServer as createHttp } from "node:http";
+import { createPublicKey } from "node:crypto";
+import { generatePrivateKey } from "viem/accounts";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
+import { LocalSessionKeySigner, USDC, verifyWebBotAuth, verifyWebBotAuthProof } from "@seedhape/core";
+import { defaultSignatureAgent, ed25519Thumbprint, generateWebBotAuthKey, registerWebBotAuthKey, revokeWebBotAuthKey, signChallenge, webBotAuthFetch } from "../dist/web-bot-auth.js";
+
+test("generated keys use the RFC 7638 thumbprint as key id and never expose private material", () => {
+  const key = generateWebBotAuthKey("https://seedhape.example/agents/laptop-1a2b3c4d");
+  assert.equal(key.keyId, ed25519Thumbprint(key.publicJwk));
+  assert.equal(key.publicJwk.d, undefined);
+  assert.match(key.privateKeyPem, /BEGIN PRIVATE KEY/);
+  assert.throws(() => generateWebBotAuthKey("http://insecure.example/agent"), /HTTPS/);
+});
+
+test("default signature agents live under the Seedhape URL and are unique per agent", () => {
+  const a = defaultSignatureAgent("https://www.seedhape.com", "laptop");
+  const b = defaultSignatureAgent("https://www.seedhape.com", "laptop");
+  assert.match(a, /^https:\/\/www\.seedhape\.com\/agents\/laptop-[0-9a-f]{8}$/);
+  assert.notEqual(a, b);
+});
+
+test("challenge signatures verify with Seedhape's registration check", () => {
+  const key = generateWebBotAuthKey("https://seedhape.example/agents/x");
+  const challenge = "Seedhape Web Bot Auth key registration\nuser=u1\nagent=laptop";
+  assert.equal(verifyWebBotAuthProof({ publicJwk: key.publicJwk, message: challenge, signature: signChallenge(key, challenge) }), true);
+  assert.equal(verifyWebBotAuthProof({ publicJwk: key.publicJwk, message: challenge + "!", signature: signChallenge(key, challenge) }), false);
+});
+
+/** A fake hosted MCP that applies the same checks as Seedhape's register/rotate/revoke tools. */
+function fakeHosted() {
+  const registered = new Map();
+  const challenges = new Set();
+  const calls = [];
+  const callTool = async (name, args) => {
+    calls.push(name);
+    if (name === "web_bot_auth_challenge") { const challenge = `challenge:${args.agent_id}:${args.key_id}:${Math.random()}`; challenges.add(challenge); return JSON.stringify({ challenge }); }
+    if (name === "register_web_bot_auth_key" || name === "rotate_web_bot_auth_key") {
+      if (args.key_id !== ed25519Thumbprint(args.public_jwk)) return "Key registration failed: key_id must be the RFC 7638 thumbprint";
+      if (!challenges.delete(args.challenge) || !verifyWebBotAuthProof({ publicJwk: args.public_jwk, message: args.challenge, signature: args.signature })) return JSON.stringify({ ok: false, error: { message: "proof invalid" } });
+      registered.set(`${args.signature_agent}|${args.key_id}`, { revoked: false });
+      return JSON.stringify({ registered: true, keyId: args.key_id });
+    }
+    if (name === "revoke_web_bot_auth_key") {
+      const entry = registered.get(`${args.signature_agent}|${args.key_id}`);
+      if (!entry) return "Web Bot Auth key not revoked: no key with that signature agent and key id is registered to this account.";
+      entry.revoked = true; return "Web Bot Auth key revoked.";
+    }
+    throw new Error(`unexpected tool ${name}`);
+  };
+  return { callTool, registered, calls };
+}
+
+test("registration, rotation, and revocation go through Seedhape's challenge flow", async () => {
+  const hosted = fakeHosted();
+  const first = generateWebBotAuthKey("https://seedhape.example/agents/laptop-1");
+  await registerWebBotAuthKey(hosted.callTool, "laptop", first);
+  assert.equal(hosted.registered.get(`${first.signatureAgent}|${first.keyId}`).revoked, false);
+
+  const next = generateWebBotAuthKey(first.signatureAgent);
+  await registerWebBotAuthKey(hosted.callTool, "laptop", next, true);
+  await revokeWebBotAuthKey(hosted.callTool, first);
+  assert.equal(hosted.registered.get(`${first.signatureAgent}|${first.keyId}`).revoked, true);
+  assert.equal(hosted.registered.get(`${next.signatureAgent}|${next.keyId}`).revoked, false);
+  assert.deepEqual(hosted.calls, ["web_bot_auth_challenge", "register_web_bot_auth_key", "web_bot_auth_challenge", "rotate_web_bot_auth_key", "revoke_web_bot_auth_key"]);
+
+  const stranger = generateWebBotAuthKey("https://seedhape.example/agents/other");
+  await assert.rejects(() => revokeWebBotAuthKey(hosted.callTool, stranger), /not revoked/);
+});
+
+test("only HTTPS requests are signed, each with its own nonce", async () => {
+  const key = generateWebBotAuthKey("https://seedhape.example/agents/laptop-1");
+  const seen = [];
+  const signedFetch = webBotAuthFetch(async (input, init) => { seen.push({ url: String(input instanceof Request ? input.url : input), headers: new Headers(init?.headers) }); return new Response("ok"); }, key);
+  await signedFetch("https://merchant.example/a");
+  await signedFetch("https://merchant.example/a");
+  await signedFetch("http://localhost:3000/dev");
+  const publicKey = createPublicKey({ key: key.publicJwk, format: "jwk" });
+  const nonces = [];
+  for (const request of seen.slice(0, 2)) {
+    const result = await verifyWebBotAuth({ url: request.url, headers: request.headers, publicKey, expectedKeyId: key.keyId });
+    nonces.push(result.nonce);
+  }
+  assert.notEqual(nonces[0], nonces[1]);
+  assert.equal(seen[2].headers.get("signature"), null, "plain HTTP is sent unsigned");
+});
+
+test("a paid purchase signs both the price probe and the paid retry, and the merchant accepts both", async () => {
+  // Fake Seedhape (plain HTTP on loopback) that approves and records settlement.
+  const settles = [];
+  const seedhape = createHttp(async (request, response) => {
+    let raw = ""; for await (const chunk of request) raw += chunk; const body = JSON.parse(raw || "{}");
+    if (request.url === "/api/local-wallet/authorize") { response.writeHead(200, { "content-type": "application/json" }).end(JSON.stringify({ ok: true, authorizationId: "auth-wba", mandateHash: "0x1", amount: body.requirement.maxAmountRequired, payTo: body.requirement.payTo, network: body.requirement.network, expiresAt: 0 })); return; }
+    settles.push(body.status); response.writeHead(200, { "content-type": "application/json" }).end("{\"ok\":true}");
+  });
+  await new Promise((resolve) => seedhape.listen(0, "127.0.0.1", resolve));
+  process.env.SEEDHAPE_URL = `http://127.0.0.1:${seedhape.address().port}`;
+  process.env.SEEDHAPE_TOKEN = "test-token";
+
+  // Fake HTTPS merchant (in-process fetch) that REQUIRES a valid, non-replayed Web Bot Auth signature.
+  const key = generateWebBotAuthKey("https://seedhape.example/agents/laptop-1");
+  const publicKey = createPublicKey({ key: key.publicJwk, format: "jwk" });
+  const usedNonces = new Set();
+  const asset = USDC["base-sepolia"];
+  const merchant = async (input, init) => {
+    const url = String(input instanceof Request ? input.url : input);
+    const headers = new Headers(init?.headers ?? (input instanceof Request ? input.headers : undefined));
+    try { await verifyWebBotAuth({ url, headers, publicKey, expectedKeyId: key.keyId, consumeNonce: ({ nonce }) => (usedNonces.has(nonce) ? false : (usedNonces.add(nonce), true)) }); }
+    catch (error) { return new Response(`bot auth failed: ${error.message}`, { status: 401 }); }
+    if (!headers.get("x-payment") && !headers.get("payment-signature")) {
+      return new Response(JSON.stringify({ x402Version: 1, accepts: [{ scheme: "exact", network: "base-sepolia", maxAmountRequired: "10000", resource: url, description: "Signal", payTo: "0x1111111111111111111111111111111111111111", asset: asset.address, maxTimeoutSeconds: 60, extra: { name: "USDC", version: "2" } }] }), { status: 402, headers: { "content-type": "application/json" } });
+    }
+    return new Response("signal: bullish", { status: 200, headers: { "x-payment-response": Buffer.from(JSON.stringify({ success: true, transaction: `0x${"cd".repeat(32)}`, network: "base-sepolia" })).toString("base64") } });
+  };
+
+  const { createServer } = await import("../dist/server.js");
+  const signer = new LocalSessionKeySigner(generatePrivateKey());
+  const server = createServer({ agentId: "laptop", address: signer.address, signer, asset, absoluteMaxPerPayment: 1_000_000n, webBotAuth: key, fetchImpl: merchant, outboundPolicy: { allowPrivateNetworks: true } });
+  const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+  await server.connect(serverTransport);
+  const client = new Client({ name: "test", version: "1" });
+  await client.connect(clientTransport);
+  try {
+    const result = (await client.callTool({ name: "pay", arguments: { url: "https://merchant.example/signal" } })).content[0].text;
+    assert.match(result, /^Paid 0\.010000 USDC/, result);
+    assert.equal(usedNonces.size, 2, "probe and paid retry each carried a fresh signature");
+    assert.deepEqual(settles, ["settled"]);
+  } finally { await client.close(); seedhape.close(); }
+});

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "include": [
+    "src/**/*.ts"
+  ],
+  "references": [
+    {
+      "path": "../core"
+    }
+  ]
+}