@aqb-foundation/aqb-agent 1.0.1 → 1.0.2

package/index.js

@@ -0,0 +1,241 @@
+#!/usr/bin/env node
+// AQB CLI. One binary for humans wiring agents and for MCP clients.
+// Usage: aqb-agent <command> [flags]
+import fs from "node:fs";
+import { ContractFactory, parseUnits, formatUnits, formatEther } from "ethers";
+import { AqbAgent, discover, wellKnown, cardHash, newIdentity, USDC } from "./client/aqb.mjs";
+
+const pkg = JSON.parse(fs.readFileSync(new URL("./package.json", import.meta.url), "utf8"));
+const regFile = JSON.parse(fs.readFileSync(new URL("./registry/agent-coin.json", import.meta.url), "utf8"));
+
+const DEFAULTS = {
+  token: process.env.AQB_TOKEN || regFile.contracts.token,
+  registry: process.env.AQB_REGISTRY || regFile.contracts.registry,
+  verifier: process.env.AQB_VERIFIER || regFile.contracts.verifier,
+  pair: process.env.AQB_PAIR || regFile.markets?.[0]?.pair,
+  sale: process.env.AQB_SALE || regFile.sale,
+  chain: process.env.AQB_CHAIN || "base",
+  rpc: process.env.AQB_RPC || process.env.BASE_RPC,
+  key: process.env.AQB_KEY || process.env.PRIVATE_KEY,
+};
+
+function parse(argv) {
+  const out = { _: [] };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (!a.startsWith("--")) { out._.push(a); continue; }
+    const body = a.slice(2);
+    if (body.includes("=")) {
+      const [k, ...rest] = body.split("=");
+      out[k] = rest.join("=");
+    } else if (i + 1 < argv.length && !argv[i + 1].startsWith("--")) {
+      out[body] = argv[++i];
+    } else {
+      out[body] = true;
+    }
+  }
+  return out;
+}
+
+function client(args, extra = {}) {
+  return new AqbAgent({
+    rpc: args.rpc || DEFAULTS.rpc,
+    chain: args.chain || DEFAULTS.chain,
+    privateKey: args.key || DEFAULTS.key,
+    token: args.token || DEFAULTS.token,
+    registry: args.registry || DEFAULTS.registry,
+    ...extra,
+  });
+}
+
+function need(v, name) {
+  if (!v) throw new Error(`missing --${name}`);
+  return v;
+}
+
+const addr = (x) => (typeof x === "string" ? x.toLowerCase() : x);
+
+function buildCard(args, account) {
+  return {
+    aqb: 1,
+    name: args.name || "aqb-agent",
+    skill: args.skill || "agent service",
+    endpoint: args.endpoint || "https://agent.example/a2a",
+    pq: "ML-DSA-65",
+    kem: "ML-KEM-768",
+    pay: `aqb:${account || args.account || "0x0000000000000000000000000000000000000000"}`,
+    price: { unit: "AQB", amount: args.price || "0", per: args.per || "call" },
+  };
+}
+
+function readCard(args, account) {
+  if (args.card) return JSON.parse(fs.readFileSync(args.card, "utf8"));
+  return buildCard(args, account);
+}
+
+const HELP = `aqb-agent ${pkg.version}
+
+  aqb-agent mcp                         start the MCP stdio server
+  aqb-agent discover <host>             read /.well-known/agent-coin.json
+  aqb-agent wellknown                   print this deployment's discovery JSON
+  aqb-agent balance [address]           AQB + USDC balances
+  aqb-agent is-agent <address>          registry membership
+  aqb-agent quote [--amount 1]          vault + Uniswap V2 quote
+  aqb-agent pay --to 0x.. --amount 1.5 [--account 0x..]
+  aqb-agent fund --amount 10 [--account 0x..]        (USDC -> AQB)
+  aqb-agent redeem --amount 10 [--account 0x..]      (AQB -> USDC)
+  aqb-agent register --account 0x.. [--name .. --skill .. --endpoint .. --price ..]
+  aqb-agent update-card --account 0x.. [--card file.json | --name .. --skill ..]
+  aqb-agent card [--card file.json | --name .. --skill .. --endpoint ..]
+  aqb-agent deploy-account             deploy a PQSmartAccount (prints its PQ keys)
+  aqb-agent announce --account 0x.. --eph-pubkey 0x.. --shared-secret 0x..
+  aqb-agent version
+
+Env: AQB_KEY/PRIVATE_KEY, AQB_RPC/BASE_RPC, AQB_CHAIN, AQB_TOKEN, AQB_REGISTRY, AQB_VERIFIER, AQB_PAIR, AQB_SALE
+The on-chain account path currently signs with the ECDSA fallback (scheme 0x01); the PQ
+key remains the account identity and is used for off-chain signatures.
+`;
+
+async function main() {
+  const args = parse(process.argv.slice(2));
+  const cmd = args._[0] || "help";
+
+  if (cmd === "help" || args.help) { process.stdout.write(HELP); return; }
+  if (cmd === "version") { console.log(pkg.version); return; }
+
+  if (cmd === "mcp") {
+    await import("./mcp/server.mjs");
+    return;
+  }
+
+  if (cmd === "discover") {
+    const host = need(args._[1] || args.host, "host");
+    console.log(JSON.stringify(await discover(host), null, 2));
+    return;
+  }
+
+  if (cmd === "wellknown") {
+    console.log(JSON.stringify(wellKnown({
+      token: DEFAULTS.token, registry: DEFAULTS.registry, verifier: DEFAULTS.verifier,
+      chainId: Number(DEFAULTS.chain === "base" ? 8453 : 84532),
+      pool: DEFAULTS.pair, sale: DEFAULTS.sale,
+    }), null, 2));
+    return;
+  }
+
+  const c = client(args);
+
+  if (cmd === "balance") {
+    const address = addr(args._[1] || args.address || c.signer?.address);
+    if (!address) throw new Error("missing address");
+    console.log(JSON.stringify({
+      address,
+      aqb: formatEther(await c.balance(address)),
+      usdc: formatUnits(await c.usdBalance(address), 6),
+    }, null, 2));
+    return;
+  }
+
+  if (cmd === "is-agent") {
+    const address = addr(need(args._[1] || args.address, "address"));
+    console.log(JSON.stringify({ address, isAgent: await c.isAgent(address) }, null, 2));
+    return;
+  }
+
+  if (cmd === "quote") {
+    const pair = addr(args.pair || DEFAULTS.pair);
+    const amount = parseUnits(args.amount || "1", 18);
+    const q = await c.poolQuote(pair, amount);
+    console.log(JSON.stringify({
+      pool: pair,
+      aqb: formatEther(amount),
+      vaultUSDC: formatUnits(amount / 10n ** 12n, 6),
+      poolUSDC: formatUnits(q.usdc, 6),
+      reserves: { aqb: formatEther(q.reserves.aqb), usdc: formatUnits(q.reserves.usdc, 6) },
+    }, null, 2));
+    return;
+  }
+
+  if (cmd === "pay") {
+    const to = addr(need(args.to, "to"));
+    const amount = parseUnits(need(args.amount, "amount"), 18);
+    const tx = args.account ? await c.payFromAccount(c.account(addr(args.account)), to, amount) : await c.pay(to, amount);
+    console.log(JSON.stringify({ tx, to, aqb: formatEther(amount) }, null, 2));
+    return;
+  }
+
+  if (cmd === "fund") {
+    const amount = parseUnits(need(args.amount, "amount"), 6);
+    const tx = args.account ? await c.fundFromAccount(c.account(addr(args.account)), amount) : await c.fund(amount);
+    console.log(JSON.stringify({ tx, usdc: formatUnits(amount, 6) }, null, 2));
+    return;
+  }
+
+  if (cmd === "redeem" || cmd === "cash-out") {
+    const amount = parseUnits(need(args.amount, "amount"), 18);
+    const tx = args.account ? await c.redeemFromAccount(c.account(addr(args.account)), amount) : await c.cashOut(amount);
+    console.log(JSON.stringify({ tx, aqb: formatEther(amount), usdc: formatUnits(amount / 10n ** 12n, 6) }, null, 2));
+    return;
+  }
+
+  if (cmd === "register") {
+    const account = addr(need(args.account, "account"));
+    const card = readCard(args, account);
+    const tx = await c.registerViaAccount(account, card);
+    console.log(JSON.stringify({ tx, account, cardHash: cardHash(card), card }, null, 2));
+    return;
+  }
+
+  if (cmd === "update-card") {
+    const account = addr(need(args.account, "account"));
+    const card = readCard(args, account);
+    const tx = await c.updateCardFromAccount(account, card);
+    console.log(JSON.stringify({ tx, account, cardHash: cardHash(card) }, null, 2));
+    return;
+  }
+
+  if (cmd === "card") {
+    const card = readCard(args, args.account);
+    console.log(JSON.stringify({ card, cardHash: cardHash(card) }, null, 2));
+    return;
+  }
+
+  if (cmd === "deploy-account") {
+    const art = JSON.parse(fs.readFileSync(new URL("./artifacts/PQSmartAccount.json", import.meta.url), "utf8"));
+    const id = newIdentity();
+    const factory = new ContractFactory(art.abi, art.bytecode, c.requireSigner());
+    const acc = await factory.deploy(DEFAULTS.verifier, c.signer.address, id.publicKey);
+    await acc.waitForDeployment();
+    const address = await acc.getAddress();
+    console.log(JSON.stringify({
+      account: address,
+      ecdsaFallback: c.signer.address,
+      verifier: DEFAULTS.verifier,
+      pqPublicKey: "0x" + Buffer.from(id.publicKey).toString("hex"),
+      pqSecretKey: "0x" + Buffer.from(id.secretKey).toString("hex"),
+      pqKeyHash: id.keyHash,
+      next: `aqb-agent register --account ${address} --name <name> --skill <skill> --endpoint <url>`,
+    }, null, 2));
+    return;
+  }
+
+  if (cmd === "announce") {
+    const account = addr(need(args.account, "account"));
+    const tx = await c.announceFromAccount(
+      c.account(account),
+      need(args["eph-pubkey"], "eph-pubkey"),
+      need(args["shared-secret"], "shared-secret"),
+      args["meta-hash"] || "0x" + "00".repeat(32)
+    );
+    console.log(JSON.stringify({ tx, account }, null, 2));
+    return;
+  }
+
+  process.stderr.write(HELP);
+  process.exitCode = 1;
+}
+
+main().catch((e) => {
+  console.error(e.shortMessage || e.message || String(e));
+  process.exit(1);
+});

package/mcp/server.mjs

@@ -1,37 +1,123 @@
 #!/usr/bin/env node
 // AQB MCP server (stdio JSON-RPC 2.0, no deps). Tools every agent can call.
-import { AqbAgent, discover, wellKnown, cardHash, keyHash } from "../client/aqb.mjs";
+import fs from "node:fs";
+import { parseUnits, formatUnits, formatEther } from "ethers";
+import { AqbAgent, discover, wellKnown, cardHash } from "../client/aqb.mjs";
+
+const regFile = JSON.parse(fs.readFileSync(new URL("../registry/agent-coin.json", import.meta.url), "utf8"));
+const TOKEN = process.env.AQB_TOKEN || regFile.contracts.token;
+const REGISTRY = process.env.AQB_REGISTRY || regFile.contracts.registry;
+const VERIFIER = process.env.AQB_VERIFIER || regFile.contracts.verifier;
+const PAIR = process.env.AQB_PAIR || regFile.markets?.[0]?.pair;
+const SALE = process.env.AQB_SALE || regFile.sale;
 
 const cfg = () => new AqbAgent({
-  rpc: process.env.AQB_RPC, chain: process.env.AQB_CHAIN || "base",
-  privateKey: process.env.AQB_KEY, token: process.env.AQB_TOKEN, registry: process.env.AQB_REGISTRY,
+  rpc: process.env.AQB_RPC || process.env.BASE_RPC,
+  chain: process.env.AQB_CHAIN || "base",
+  privateKey: process.env.AQB_KEY || process.env.PRIVATE_KEY,
+  token: TOKEN,
+  registry: REGISTRY,
 });
 
 const TOOLS = [
   { name: "aqb_discover", description: "Fetch AQB discovery doc from an agent host", inputSchema: { type: "object", properties: { host: { type: "string" } }, required: ["host"] } },
-  { name: "aqb_balance", description: "Get AQB and USDC balances (read-only)", inputSchema: { type: "object", properties: { address: { type: "string" } } } },
+  { name: "aqb_balance", description: "Get AQB and USDC balances for an address (read-only)", inputSchema: { type: "object", properties: { address: { type: "string" } } } },
   { name: "aqb_is_agent", description: "Check whether an address is a registered agent", inputSchema: { type: "object", properties: { address: { type: "string" } }, required: ["address"] } },
-  { name: "aqb_register", description: "Register this wallet as an agent with a card and ML-DSA public key", inputSchema: { type: "object", properties: { card: { type: "object" }, pubKey: { type: "string" } }, required: ["card", "pubKey"] } },
-  { name: "aqb_fund", description: "Mint AQB against USDC, 1:1 (usd in 6 decimals)", inputSchema: { type: "object", properties: { usd: { type: "string" } }, required: ["usd"] } },
-  { name: "aqb_pay", description: "Pay AQB to another agent", inputSchema: { type: "object", properties: { to: { type: "string" }, aqb: { type: "string" } }, required: ["to", "aqb"] } },
-  { name: "aqb_cash_out", description: "Redeem AQB for USDC, 1:1", inputSchema: { type: "object", properties: { aqb: { type: "string" } }, required: ["aqb"] } },
-  { name: "aqb_announce_stealth", description: "Publish a stealth address for a payer", inputSchema: { type: "object", properties: { ephPubKey: { type: "string" }, sharedSecret: { type: "string" }, metaHash: { type: "string" } }, required: ["ephPubKey", "sharedSecret"] } },
-  { name: "aqb_wellknown", description: "Generate your own /.well-known/agent-coin.json", inputSchema: { type: "object", properties: { token: { type: "string" }, registry: { type: "string" }, verifier: { type: "string" } } } },
+  { name: "aqb_quote", description: "Quote 1 AQB in USDC from the vault (1.0) and the Uniswap V2 pool", inputSchema: { type: "object", properties: { amount: { type: "string" }, pair: { type: "string" } } } },
+  { name: "aqb_register", description: "Register a PQSmartAccount as an agent (caller must be the account)", inputSchema: { type: "object", properties: { account: { type: "string" }, card: { type: "object" }, scheme: { type: "string", enum: ["ecdsa", "pq"] } }, required: ["account", "card"] } },
+  { name: "aqb_update_card", description: "Publish a new agent card hash from a PQSmartAccount", inputSchema: { type: "object", properties: { account: { type: "string" }, card: { type: "object" }, scheme: { type: "string", enum: ["ecdsa", "pq"] } }, required: ["account", "card"] } },
+  { name: "aqb_fund", description: "Mint AQB against USDC, 1:1 (usd in human units, e.g. 10.5)", inputSchema: { type: "object", properties: { usd: { type: "string" }, account: { type: "string" } }, required: ["usd"] } },
+  { name: "aqb_pay", description: "Pay AQB to another agent (amount in human units, e.g. 1.5)", inputSchema: { type: "object", properties: { to: { type: "string" }, aqb: { type: "string" }, account: { type: "string" } }, required: ["to", "aqb"] } },
+  { name: "aqb_redeem", description: "Redeem AQB for USDC, 1:1 (amount in human units)", inputSchema: { type: "object", properties: { aqb: { type: "string" }, account: { type: "string" } }, required: ["aqb"] } },
+  { name: "aqb_cash_out", description: "Alias for aqb_redeem", inputSchema: { type: "object", properties: { aqb: { type: "string" }, account: { type: "string" } }, required: ["aqb"] } },
+  { name: "aqb_announce_stealth", description: "Publish a stealth address for a payer from a PQSmartAccount", inputSchema: { type: "object", properties: { account: { type: "string" }, ephPubKey: { type: "string" }, sharedSecret: { type: "string" }, metaHash: { type: "string" } }, required: ["account", "ephPubKey", "sharedSecret"] } },
+  { name: "aqb_wellknown", description: "Generate your own /.well-known/agent-coin.json", inputSchema: { type: "object", properties: { token: { type: "string" }, registry: { type: "string" }, verifier: { type: "string" }, pool: { type: "string" } } } },
 ];
 
+function requireArg(a, name) {
+  if (!a[name]) throw new Error(`missing argument: ${name}`);
+  return a[name];
+}
+
+const addr = (x) => (typeof x === "string" ? x.toLowerCase() : x);
+
+function accountOf(c, a) {
+  return a.account ? c.account(addr(a.account)) : null;
+}
+
 async function run(name, a) {
   const c = cfg();
   switch (name) {
-    case "aqb_discover": return await discover(a.host);
-    case "aqb_balance": return { aqb: String(await c.balance(a.address)).padStart(1), usdc: String(await c.usdBalance()) };
-    case "aqb_is_agent": return { isAgent: await c.isAgent(a.address) };
-    case "aqb_register": return { tx: await c.register(a.card, a.pubKey), cardHash: cardHash(a.card), pqKeyHash: keyHash(a.pubKey) };
-    case "aqb_fund": return { tx: await c.fund(BigInt(a.usd)) };
-    case "aqb_pay": return { tx: await c.pay(a.to, BigInt(a.aqb)) };
-    case "aqb_cash_out": return { tx: await c.cashOut(BigInt(a.aqb)) };
-    case "aqb_announce_stealth": return { tx: await c.announce(a.ephPubKey, a.sharedSecret, a.metaHash) };
-    case "aqb_wellknown": return wellKnown({ token: a.token || process.env.AQB_TOKEN, registry: a.registry || process.env.AQB_REGISTRY, verifier: process.env.AQB_VERIFIER, chainId: Number(process.env.AQB_CHAIN_ID || 8453) });
-    default: throw new Error(`unknown tool ${name}`);
+    case "aqb_discover":
+      return await discover(requireArg(a, "host"));
+    case "aqb_balance": {
+      const address = addr(a.address || c.signer?.address);
+      if (!address) throw new Error("address required");
+      return {
+        address,
+        aqb: formatEther(await c.balance(address)),
+        usdc: formatUnits(await c.usdBalance(address), 6),
+      };
+    }
+    case "aqb_is_agent":
+      return { isAgent: await c.isAgent(addr(requireArg(a, "address"))) };
+    case "aqb_quote": {
+      const amount = parseUnits(a.amount || "1", 18);
+      const q = await c.poolQuote(addr(a.pair || PAIR), amount);
+      return {
+        pool: addr(a.pair || PAIR),
+        aqb: formatEther(amount),
+        vaultUSDC: formatUnits(amount / 10n ** 12n, 6),
+        poolUSDC: formatUnits(q.usdc, 6),
+        reserves: { aqb: formatEther(q.reserves.aqb), usdc: formatUnits(q.reserves.usdc, 6) },
+      };
+    }
+    case "aqb_register": {
+      const account = addr(requireArg(a, "account"));
+      const tx = await c.registerViaAccount(account, requireArg(a, "card"), a.scheme || "ecdsa");
+      return { tx, account, cardHash: cardHash(a.card) };
+    }
+    case "aqb_update_card": {
+      const account = addr(requireArg(a, "account"));
+      const tx = await c.updateCardFromAccount(account, requireArg(a, "card"), a.scheme || "ecdsa");
+      return { tx, account, cardHash: cardHash(a.card) };
+    }
+    case "aqb_fund": {
+      const usd = parseUnits(requireArg(a, "usd"), 6);
+      const acc = accountOf(c, a);
+      return { tx: acc ? await c.fundFromAccount(acc, usd) : await c.fund(usd), usdc: formatUnits(usd, 6) };
+    }
+    case "aqb_pay": {
+      const aqb = parseUnits(requireArg(a, "aqb"), 18);
+      const acc = accountOf(c, a);
+      const to = addr(requireArg(a, "to")); return { tx: acc ? await c.payFromAccount(acc, to, aqb) : await c.pay(to, aqb), aqb: formatEther(aqb) };
+    }
+    case "aqb_redeem":
+    case "aqb_cash_out": {
+      const aqb = parseUnits(requireArg(a, "aqb"), 18);
+      const acc = accountOf(c, a);
+      return { tx: acc ? await c.redeemFromAccount(acc, aqb) : await c.cashOut(aqb), aqb: formatEther(aqb) };
+    }
+    case "aqb_announce_stealth": {
+      const tx = await c.announceFromAccount(
+        c.account(addr(requireArg(a, "account"))),
+        requireArg(a, "ephPubKey"),
+        requireArg(a, "sharedSecret"),
+        a.metaHash || "0x" + "00".repeat(32)
+      );
+      return { tx };
+    }
+    case "aqb_wellknown":
+      return wellKnown({
+        token: a.token || TOKEN,
+        registry: a.registry || REGISTRY,
+        verifier: a.verifier || VERIFIER,
+        chainId: Number(process.env.AQB_CHAIN_ID || 8453),
+        pool: a.pool || PAIR,
+        sale: SALE,
+      });
+    default:
+      throw new Error(`unknown tool ${name}`);
   }
 }
 
@@ -47,14 +133,21 @@ process.stdin.on("data", async (chunk) => {
     let m;
     try { m = JSON.parse(line); } catch { continue; }
     try {
-      if (m.method === "initialize") send({ jsonrpc: "2.0", id: m.id, result: { protocolVersion: "2024-11-05", capabilities: { tools: {} }, serverInfo: { name: "aqb", version: "1.0.0" } } });
-      else if (m.method === "tools/list") send({ jsonrpc: "2.0", id: m.id, result: { tools: TOOLS } });
-      else if (m.method === "tools/call") {
+      if (m.method === "initialize") {
+        send({ jsonrpc: "2.0", id: m.id, result: { protocolVersion: "2024-11-05", capabilities: { tools: {} }, serverInfo: { name: "aqb", version: "1.0.2" } } });
+      } else if (m.method === "tools/list") {
+        send({ jsonrpc: "2.0", id: m.id, result: { tools: TOOLS } });
+      } else if (m.method === "tools/call") {
         const out = await run(m.params.name, m.params.arguments || {});
         send({ jsonrpc: "2.0", id: m.id, result: { content: [{ type: "text", text: JSON.stringify(out) }] } });
-      } else if (m.id !== undefined) send({ jsonrpc: "2.0", id: m.id, result: {} });
+      } else if (m.id !== undefined) {
+        send({ jsonrpc: "2.0", id: m.id, result: {} });
+      }
     } catch (e) {
-      send({ jsonrpc: "2.0", id: m.id, error: { code: -32000, message: String(e.message || e) } });
+      const msg = String(e.shortMessage || e.message || e);
+      if (m.id !== undefined) {
+        send({ jsonrpc: "2.0", id: m.id, result: { content: [{ type: "text", text: msg }], isError: true } });
+      }
     }
   }
 });

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@aqb-foundation/aqb-agent",
-  "version": "1.0.1",
-  "description": "AQB — agent-only, USD-pegged, post-quantum credit token on Base",
-  "main": "index.js",
+  "version": "1.0.2",
+  "description": "AQB — agent-only, USD-pegged, post-quantum credit token on Base. SDK, CLI and MCP server.",
+  "main": "client/aqb.mjs",
   "directories": {
     "doc": "docs",
     "test": "test"
@@ -10,43 +10,71 @@
   "scripts": {
     "compile": "node compile.mjs",
     "test": "node compile.mjs && node test/pq.mjs && node test/e2e.mjs",
-    "deploy": "node deploy.mjs"
+    "mcp": "node mcp/server.mjs"
   },
   "keywords": [
     "ai-agents",
+    "agent-payments",
     "x402",
     "post-quantum",
     "ml-dsa",
     "base",
-    "stablecoin"
+    "stablecoin",
+    "mcp",
+    "mcp-server"
   ],
-  "author": "",
-  "license": "ISC",
+  "author": "AgentQubit",
+  "license": "MIT",
   "type": "module",
+  "engines": {
+    "node": ">=20"
+  },
   "dependencies": {
-    "@aqb-foundation/aqb-agent": "^1.0.0",
     "@noble/post-quantum": "^0.6.0",
     "ethers": "^6.17.0"
   },
+  "devDependencies": {
+    "@ethereumjs/common": "^10.1.3",
+    "@ethereumjs/statemanager": "^10.1.3",
+    "@ethereumjs/util": "^10.1.3",
+    "@ethereumjs/vm": "^10.1.3",
+    "solc": "0.8.24"
+  },
   "bin": {
+    "aqb-agent": "index.js",
     "aqb-mcp": "mcp/server.mjs"
   },
   "exports": {
-    "./client": "./client/aqb.mjs"
+    ".": "./client/aqb.mjs",
+    "./client": "./client/aqb.mjs",
+    "./pq": "./pq/pq.mjs",
+    "./mcp": "./mcp/server.mjs"
   },
   "files": [
+    "index.js",
     "client",
     "pq",
     "mcp",
     "registry",
     "docs",
     "artifacts",
+    "contracts",
+    "test",
+    "compile.mjs",
     "WHITEPAPER.md",
-    "README.md"
+    "README.md",
+    "LICENSE"
   ],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/yss787976-ai/agent-coin.git"
   },
-  "mcpName": "io.github.yss787976-ai/aqb-agent"
+  "homepage": "https://agentqubit.pages.dev",
+  "bugs": {
+    "url": "https://github.com/yss787976-ai/agent-coin/issues"
+  },
+  "mcpName": "io.github.yss787976-ai/aqb-agent",
+  "publishConfig": {
+    "access": "public"
+  }
 }

package/registry/agent-coin.json

@@ -26,19 +26,22 @@
   },
   "contracts": {
     "token": "0x2C54F202B565086B6d8D2226Edb67AC3E14C39d1",
+    "vault": "0x2C54F202B565086B6d8D2226Edb67AC3E14C39d1",
     "registry": "0xAa964f6ea767f0D709b268abBFdd8B6C2Beef3eB",
-    "verifier": "0x53d34e4Ffd0bd984f8b92561f9e2B7D3EDdbE60d"
+    "verifier": "0x53d34e4Ffd0bd984f8b92561f9e2B7D3EDdbE60d",
+    "pool": "0xF61Cb078f87425933741Dd7d02F5779c030dB1A6",
+    "sale": "0xeDBD6B860c37C411aeeA513cbc0656e3135f59c1"
   },
   "discovery": {
-    "wellKnown": "/.well-known/agent-coin.json",
-    "llms": "/llms.txt",
+    "wellKnown": "https://agentqubit.pages.dev/.well-known/agent-coin.json",
+    "llms": "https://agentqubit.pages.dev/llms.txt",
     "dns": "_aqb.<host> TXT v=aqb1",
-    "npm": "aqb-agent",
+    "npm": "@aqb-foundation/aqb-agent",
     "hosted": {
-      "agentCoin": "https://yss787976-ai.github.io/agent-coin/.well-known/agent-coin.json",
-      "agentCard": "https://yss787976-ai.github.io/agent-coin/.well-known/agent-card.json",
-      "llms": "https://yss787976-ai.github.io/agent-coin/llms.txt",
-      "cardHash": "0x5fba6b2fca551dcfb840406204a784c5d261225f5b8fb3b95d2593dae64fc48e",
+      "agentCoin": "https://agentqubit.pages.dev/.well-known/agent-coin.json",
+      "agentCard": "https://agentqubit.pages.dev/.well-known/agent-card.json",
+      "llms": "https://agentqubit.pages.dev/llms.txt",
+      "cardHash": "0x3294204f00383bc8f28a0bc52142ceb0bfe7197dd46f68998403fe9d234c1097",
       "mirror": "https://cdn.jsdelivr.net/gh/yss787976-ai/agent-coin@main/.well-known/agent-coin.json"
     }
   },
@@ -62,8 +65,10 @@
       "token0": "0x2C54F202B565086B6d8D2226Edb67AC3E14C39d1",
       "token1": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
       "liquidity": {
-        "aqb": "259400000000000000000",
-        "usdc": "259400000"
+        "aqb": "279337988620041039026",
+        "usdc": "241059777",
+        "priceUSDC": "0.8629",
+        "asOf": "2026-11-13"
       }
     }
   ],

package/test/e2e.mjs

@@ -0,0 +1,100 @@
+// E2E invariant test on local EVM. Build first: node compile.mjs
+import { deploy, exec, me, b32 } from "./evm.mjs";
+import { newIdentity } from "../pq/pq.mjs";
+
+let fails = 0;
+const ok = (c, m) => { console.log((c ? "PASS " : "FAIL ") + m); if (!c) fails++; };
+const ALLOT = 5n * 10n ** 18n; // scaled-down founder allotment for the test
+
+const idA = newIdentity(), pubA = "0x" + Buffer.from(idA.publicKey).toString("hex");
+const idB = newIdentity(), pubB = "0x" + Buffer.from(idB.publicKey).toString("hex");
+const keyA = idA.keyHash, keyB = idB.keyHash;
+
+const usdc = await deploy("MockUSDC");
+const verifier = await deploy("MockVerifier");
+const registry = await deploy("AgentRegistry");
+const token = await deploy("AgentQuantumCredit", [usdc.hex, registry.hex, me.toString()]);
+const accA = await deploy("PQSmartAccount", [verifier.hex, me.toString(), pubA]); // founder
+const accB = await deploy("PQSmartAccount", [verifier.hex, me.toString(), pubB]); // buyer
+
+ok(await registry.read("isAgent", accA.hex) === false, "not agent before register");
+let r = await registry.send("register", keyA, b32("0x78"));
+ok(r.status === 0, "EOA registration rejected");
+await exec(accA, registry.hex, registry.iface.encodeFunctionData("register", [keyA, b32("0xca11")]), "pq", idA);
+ok(await registry.read("isAgent", accA.hex) === true, "agent A registered (PQ sig)");
+r = await exec(accB, registry.hex, registry.iface.encodeFunctionData("register", [keyB, b32("0xca12")]), "pq", idB);
+ok(r.status === 1, "agent B registered");
+
+// ---- genesis allotment: minted first, sold first, 1:1 into the vault
+await token.send("genesisMint", accA.hex, ALLOT);
+ok(await token.read("balanceOf", accA.hex) === ALLOT, "founder allotment minted first");
+ok(await token.read("genesisSupply") === ALLOT, "genesisSupply recorded");
+ok(await token.read("backedSupply") === 0n, "unsold allotment is not counted as backed");
+const sale = await deploy("GenesisSale", [token.hex, usdc.hex, accA.hex, ALLOT]);
+await token.send("setSale", sale.hex);
+ok(await token.read("backedSupply") === 0n, "sale escrow does not inflate backed supply");
+
+r = await token.send("mint", 1n);
+ok(r.status === 0, "public mint blocked while the genesis sale is open");
+
+await usdc.send("mint", accB.hex, 10_000_000n);
+await exec(accB, usdc.hex, usdc.iface.encodeFunctionData("approve", [sale.hex, 2n ** 200n]));
+await exec(accA, token.hex, token.iface.encodeFunctionData("approve", [sale.hex, ALLOT]));
+await exec(accB, sale.hex, sale.iface.encodeFunctionData("buy", [3_000_000n]));
+ok(await token.read("balanceOf", accB.hex) === 3n * 10n ** 18n, "buyer received 3 AQB for 3 USD");
+ok(await usdc.read("balanceOf", token.hex) === 3_000_000n, "buyer dollars escrowed in the vault");
+ok(await token.read("backedSupply") === 3n * 10n ** 18n, "sold coins now back the peg");
+ok(await token.read("collateralRatio") === 10n ** 18n, "ratio == 1e18 for live coins");
+ok(await sale.read("remaining") === 2n * 10n ** 18n, "allotment decreasing");
+
+r = await exec(accB, sale.hex, sale.iface.encodeFunctionData("buy", [5_000_000n]));
+ok(r.status === 0, "over-allotment buy reverts");
+await exec(accB, sale.hex, sale.iface.encodeFunctionData("buy", [2_000_000n]));
+ok(await sale.read("closed") === true, "sale closes when the allotment is exhausted");
+ok(await token.read("saleOpen") === false, "public mint re-opened after the allotment sold out");
+
+// ---- public mint against USDC
+await usdc.send("mint", accA.hex, 100_000_000n);
+await exec(accA, usdc.hex, usdc.iface.encodeFunctionData("approve", [token.hex, 2n ** 200n]));
+r = await token.send("mint", 1n);
+ok(r.status === 0, "EOA mint rejected (not an agent)");
+await exec(accA, token.hex, token.iface.encodeFunctionData("mint", [10_000_000n]));
+ok(await token.read("balanceOf", accA.hex) === 10n ** 19n, "10 USD -> 10 AQB for founder (allotment spent)");
+ok(await token.read("collateralRatio") === 10n ** 18n, "ratio stays 1e18");
+ok(await token.read("backedSupply") === await token.read("totalSupply"), "everything is sold, all supply backed");
+ok(await token.read("MAX_SUPPLY") === 900_000_000_000n * 10n ** 18n, "cap == 900e9 AQB");
+
+// ---- transfer gates
+await exec(accA, token.hex, token.iface.encodeFunctionData("transfer", [accB.hex, 3n * 10n ** 18n]));
+ok(await token.read("balanceOf", accB.hex) === 8n * 10n ** 18n, "transfer to agent ok");
+r = await exec(accA, token.hex, token.iface.encodeFunctionData("transfer", [me.toString(), 10n ** 18n]));
+ok(r.status === 0, "transfer to plain EOA blocked");
+await token.send("setPool", me.toString(), true);
+r = await exec(accA, token.hex, token.iface.encodeFunctionData("transfer", [me.toString(), 10n ** 18n]));
+ok(r.status === 1, "transfer to whitelisted pool allowed");
+
+// ---- redeem
+r = await exec(accA, token.hex, token.iface.encodeFunctionData("redeem", [1n]));
+ok(r.status === 0, "redeem below 1e12 rejected");
+const before = await usdc.read("balanceOf", accA.hex);
+await exec(accA, token.hex, token.iface.encodeFunctionData("redeem", [2n * 10n ** 18n]));
+ok(await usdc.read("balanceOf", accA.hex) - before === 2_000_000n, "2 AQB -> 2 USD");
+ok(await token.read("collateralRatio") === 10n ** 18n, "ratio stays 1e18 after redeem");
+
+// ---- stealth + card
+const eph = "0x" + "7a".repeat(1088);
+r = await exec(accA, registry.hex, registry.iface.encodeFunctionData("announce", ["0x" + "5b".repeat(20), eph, "0xa7", "0x" + "00".repeat(32)]));
+ok(r.status === 1, "agent can announce a stealth address");
+r = await registry.send("announce", "0x" + "5b".repeat(20), eph, "0xa7", "0x" + "00".repeat(32));
+ok(r.status === 0, "non-agent cannot announce");
+r = await exec(accA, registry.hex, registry.iface.encodeFunctionData("updateCard", [b32("0xca99")]));
+ok(r.status === 1, "agent can publish a new card hash");
+
+// ---- signature authority
+const d = await accA.read("digest", usdc.hex, 0n, "0x", await accA.read("nonce"));
+r = await accA.send("execute", usdc.hex, 0n, "0x", "0x01" + "11".repeat(32) + "22".repeat(32) + "1b");
+ok(r.status === 0, "wrong ECDSA sig rejected");
+ok(await registry.read("agentCount") === 2n, "agentCount == 2");
+
+console.log(fails ? `E2E FAILED (${fails})` : "E2E OK");
+process.exit(fails ? 1 : 0);