@aqb-foundation/aqb-agent 1.0.0 → 1.0.2

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);

package/test/evm.mjs

@@ -0,0 +1,69 @@
+// Local EVM harness (ethereumjs v10). No JSON-RPC, no hardhat.
+import { createVM } from "@ethereumjs/vm";
+import { MerkleStateManager } from "@ethereumjs/statemanager";
+import { Common, Mainnet, Hardfork } from "@ethereumjs/common";
+import { Address, Account, hexToBytes, bytesToHex, createAddressFromString } from "@ethereumjs/util";
+import { Wallet, AbiCoder, keccak256, solidityPacked, Contract } from "ethers";
+import fs from "node:fs";
+import { signDigest } from "../pq/pq.mjs";
+
+const coder = AbiCoder.defaultAbiCoder();
+const common = new Common({ chain: Mainnet, hardfork: Hardfork.Cancun });
+export const vm = await createVM({ common });
+const sm = vm.stateManager;
+
+export const PK = "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80";
+export const signer = new Wallet(PK);
+export const me = createAddressFromString(signer.address.toLowerCase());
+
+await sm.putAccount(me, new Account(0n, 10n ** 24n));
+
+export const art = (n) => JSON.parse(fs.readFileSync(`artifacts/${n}.json`, "utf8"));
+
+export async function call(from, to, data, value = 0n) {
+  const r = await vm.evm.runCall({
+    caller: from, origin: from, to, data: hexToBytes(data), value, gasLimit: 30_000_000n,
+  });
+  return { status: r.execResult.exceptionError ? 0 : 1, ret: bytesToHex(r.execResult.returnValue), err: r.execResult.exceptionError?.error, logs: r.execResult.logs };
+}
+
+export async function deploy(name, args = []) {
+  const a = art(name);
+  const data = a.bytecode + coder.encode(a.ctorTypes || guessCtor(a.abi), args).slice(2);
+  const r = await vm.evm.runCall({ caller: me, origin: me, data: hexToBytes(data), gasLimit: 30_000_000n });
+  if (r.execResult.exceptionError) throw new Error(`${name} deploy: ${r.execResult.exceptionError.error}`);
+  const addr = r.createdAddress;
+  return {
+    addr,
+    hex: bytesToHex(addr.bytes),
+    iface: new Contract(bytesToHex(addr.bytes), a.abi).interface,
+    abi: a.abi,
+    send: (fn, ...a2) => call(me, addr, new Contract(bytesToHex(addr.bytes), a.abi).interface.encodeFunctionData(fn, a2)),
+    read: async (fn, ...a2) => decode(a.abi, fn, (await call(me, addr, new Contract(bytesToHex(addr.bytes), a.abi).interface.encodeFunctionData(fn, a2))).ret),
+  };
+}
+
+function guessCtor(abi) {
+  const c = abi.find((x) => x.type === "constructor");
+  return (c?.inputs || []).map((i) => i.type);
+}
+
+export function decode(abi, fn, hex) {
+  const f = abi.find((x) => x.type === "function" && x.name === fn);
+  const vals = coder.decode(f.outputs.map((o) => o.type), hex);
+  return vals.length === 1 ? vals[0] : vals;
+}
+
+export const b32 = (s) => keccak256(s);
+
+export async function exec(acc, targetHex, data, scheme = "ecdsa", identity) {
+  const nonce = await acc.read("nonce");
+  const digest = await acc.read("digest", targetHex, 0n, data, nonce);
+  let sig;
+  if (scheme === "pq") sig = signDigest(identity, digest);
+  else {
+    const s = signer.signingKey.sign(digest);
+    sig = "0x01" + s.r.slice(2) + s.s.slice(2) + s.v.toString(16).padStart(2, "0");
+  }
+  return acc.send("execute", targetHex, 0n, data, sig);
+}

package/test/local.mjs

@@ -0,0 +1,86 @@
+// End-to-end invariant test on a local EVM. Run: node test/local.mjs
+import { JsonRpcProvider, Wallet, ContractFactory, Contract, keccak256, AbiCoder, solidityPacked } from "ethers";
+import fs from "node:fs";
+
+const p = new JsonRpcProvider("http://127.0.0.1:8545");
+const signer = new Wallet("0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80", p);
+const art = (n) => JSON.parse(fs.readFileSync(`artifacts/${n}.json`, "utf8"));
+const dep = async (n, args) => {
+  const c = await new ContractFactory(art(n).abi, art(n).bytecode, signer).deploy(...args);
+  await c.waitForDeployment();
+  return c;
+};
+let fails = 0;
+const ok = (c, m) => { console.log((c ? "PASS " : "FAIL ") + m); if (!c) fails++; };
+
+const pubA = solidityPacked(["bytes32"], [keccak256("0x01")]).concat("00".repeat(1904));
+const pubB = solidityPacked(["bytes32"], [keccak256("0x02")]).concat("00".repeat(1904));
+const keyA = keccak256(pubA), keyB = keccak256(pubB);
+
+const usdc = await dep("MockUSDC", []);
+const verifier = await dep("MockVerifier", []);
+const registry = await dep("AgentRegistry", []);
+const token = await dep("AgentQuantumCredit", [await usdc.getAddress(), await registry.getAddress(), signer.address]);
+const accA = await dep("PQSmartAccount", [await verifier.getAddress(), signer.address, pubA]);
+const accB = await dep("PQSmartAccount", [await verifier.getAddress(), signer.address, pubB]);
+const A = await accA.getAddress(), B = await accB.getAddress();
+
+async function exec(acc, target, data, scheme = "ecdsa") {
+  const addr = await acc.getAddress();
+  const nonce = await acc.nonce();
+  const digest = await acc.digest(target, 0n, data, nonce);
+  let sig;
+  if (scheme === "pq") {
+    sig = "0x02" + "ab".repeat(3309);
+  } else {
+    const s = signer.signingKey.sign(digest);
+    sig = "0x01" + s.r.slice(2) + s.s.slice(2) + s.v.toString(16).padStart(2, "0");
+  }
+  return acc.execute(target, 0n, data, sig);
+}
+
+// registration requires a PQ account bound to the announced key
+const c = (n, a) => new Contract(n, a).interface.encodeFunctionData;
+try {
+  await exec(accA, await registry.getAddress(), registry.interface.encodeFunctionData("register", [keyA, keccak256("0xaaaa")]), "pq");
+  ok(await registry.isAgent(A), "agent A registered via PQ sig");
+} catch (e) { ok(false, "agent A registered via PQ sig: " + e.shortMessage); }
+await exec(accB, await registry.getAddress(), registry.interface.encodeFunctionData("register", [keyB, keccak256("0xbbbb")]));
+
+await usdc.mint(A, 100_000_000n); // 100 USD
+await exec(accA, await usdc.getAddress(), usdc.interface.encodeFunctionData("approve", [await token.getAddress(), 2n ** 200n]));
+
+// EOA cannot mint
+try { await (await token.connect(signer).mint(1n)).wait(); ok(false, "EOA mint blocked"); }
+catch { ok(true, "EOA mint blocked"); }
+
+await exec(accA, await token.getAddress(), token.interface.encodeFunctionData("mint", [10_000_000n]));
+ok(await token.balanceOf(A) === 10n ** 19n, "minted 10 AQB for 10 USD");
+ok(await token.collateralRatio() === 10n ** 18n, "ratio == 1e18");
+
+// transfer to agent OK, to EOA blocked
+await exec(accA, await token.getAddress(), token.interface.encodeFunctionData("transfer", [B, 3n * 10n ** 18n]));
+ok(await token.balanceOf(B) === 3n * 10n ** 18n, "transfer to agent ok");
+try { await exec(accA, await token.getAddress(), token.interface.encodeFunctionData("transfer", [signer.address, 1n])); ok(false, "transfer to EOA blocked"); }
+catch { ok(true, "transfer to EOA blocked"); }
+await token.connect(signer).setPool(signer.address, true);
+await exec(accA, await token.getAddress(), token.interface.encodeFunctionData("transfer", [signer.address, 1n]));
+ok(true, "transfer to whitelisted pool ok");
+
+// redeem peg, fractional reverts
+try { await exec(accA, await token.getAddress(), token.interface.encodeFunctionData("redeem", [1n])); ok(false, "redeem of <1e12 reverts"); }
+catch { ok(true, "redeem of <1e12 reverts"); }
+const usdBefore = await usdc.balanceOf(A);
+await exec(accA, await token.getAddress(), token.interface.encodeFunctionData("redeem", [2n * 10n ** 18n]));
+ok(await usdc.balanceOf(A) - usdBefore === 2_000_000n, "redeem paid 2 USD");
+ok(await token.collateralRatio() === 10n ** 18n, "ratio == 1e18 after redeem");
+
+ok(await token.MAX_SUPPLY() === 900_000_000_000n * 10n ** 18n, "cap == 900e9");
+ok(await registry.agentCount() === 2n, "agentCount == 2");
+
+// ecdsa fallback authority works
+await exec(accA, await usdc.getAddress(), usdc.interface.encodeFunctionData("approve", [await token.getAddress(), 0n]));
+ok(true, "ecdsa fallback path ok");
+
+console.log(fails ? `SMOKE FAILED (${fails})` : "SMOKE OK");
+process.exit(fails ? 1 : 0);

package/test/pq.mjs

@@ -0,0 +1,37 @@
+// Real post-quantum crypto test: identity, digest signing, stealth KEM round trip.
+import { newIdentity, signDigest, verifyDigest, newKemIdentity, stealthFor, stealthCheck, PK_LEN, SIG_LEN } from "../pq/pq.mjs";
+import { stealth as clientStealth, cardHash } from "../client/aqb.mjs";
+import { keccak256, toUtf8Bytes } from "ethers";
+const hex = (b) => (b ? Buffer.from(b).toString("hex") : null);
+
+let fails = 0;
+const ok = (c, m) => { console.log((c ? "PASS " : "FAIL ") + m); if (!c) fails++; };
+
+const id = newIdentity();
+ok(id.publicKey.length === PK_LEN, `ML-DSA-65 pubkey is ${PK_LEN} bytes`);
+ok(id.keyHash === keccak256(id.publicKey), "keyHash commits the pubkey");
+
+const digest = keccak256(toUtf8Bytes("aqb-execute"));
+const blob = signDigest(id, digest);
+ok((blob.length - 2) / 2 === SIG_LEN + 1, "sig blob = scheme tag + 3309 bytes");
+ok(verifyDigest(id.publicKey, digest, blob), "real ML-DSA-65 signature verifies");
+ok(!verifyDigest(id.publicKey, keccak256(toUtf8Bytes("other")), blob), "wrong digest rejected");
+const impostor = newIdentity();
+ok(!verifyDigest(impostor.publicKey, digest, blob), "wrong key rejected");
+
+const kem = newKemIdentity();
+const s = stealthFor(kem.publicKey);
+ok(s.addr.length === 42, "stealth address derived");
+ok(hex(stealthCheck(kem, s.ephPubKey, s.viewTag, s.addr)) === hex(s.sharedSecret), "recipient decapsulates to same secret");
+ok(stealthCheck(newKemIdentity(), s.ephPubKey, s.viewTag, s.addr) === null, "stranger cannot claim stealth");
+ok(stealthCheck(kem, s.ephPubKey, "0x00", s.addr) === null, "view-tag mismatch filters announcement");
+const cs = clientStealth(s.ephPubKey, s.sharedSecret);
+ok(cs.addr === s.addr && cs.viewTag === s.viewTag, "client stealth matches pq.stealthFor");
+
+const card = { aqb: 1, name: "x", price: { unit: "AQB", amount: "2" }, tags: ["a", "b"] };
+const reordered = { tags: ["a", "b"], price: { amount: "2", unit: "AQB" }, name: "x", aqb: 1 };
+ok(cardHash(card) === cardHash(reordered), "cardHash is recursive key-order independent");
+ok(cardHash(card) !== keccak256(toUtf8Bytes(JSON.stringify(card, Object.keys(card).sort()))), "cardHash keeps nested keys");
+
+console.log(fails ? `PQ FAILED (${fails})` : "PQ OK");
+process.exit(fails ? 1 : 0);

package/test/smoke.mjs

@@ -0,0 +1,27 @@
+// Post-deploy invariant test. Run after deploy.mjs: node test/smoke.mjs
+import { JsonRpcProvider, Wallet, Contract } from "ethers";
+import fs from "node:fs";
+
+const d = JSON.parse(fs.readFileSync("deployment.json", "utf8"));
+const p = new JsonRpcProvider(process.env.RPC_URL);
+const w = new Wallet(process.env.PRIVATE_KEY, p);
+const t = new Contract(d.token, [
+  "function mint(uint256)", "function redeem(uint256)", "function totalSupply() view returns(uint256)",
+  "function collateralRatio() view returns(uint256)", "function MAX_SUPPLY() view returns(uint256)",
+  "function balanceOf(address) view returns(uint256)", "function setPool(address,bool)",
+], w);
+const r = new Contract(d.registry, ["function isAgent(address) view returns(bool)"], w);
+const usdc = new Contract(d.usdc, ["function balanceOf(address) view returns(uint256)"], w);
+
+const ok = (c, m) => { console.log((c ? "PASS " : "FAIL ") + m); if (!c) process.exitCode = 1; };
+
+ok((await r.isAgent(w.address)) === true, "deployer is agent");
+await (await t.mint(10_000_000n)).wait(); // 10 USDC
+ok((await t.collateralRatio()) === 10n ** 18n, "ratio == 1e18 after mint");
+await (await t.redeem(5n * 10n ** 18n)).wait();
+ok((await t.collateralRatio()) === 10n ** 18n, "ratio == 1e18 after redeem");
+ok((await t.totalSupply()) === 5n * 10n ** 18n, "supply == 5 AQB");
+ok((await usdc.balanceOf(d.token)) === 5_000_000n, "usdc reserves == 5");
+try { await (await t.mint(0n)).wait(); ok(false, "mint(0) reverts"); } catch { ok(true, "mint(0) reverts"); }
+ok((await t.MAX_SUPPLY()) === 900_000_000_000n * 10n ** 18n, "cap == 900e9");
+console.log(process.exitCode ? "SMOKE FAILED" : "SMOKE OK");