leash-monad 0.1.0

package/README.md

@@ -0,0 +1,73 @@
+# leash-monad
+
+Spend limits for AI agents, enforced on Monad. This package is the seller and agent side of
+[Leash](https://leash-monad.vercel.app): one call tells you whose agent is knocking, what it may still spend
+today, and whether a payment will go through, before you do any work.
+
+```bash
+npm i leash-monad viem
+```
+
+## Check an agent (seller)
+
+```ts
+import { checkAgent } from "leash-monad";
+
+const v = await checkAgent(agentAddress, myAddress, "2.00");   // Monad mainnet by default
+if (!v.ok) return res.status(403).json(v);
+// v = { status: "OK", ok: true, remainingToday: "3.0", expiry: 1791887540,
+//       erc8004Id: "10281", account: "0xB1C6…", reason: "This agent is leashed and this payment fits its budget." }
+```
+
+| `status` | Meaning |
+|---|---|
+| `OK` | Leashed, and this payment fits today's budget |
+| `UNKNOWN_AGENT` | No leash: nobody has capped this agent |
+| `REVOKED` | The owner revoked it |
+| `EXPIRED` | The leash ran out |
+| `SELLER_NOT_ALLOWED` | The owner didn't allow this agent to pay you |
+| `OVER_CAP` | This payment would break the daily limit |
+
+It's one `eth_call` to the `LeashHub` contract. No API key, no Leash server in the path.
+
+## Charge agents (x402-style gate)
+
+`leashGate` is framework-agnostic. First request: 402 with your price and a payment reference. The agent pays
+inside its leash (one Monad transaction) and retries with the tx hash. The gate checks the `Paid` event on-chain
+(right agent, right seller, enough money, right reference) and lets it through.
+
+```ts
+import { leashGate } from "leash-monad";
+
+app.get("/api/forecast", async (req, res) => {
+  const g = await leashGate(req, { seller: MY_ADDRESS, priceUsd: "1" });
+  if (!g.allow) return res.status(g.status).json(g.body);
+  res.json({ paid: g.paid, tx: g.tx, data: await forecast() });
+});
+```
+
+A revoked, expired or over-cap agent gets a 403 with the reason before you've done any work.
+
+## Pay (agent)
+
+```ts
+import { fetchWithLeash } from "leash-monad";
+import { privateKeyToAccount } from "viem/accounts";
+
+const agent = privateKeyToAccount(AGENT_KEY);           // the session key its owner leashed
+const res = await fetchWithLeash("https://leash-monad.vercel.app/api/forecast", agent);
+```
+
+On a 402 it pays inside the leash and retries once. If the leash says no, the payment reverts on-chain and
+nothing leaves the account.
+
+## Networks
+
+| | Chain | LeashHub |
+|---|---|---|
+| `mainnet` (default) | Monad, 143 | `0xecefc8c322e2aa77327c2b4912caec04323f4f37` |
+| `testnet` | Monad Testnet, 10143 | `0x8b427106c04e66dfc6e8d58fa4de0478a54f510a` |
+
+Pass `{ network: "testnet" }` as the last argument to any call.
+
+MIT

package/dist/abi.d.ts

@@ -0,0 +1,114 @@
+export declare const hubAbi: readonly [{
+    readonly name: "check";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "agent";
+    }, {
+        readonly type: "address";
+        readonly name: "seller";
+    }, {
+        readonly type: "uint256";
+        readonly name: "amount";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint8";
+        readonly name: "status";
+    }, {
+        readonly type: "uint256";
+        readonly name: "remainingToday";
+    }, {
+        readonly type: "uint64";
+        readonly name: "expiry";
+    }, {
+        readonly type: "uint256";
+        readonly name: "agentId";
+    }, {
+        readonly type: "address";
+        readonly name: "account";
+    }];
+}, {
+    readonly name: "accountOf";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "agent";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+}];
+export declare const accountAbi: readonly [{
+    readonly name: "pay";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "seller";
+    }, {
+        readonly type: "uint256";
+        readonly name: "amount";
+    }, {
+        readonly type: "bytes32";
+        readonly name: "ref";
+    }];
+    readonly outputs: readonly [];
+}, {
+    readonly name: "leashes";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "address";
+        readonly name: "token";
+    }, {
+        readonly type: "uint128";
+        readonly name: "dailyCap";
+    }, {
+        readonly type: "uint128";
+        readonly name: "spentToday";
+    }, {
+        readonly type: "uint64";
+        readonly name: "day";
+    }, {
+        readonly type: "uint64";
+        readonly name: "expiry";
+    }, {
+        readonly type: "uint64";
+        readonly name: "agentId";
+    }, {
+        readonly type: "bool";
+        readonly name: "active";
+    }, {
+        readonly type: "bool";
+        readonly name: "anySeller";
+    }];
+}, {
+    readonly name: "Paid";
+    readonly type: "event";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "agent";
+        readonly indexed: true;
+    }, {
+        readonly type: "address";
+        readonly name: "seller";
+        readonly indexed: true;
+    }, {
+        readonly type: "address";
+        readonly name: "token";
+    }, {
+        readonly type: "uint256";
+        readonly name: "amount";
+    }, {
+        readonly type: "bytes32";
+        readonly name: "ref";
+    }, {
+        readonly type: "uint256";
+        readonly name: "remainingToday";
+    }];
+}];

package/dist/index.cjs

@@ -0,0 +1,176 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  STATUS: () => STATUS,
+  accountAbi: () => accountAbi,
+  checkAgent: () => checkAgent,
+  fetchWithLeash: () => fetchWithLeash,
+  hubAbi: () => hubAbi,
+  leashGate: () => leashGate,
+  networks: () => networks,
+  payWithLeash: () => payWithLeash,
+  paymentRef: () => paymentRef,
+  proofMessage: () => proofMessage
+});
+module.exports = __toCommonJS(src_exports);
+var import_viem2 = require("viem");
+
+// src/networks.ts
+var networks = {
+  mainnet: {
+    name: "Monad",
+    chainId: 143,
+    rpc: "https://rpc.monad.xyz",
+    explorer: "https://monadvision.com",
+    hub: "0xecefc8c322e2aa77327c2b4912caec04323f4f37",
+    identityRegistry: "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432",
+    testUsd: "0x4adf40e6e5113339635e6dc54ff638e7b63bbea3"
+  },
+  testnet: {
+    name: "Monad Testnet",
+    chainId: 10143,
+    rpc: "https://testnet-rpc.monad.xyz",
+    explorer: "https://testnet.monadvision.com",
+    hub: "0x8b427106c04e66dfc6e8d58fa4de0478a54f510a",
+    identityRegistry: "0x8004A818BFB912233c491871b3d84c89A494BD9e",
+    testUsd: "0xd563843fc54be3e262df4ef3281f6ad397153197"
+  }
+};
+
+// src/abi.ts
+var import_viem = require("viem");
+var hubAbi = (0, import_viem.parseAbi)([
+  "function check(address agent, address seller, uint256 amount) view returns (uint8 status, uint256 remainingToday, uint64 expiry, uint256 agentId, address account)",
+  "function accountOf(address agent) view returns (address)"
+]);
+var accountAbi = (0, import_viem.parseAbi)([
+  "function pay(address seller, uint256 amount, bytes32 ref)",
+  "function leashes(address) view returns (address token, uint128 dailyCap, uint128 spentToday, uint64 day, uint64 expiry, uint64 agentId, bool active, bool anySeller)",
+  "event Paid(address indexed agent, address indexed seller, address token, uint256 amount, bytes32 ref, uint256 remainingToday)"
+]);
+
+// src/index.ts
+var STATUS = ["OK", "UNKNOWN_AGENT", "REVOKED", "EXPIRED", "SELLER_NOT_ALLOWED", "OVER_CAP"];
+var net = (o = {}) => (typeof o.network === "string" ? networks[o.network] : o.network) ?? networks.mainnet;
+var clientFor = (o = {}) => o.client ?? (0, import_viem2.createPublicClient)({ transport: (0, import_viem2.http)(net(o).rpc) });
+var REASONS = {
+  OK: "This agent is leashed and this payment fits its budget.",
+  UNKNOWN_AGENT: "This agent has no leash. Its owner hasn't set a spend limit.",
+  REVOKED: "The owner revoked this agent.",
+  EXPIRED: "This agent's leash has expired.",
+  SELLER_NOT_ALLOWED: "The owner hasn't allowed this agent to pay you.",
+  OVER_CAP: "This payment would take the agent over its daily limit."
+};
+async function checkAgent(agent, seller, amountUsd, o = {}) {
+  const d = o.decimals ?? 6;
+  const r = await clientFor(o).readContract({
+    address: net(o).hub,
+    abi: hubAbi,
+    functionName: "check",
+    args: [agent, seller, (0, import_viem2.parseUnits)(String(amountUsd), d)]
+  });
+  const status = STATUS[r[0]];
+  return {
+    status,
+    ok: status === "OK",
+    remainingToday: (0, import_viem2.formatUnits)(r[1], d),
+    expiry: Number(r[2]),
+    erc8004Id: r[3].toString(),
+    account: r[4] === "0x0000000000000000000000000000000000000000" ? null : r[4],
+    reason: REASONS[status]
+  };
+}
+var paymentRef = (seller, resource, nonce) => (0, import_viem2.keccak256)((0, import_viem2.toHex)(`leash:${seller.toLowerCase()}:${resource}:${nonce}`));
+var proofMessage = (resource, nonce) => `leash:${resource}:${nonce}`;
+async function leashGate(req, cfg) {
+  const h = (k) => {
+    const v = req.headers[k] ?? req.headers[k.toLowerCase()];
+    return Array.isArray(v) ? v[0] : v;
+  };
+  const resource = cfg.resource ?? new URL(req.url, "http://x").pathname;
+  const agent = h("x-leash-agent");
+  const nonce = h("x-leash-nonce"), sig = h("x-leash-proof");
+  if (!agent || !nonce || !sig) {
+    return { allow: false, status: 402, body: { error: "payment_required", price: cfg.priceUsd, payTo: cfg.seller, network: net(cfg).chainId, howTo: "Send x-leash-agent, x-leash-nonce and x-leash-proof (agent signature over 'leash:<resource>:<nonce>')." } };
+  }
+  if (!await (0, import_viem2.verifyMessage)({ address: agent, message: proofMessage(resource, nonce), signature: sig })) {
+    return { allow: false, status: 403, body: { error: "bad_proof", reason: "The signature doesn't match x-leash-agent." } };
+  }
+  const ref = paymentRef(cfg.seller, resource, nonce);
+  const payment = h("x-leash-payment");
+  if (!payment) {
+    const verdict = await checkAgent(agent, cfg.seller, cfg.priceUsd, cfg);
+    return { allow: false, status: verdict.ok ? 402 : 403, body: { error: verdict.ok ? "payment_required" : "leash_refused", price: cfg.priceUsd, payTo: cfg.seller, ref, leash: verdict } };
+  }
+  const client = clientFor(cfg);
+  const rc = await client.getTransactionReceipt({ hash: payment }).catch(() => null);
+  if (!rc || rc.status !== "success") return { allow: false, status: 402, body: { error: "payment_not_found", ref } };
+  const d = cfg.decimals ?? 6, need = (0, import_viem2.parseUnits)(cfg.priceUsd, d);
+  for (const log of rc.logs) {
+    try {
+      const ev = (0, import_viem2.decodeEventLog)({ abi: accountAbi, data: log.data, topics: log.topics });
+      if (ev.eventName !== "Paid") continue;
+      const a = ev.args;
+      const account = await client.readContract({ address: net(cfg).hub, abi: hubAbi, functionName: "accountOf", args: [agent] });
+      if (log.address.toLowerCase() === account.toLowerCase() && a.agent.toLowerCase() === agent.toLowerCase() && a.seller.toLowerCase() === cfg.seller.toLowerCase() && a.amount >= need && a.ref === ref) {
+        const verdict = await checkAgent(agent, cfg.seller, "0", cfg);
+        return { allow: true, agent, paid: (0, import_viem2.formatUnits)(a.amount, d), tx: payment, verdict };
+      }
+    } catch {
+    }
+  }
+  return { allow: false, status: 402, body: { error: "payment_mismatch", ref } };
+}
+async function payWithLeash(agentAccount, seller, amountUsd, ref, o = {}) {
+  const n = net(o), client = clientFor(o);
+  const account = await client.readContract({ address: n.hub, abi: hubAbi, functionName: "accountOf", args: [agentAccount.address] });
+  if (account === "0x0000000000000000000000000000000000000000") throw new Error("This agent has no leash");
+  const w = (0, import_viem2.createWalletClient)({ account: agentAccount, transport: (0, import_viem2.http)(n.rpc), chain: { id: n.chainId, name: n.name, nativeCurrency: { name: "MON", symbol: "MON", decimals: 18 }, rpcUrls: { default: { http: [n.rpc] } } } });
+  const hash = await w.writeContract({ address: account, abi: accountAbi, functionName: "pay", args: [seller, (0, import_viem2.parseUnits)(amountUsd, o.decimals ?? 6), ref], gas: o.gas ?? 150000n });
+  const rc = await client.waitForTransactionReceipt({ hash });
+  if (rc.status !== "success") throw Object.assign(new Error("Refused on-chain by the leash"), { hash });
+  return hash;
+}
+async function fetchWithLeash(url, agentAccount, init = {}) {
+  const resource = new URL(url).pathname, nonce = (0, import_viem2.toHex)(crypto.getRandomValues(new Uint8Array(12)));
+  const proof = await agentAccount.signMessage({ message: proofMessage(resource, nonce) });
+  const headers = { ...init.headers, "x-leash-agent": agentAccount.address, "x-leash-nonce": nonce, "x-leash-proof": proof };
+  const first = await fetch(url, { ...init, headers });
+  if (first.status !== 402) return first;
+  const body = await first.json();
+  if (!body.ref || !body.payTo) return new Response(JSON.stringify(body), { status: 402 });
+  const tx = await payWithLeash(agentAccount, body.payTo, body.price, body.ref, init);
+  return fetch(url, { ...init, headers: { ...headers, "x-leash-payment": tx } });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  STATUS,
+  accountAbi,
+  checkAgent,
+  fetchWithLeash,
+  hubAbi,
+  leashGate,
+  networks,
+  payWithLeash,
+  paymentRef,
+  proofMessage
+});

package/dist/index.d.ts

@@ -0,0 +1,75 @@
+/**
+ * leash-monad: spend limits for AI agents, enforced on Monad.
+ *
+ * Seller side:  checkAgent() before you serve, leashGate() as drop-in HTTP middleware (402 until paid).
+ * Agent side:   payWithLeash() to pay inside the leash, fetchWithLeash() to handle a 402 automatically.
+ */
+import { type Address, type Hex, type PublicClient, type Account } from "viem";
+import { networks, type LeashNetwork } from "./networks";
+import { hubAbi, accountAbi } from "./abi";
+export { networks, hubAbi, accountAbi };
+export type { LeashNetwork };
+export declare const STATUS: readonly ["OK", "UNKNOWN_AGENT", "REVOKED", "EXPIRED", "SELLER_NOT_ALLOWED", "OVER_CAP"];
+export type LeashStatus = (typeof STATUS)[number];
+export type Options = {
+    network?: LeashNetwork | keyof typeof networks;
+    client?: PublicClient;
+    decimals?: number;
+};
+export type Verdict = {
+    /** OK means this payment would go through right now. */
+    status: LeashStatus;
+    ok: boolean;
+    /** What the agent can still spend today, in dollars (string, 2+ decimals). */
+    remainingToday: string;
+    /** Unix seconds when the leash expires (0 if unknown agent). */
+    expiry: number;
+    /** The agent's ERC-8004 identity id in Monad's registry. */
+    erc8004Id: string;
+    /** The passkey-owned Leash account the agent belongs to. */
+    account: Address | null;
+    /** A one-line, human-readable reason, safe to return to the agent. */
+    reason: string;
+};
+/** The seller's question, answered by Monad in one read: if this agent pays me this much, will it go through? */
+export declare function checkAgent(agent: Address, seller: Address, amountUsd: string | number, o?: Options): Promise<Verdict>;
+/** A request reference both sides can derive: binds the payment to this seller, this resource and this nonce. */
+export declare const paymentRef: (seller: Address, resource: string, nonce: string) => `0x${string}`;
+/** Message an agent signs to prove it controls the agent key named in x-leash-agent. */
+export declare const proofMessage: (resource: string, nonce: string) => string;
+export type GateRequest = {
+    method: string;
+    url: string;
+    headers: Record<string, string | string[] | undefined>;
+};
+export type GateResult = {
+    allow: true;
+    agent: Address;
+    paid: string;
+    tx: Hex;
+    verdict: Verdict;
+} | {
+    allow: false;
+    status: 402 | 403;
+    body: Record<string, unknown>;
+};
+/**
+ * Framework-agnostic gate. Call it with the incoming request; serve on allow, otherwise reply with status+body.
+ *
+ *   1st request: no payment header -> 402 with price, payTo, ref and the agent's live leash verdict
+ *   agent pays through its Leash (one tx), then retries with x-leash-payment: <txHash>
+ *   2nd request: the gate checks the receipt's Paid event (agent, seller, amount >= price, ref) -> allow
+ */
+export declare function leashGate(req: GateRequest, cfg: {
+    seller: Address;
+    priceUsd: string;
+    resource?: string;
+} & Options): Promise<GateResult>;
+/** Pay a seller from inside the leash. Reverts on-chain (and throws here) if it would break the leash. */
+export declare function payWithLeash(agentAccount: Account, seller: Address, amountUsd: string, ref: Hex, o?: Options & {
+    gas?: bigint;
+}): Promise<`0x${string}`>;
+/** fetch() for agents: on a 402 from a Leash gate, pays inside the leash and retries once. */
+export declare function fetchWithLeash(url: string, agentAccount: Account & {
+    signMessage: NonNullable<Account["signMessage"]>;
+}, init?: RequestInit & Options): Promise<Response>;

package/dist/index.mjs

@@ -0,0 +1,152 @@
+// src/index.ts
+import {
+  createPublicClient,
+  createWalletClient,
+  http,
+  parseUnits,
+  formatUnits,
+  keccak256,
+  toHex,
+  decodeEventLog,
+  verifyMessage
+} from "viem";
+
+// src/networks.ts
+var networks = {
+  mainnet: {
+    name: "Monad",
+    chainId: 143,
+    rpc: "https://rpc.monad.xyz",
+    explorer: "https://monadvision.com",
+    hub: "0xecefc8c322e2aa77327c2b4912caec04323f4f37",
+    identityRegistry: "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432",
+    testUsd: "0x4adf40e6e5113339635e6dc54ff638e7b63bbea3"
+  },
+  testnet: {
+    name: "Monad Testnet",
+    chainId: 10143,
+    rpc: "https://testnet-rpc.monad.xyz",
+    explorer: "https://testnet.monadvision.com",
+    hub: "0x8b427106c04e66dfc6e8d58fa4de0478a54f510a",
+    identityRegistry: "0x8004A818BFB912233c491871b3d84c89A494BD9e",
+    testUsd: "0xd563843fc54be3e262df4ef3281f6ad397153197"
+  }
+};
+
+// src/abi.ts
+import { parseAbi } from "viem";
+var hubAbi = parseAbi([
+  "function check(address agent, address seller, uint256 amount) view returns (uint8 status, uint256 remainingToday, uint64 expiry, uint256 agentId, address account)",
+  "function accountOf(address agent) view returns (address)"
+]);
+var accountAbi = parseAbi([
+  "function pay(address seller, uint256 amount, bytes32 ref)",
+  "function leashes(address) view returns (address token, uint128 dailyCap, uint128 spentToday, uint64 day, uint64 expiry, uint64 agentId, bool active, bool anySeller)",
+  "event Paid(address indexed agent, address indexed seller, address token, uint256 amount, bytes32 ref, uint256 remainingToday)"
+]);
+
+// src/index.ts
+var STATUS = ["OK", "UNKNOWN_AGENT", "REVOKED", "EXPIRED", "SELLER_NOT_ALLOWED", "OVER_CAP"];
+var net = (o = {}) => (typeof o.network === "string" ? networks[o.network] : o.network) ?? networks.mainnet;
+var clientFor = (o = {}) => o.client ?? createPublicClient({ transport: http(net(o).rpc) });
+var REASONS = {
+  OK: "This agent is leashed and this payment fits its budget.",
+  UNKNOWN_AGENT: "This agent has no leash. Its owner hasn't set a spend limit.",
+  REVOKED: "The owner revoked this agent.",
+  EXPIRED: "This agent's leash has expired.",
+  SELLER_NOT_ALLOWED: "The owner hasn't allowed this agent to pay you.",
+  OVER_CAP: "This payment would take the agent over its daily limit."
+};
+async function checkAgent(agent, seller, amountUsd, o = {}) {
+  const d = o.decimals ?? 6;
+  const r = await clientFor(o).readContract({
+    address: net(o).hub,
+    abi: hubAbi,
+    functionName: "check",
+    args: [agent, seller, parseUnits(String(amountUsd), d)]
+  });
+  const status = STATUS[r[0]];
+  return {
+    status,
+    ok: status === "OK",
+    remainingToday: formatUnits(r[1], d),
+    expiry: Number(r[2]),
+    erc8004Id: r[3].toString(),
+    account: r[4] === "0x0000000000000000000000000000000000000000" ? null : r[4],
+    reason: REASONS[status]
+  };
+}
+var paymentRef = (seller, resource, nonce) => keccak256(toHex(`leash:${seller.toLowerCase()}:${resource}:${nonce}`));
+var proofMessage = (resource, nonce) => `leash:${resource}:${nonce}`;
+async function leashGate(req, cfg) {
+  const h = (k) => {
+    const v = req.headers[k] ?? req.headers[k.toLowerCase()];
+    return Array.isArray(v) ? v[0] : v;
+  };
+  const resource = cfg.resource ?? new URL(req.url, "http://x").pathname;
+  const agent = h("x-leash-agent");
+  const nonce = h("x-leash-nonce"), sig = h("x-leash-proof");
+  if (!agent || !nonce || !sig) {
+    return { allow: false, status: 402, body: { error: "payment_required", price: cfg.priceUsd, payTo: cfg.seller, network: net(cfg).chainId, howTo: "Send x-leash-agent, x-leash-nonce and x-leash-proof (agent signature over 'leash:<resource>:<nonce>')." } };
+  }
+  if (!await verifyMessage({ address: agent, message: proofMessage(resource, nonce), signature: sig })) {
+    return { allow: false, status: 403, body: { error: "bad_proof", reason: "The signature doesn't match x-leash-agent." } };
+  }
+  const ref = paymentRef(cfg.seller, resource, nonce);
+  const payment = h("x-leash-payment");
+  if (!payment) {
+    const verdict = await checkAgent(agent, cfg.seller, cfg.priceUsd, cfg);
+    return { allow: false, status: verdict.ok ? 402 : 403, body: { error: verdict.ok ? "payment_required" : "leash_refused", price: cfg.priceUsd, payTo: cfg.seller, ref, leash: verdict } };
+  }
+  const client = clientFor(cfg);
+  const rc = await client.getTransactionReceipt({ hash: payment }).catch(() => null);
+  if (!rc || rc.status !== "success") return { allow: false, status: 402, body: { error: "payment_not_found", ref } };
+  const d = cfg.decimals ?? 6, need = parseUnits(cfg.priceUsd, d);
+  for (const log of rc.logs) {
+    try {
+      const ev = decodeEventLog({ abi: accountAbi, data: log.data, topics: log.topics });
+      if (ev.eventName !== "Paid") continue;
+      const a = ev.args;
+      const account = await client.readContract({ address: net(cfg).hub, abi: hubAbi, functionName: "accountOf", args: [agent] });
+      if (log.address.toLowerCase() === account.toLowerCase() && a.agent.toLowerCase() === agent.toLowerCase() && a.seller.toLowerCase() === cfg.seller.toLowerCase() && a.amount >= need && a.ref === ref) {
+        const verdict = await checkAgent(agent, cfg.seller, "0", cfg);
+        return { allow: true, agent, paid: formatUnits(a.amount, d), tx: payment, verdict };
+      }
+    } catch {
+    }
+  }
+  return { allow: false, status: 402, body: { error: "payment_mismatch", ref } };
+}
+async function payWithLeash(agentAccount, seller, amountUsd, ref, o = {}) {
+  const n = net(o), client = clientFor(o);
+  const account = await client.readContract({ address: n.hub, abi: hubAbi, functionName: "accountOf", args: [agentAccount.address] });
+  if (account === "0x0000000000000000000000000000000000000000") throw new Error("This agent has no leash");
+  const w = createWalletClient({ account: agentAccount, transport: http(n.rpc), chain: { id: n.chainId, name: n.name, nativeCurrency: { name: "MON", symbol: "MON", decimals: 18 }, rpcUrls: { default: { http: [n.rpc] } } } });
+  const hash = await w.writeContract({ address: account, abi: accountAbi, functionName: "pay", args: [seller, parseUnits(amountUsd, o.decimals ?? 6), ref], gas: o.gas ?? 150000n });
+  const rc = await client.waitForTransactionReceipt({ hash });
+  if (rc.status !== "success") throw Object.assign(new Error("Refused on-chain by the leash"), { hash });
+  return hash;
+}
+async function fetchWithLeash(url, agentAccount, init = {}) {
+  const resource = new URL(url).pathname, nonce = toHex(crypto.getRandomValues(new Uint8Array(12)));
+  const proof = await agentAccount.signMessage({ message: proofMessage(resource, nonce) });
+  const headers = { ...init.headers, "x-leash-agent": agentAccount.address, "x-leash-nonce": nonce, "x-leash-proof": proof };
+  const first = await fetch(url, { ...init, headers });
+  if (first.status !== 402) return first;
+  const body = await first.json();
+  if (!body.ref || !body.payTo) return new Response(JSON.stringify(body), { status: 402 });
+  const tx = await payWithLeash(agentAccount, body.payTo, body.price, body.ref, init);
+  return fetch(url, { ...init, headers: { ...headers, "x-leash-payment": tx } });
+}
+export {
+  STATUS,
+  accountAbi,
+  checkAgent,
+  fetchWithLeash,
+  hubAbi,
+  leashGate,
+  networks,
+  payWithLeash,
+  paymentRef,
+  proofMessage
+};

package/dist/networks.d.ts

@@ -0,0 +1,31 @@
+import type { Address } from "viem";
+export type LeashNetwork = {
+    name: string;
+    chainId: number;
+    rpc: string;
+    explorer: string;
+    hub: Address;
+    identityRegistry: Address;
+    testUsd?: Address;
+};
+/** Live deployments. Mainnet is the default everywhere in this package. */
+export declare const networks: {
+    mainnet: {
+        name: string;
+        chainId: number;
+        rpc: string;
+        explorer: string;
+        hub: "0xecefc8c322e2aa77327c2b4912caec04323f4f37";
+        identityRegistry: "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432";
+        testUsd: "0x4adf40e6e5113339635e6dc54ff638e7b63bbea3";
+    };
+    testnet: {
+        name: string;
+        chainId: number;
+        rpc: string;
+        explorer: string;
+        hub: "0x8b427106c04e66dfc6e8d58fa4de0478a54f510a";
+        identityRegistry: "0x8004A818BFB912233c491871b3d84c89A494BD9e";
+        testUsd: "0xd563843fc54be3e262df4ef3281f6ad397153197";
+    };
+};

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "leash-monad",
+  "version": "0.1.0",
+  "description": "Spend limits for AI agents on Monad. One call tells a seller whose agent it is, what it may spend today, and whether a payment will go through.",
+  "license": "MIT",
+  "author": "Robert Moore",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/iamrobertmoore/leash.git",
+    "directory": "sdk"
+  },
+  "homepage": "https://leash-monad.vercel.app",
+  "keywords": [
+    "monad",
+    "ai-agents",
+    "erc-8004",
+    "x402",
+    "passkey",
+    "spend-limits",
+    "agent-payments"
+  ],
+  "main": "./dist/index.cjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "esbuild src/index.ts --bundle --format=esm --platform=neutral --external:viem --outfile=dist/index.mjs && esbuild src/index.ts --bundle --format=cjs --platform=node --external:viem --outfile=dist/index.cjs && tsc -p . --emitDeclarationOnly",
+    "test": "node --test dist/test/*.test.js"
+  },
+  "peerDependencies": {
+    "viem": "^2.20.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.6.0",
+    "viem": "^2.20.0",
+    "esbuild": "^0.21.0"
+  },
+  "module": "./dist/index.mjs"
+}