@agent-fuel/sdk 0.2.0 → 0.3.0

package/dist/cli.cjs

@@ -0,0 +1,4530 @@
+#!/usr/bin/env node
+'use strict';
+
+var commander = require('commander');
+var web3_js = require('@solana/web3.js');
+var crypto = require('crypto');
+var fs = require('fs');
+var path = require('path');
+var anchor = require('@coral-xyz/anchor');
+
+var TOKEN_PROGRAM_ID = new web3_js.PublicKey("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
+var ASSOCIATED_TOKEN_PROGRAM_ID = new web3_js.PublicKey(
+  "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"
+);
+var SLOTS_PER_HOUR = 9e3;
+function getAssociatedTokenAddress(mint, owner) {
+  const [ata] = web3_js.PublicKey.findProgramAddressSync(
+    [owner.toBuffer(), TOKEN_PROGRAM_ID.toBuffer(), mint.toBuffer()],
+    ASSOCIATED_TOKEN_PROGRAM_ID
+  );
+  return ata;
+}
+function createAssociatedTokenAccountIdempotentInstruction(payer, ata, owner, mint) {
+  return new web3_js.TransactionInstruction({
+    programId: ASSOCIATED_TOKEN_PROGRAM_ID,
+    keys: [
+      { pubkey: payer, isSigner: true, isWritable: true },
+      { pubkey: ata, isSigner: false, isWritable: true },
+      { pubkey: owner, isSigner: false, isWritable: false },
+      { pubkey: mint, isSigner: false, isWritable: false },
+      { pubkey: web3_js.SystemProgram.programId, isSigner: false, isWritable: false },
+      { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false }
+    ],
+    data: Buffer.from([1])
+  });
+}
+function bnToNum(bn) {
+  return bn.toNumber();
+}
+function nameFromBytes(bytes) {
+  const buf = Buffer.from(bytes);
+  const end = buf.indexOf(0);
+  return (end === -1 ? buf : buf.subarray(0, end)).toString("utf8");
+}
+function categoryFromRaw(raw) {
+  if ("dataFeed" in raw) return "DataFeed";
+  if ("compute" in raw) return "Compute";
+  if ("swap" in raw) return "Swap";
+  if ("rpc" in raw) return "Rpc";
+  return "Other";
+}
+function decodeCreditVault(pubkey, raw) {
+  const total_deposited = bnToNum(raw.totalDeposited);
+  const total_withdrawn = bnToNum(raw.totalWithdrawn);
+  const total_spent = bnToNum(raw.totalSpent);
+  const total_claimed = bnToNum(raw.totalClaimed);
+  return {
+    pubkey,
+    owner: raw.owner,
+    agent: raw.agent,
+    usdc_mint: raw.usdcMint,
+    vault_token_account: raw.vaultTokenAccount,
+    total_deposited,
+    total_withdrawn,
+    total_spent,
+    total_claimed,
+    balance: total_deposited - total_withdrawn - total_spent + total_claimed,
+    frozen: raw.frozen,
+    created_slot: bnToNum(raw.createdSlot),
+    last_active_slot: bnToNum(raw.lastActiveSlot),
+    pending_count: bnToNum(raw.pendingCount)
+  };
+}
+var DEFAULT_PUBKEY = web3_js.PublicKey.default.toBase58();
+function decodeSpendPolicy(pubkey, raw) {
+  return {
+    pubkey,
+    vault: raw.vault,
+    whitelist: raw.whitelist.filter((pk) => pk.toBase58() !== DEFAULT_PUBKEY),
+    per_tx_limit_usdc: bnToNum(raw.perTxLimitUsdc),
+    hourly_limit_usdc: bnToNum(raw.hourlyLimitUsdc),
+    lifetime_limit_usdc: bnToNum(raw.lifetimeLimitUsdc),
+    hourly_window_start_slot: bnToNum(raw.hourlyWindowStartSlot),
+    hourly_window_spent_usdc: bnToNum(raw.hourlyWindowSpentUsdc),
+    allow_post_pay: raw.allowPostPay
+  };
+}
+function decodeServiceRegistry(pubkey, raw) {
+  return {
+    pubkey,
+    authority: raw.authority,
+    name: nameFromBytes(raw.name),
+    category: categoryFromRaw(raw.category),
+    total_agents_served: bnToNum(raw.totalAgentsServed),
+    total_volume_received_usdc: bnToNum(raw.totalVolumeReceivedUsdc),
+    active: raw.active,
+    first_active_slot: bnToNum(raw.firstActiveSlot),
+    last_active_slot: bnToNum(raw.lastActiveSlot)
+  };
+}
+
+// src/errors.ts
+var AgentFuelError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AgentFuelError";
+  }
+};
+var OwnerNotConfiguredError = class extends AgentFuelError {
+  constructor() {
+    super("vault owner is not configured: pass `owner` to `new AgentFuel({...})` or to the method");
+    this.name = "OwnerNotConfiguredError";
+  }
+};
+var AccountNotFoundError = class extends AgentFuelError {
+  account;
+  constructor(account) {
+    super(`account not found: ${account}`);
+    this.name = "AccountNotFoundError";
+    this.account = account;
+  }
+};
+var HttpError = class extends AgentFuelError {
+  status;
+  url;
+  body;
+  constructor(status, url, body) {
+    super(`HTTP ${status} from ${url}`);
+    this.name = "HttpError";
+    this.status = status;
+    this.url = url;
+    this.body = body;
+  }
+};
+var SpendPolicyError = class extends AgentFuelError {
+  constructor(message) {
+    super(message);
+    this.name = "SpendPolicyError";
+  }
+};
+var VaultFrozenError = class extends SpendPolicyError {
+  constructor() {
+    super("vault is frozen");
+    this.name = "VaultFrozenError";
+  }
+};
+var ZeroAmountError = class extends SpendPolicyError {
+  constructor() {
+    super("amount must be > 0");
+    this.name = "ZeroAmountError";
+  }
+};
+var PerTxLimitExceededError = class extends SpendPolicyError {
+  limit;
+  amount;
+  constructor(amount, limit) {
+    super(`per-tx limit exceeded: ${amount} > ${limit}`);
+    this.name = "PerTxLimitExceededError";
+    this.amount = amount;
+    this.limit = limit;
+  }
+};
+var HourlyLimitExceededError = class extends SpendPolicyError {
+  limit;
+  windowSpent;
+  amount;
+  constructor(amount, windowSpent, limit) {
+    super(`hourly limit exceeded: ${windowSpent} + ${amount} > ${limit}`);
+    this.name = "HourlyLimitExceededError";
+    this.amount = amount;
+    this.windowSpent = windowSpent;
+    this.limit = limit;
+  }
+};
+var LifetimeLimitExceededError = class extends SpendPolicyError {
+  limit;
+  totalSpent;
+  amount;
+  constructor(amount, totalSpent, limit) {
+    super(`lifetime limit exceeded: ${totalSpent} + ${amount} > ${limit}`);
+    this.name = "LifetimeLimitExceededError";
+    this.amount = amount;
+    this.totalSpent = totalSpent;
+    this.limit = limit;
+  }
+};
+var NotWhitelistedError = class extends SpendPolicyError {
+  service;
+  constructor(service) {
+    super(`service ${service} is not in the vault's whitelist`);
+    this.name = "NotWhitelistedError";
+    this.service = service;
+  }
+};
+var RecordPaymentError = class extends AgentFuelError {
+  constructor(message) {
+    super(message);
+    this.name = "RecordPaymentError";
+  }
+};
+var ReceiptAlreadyRecordedError = class extends RecordPaymentError {
+  receiptHash;
+  constructor(receiptHash) {
+    super("payment receipt was already recorded on chain");
+    this.name = "ReceiptAlreadyRecordedError";
+    this.receiptHash = receiptHash;
+  }
+};
+var ServiceInactiveError = class extends RecordPaymentError {
+  service;
+  constructor(service) {
+    super(`service ${service} is paused; record_payment rejected`);
+    this.name = "ServiceInactiveError";
+    this.service = service;
+  }
+};
+
+// src/guardrails.ts
+function guardSpend(args) {
+  const { vault, policy, service, amountUsdc, currentSlot } = args;
+  if (vault.frozen) throw new VaultFrozenError();
+  if (amountUsdc <= 0) throw new ZeroAmountError();
+  if (policy.whitelist.length > 0) {
+    const allowed = policy.whitelist.some((pk) => pk.equals(service));
+    if (!allowed) throw new NotWhitelistedError(service.toBase58());
+  }
+  if (policy.per_tx_limit_usdc > 0 && amountUsdc > policy.per_tx_limit_usdc) {
+    throw new PerTxLimitExceededError(amountUsdc, policy.per_tx_limit_usdc);
+  }
+  if (policy.hourly_limit_usdc > 0) {
+    const windowElapsed = currentSlot - policy.hourly_window_start_slot >= SLOTS_PER_HOUR;
+    const windowSpent = windowElapsed ? 0 : policy.hourly_window_spent_usdc;
+    const newWindowTotal = windowSpent + amountUsdc;
+    if (newWindowTotal > policy.hourly_limit_usdc) {
+      throw new HourlyLimitExceededError(amountUsdc, windowSpent, policy.hourly_limit_usdc);
+    }
+  }
+  if (policy.lifetime_limit_usdc > 0) {
+    const newTotalSpent = vault.total_spent + amountUsdc;
+    if (newTotalSpent > policy.lifetime_limit_usdc) {
+      throw new LifetimeLimitExceededError(amountUsdc, vault.total_spent, policy.lifetime_limit_usdc);
+    }
+  }
+}
+
+// src/live.ts
+var cachedCtor = null;
+async function getWebSocketCtor() {
+  if (cachedCtor) return cachedCtor;
+  const globalCtor = globalThis.WebSocket;
+  if (globalCtor) {
+    cachedCtor = globalCtor;
+    return globalCtor;
+  }
+  cachedCtor = (async () => {
+    const mod = await import('ws');
+    return mod.WebSocket;
+  })();
+  return cachedCtor;
+}
+var WS_OPEN = 1;
+var MAX_BACKOFF_MS = 3e4;
+function subscribe(url, opts) {
+  let socket = null;
+  let alive = true;
+  let attempts = 0;
+  let reconnectTimer = null;
+  let currentStatus = "connecting";
+  function setStatus(next) {
+    currentStatus = next;
+    opts.onStatus?.(next);
+  }
+  async function connect() {
+    if (!alive) return;
+    setStatus(attempts === 0 ? "connecting" : "reconnecting");
+    const WS = await getWebSocketCtor();
+    if (!alive) return;
+    socket = new WS(url);
+    socket.addEventListener("open", () => {
+      attempts = 0;
+      setStatus("open");
+    });
+    socket.addEventListener("message", (ev) => {
+      if (typeof ev.data !== "string" || ev.data.length === 0) return;
+      try {
+        const parsed = JSON.parse(ev.data);
+        if (parsed.type === "event") opts.onFrame(parsed);
+      } catch {
+      }
+    });
+    socket.addEventListener("close", () => {
+      if (!alive) return;
+      attempts += 1;
+      const delay = Math.min(MAX_BACKOFF_MS, 1e3 * 2 ** (attempts - 1));
+      setStatus("reconnecting");
+      reconnectTimer = setTimeout(() => {
+        void connect();
+      }, delay);
+    });
+    socket.addEventListener("error", () => {
+    });
+  }
+  void connect();
+  return {
+    close() {
+      alive = false;
+      if (reconnectTimer !== null) clearTimeout(reconnectTimer);
+      if (socket && socket.readyState === WS_OPEN) {
+        socket.close(1e3, "client close");
+      }
+      socket = null;
+      setStatus("closed");
+    },
+    get status() {
+      return currentStatus;
+    }
+  };
+}
+function wsUrl(apiBase, path) {
+  if (apiBase.startsWith("https://")) return apiBase.replace(/^https/, "wss") + path;
+  if (apiBase.startsWith("http://")) return apiBase.replace(/^http/, "ws") + path;
+  return apiBase + path;
+}
+
+// src/idl/reputation.json
+var reputation_default = {
+  address: "4GjB4xdm1VTPVM6KSiEEfJpD4u7BfY1qDx77StiFShvQ",
+  metadata: {
+    name: "reputation",
+    version: "0.1.0",
+    spec: "0.1.0",
+    description: "Agent Fuel \u2014 On-chain reputation primitive for AI agents on Solana",
+    repository: "https://github.com/TODO/agent_fuel"
+  },
+  instructions: [
+    {
+      name: "append_response",
+      discriminator: [
+        162,
+        210,
+        186,
+        50,
+        180,
+        4,
+        47,
+        104
+      ],
+      accounts: [
+        {
+          name: "responder",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "agent_profile",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  97,
+                  103,
+                  101,
+                  110,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "agent_profile.authority",
+                account: "AgentProfile"
+              }
+            ]
+          },
+          relations: [
+            "feedback_record"
+          ]
+        },
+        {
+          name: "feedback_record",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  102,
+                  101,
+                  101,
+                  100,
+                  98,
+                  97,
+                  99,
+                  107
+                ]
+              },
+              {
+                kind: "arg",
+                path: "payment_receipt_hash"
+              }
+            ]
+          }
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: [
+        {
+          name: "payment_receipt_hash",
+          type: {
+            array: [
+              "u8",
+              32
+            ]
+          }
+        },
+        {
+          name: "response_uri",
+          type: {
+            array: [
+              "u8",
+              128
+            ]
+          }
+        },
+        {
+          name: "response_hash",
+          type: {
+            array: [
+              "u8",
+              32
+            ]
+          }
+        }
+      ]
+    },
+    {
+      name: "compute_score",
+      discriminator: [
+        161,
+        101,
+        4,
+        93,
+        120,
+        62,
+        41,
+        20
+      ],
+      accounts: [
+        {
+          name: "caller",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "agent_profile",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  97,
+                  103,
+                  101,
+                  110,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "agent_profile.authority",
+                account: "AgentProfile"
+              }
+            ]
+          }
+        }
+      ],
+      args: []
+    },
+    {
+      name: "give_feedback",
+      discriminator: [
+        145,
+        136,
+        123,
+        3,
+        215,
+        165,
+        98,
+        41
+      ],
+      accounts: [
+        {
+          name: "service",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "agent_profile",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  97,
+                  103,
+                  101,
+                  110,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "agent_profile.authority",
+                account: "AgentProfile"
+              }
+            ]
+          }
+        },
+        {
+          name: "service_registry",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  115,
+                  101,
+                  114,
+                  118,
+                  105,
+                  99,
+                  101
+                ]
+              },
+              {
+                kind: "account",
+                path: "service"
+              }
+            ]
+          }
+        },
+        {
+          name: "agent_service_link",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  108,
+                  105,
+                  110,
+                  107
+                ]
+              },
+              {
+                kind: "account",
+                path: "agent_profile"
+              },
+              {
+                kind: "account",
+                path: "service_registry"
+              }
+            ]
+          }
+        },
+        {
+          name: "receipt_used",
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  114,
+                  101,
+                  99,
+                  101,
+                  105,
+                  112,
+                  116
+                ]
+              },
+              {
+                kind: "arg",
+                path: "payment_receipt_hash"
+              }
+            ]
+          }
+        },
+        {
+          name: "feedback_record",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  102,
+                  101,
+                  101,
+                  100,
+                  98,
+                  97,
+                  99,
+                  107
+                ]
+              },
+              {
+                kind: "arg",
+                path: "payment_receipt_hash"
+              }
+            ]
+          }
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: [
+        {
+          name: "payment_receipt_hash",
+          type: {
+            array: [
+              "u8",
+              32
+            ]
+          }
+        },
+        {
+          name: "value",
+          type: "i8"
+        },
+        {
+          name: "tags",
+          type: "u32"
+        },
+        {
+          name: "evidence_uri",
+          type: {
+            array: [
+              "u8",
+              128
+            ]
+          }
+        },
+        {
+          name: "evidence_hash",
+          type: {
+            array: [
+              "u8",
+              32
+            ]
+          }
+        }
+      ]
+    },
+    {
+      name: "initialize_agent",
+      discriminator: [
+        212,
+        81,
+        156,
+        211,
+        212,
+        110,
+        21,
+        28
+      ],
+      accounts: [
+        {
+          name: "owner",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "agent",
+          signer: true
+        },
+        {
+          name: "agent_profile",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  97,
+                  103,
+                  101,
+                  110,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "agent"
+              }
+            ]
+          }
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: [
+        {
+          name: "agent_uri",
+          type: {
+            array: [
+              "u8",
+              128
+            ]
+          }
+        },
+        {
+          name: "external_agent_id",
+          type: "u64"
+        }
+      ]
+    },
+    {
+      name: "record_payment",
+      discriminator: [
+        226,
+        154,
+        10,
+        27,
+        9,
+        14,
+        148,
+        137
+      ],
+      accounts: [
+        {
+          name: "service",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "agent_profile",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  97,
+                  103,
+                  101,
+                  110,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "agent_profile.authority",
+                account: "AgentProfile"
+              }
+            ]
+          }
+        },
+        {
+          name: "service_registry",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  115,
+                  101,
+                  114,
+                  118,
+                  105,
+                  99,
+                  101
+                ]
+              },
+              {
+                kind: "account",
+                path: "service"
+              }
+            ]
+          }
+        },
+        {
+          name: "agent_service_link",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  108,
+                  105,
+                  110,
+                  107
+                ]
+              },
+              {
+                kind: "account",
+                path: "agent_profile"
+              },
+              {
+                kind: "account",
+                path: "service_registry"
+              }
+            ]
+          }
+        },
+        {
+          name: "receipt_used",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  114,
+                  101,
+                  99,
+                  101,
+                  105,
+                  112,
+                  116
+                ]
+              },
+              {
+                kind: "arg",
+                path: "payment_receipt_hash"
+              }
+            ]
+          }
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: [
+        {
+          name: "amount_usdc",
+          type: "u64"
+        },
+        {
+          name: "payment_receipt_hash",
+          type: {
+            array: [
+              "u8",
+              32
+            ]
+          }
+        }
+      ]
+    },
+    {
+      name: "register_service",
+      discriminator: [
+        11,
+        133,
+        158,
+        232,
+        193,
+        19,
+        229,
+        73
+      ],
+      accounts: [
+        {
+          name: "sponsor",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "service",
+          signer: true
+        },
+        {
+          name: "service_registry",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  115,
+                  101,
+                  114,
+                  118,
+                  105,
+                  99,
+                  101
+                ]
+              },
+              {
+                kind: "account",
+                path: "service"
+              }
+            ]
+          }
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: [
+        {
+          name: "name",
+          type: {
+            array: [
+              "u8",
+              32
+            ]
+          }
+        },
+        {
+          name: "category",
+          type: {
+            defined: {
+              name: "ServiceCategory"
+            }
+          }
+        },
+        {
+          name: "service_uri",
+          type: {
+            array: [
+              "u8",
+              128
+            ]
+          }
+        }
+      ]
+    },
+    {
+      name: "revoke_feedback",
+      discriminator: [
+        211,
+        37,
+        230,
+        82,
+        118,
+        216,
+        137,
+        206
+      ],
+      accounts: [
+        {
+          name: "service",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "agent_profile",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  97,
+                  103,
+                  101,
+                  110,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "agent_profile.authority",
+                account: "AgentProfile"
+              }
+            ]
+          },
+          relations: [
+            "feedback_record"
+          ]
+        },
+        {
+          name: "service_registry",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  115,
+                  101,
+                  114,
+                  118,
+                  105,
+                  99,
+                  101
+                ]
+              },
+              {
+                kind: "account",
+                path: "service"
+              }
+            ]
+          },
+          relations: [
+            "feedback_record"
+          ]
+        },
+        {
+          name: "feedback_record",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  102,
+                  101,
+                  101,
+                  100,
+                  98,
+                  97,
+                  99,
+                  107
+                ]
+              },
+              {
+                kind: "arg",
+                path: "payment_receipt_hash"
+              }
+            ]
+          }
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: [
+        {
+          name: "payment_receipt_hash",
+          type: {
+            array: [
+              "u8",
+              32
+            ]
+          }
+        }
+      ]
+    },
+    {
+      name: "set_service_active",
+      discriminator: [
+        221,
+        172,
+        149,
+        49,
+        212,
+        184,
+        77,
+        101
+      ],
+      accounts: [
+        {
+          name: "service",
+          signer: true
+        },
+        {
+          name: "service_registry",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  115,
+                  101,
+                  114,
+                  118,
+                  105,
+                  99,
+                  101
+                ]
+              },
+              {
+                kind: "account",
+                path: "service"
+              }
+            ]
+          }
+        },
+        {
+          name: "authority",
+          relations: [
+            "service_registry"
+          ]
+        }
+      ],
+      args: [
+        {
+          name: "active",
+          type: "bool"
+        }
+      ]
+    }
+  ],
+  accounts: [
+    {
+      name: "AgentProfile",
+      discriminator: [
+        60,
+        227,
+        42,
+        24,
+        0,
+        87,
+        86,
+        205
+      ]
+    },
+    {
+      name: "AgentServiceLink",
+      discriminator: [
+        123,
+        74,
+        215,
+        240,
+        42,
+        88,
+        217,
+        216
+      ]
+    },
+    {
+      name: "FeedbackRecord",
+      discriminator: [
+        15,
+        45,
+        246,
+        217,
+        63,
+        251,
+        69,
+        100
+      ]
+    },
+    {
+      name: "ReceiptUsed",
+      discriminator: [
+        143,
+        21,
+        251,
+        75,
+        166,
+        7,
+        163,
+        137
+      ]
+    },
+    {
+      name: "ServiceRegistry",
+      discriminator: [
+        105,
+        133,
+        96,
+        79,
+        207,
+        176,
+        202,
+        71
+      ]
+    }
+  ],
+  events: [
+    {
+      name: "AgentInitialized",
+      discriminator: [
+        124,
+        252,
+        85,
+        27,
+        146,
+        101,
+        64,
+        160
+      ]
+    },
+    {
+      name: "FeedbackGiven",
+      discriminator: [
+        64,
+        65,
+        2,
+        152,
+        174,
+        215,
+        156,
+        194
+      ]
+    },
+    {
+      name: "FeedbackRevoked",
+      discriminator: [
+        205,
+        16,
+        31,
+        94,
+        54,
+        101,
+        16,
+        199
+      ]
+    },
+    {
+      name: "PaymentRecorded",
+      discriminator: [
+        214,
+        3,
+        212,
+        116,
+        135,
+        35,
+        104,
+        98
+      ]
+    },
+    {
+      name: "ResponseAppended",
+      discriminator: [
+        168,
+        169,
+        214,
+        193,
+        171,
+        1,
+        232,
+        123
+      ]
+    },
+    {
+      name: "ScoreComputed",
+      discriminator: [
+        52,
+        76,
+        80,
+        33,
+        2,
+        43,
+        75,
+        109
+      ]
+    },
+    {
+      name: "ServiceActiveSet",
+      discriminator: [
+        151,
+        122,
+        7,
+        40,
+        191,
+        139,
+        237,
+        52
+      ]
+    },
+    {
+      name: "ServiceRegistered",
+      discriminator: [
+        25,
+        219,
+        76,
+        223,
+        57,
+        191,
+        117,
+        38
+      ]
+    }
+  ],
+  errors: [
+    {
+      code: 6e3,
+      name: "Overflow",
+      msg: "Counter or amount overflow"
+    },
+    {
+      code: 6001,
+      name: "ServiceInactive",
+      msg: "Service is not active"
+    },
+    {
+      code: 6002,
+      name: "ZeroAmount",
+      msg: "Payment amount must be greater than zero"
+    },
+    {
+      code: 6003,
+      name: "SelfRating",
+      msg: "A service may not rate itself or the agent owner"
+    },
+    {
+      code: 6004,
+      name: "ReceiptMismatch",
+      msg: "Receipt does not belong to this (agent, service) pair"
+    },
+    {
+      code: 6005,
+      name: "InvalidFeedbackValue",
+      msg: "Feedback value is outside the allowed range"
+    },
+    {
+      code: 6006,
+      name: "UnauthorizedResponder",
+      msg: "Responder must be the agent or its owner"
+    },
+    {
+      code: 6007,
+      name: "AlreadyHasResponse",
+      msg: "Feedback already has a response"
+    },
+    {
+      code: 6008,
+      name: "AlreadyRevoked",
+      msg: "Feedback has already been revoked"
+    },
+    {
+      code: 6009,
+      name: "FeedbackRateLimited",
+      msg: "Feedback rate limit not yet expired for this (service, agent) pair"
+    },
+    {
+      code: 6010,
+      name: "UnauthorizedService",
+      msg: "Only the service authority may perform this action"
+    }
+  ],
+  types: [
+    {
+      name: "AgentInitialized",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "agent",
+            type: "pubkey"
+          },
+          {
+            name: "owner",
+            type: "pubkey"
+          },
+          {
+            name: "init_slot",
+            type: "u64"
+          }
+        ]
+      }
+    },
+    {
+      name: "AgentProfile",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "authority",
+            type: "pubkey"
+          },
+          {
+            name: "owner",
+            type: "pubkey"
+          },
+          {
+            name: "agent_uri",
+            type: {
+              array: [
+                "u8",
+                128
+              ]
+            }
+          },
+          {
+            name: "external_agent_id",
+            type: "u64"
+          },
+          {
+            name: "total_transactions",
+            type: "u64"
+          },
+          {
+            name: "total_volume_usdc",
+            type: "u64"
+          },
+          {
+            name: "consecutive_success",
+            type: "u32"
+          },
+          {
+            name: "total_feedback_count",
+            type: "u32"
+          },
+          {
+            name: "active_negative_feedback_count",
+            type: "u32"
+          },
+          {
+            name: "services_used",
+            type: "u16"
+          },
+          {
+            name: "first_active_slot",
+            type: "u64"
+          },
+          {
+            name: "last_active_slot",
+            type: "u64"
+          },
+          {
+            name: "reputation_score",
+            type: "u16"
+          },
+          {
+            name: "bump",
+            type: "u8"
+          },
+          {
+            name: "_padding",
+            type: {
+              array: [
+                "u8",
+                64
+              ]
+            }
+          }
+        ]
+      }
+    },
+    {
+      name: "AgentServiceLink",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "agent",
+            type: "pubkey"
+          },
+          {
+            name: "service",
+            type: "pubkey"
+          },
+          {
+            name: "total_transactions",
+            type: "u64"
+          },
+          {
+            name: "total_volume_usdc",
+            type: "u64"
+          },
+          {
+            name: "first_payment_slot",
+            type: "u64"
+          },
+          {
+            name: "last_payment_slot",
+            type: "u64"
+          },
+          {
+            name: "last_feedback_slot",
+            type: "u64"
+          },
+          {
+            name: "has_received_feedback",
+            type: "bool"
+          },
+          {
+            name: "bump",
+            type: "u8"
+          },
+          {
+            name: "_padding",
+            type: {
+              array: [
+                "u8",
+                64
+              ]
+            }
+          }
+        ]
+      }
+    },
+    {
+      name: "FeedbackGiven",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "agent",
+            type: "pubkey"
+          },
+          {
+            name: "service",
+            type: "pubkey"
+          },
+          {
+            name: "feedback",
+            type: "pubkey"
+          },
+          {
+            name: "payment_receipt_hash",
+            type: {
+              array: [
+                "u8",
+                32
+              ]
+            }
+          },
+          {
+            name: "value",
+            type: "i8"
+          },
+          {
+            name: "tags",
+            type: "u32"
+          },
+          {
+            name: "slot",
+            type: "u64"
+          }
+        ]
+      }
+    },
+    {
+      name: "FeedbackRecord",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "agent_profile",
+            type: "pubkey"
+          },
+          {
+            name: "service_registry",
+            type: "pubkey"
+          },
+          {
+            name: "payment_receipt_hash",
+            type: {
+              array: [
+                "u8",
+                32
+              ]
+            }
+          },
+          {
+            name: "value",
+            type: "i8"
+          },
+          {
+            name: "tags",
+            type: "u32"
+          },
+          {
+            name: "evidence_uri",
+            type: {
+              array: [
+                "u8",
+                128
+              ]
+            }
+          },
+          {
+            name: "evidence_hash",
+            type: {
+              array: [
+                "u8",
+                32
+              ]
+            }
+          },
+          {
+            name: "response_uri",
+            type: {
+              array: [
+                "u8",
+                128
+              ]
+            }
+          },
+          {
+            name: "response_hash",
+            type: {
+              array: [
+                "u8",
+                32
+              ]
+            }
+          },
+          {
+            name: "has_response",
+            type: "bool"
+          },
+          {
+            name: "revoked",
+            type: "bool"
+          },
+          {
+            name: "created_slot",
+            type: "u64"
+          },
+          {
+            name: "last_modified_slot",
+            type: "u64"
+          },
+          {
+            name: "bump",
+            type: "u8"
+          },
+          {
+            name: "_padding",
+            type: {
+              array: [
+                "u8",
+                64
+              ]
+            }
+          }
+        ]
+      }
+    },
+    {
+      name: "FeedbackRevoked",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "agent",
+            type: "pubkey"
+          },
+          {
+            name: "service",
+            type: "pubkey"
+          },
+          {
+            name: "feedback",
+            type: "pubkey"
+          },
+          {
+            name: "was_negative",
+            type: "bool"
+          },
+          {
+            name: "slot",
+            type: "u64"
+          }
+        ]
+      }
+    },
+    {
+      name: "PaymentRecorded",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "agent",
+            type: "pubkey"
+          },
+          {
+            name: "service",
+            type: "pubkey"
+          },
+          {
+            name: "amount_usdc",
+            type: "u64"
+          },
+          {
+            name: "payment_receipt_hash",
+            type: {
+              array: [
+                "u8",
+                32
+              ]
+            }
+          },
+          {
+            name: "was_new_pair",
+            type: "bool"
+          },
+          {
+            name: "slot",
+            type: "u64"
+          }
+        ]
+      }
+    },
+    {
+      name: "ReceiptUsed",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "receipt_hash",
+            type: {
+              array: [
+                "u8",
+                32
+              ]
+            }
+          },
+          {
+            name: "agent_service_link",
+            type: "pubkey"
+          },
+          {
+            name: "recorded_slot",
+            type: "u64"
+          },
+          {
+            name: "bump",
+            type: "u8"
+          },
+          {
+            name: "_padding",
+            type: {
+              array: [
+                "u8",
+                32
+              ]
+            }
+          }
+        ]
+      }
+    },
+    {
+      name: "ResponseAppended",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "agent",
+            type: "pubkey"
+          },
+          {
+            name: "feedback",
+            type: "pubkey"
+          },
+          {
+            name: "responder",
+            type: "pubkey"
+          },
+          {
+            name: "slot",
+            type: "u64"
+          }
+        ]
+      }
+    },
+    {
+      name: "ScoreComputed",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "agent",
+            type: "pubkey"
+          },
+          {
+            name: "score",
+            type: "u16"
+          },
+          {
+            name: "slot",
+            type: "u64"
+          }
+        ]
+      }
+    },
+    {
+      name: "ServiceActiveSet",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "service",
+            type: "pubkey"
+          },
+          {
+            name: "active",
+            type: "bool"
+          },
+          {
+            name: "slot",
+            type: "u64"
+          }
+        ]
+      }
+    },
+    {
+      name: "ServiceCategory",
+      type: {
+        kind: "enum",
+        variants: [
+          {
+            name: "DataFeed"
+          },
+          {
+            name: "Compute"
+          },
+          {
+            name: "Swap"
+          },
+          {
+            name: "Rpc"
+          },
+          {
+            name: "Other"
+          }
+        ]
+      }
+    },
+    {
+      name: "ServiceRegistered",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "service",
+            type: "pubkey"
+          },
+          {
+            name: "sponsor",
+            docs: [
+              'Wallet that paid rent. Lets us answer "who registered this service?"',
+              "without an extra column on the on-chain account."
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "name",
+            type: {
+              array: [
+                "u8",
+                32
+              ]
+            }
+          },
+          {
+            name: "category",
+            type: {
+              defined: {
+                name: "ServiceCategory"
+              }
+            }
+          },
+          {
+            name: "init_slot",
+            type: "u64"
+          }
+        ]
+      }
+    },
+    {
+      name: "ServiceRegistry",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "authority",
+            type: "pubkey"
+          },
+          {
+            name: "name",
+            type: {
+              array: [
+                "u8",
+                32
+              ]
+            }
+          },
+          {
+            name: "service_uri",
+            docs: [
+              "Off-chain metadata URI (pricing, docs, endpoint, logo). Padded to 128 bytes;",
+              "trailing NULs are trimmed when read. Mirrors `AgentProfile::agent_uri`."
+            ],
+            type: {
+              array: [
+                "u8",
+                128
+              ]
+            }
+          },
+          {
+            name: "category",
+            type: {
+              defined: {
+                name: "ServiceCategory"
+              }
+            }
+          },
+          {
+            name: "total_agents_served",
+            type: "u64"
+          },
+          {
+            name: "total_volume_received_usdc",
+            type: "u64"
+          },
+          {
+            name: "active",
+            type: "bool"
+          },
+          {
+            name: "first_active_slot",
+            type: "u64"
+          },
+          {
+            name: "last_active_slot",
+            type: "u64"
+          },
+          {
+            name: "bump",
+            type: "u8"
+          },
+          {
+            name: "_padding",
+            type: {
+              array: [
+                "u8",
+                64
+              ]
+            }
+          }
+        ]
+      }
+    }
+  ]
+};
+
+// src/idl/credit-vault.json
+var credit_vault_default = {
+  address: "EsykPsafhHUeN7jA9DGqBiGuBsTBaFynLDVVpE4jFXDg",
+  metadata: {
+    name: "credit_vault",
+    version: "0.1.0",
+    spec: "0.1.0",
+    description: "Agent Fuel \u2014 Budget-bound USDC spending vault for AI agents on Solana",
+    repository: "https://github.com/TODO/agent_fuel"
+  },
+  instructions: [
+    {
+      name: "approve_spend",
+      discriminator: [
+        248,
+        201,
+        151,
+        15,
+        28,
+        162,
+        112,
+        90
+      ],
+      accounts: [
+        {
+          name: "owner",
+          writable: true,
+          signer: true,
+          relations: [
+            "vault"
+          ]
+        },
+        {
+          name: "vault",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "owner"
+              },
+              {
+                kind: "account",
+                path: "vault.agent",
+                account: "CreditVault"
+              }
+            ]
+          }
+        },
+        {
+          name: "policy",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  112,
+                  111,
+                  108,
+                  105,
+                  99,
+                  121
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault"
+              }
+            ]
+          }
+        },
+        {
+          name: "pending_spend",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  112,
+                  101,
+                  110,
+                  100,
+                  105,
+                  110,
+                  103
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault"
+              },
+              {
+                kind: "account",
+                path: "pending_spend.nonce",
+                account: "PendingSpend"
+              }
+            ]
+          }
+        },
+        {
+          name: "vault_token_account",
+          writable: true
+        },
+        {
+          name: "service_token_account",
+          writable: true
+        },
+        {
+          name: "token_program",
+          address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
+        }
+      ],
+      args: []
+    },
+    {
+      name: "cancel_spend",
+      discriminator: [
+        122,
+        254,
+        101,
+        132,
+        241,
+        232,
+        205,
+        179
+      ],
+      accounts: [
+        {
+          name: "owner",
+          writable: true,
+          signer: true,
+          relations: [
+            "vault"
+          ]
+        },
+        {
+          name: "vault",
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "owner"
+              },
+              {
+                kind: "account",
+                path: "vault.agent",
+                account: "CreditVault"
+              }
+            ]
+          }
+        },
+        {
+          name: "pending_spend",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  112,
+                  101,
+                  110,
+                  100,
+                  105,
+                  110,
+                  103
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault"
+              },
+              {
+                kind: "account",
+                path: "pending_spend.nonce",
+                account: "PendingSpend"
+              }
+            ]
+          }
+        }
+      ],
+      args: []
+    },
+    {
+      name: "claim",
+      discriminator: [
+        62,
+        198,
+        214,
+        193,
+        213,
+        159,
+        108,
+        210
+      ],
+      accounts: [
+        {
+          name: "service",
+          signer: true
+        },
+        {
+          name: "vault",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault.owner",
+                account: "CreditVault"
+              },
+              {
+                kind: "account",
+                path: "vault.agent",
+                account: "CreditVault"
+              }
+            ]
+          }
+        },
+        {
+          name: "policy",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  112,
+                  111,
+                  108,
+                  105,
+                  99,
+                  121
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault"
+              }
+            ]
+          }
+        },
+        {
+          name: "vault_token_account",
+          writable: true
+        },
+        {
+          name: "service_token_account",
+          writable: true
+        },
+        {
+          name: "token_program",
+          address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
+        }
+      ],
+      args: [
+        {
+          name: "amount_usdc",
+          type: "u64"
+        }
+      ]
+    },
+    {
+      name: "create_vault",
+      discriminator: [
+        29,
+        237,
+        247,
+        208,
+        193,
+        82,
+        54,
+        135
+      ],
+      accounts: [
+        {
+          name: "owner",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "agent",
+          docs: [
+            "account need not exist on chain; we never read or write its data."
+          ]
+        },
+        {
+          name: "usdc_mint"
+        },
+        {
+          name: "vault",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "owner"
+              },
+              {
+                kind: "account",
+                path: "agent"
+              }
+            ]
+          }
+        },
+        {
+          name: "policy",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  112,
+                  111,
+                  108,
+                  105,
+                  99,
+                  121
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault"
+              }
+            ]
+          }
+        },
+        {
+          name: "vault_token_account",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "account",
+                path: "vault"
+              },
+              {
+                kind: "const",
+                value: [
+                  6,
+                  221,
+                  246,
+                  225,
+                  215,
+                  101,
+                  161,
+                  147,
+                  217,
+                  203,
+                  225,
+                  70,
+                  206,
+                  235,
+                  121,
+                  172,
+                  28,
+                  180,
+                  133,
+                  237,
+                  95,
+                  91,
+                  55,
+                  145,
+                  58,
+                  140,
+                  245,
+                  133,
+                  126,
+                  255,
+                  0,
+                  169
+                ]
+              },
+              {
+                kind: "account",
+                path: "usdc_mint"
+              }
+            ],
+            program: {
+              kind: "const",
+              value: [
+                140,
+                151,
+                37,
+                143,
+                78,
+                36,
+                137,
+                241,
+                187,
+                61,
+                16,
+                41,
+                20,
+                142,
+                13,
+                131,
+                11,
+                90,
+                19,
+                153,
+                218,
+                255,
+                16,
+                132,
+                4,
+                142,
+                123,
+                216,
+                219,
+                233,
+                248,
+                89
+              ]
+            }
+          }
+        },
+        {
+          name: "token_program",
+          address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
+        },
+        {
+          name: "associated_token_program",
+          address: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: [
+        {
+          name: "per_tx_limit_usdc",
+          type: "u64"
+        },
+        {
+          name: "hourly_limit_usdc",
+          type: "u64"
+        },
+        {
+          name: "lifetime_limit_usdc",
+          type: "u64"
+        },
+        {
+          name: "allow_post_pay",
+          type: "bool"
+        }
+      ]
+    },
+    {
+      name: "deposit",
+      discriminator: [
+        242,
+        35,
+        198,
+        137,
+        82,
+        225,
+        242,
+        182
+      ],
+      accounts: [
+        {
+          name: "owner",
+          writable: true,
+          signer: true,
+          relations: [
+            "vault"
+          ]
+        },
+        {
+          name: "vault",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault.owner",
+                account: "CreditVault"
+              },
+              {
+                kind: "account",
+                path: "vault.agent",
+                account: "CreditVault"
+              }
+            ]
+          }
+        },
+        {
+          name: "owner_token_account",
+          writable: true
+        },
+        {
+          name: "vault_token_account",
+          writable: true
+        },
+        {
+          name: "token_program",
+          address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
+        }
+      ],
+      args: [
+        {
+          name: "amount_usdc",
+          type: "u64"
+        }
+      ]
+    },
+    {
+      name: "freeze_vault",
+      discriminator: [
+        144,
+        211,
+        63,
+        236,
+        97,
+        31,
+        170,
+        175
+      ],
+      accounts: [
+        {
+          name: "owner",
+          signer: true,
+          relations: [
+            "vault"
+          ]
+        },
+        {
+          name: "vault",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault.owner",
+                account: "CreditVault"
+              },
+              {
+                kind: "account",
+                path: "vault.agent",
+                account: "CreditVault"
+              }
+            ]
+          }
+        }
+      ],
+      args: []
+    },
+    {
+      name: "request_spend",
+      discriminator: [
+        127,
+        12,
+        23,
+        75,
+        137,
+        178,
+        148,
+        71
+      ],
+      accounts: [
+        {
+          name: "agent",
+          writable: true,
+          signer: true,
+          relations: [
+            "vault"
+          ]
+        },
+        {
+          name: "vault",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault.owner",
+                account: "CreditVault"
+              },
+              {
+                kind: "account",
+                path: "vault.agent",
+                account: "CreditVault"
+              }
+            ]
+          }
+        },
+        {
+          name: "service_token_account",
+          docs: [
+            "The recipient token account. We only need it for its `owner` field",
+            "(the service pubkey we record in PendingSpend); mint constraint is",
+            "belt-and-suspenders since `approve_spend` re-checks both."
+          ]
+        },
+        {
+          name: "pending_spend",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  112,
+                  101,
+                  110,
+                  100,
+                  105,
+                  110,
+                  103
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault"
+              },
+              {
+                kind: "account",
+                path: "vault.pending_count",
+                account: "CreditVault"
+              }
+            ]
+          }
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: [
+        {
+          name: "amount_usdc",
+          type: "u64"
+        }
+      ]
+    },
+    {
+      name: "spend",
+      discriminator: [
+        242,
+        205,
+        255,
+        87,
+        101,
+        217,
+        245,
+        57
+      ],
+      accounts: [
+        {
+          name: "agent",
+          signer: true,
+          relations: [
+            "vault"
+          ]
+        },
+        {
+          name: "vault",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault.owner",
+                account: "CreditVault"
+              },
+              {
+                kind: "account",
+                path: "vault.agent",
+                account: "CreditVault"
+              }
+            ]
+          }
+        },
+        {
+          name: "policy",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  112,
+                  111,
+                  108,
+                  105,
+                  99,
+                  121
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault"
+              }
+            ]
+          }
+        },
+        {
+          name: "vault_token_account",
+          writable: true
+        },
+        {
+          name: "service_token_account",
+          writable: true
+        },
+        {
+          name: "token_program",
+          address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
+        }
+      ],
+      args: [
+        {
+          name: "amount_usdc",
+          type: "u64"
+        }
+      ]
+    },
+    {
+      name: "unfreeze_vault",
+      discriminator: [
+        145,
+        244,
+        206,
+        234,
+        251,
+        250,
+        116,
+        183
+      ],
+      accounts: [
+        {
+          name: "owner",
+          signer: true,
+          relations: [
+            "vault"
+          ]
+        },
+        {
+          name: "vault",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault.owner",
+                account: "CreditVault"
+              },
+              {
+                kind: "account",
+                path: "vault.agent",
+                account: "CreditVault"
+              }
+            ]
+          }
+        }
+      ],
+      args: []
+    },
+    {
+      name: "update_policy",
+      discriminator: [
+        212,
+        245,
+        246,
+        7,
+        163,
+        151,
+        18,
+        57
+      ],
+      accounts: [
+        {
+          name: "owner",
+          signer: true,
+          relations: [
+            "vault"
+          ]
+        },
+        {
+          name: "vault",
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault.owner",
+                account: "CreditVault"
+              },
+              {
+                kind: "account",
+                path: "vault.agent",
+                account: "CreditVault"
+              }
+            ]
+          }
+        },
+        {
+          name: "policy",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  112,
+                  111,
+                  108,
+                  105,
+                  99,
+                  121
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault"
+              }
+            ]
+          }
+        }
+      ],
+      args: [
+        {
+          name: "new_per_tx_limit_usdc",
+          type: "u64"
+        },
+        {
+          name: "new_hourly_limit_usdc",
+          type: "u64"
+        },
+        {
+          name: "new_lifetime_limit_usdc",
+          type: "u64"
+        },
+        {
+          name: "new_allow_post_pay",
+          type: "bool"
+        },
+        {
+          name: "new_whitelist",
+          type: {
+            array: [
+              "pubkey",
+              8
+            ]
+          }
+        }
+      ]
+    },
+    {
+      name: "withdraw",
+      discriminator: [
+        183,
+        18,
+        70,
+        156,
+        148,
+        109,
+        161,
+        34
+      ],
+      accounts: [
+        {
+          name: "owner",
+          writable: true,
+          signer: true,
+          relations: [
+            "vault"
+          ]
+        },
+        {
+          name: "vault",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault.owner",
+                account: "CreditVault"
+              },
+              {
+                kind: "account",
+                path: "vault.agent",
+                account: "CreditVault"
+              }
+            ]
+          }
+        },
+        {
+          name: "vault_token_account",
+          writable: true
+        },
+        {
+          name: "owner_token_account",
+          writable: true
+        },
+        {
+          name: "token_program",
+          address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
+        }
+      ],
+      args: [
+        {
+          name: "amount_usdc",
+          type: "u64"
+        }
+      ]
+    }
+  ],
+  accounts: [
+    {
+      name: "CreditVault",
+      discriminator: [
+        143,
+        180,
+        135,
+        248,
+        84,
+        85,
+        183,
+        70
+      ]
+    },
+    {
+      name: "PendingSpend",
+      discriminator: [
+        193,
+        205,
+        85,
+        66,
+        25,
+        3,
+        67,
+        134
+      ]
+    },
+    {
+      name: "SpendPolicy",
+      discriminator: [
+        139,
+        90,
+        209,
+        31,
+        205,
+        15,
+        68,
+        243
+      ]
+    }
+  ],
+  events: [
+    {
+      name: "Claimed",
+      discriminator: [
+        217,
+        192,
+        123,
+        72,
+        108,
+        150,
+        248,
+        33
+      ]
+    },
+    {
+      name: "Deposited",
+      discriminator: [
+        111,
+        141,
+        26,
+        45,
+        161,
+        35,
+        100,
+        57
+      ]
+    },
+    {
+      name: "PolicyUpdated",
+      discriminator: [
+        225,
+        112,
+        112,
+        67,
+        95,
+        236,
+        245,
+        161
+      ]
+    },
+    {
+      name: "SpendRejected",
+      discriminator: [
+        22,
+        233,
+        208,
+        109,
+        202,
+        231,
+        175,
+        22
+      ]
+    },
+    {
+      name: "SpendRequested",
+      discriminator: [
+        144,
+        207,
+        254,
+        247,
+        81,
+        146,
+        84,
+        87
+      ]
+    },
+    {
+      name: "Spent",
+      discriminator: [
+        43,
+        51,
+        164,
+        100,
+        191,
+        244,
+        174,
+        98
+      ]
+    },
+    {
+      name: "VaultCreated",
+      discriminator: [
+        117,
+        25,
+        120,
+        254,
+        75,
+        236,
+        78,
+        115
+      ]
+    },
+    {
+      name: "VaultFrozen",
+      discriminator: [
+        13,
+        199,
+        172,
+        111,
+        88,
+        10,
+        151,
+        247
+      ]
+    },
+    {
+      name: "VaultUnfrozen",
+      discriminator: [
+        128,
+        194,
+        79,
+        155,
+        85,
+        31,
+        226,
+        170
+      ]
+    },
+    {
+      name: "Withdrawn",
+      discriminator: [
+        20,
+        89,
+        223,
+        198,
+        194,
+        124,
+        219,
+        13
+      ]
+    }
+  ],
+  errors: [
+    {
+      code: 6e3,
+      name: "Overflow",
+      msg: "Counter or amount overflow"
+    },
+    {
+      code: 6001,
+      name: "ZeroAmount",
+      msg: "Amount must be greater than zero"
+    },
+    {
+      code: 6002,
+      name: "Frozen",
+      msg: "Vault is frozen"
+    },
+    {
+      code: 6003,
+      name: "NotWhitelisted",
+      msg: "Service is not on the vault's whitelist"
+    },
+    {
+      code: 6004,
+      name: "PerTxLimitExceeded",
+      msg: "Amount exceeds the per-transaction limit"
+    },
+    {
+      code: 6005,
+      name: "HourlyLimitExceeded",
+      msg: "Amount exceeds the hourly rolling-window limit"
+    },
+    {
+      code: 6006,
+      name: "LifetimeLimitExceeded",
+      msg: "Amount would exceed the lifetime spend ceiling"
+    },
+    {
+      code: 6007,
+      name: "AlreadyFrozen",
+      msg: "Vault is already frozen"
+    },
+    {
+      code: 6008,
+      name: "NotFrozen",
+      msg: "Vault is not frozen"
+    },
+    {
+      code: 6009,
+      name: "PostPayDisabled",
+      msg: "Post-pay claims are disabled for this vault"
+    },
+    {
+      code: 6010,
+      name: "PendingSpendVaultMismatch",
+      msg: "Pending spend belongs to a different vault"
+    },
+    {
+      code: 6011,
+      name: "PendingNonceOverflow",
+      msg: "Pending spend counter would overflow"
+    }
+  ],
+  types: [
+    {
+      name: "Claimed",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "vault",
+            type: "pubkey"
+          },
+          {
+            name: "service",
+            type: "pubkey"
+          },
+          {
+            name: "amount_usdc",
+            type: "u64"
+          },
+          {
+            name: "new_total_spent",
+            type: "u64"
+          },
+          {
+            name: "new_total_claimed",
+            type: "u64"
+          },
+          {
+            name: "slot",
+            type: "u64"
+          }
+        ]
+      }
+    },
+    {
+      name: "CreditVault",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "owner",
+            type: "pubkey"
+          },
+          {
+            name: "agent",
+            type: "pubkey"
+          },
+          {
+            name: "usdc_mint",
+            type: "pubkey"
+          },
+          {
+            name: "vault_token_account",
+            type: "pubkey"
+          },
+          {
+            name: "total_deposited",
+            type: "u64"
+          },
+          {
+            name: "total_withdrawn",
+            type: "u64"
+          },
+          {
+            name: "total_spent",
+            type: "u64"
+          },
+          {
+            name: "total_claimed",
+            type: "u64"
+          },
+          {
+            name: "frozen",
+            type: "bool"
+          },
+          {
+            name: "created_slot",
+            type: "u64"
+          },
+          {
+            name: "last_active_slot",
+            type: "u64"
+          },
+          {
+            name: "bump",
+            type: "u8"
+          },
+          {
+            name: "pending_count",
+            docs: [
+              "Monotonic counter used as a PDA seed for PendingSpend accounts so",
+              "every approval request gets a unique deterministic address.",
+              "Borrowed 8 bytes from the original 64-byte padding so the account",
+              "size stays at `ACCOUNT_SIZE` and existing vaults need no migration."
+            ],
+            type: "u64"
+          },
+          {
+            name: "_padding",
+            type: {
+              array: [
+                "u8",
+                56
+              ]
+            }
+          }
+        ]
+      }
+    },
+    {
+      name: "Deposited",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "vault",
+            type: "pubkey"
+          },
+          {
+            name: "owner",
+            type: "pubkey"
+          },
+          {
+            name: "amount_usdc",
+            type: "u64"
+          },
+          {
+            name: "new_total_deposited",
+            type: "u64"
+          },
+          {
+            name: "slot",
+            type: "u64"
+          }
+        ]
+      }
+    },
+    {
+      name: "PendingSpend",
+      docs: [
+        "A spend request that exceeded one of the policy's rate limits. The agent",
+        "creates this account by calling `request_spend`; the owner reviews from",
+        "the mobile Alerts tab and either calls `approve_spend` (PDA-signed CPI",
+        "transfer, account closed) or `cancel_spend` (account closed, no transfer).",
+        "",
+        'Seeded by `["pending", vault, nonce_le]` where `nonce` is the value of',
+        "`vault.pending_count` at request time, so each request has a unique",
+        "deterministic address that both the agent and the owner can derive."
+      ],
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "vault",
+            type: "pubkey"
+          },
+          {
+            name: "agent",
+            type: "pubkey"
+          },
+          {
+            name: "service",
+            docs: [
+              "Owner of the destination token account (mirrors how `Spent` records",
+              "service: `service_token_account.owner`)."
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "amount_usdc",
+            type: "u64"
+          },
+          {
+            name: "requested_slot",
+            type: "u64"
+          },
+          {
+            name: "nonce",
+            type: "u64"
+          },
+          {
+            name: "bump",
+            type: "u8"
+          },
+          {
+            name: "_padding",
+            type: {
+              array: [
+                "u8",
+                31
+              ]
+            }
+          }
+        ]
+      }
+    },
+    {
+      name: "PolicyUpdated",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "vault",
+            type: "pubkey"
+          },
+          {
+            name: "owner",
+            type: "pubkey"
+          },
+          {
+            name: "per_tx_limit_usdc",
+            type: "u64"
+          },
+          {
+            name: "hourly_limit_usdc",
+            type: "u64"
+          },
+          {
+            name: "lifetime_limit_usdc",
+            type: "u64"
+          },
+          {
+            name: "allow_post_pay",
+            type: "bool"
+          },
+          {
+            name: "whitelist",
+            type: {
+              array: [
+                "pubkey",
+                8
+              ]
+            }
+          },
+          {
+            name: "slot",
+            type: "u64"
+          }
+        ]
+      }
+    },
+    {
+      name: "SpendPolicy",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "vault",
+            type: "pubkey"
+          },
+          {
+            name: "whitelist",
+            type: {
+              array: [
+                "pubkey",
+                8
+              ]
+            }
+          },
+          {
+            name: "per_tx_limit_usdc",
+            type: "u64"
+          },
+          {
+            name: "hourly_limit_usdc",
+            type: "u64"
+          },
+          {
+            name: "lifetime_limit_usdc",
+            type: "u64"
+          },
+          {
+            name: "hourly_window_start_slot",
+            type: "u64"
+          },
+          {
+            name: "hourly_window_spent_usdc",
+            type: "u64"
+          },
+          {
+            name: "allow_post_pay",
+            type: "bool"
+          },
+          {
+            name: "bump",
+            type: "u8"
+          },
+          {
+            name: "_padding",
+            type: {
+              array: [
+                "u8",
+                64
+              ]
+            }
+          }
+        ]
+      }
+    },
+    {
+      name: "SpendRejected",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "vault",
+            type: "pubkey"
+          },
+          {
+            name: "owner",
+            type: "pubkey"
+          },
+          {
+            name: "pending_spend",
+            type: "pubkey"
+          },
+          {
+            name: "nonce",
+            type: "u64"
+          },
+          {
+            name: "slot",
+            type: "u64"
+          }
+        ]
+      }
+    },
+    {
+      name: "SpendRequested",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "vault",
+            type: "pubkey"
+          },
+          {
+            name: "agent",
+            type: "pubkey"
+          },
+          {
+            name: "service",
+            type: "pubkey"
+          },
+          {
+            name: "pending_spend",
+            type: "pubkey"
+          },
+          {
+            name: "amount_usdc",
+            type: "u64"
+          },
+          {
+            name: "nonce",
+            type: "u64"
+          },
+          {
+            name: "slot",
+            type: "u64"
+          }
+        ]
+      }
+    },
+    {
+      name: "Spent",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "vault",
+            type: "pubkey"
+          },
+          {
+            name: "agent",
+            type: "pubkey"
+          },
+          {
+            name: "service",
+            type: "pubkey"
+          },
+          {
+            name: "amount_usdc",
+            type: "u64"
+          },
+          {
+            name: "new_total_spent",
+            type: "u64"
+          },
+          {
+            name: "slot",
+            type: "u64"
+          }
+        ]
+      }
+    },
+    {
+      name: "VaultCreated",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "vault",
+            type: "pubkey"
+          },
+          {
+            name: "owner",
+            type: "pubkey"
+          },
+          {
+            name: "agent",
+            type: "pubkey"
+          },
+          {
+            name: "usdc_mint",
+            type: "pubkey"
+          },
+          {
+            name: "vault_token_account",
+            type: "pubkey"
+          },
+          {
+            name: "slot",
+            type: "u64"
+          }
+        ]
+      }
+    },
+    {
+      name: "VaultFrozen",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "vault",
+            type: "pubkey"
+          },
+          {
+            name: "owner",
+            type: "pubkey"
+          },
+          {
+            name: "slot",
+            type: "u64"
+          }
+        ]
+      }
+    },
+    {
+      name: "VaultUnfrozen",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "vault",
+            type: "pubkey"
+          },
+          {
+            name: "owner",
+            type: "pubkey"
+          },
+          {
+            name: "slot",
+            type: "u64"
+          }
+        ]
+      }
+    },
+    {
+      name: "Withdrawn",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "vault",
+            type: "pubkey"
+          },
+          {
+            name: "owner",
+            type: "pubkey"
+          },
+          {
+            name: "amount_usdc",
+            type: "u64"
+          },
+          {
+            name: "new_total_withdrawn",
+            type: "u64"
+          },
+          {
+            name: "slot",
+            type: "u64"
+          }
+        ]
+      }
+    }
+  ]
+};
+
+// src/program-ids.ts
+var PROGRAM_IDS = {
+  reputation: new web3_js.PublicKey(reputation_default.address),
+  creditVault: new web3_js.PublicKey(credit_vault_default.address)
+};
+
+// src/pda.ts
+function toPubkey(value) {
+  return value instanceof web3_js.PublicKey ? value : new web3_js.PublicKey(value);
+}
+function vaultPda(owner, agent) {
+  const [pda] = web3_js.PublicKey.findProgramAddressSync(
+    [Buffer.from("vault"), toPubkey(owner).toBuffer(), toPubkey(agent).toBuffer()],
+    PROGRAM_IDS.creditVault
+  );
+  return pda;
+}
+function policyPda(vault) {
+  const [pda] = web3_js.PublicKey.findProgramAddressSync(
+    [Buffer.from("policy"), toPubkey(vault).toBuffer()],
+    PROGRAM_IDS.creditVault
+  );
+  return pda;
+}
+function serviceRegistryPda(serviceAuthority) {
+  const [pda] = web3_js.PublicKey.findProgramAddressSync(
+    [Buffer.from("service"), toPubkey(serviceAuthority).toBuffer()],
+    PROGRAM_IDS.reputation
+  );
+  return pda;
+}
+function agentProfilePda(agent) {
+  const [pda] = web3_js.PublicKey.findProgramAddressSync(
+    [Buffer.from("agent"), toPubkey(agent).toBuffer()],
+    PROGRAM_IDS.reputation
+  );
+  return pda;
+}
+function agentServiceLinkPda(agentProfile, serviceRegistry) {
+  const [pda] = web3_js.PublicKey.findProgramAddressSync(
+    [
+      Buffer.from("link"),
+      toPubkey(agentProfile).toBuffer(),
+      toPubkey(serviceRegistry).toBuffer()
+    ],
+    PROGRAM_IDS.reputation
+  );
+  return pda;
+}
+function pendingSpendPda(vault, nonce) {
+  const nonceBuf = Buffer.alloc(8);
+  nonceBuf.writeBigUInt64LE(typeof nonce === "bigint" ? nonce : BigInt(nonce));
+  const [pda] = web3_js.PublicKey.findProgramAddressSync(
+    [Buffer.from("pending"), toPubkey(vault).toBuffer(), nonceBuf],
+    PROGRAM_IDS.creditVault
+  );
+  return pda;
+}
+function receiptUsedPda(receiptHash) {
+  if (receiptHash.length !== 32) {
+    throw new Error(`receiptUsedPda expects a 32-byte hash, got ${receiptHash.length}`);
+  }
+  const [pda] = web3_js.PublicKey.findProgramAddressSync(
+    [Buffer.from("receipt"), Buffer.from(receiptHash)],
+    PROGRAM_IDS.reputation
+  );
+  return pda;
+}
+function buildProvider(connection, keypair) {
+  return new anchor.AnchorProvider(connection, new anchor.Wallet(keypair), anchor.AnchorProvider.defaultOptions());
+}
+function creditVaultProgram(provider) {
+  return new anchor.Program(credit_vault_default, provider);
+}
+function reputationProgram(provider) {
+  return new anchor.Program(reputation_default, provider);
+}
+
+// src/pay.ts
+async function pay(args) {
+  const { agent, service, connection, amountUsdc } = args;
+  const owner = toPubkey(args.owner);
+  if (amountUsdc <= 0) {
+    throw new ZeroAmountError();
+  }
+  if (args.receiptHash.length !== 32) {
+    throw new Error(
+      `pay: receiptHash must be 32 bytes, got ${args.receiptHash.length}`
+    );
+  }
+  const vaultAddr = vaultPda(owner, agent.publicKey);
+  const policyAddr = policyPda(vaultAddr);
+  const provider = buildProvider(connection, agent);
+  const cv = creditVaultProgram(provider);
+  const rep = reputationProgram(provider);
+  const [rawVault, rawPolicy, currentSlot] = await Promise.all([
+    cv.account.creditVault.fetchNullable(vaultAddr),
+    cv.account.spendPolicy.fetchNullable(policyAddr),
+    connection.getSlot()
+  ]);
+  if (!rawVault) throw new AccountNotFoundError(vaultAddr.toBase58());
+  if (!rawPolicy) throw new AccountNotFoundError(policyAddr.toBase58());
+  const vault = decodeCreditVault(vaultAddr, rawVault);
+  const policy = decodeSpendPolicy(policyAddr, rawPolicy);
+  guardSpend({
+    vault,
+    policy,
+    service: service.publicKey,
+    amountUsdc,
+    currentSlot
+  });
+  const serviceTokenAccount = getAssociatedTokenAddress(
+    vault.usdc_mint,
+    service.publicKey
+  );
+  const createAtaIx = createAssociatedTokenAccountIdempotentInstruction(
+    agent.publicKey,
+    serviceTokenAccount,
+    service.publicKey,
+    vault.usdc_mint
+  );
+  const agentProfile = agentProfilePda(agent.publicKey);
+  const serviceRegistry = serviceRegistryPda(service.publicKey);
+  const link = agentServiceLinkPda(agentProfile, serviceRegistry);
+  const receipt = receiptUsedPda(args.receiptHash);
+  const spendBuilder = cv.methods.spend(new anchor.BN(amountUsdc)).accounts({
+    agent: agent.publicKey,
+    vault: vaultAddr,
+    policy: policyAddr,
+    vaultTokenAccount: vault.vault_token_account,
+    serviceTokenAccount,
+    tokenProgram: TOKEN_PROGRAM_ID
+  });
+  const recordBuilder = rep.methods.recordPayment(new anchor.BN(amountUsdc), args.receiptHash).accounts({
+    service: service.publicKey,
+    agentProfile,
+    serviceRegistry,
+    agentServiceLink: link,
+    receiptUsed: receipt,
+    systemProgram: web3_js.SystemProgram.programId
+  });
+  const spendIx = await spendBuilder.instruction();
+  const recordIx = await recordBuilder.instruction();
+  const tx = new web3_js.Transaction().add(createAtaIx, spendIx, recordIx);
+  try {
+    const signature = await web3_js.sendAndConfirmTransaction(
+      connection,
+      tx,
+      [agent, service],
+      { commitment: "confirmed" }
+    );
+    return { signature };
+  } catch (err) {
+    throw mapPayError(err, {
+      service: service.publicKey,
+      amountUsdc,
+      vault,
+      policy,
+      receiptHash: args.receiptHash
+    });
+  }
+}
+function mapPayError(err, ctx) {
+  const message = err instanceof Error ? err.message : String(err);
+  if (/already in use/i.test(message)) {
+    return new ReceiptAlreadyRecordedError(ctx.receiptHash);
+  }
+  if (!(err instanceof anchor.AnchorError)) return err;
+  switch (err.error.errorCode.number) {
+    case 6001:
+      return new ZeroAmountError();
+    case 6002:
+      return new VaultFrozenError();
+    case 6003:
+      return new NotWhitelistedError(ctx.service.toBase58());
+    case 6004:
+      return new PerTxLimitExceededError(ctx.amountUsdc, ctx.policy.per_tx_limit_usdc);
+    case 6005:
+      return new HourlyLimitExceededError(
+        ctx.amountUsdc,
+        ctx.policy.hourly_window_spent_usdc,
+        ctx.policy.hourly_limit_usdc
+      );
+    case 6006:
+      return new LifetimeLimitExceededError(
+        ctx.amountUsdc,
+        ctx.vault.total_spent,
+        ctx.policy.lifetime_limit_usdc
+      );
+    // Reputation errors:
+    case 6e3:
+      return new RecordPaymentError("counter overflow on chain");
+    case 6011:
+      return new ServiceInactiveError(ctx.service.toBase58());
+    default:
+      return err;
+  }
+}
+async function requestSpend(args) {
+  const { agent, connection, amountUsdc } = args;
+  const owner = toPubkey(args.owner);
+  const service = toPubkey(args.service);
+  if (amountUsdc <= 0) {
+    throw new Error("requestSpend: amountUsdc must be > 0");
+  }
+  const vaultAddr = vaultPda(owner, agent.publicKey);
+  const provider = buildProvider(connection, agent);
+  const cv = creditVaultProgram(provider);
+  const rawVault = await cv.account.creditVault.fetchNullable(vaultAddr);
+  if (!rawVault) throw new AccountNotFoundError(vaultAddr.toBase58());
+  const vault = decodeCreditVault(vaultAddr, rawVault);
+  const nonce = vault.pending_count;
+  const pendingSpend = pendingSpendPda(vaultAddr, nonce);
+  const serviceTokenAccount = getAssociatedTokenAddress(
+    vault.usdc_mint,
+    service
+  );
+  const signature = await cv.methods.requestSpend(new anchor.BN(amountUsdc)).accounts({
+    agent: agent.publicKey,
+    vault: vaultAddr,
+    serviceTokenAccount,
+    pendingSpend,
+    systemProgram: web3_js.SystemProgram.programId
+  }).signers([agent]).rpc();
+  return { signature, pendingSpend, nonce };
+}
+var NAME_BYTES = 32;
+var URI_BYTES = 128;
+async function registerService(args) {
+  const { sponsor, service, connection } = args;
+  if (args.name.length === 0) {
+    throw new Error("registerService: name must not be empty");
+  }
+  if (Buffer.byteLength(args.name, "utf8") > NAME_BYTES) {
+    throw new Error(
+      `registerService: name exceeds ${NAME_BYTES} bytes (got ${Buffer.byteLength(args.name, "utf8")})`
+    );
+  }
+  const uri = args.serviceUri ?? "";
+  if (Buffer.byteLength(uri, "utf8") > URI_BYTES) {
+    throw new Error(
+      `registerService: serviceUri exceeds ${URI_BYTES} bytes (got ${Buffer.byteLength(uri, "utf8")})`
+    );
+  }
+  const registry = serviceRegistryPda(service.publicKey);
+  const provider = buildProvider(connection, sponsor);
+  const rep = reputationProgram(provider);
+  const signature = await rep.methods.registerService(
+    packFixed(args.name, NAME_BYTES),
+    categoryArg(args.category),
+    packFixed(uri, URI_BYTES)
+  ).accounts({
+    sponsor: sponsor.publicKey,
+    service: service.publicKey,
+    serviceRegistry: registry,
+    systemProgram: web3_js.SystemProgram.programId
+  }).signers([sponsor, service]).rpc();
+  return { signature };
+}
+function packFixed(s, length) {
+  const buf = Buffer.alloc(length);
+  buf.write(s, 0, "utf8");
+  return Array.from(buf);
+}
+function categoryArg(c) {
+  switch (c) {
+    case "DataFeed":
+      return { dataFeed: {} };
+    case "Compute":
+      return { compute: {} };
+    case "Swap":
+      return { swap: {} };
+    case "Rpc":
+      return { rpc: {} };
+    case "Other":
+      return { other: {} };
+  }
+}
+
+// src/client.ts
+var DEFAULT_API_BASE = "http://localhost:8080";
+var AgentFuel = class {
+  agent;
+  cluster;
+  connection;
+  apiBase;
+  owner;
+  _creditVault;
+  _reputation;
+  constructor(opts) {
+    this.agent = opts.agent;
+    this.cluster = opts.cluster;
+    this.connection = typeof opts.rpc === "string" ? new web3_js.Connection(opts.rpc, "confirmed") : opts.rpc;
+    this.apiBase = opts.apiBase ?? DEFAULT_API_BASE;
+    this.owner = opts.owner ? toPubkey(opts.owner) : void 0;
+  }
+  get agentPubkey() {
+    return this.agent.publicKey;
+  }
+  get creditVault() {
+    if (!this._creditVault) {
+      this._creditVault = creditVaultProgram(buildProvider(this.connection, this.agent));
+    }
+    return this._creditVault;
+  }
+  get reputation() {
+    if (!this._reputation) {
+      this._reputation = reputationProgram(buildProvider(this.connection, this.agent));
+    }
+    return this._reputation;
+  }
+  resolveOwner(override) {
+    const value = override ?? this.owner;
+    if (!value) throw new OwnerNotConfiguredError();
+    return toPubkey(value);
+  }
+  async getScore(agent) {
+    const target = agent ? toPubkey(agent) : this.agentPubkey;
+    const agentStr = target.toBase58();
+    const url = `${this.apiBase.replace(/\/$/, "")}/reputation/${agentStr}`;
+    const res = await fetch(url);
+    if (res.status === 404) throw new AccountNotFoundError(agentStr);
+    if (!res.ok) throw new HttpError(res.status, url, await safeText(res));
+    return await res.json();
+  }
+  async getVaultBalance(ref) {
+    const owner = this.resolveOwner(ref?.owner);
+    const agent = ref?.agent ? toPubkey(ref.agent) : this.agentPubkey;
+    const pda = vaultPda(owner, agent);
+    const raw = await this.creditVault.account.creditVault.fetchNullable(pda);
+    if (!raw) throw new AccountNotFoundError(pda.toBase58());
+    return decodeCreditVault(pda, raw);
+  }
+  async getPolicy(ref) {
+    const owner = this.resolveOwner(ref?.owner);
+    const agent = ref?.agent ? toPubkey(ref.agent) : this.agentPubkey;
+    const vault = vaultPda(owner, agent);
+    const pda = policyPda(vault);
+    const raw = await this.creditVault.account.spendPolicy.fetchNullable(pda);
+    if (!raw) throw new AccountNotFoundError(pda.toBase58());
+    return decodeSpendPolicy(pda, raw);
+  }
+  async checkService(serviceAuthority) {
+    const pda = serviceRegistryPda(serviceAuthority);
+    const raw = await this.reputation.account.serviceRegistry.fetchNullable(pda);
+    if (!raw) throw new AccountNotFoundError(pda.toBase58());
+    return decodeServiceRegistry(pda, raw);
+  }
+  async spend(args) {
+    const owner = this.resolveOwner(args.owner);
+    const service = toPubkey(args.service);
+    const amountUsdc = args.amountUsdc;
+    const vault = await this.getVaultBalance({ owner, agent: this.agentPubkey });
+    const policy = await this.getPolicy({ owner, agent: this.agentPubkey });
+    const currentSlot = await this.connection.getSlot();
+    guardSpend({ vault, policy, service, amountUsdc, currentSlot });
+    const serviceTokenAccount = getAssociatedTokenAddress(vault.usdc_mint, service);
+    const createAtaIx = createAssociatedTokenAccountIdempotentInstruction(
+      this.agentPubkey,
+      serviceTokenAccount,
+      service,
+      vault.usdc_mint
+    );
+    try {
+      const signature = await this.creditVault.methods.spend(new anchor.BN(amountUsdc)).accounts({
+        agent: this.agentPubkey,
+        vault: vault.pubkey,
+        policy: policy.pubkey,
+        vaultTokenAccount: vault.vault_token_account,
+        serviceTokenAccount,
+        tokenProgram: TOKEN_PROGRAM_ID
+      }).preInstructions([createAtaIx]).signers([this.agent]).rpc();
+      return { signature };
+    } catch (err) {
+      throw mapSpendError(err, { service, amountUsdc, vault, policy });
+    }
+  }
+  /// Atomic spend + record_payment in one transaction. Use this instead
+  /// of `spend()` + `recordPayment()` when you want the vault burn and
+  /// the reputation accrual to be all-or-nothing. The service keypair
+  /// co-signs.
+  async pay(args) {
+    return pay({
+      agent: this.agent,
+      owner: this.resolveOwner(args.owner),
+      service: args.service,
+      amountUsdc: args.amountUsdc,
+      receiptHash: args.receiptHash,
+      connection: this.connection
+    });
+  }
+  /// Submit an over-limit spend request the owner can approve from the
+  /// mobile app. Returns the `pendingSpend` PDA so the bot can poll for
+  /// resolution.
+  async requestSpend(args) {
+    return requestSpend({
+      agent: this.agent,
+      owner: this.resolveOwner(args.owner),
+      service: args.service,
+      amountUsdc: args.amountUsdc,
+      connection: this.connection
+    });
+  }
+  /// Register a service on chain. The `sponsor` (typically `this.agent`'s
+  /// owner wallet) pays rent; the `service` keypair is the long-lived
+  /// identity that will co-sign every future `record_payment`.
+  async registerService(args) {
+    return registerService({ ...args, connection: this.connection });
+  }
+  /// Triggers an on-chain recomputation of the agent's reputation score.
+  /// Permissionless — any signer can call it; we use the agent itself since
+  /// the SDK already has its keypair available and it already pays tx fees
+  /// for spends. The instruction reads the agent's already-public counters
+  /// (volume, diversity, streak, tenure, feedback), recalculates the score
+  /// to a single u16 ≤ 1000, and emits a `ScoreComputed` event. The webhook
+  /// picks that up; the next `getScore()` returns the fresh value.
+  async computeScore() {
+    const profile = agentProfilePda(this.agentPubkey);
+    const signature = await this.reputation.methods.computeScore().accounts({
+      caller: this.agentPubkey,
+      agentProfile: profile
+    }).signers([this.agent]).rpc();
+    return { signature };
+  }
+  onEvent(callback, options) {
+    const target = options?.agent ? toPubkey(options.agent) : this.agentPubkey;
+    const url = wsUrl(this.apiBase, `/ws/agents/${target.toBase58()}`);
+    const subOpts = {
+      onFrame: callback
+    };
+    if (options?.onStatus) subOpts.onStatus = options.onStatus;
+    return subscribe(url, subOpts);
+  }
+};
+function mapSpendError(err, ctx) {
+  if (!(err instanceof anchor.AnchorError)) return err;
+  switch (err.error.errorCode.number) {
+    case 6001:
+      return new ZeroAmountError();
+    case 6002:
+      return new VaultFrozenError();
+    case 6003:
+      return new NotWhitelistedError(ctx.service.toBase58());
+    case 6004:
+      return new PerTxLimitExceededError(ctx.amountUsdc, ctx.policy.per_tx_limit_usdc);
+    case 6005:
+      return new HourlyLimitExceededError(
+        ctx.amountUsdc,
+        ctx.policy.hourly_window_spent_usdc,
+        ctx.policy.hourly_limit_usdc
+      );
+    case 6006:
+      return new LifetimeLimitExceededError(
+        ctx.amountUsdc,
+        ctx.vault.total_spent,
+        ctx.policy.lifetime_limit_usdc
+      );
+    default:
+      return err;
+  }
+}
+async function safeText(res) {
+  try {
+    return await res.text();
+  } catch {
+    return void 0;
+  }
+}
+
+// src/cli.ts
+var VERSION = "0.3.0";
+var RPC_DEFAULTS = {
+  "mainnet-beta": "https://api.mainnet-beta.solana.com",
+  devnet: "https://api.devnet.solana.com",
+  testnet: "https://api.testnet.solana.com",
+  localnet: "http://127.0.0.1:8899"
+};
+var DEFAULT_API_BASE2 = "https://api.agentfuel.online";
+function readGlobalOpts(cmd) {
+  const root = rootOf(cmd);
+  const o = root.opts();
+  const g = {
+    cluster: o.cluster,
+    apiBase: o.apiBase ?? DEFAULT_API_BASE2,
+    json: o.json ?? false
+  };
+  if (o.rpc !== void 0) g.rpc = o.rpc;
+  return g;
+}
+function rootOf(cmd) {
+  let cur = cmd;
+  while (cur.parent) cur = cur.parent;
+  return cur;
+}
+function connectionFor(g) {
+  return new web3_js.Connection(g.rpc ?? RPC_DEFAULTS[g.cluster], "confirmed");
+}
+function loadKeypair(path) {
+  let raw;
+  try {
+    raw = fs.readFileSync(path, "utf8");
+  } catch (e) {
+    throw new Error(`could not read keypair file '${path}': ${errMsg(e)}`);
+  }
+  let bytes;
+  try {
+    bytes = JSON.parse(raw);
+  } catch (e) {
+    throw new Error(
+      `keypair file '${path}' is not valid JSON (expected a 64-byte array, the same format \`solana-keygen new\` writes): ${errMsg(e)}`
+    );
+  }
+  if (!Array.isArray(bytes) || bytes.length !== 64) {
+    throw new Error(
+      `keypair file '${path}' must contain a JSON array of exactly 64 bytes (got ${Array.isArray(bytes) ? `${bytes.length}` : typeof bytes})`
+    );
+  }
+  return web3_js.Keypair.fromSecretKey(Uint8Array.from(bytes));
+}
+function parsePubkey(s, label) {
+  try {
+    return new web3_js.PublicKey(s);
+  } catch {
+    throw new Error(`${label} is not a valid base58 pubkey: ${s}`);
+  }
+}
+function parseAmountToMicro(s) {
+  const n = Number(s);
+  if (!Number.isFinite(n) || n <= 0) {
+    throw new Error(`--amount must be a positive number (USDC), got '${s}'`);
+  }
+  const micro2 = Math.round(n * 1e6);
+  if (micro2 <= 0) throw new Error(`--amount too small: ${s}`);
+  return micro2;
+}
+function parseCategory(s) {
+  const lower = s.toLowerCase();
+  switch (lower) {
+    case "datafeed":
+    case "data-feed":
+      return "DataFeed";
+    case "compute":
+      return "Compute";
+    case "swap":
+      return "Swap";
+    case "rpc":
+      return "Rpc";
+    case "other":
+      return "Other";
+    default:
+      throw new Error(
+        `--category must be one of: DataFeed, Compute, Swap, Rpc, Other (got '${s}')`
+      );
+  }
+}
+function parseReceiptHash(s) {
+  if (!s) return crypto.randomBytes(32);
+  const hex = s.startsWith("0x") ? s.slice(2) : s;
+  if (hex.length !== 64 || !/^[0-9a-fA-F]+$/.test(hex)) {
+    throw new Error(
+      `--receipt-hash must be 32 bytes hex (64 hex chars, with or without 0x prefix)`
+    );
+  }
+  return Uint8Array.from(Buffer.from(hex, "hex"));
+}
+function readOnlyFuel(g) {
+  return new AgentFuel({
+    agent: web3_js.Keypair.generate(),
+    cluster: g.cluster,
+    rpc: connectionFor(g),
+    apiBase: g.apiBase
+  });
+}
+function emit(g, human, data) {
+  if (g.json) {
+    process.stdout.write(JSON.stringify(data, jsonReplacer, 2) + "\n");
+  } else {
+    process.stdout.write(human() + "\n");
+  }
+}
+function jsonReplacer(_key, value) {
+  if (value instanceof web3_js.PublicKey) return value.toBase58();
+  if (value instanceof Uint8Array) return Buffer.from(value).toString("hex");
+  return value;
+}
+function errMsg(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+function explorerUrl(cluster, sig) {
+  const suffix = cluster === "mainnet-beta" ? "" : `?cluster=${cluster}`;
+  return `https://explorer.solana.com/tx/${sig}${suffix}`;
+}
+var program = new commander.Command();
+program.name("agent-fuel").description(
+  "Agent Fuel CLI \u2014 inspect vaults, register services, fire payments from the terminal."
+).version(VERSION).addOption(
+  new commander.Option("--cluster <name>", "Solana cluster").choices(["mainnet-beta", "devnet", "testnet", "localnet"]).default("devnet")
+).option("--rpc <url>", "override the default RPC URL for the chosen cluster").option(
+  "--api-base <url>",
+  "Agent Fuel backend base URL (used by read commands)",
+  DEFAULT_API_BASE2
+).option("--json", "emit machine-readable JSON instead of human text");
+program.command("score <agent>").description("Show the latest reputation snapshot for an agent (REST, no key).").action(async (agent, _opts, cmd) => {
+  const g = readGlobalOpts(cmd);
+  const agentPk = parsePubkey(agent, "<agent>");
+  const fuel = readOnlyFuel(g);
+  const score = await fuel.getScore(agentPk);
+  emit(g, () => formatScore(score), score);
+});
+program.command("vault <owner> <agent>").description("Show on-chain credit vault state for the (owner, agent) pair.").action(async (owner, agent, _opts, cmd) => {
+  const g = readGlobalOpts(cmd);
+  const ownerPk = parsePubkey(owner, "<owner>");
+  const agentPk = parsePubkey(agent, "<agent>");
+  const fuel = readOnlyFuel(g);
+  const vault = await fuel.getVaultBalance({ owner: ownerPk, agent: agentPk });
+  emit(g, () => formatVault(vault), vault);
+});
+program.command("policy <owner> <agent>").description("Show the spend policy guarding an (owner, agent) vault.").action(async (owner, agent, _opts, cmd) => {
+  const g = readGlobalOpts(cmd);
+  const ownerPk = parsePubkey(owner, "<owner>");
+  const agentPk = parsePubkey(agent, "<agent>");
+  const fuel = readOnlyFuel(g);
+  const policy = await fuel.getPolicy({ owner: ownerPk, agent: agentPk });
+  emit(g, () => formatPolicy(policy), policy);
+});
+program.command("service <authority>").description("Look up a registered service by its authority pubkey.").action(async (authority, _opts, cmd) => {
+  const g = readGlobalOpts(cmd);
+  const authPk = parsePubkey(authority, "<authority>");
+  const fuel = readOnlyFuel(g);
+  const svc = await fuel.checkService(authPk);
+  emit(g, () => formatService(svc), svc);
+});
+program.command("pay").description(
+  "Atomically spend from a vault and record the payment for reputation."
+).requiredOption("--keypair <path>", "agent keypair (signs the spend half)").requiredOption("--service-keypair <path>", "service keypair (co-signs)").requiredOption("--owner <pubkey>", "vault owner pubkey").requiredOption("--amount <usdc>", "amount in USDC (e.g. 0.5)").option(
+  "--receipt-hash <hex>",
+  "32-byte receipt hash as hex (auto-generated if omitted)"
+).action(
+  async (opts, cmd) => {
+    const g = readGlobalOpts(cmd);
+    const agent = loadKeypair(opts.keypair);
+    const service = loadKeypair(opts.serviceKeypair);
+    const owner = parsePubkey(opts.owner, "--owner");
+    const amountUsdc = parseAmountToMicro(opts.amount);
+    const receiptHash = parseReceiptHash(opts.receiptHash);
+    const result = await pay({
+      agent,
+      service,
+      owner,
+      amountUsdc,
+      receiptHash,
+      connection: connectionFor(g)
+    });
+    emit(
+      g,
+      () => [
+        `paid ${opts.amount} USDC`,
+        `  agent     ${agent.publicKey.toBase58()}`,
+        `  service   ${service.publicKey.toBase58()}`,
+        `  signature ${result.signature}`,
+        `  ${explorerUrl(g.cluster, result.signature)}`
+      ].join("\n"),
+      { ...result, receipt_hash: Buffer.from(receiptHash).toString("hex") }
+    );
+  }
+);
+program.command("request-spend").description(
+  "Submit an over-limit spend that the owner must approve from the app."
+).requiredOption("--keypair <path>", "agent keypair (submits the request)").requiredOption("--owner <pubkey>", "vault owner pubkey").requiredOption("--service <pubkey>", "service authority pubkey").requiredOption("--amount <usdc>", "amount in USDC (e.g. 5.0)").action(
+  async (opts, cmd) => {
+    const g = readGlobalOpts(cmd);
+    const agent = loadKeypair(opts.keypair);
+    const owner = parsePubkey(opts.owner, "--owner");
+    const service = parsePubkey(opts.service, "--service");
+    const amountUsdc = parseAmountToMicro(opts.amount);
+    const result = await requestSpend({
+      agent,
+      owner,
+      service,
+      amountUsdc,
+      connection: connectionFor(g)
+    });
+    emit(
+      g,
+      () => [
+        `requested ${opts.amount} USDC (over-limit, awaiting owner approval)`,
+        `  pending   ${result.pendingSpend.toBase58()}`,
+        `  nonce     ${result.nonce}`,
+        `  signature ${result.signature}`,
+        `  ${explorerUrl(g.cluster, result.signature)}`
+      ].join("\n"),
+      result
+    );
+  }
+);
+program.command("register-service").description("Register a new service on chain (two-signer).").requiredOption("--sponsor <path>", "sponsor keypair (pays rent, submits tx)").requiredOption(
+  "--service-keypair <path>",
+  "service keypair (long-lived signing identity)"
+).requiredOption("--name <name>", "service name (max 32 bytes UTF-8)").requiredOption(
+  "--category <c>",
+  "DataFeed | Compute | Swap | Rpc | Other"
+).option("--uri <url>", "optional off-chain metadata URI (max 128 bytes)").action(
+  async (opts, cmd) => {
+    const g = readGlobalOpts(cmd);
+    const sponsor = loadKeypair(opts.sponsor);
+    const service = loadKeypair(opts.serviceKeypair);
+    const category = parseCategory(opts.category);
+    const registerArgs = {
+      sponsor,
+      service,
+      name: opts.name,
+      category,
+      connection: connectionFor(g)
+    };
+    if (opts.uri !== void 0) registerArgs.serviceUri = opts.uri;
+    const result = await registerService(registerArgs);
+    emit(
+      g,
+      () => [
+        `registered service "${opts.name}" (${category})`,
+        `  authority ${service.publicKey.toBase58()}`,
+        `  sponsor   ${sponsor.publicKey.toBase58()}`,
+        `  signature ${result.signature}`,
+        `  ${explorerUrl(g.cluster, result.signature)}`
+      ].join("\n"),
+      result
+    );
+  }
+);
+program.command("keygen").description(
+  "Generate a new Solana keypair (compatible with solana-keygen JSON format)."
+).option(
+  "--out <path>",
+  "write the secret-key JSON to a file (parent dirs created)"
+).action((opts, cmd) => {
+  const g = readGlobalOpts(cmd);
+  const kp = web3_js.Keypair.generate();
+  const bytes = Array.from(kp.secretKey);
+  const pub = kp.publicKey.toBase58();
+  if (opts.out) {
+    fs.mkdirSync(path.dirname(opts.out), { recursive: true });
+    fs.writeFileSync(opts.out, JSON.stringify(bytes), { mode: 384 });
+    emit(
+      g,
+      () => `wrote keypair to ${opts.out}
+  pubkey ${pub}`,
+      { pubkey: pub, path: opts.out }
+    );
+  } else {
+    if (g.json) {
+      emit(g, () => "", { pubkey: pub, secret_key: bytes });
+    } else {
+      process.stderr.write(JSON.stringify(bytes) + "\n");
+      process.stdout.write(`pubkey ${pub}
+`);
+    }
+  }
+});
+function formatScore(s) {
+  return [
+    `agent              ${s.agent}`,
+    `score              ${s.score ?? "(unscored)"}`,
+    `transactions       ${s.total_transactions}`,
+    `services used      ${s.services_used}`,
+    `volume USDC        ${micro(s.total_volume_usdc)}`,
+    `consecutive ok     ${s.consecutive_success}`,
+    `feedback total     ${s.total_feedback_count}`,
+    `feedback negative  ${s.active_negative_feedback_count}`,
+    `last active slot   ${s.last_active_slot}`,
+    `updated            ${s.updated_at}`
+  ].join("\n");
+}
+function formatVault(v) {
+  return [
+    `vault              ${v.pubkey.toBase58()}`,
+    `owner              ${v.owner.toBase58()}`,
+    `agent              ${v.agent.toBase58()}`,
+    `usdc mint          ${v.usdc_mint.toBase58()}`,
+    `vault token acct   ${v.vault_token_account.toBase58()}`,
+    `balance            ${micro(v.balance)} USDC`,
+    `  deposited        ${micro(v.total_deposited)}`,
+    `  withdrawn        ${micro(v.total_withdrawn)}`,
+    `  spent            ${micro(v.total_spent)}`,
+    `  claimed          ${micro(v.total_claimed)}`,
+    `frozen             ${v.frozen}`,
+    `pending count      ${v.pending_count}`,
+    `last active slot   ${v.last_active_slot}`
+  ].join("\n");
+}
+function formatPolicy(p) {
+  const whitelist = p.whitelist.length ? p.whitelist.map((pk) => `  - ${pk.toBase58()}`).join("\n") : "  (empty \u2014 no whitelist enforcement)";
+  return [
+    `policy             ${p.pubkey.toBase58()}`,
+    `vault              ${p.vault.toBase58()}`,
+    `per-tx limit       ${micro(p.per_tx_limit_usdc)} USDC`,
+    `hourly limit       ${micro(p.hourly_limit_usdc)} USDC`,
+    `lifetime limit     ${micro(p.lifetime_limit_usdc)} USDC`,
+    `hourly window slot ${p.hourly_window_start_slot}`,
+    `hourly spent       ${micro(p.hourly_window_spent_usdc)} USDC`,
+    `allow post-pay     ${p.allow_post_pay}`,
+    `whitelist:`,
+    whitelist
+  ].join("\n");
+}
+function formatService(s) {
+  return [
+    `registry           ${s.pubkey.toBase58()}`,
+    `authority          ${s.authority.toBase58()}`,
+    `name               ${s.name}`,
+    `category           ${s.category}`,
+    `active             ${s.active}`,
+    `agents served      ${s.total_agents_served}`,
+    `volume received    ${micro(s.total_volume_received_usdc)} USDC`,
+    `first active slot  ${s.first_active_slot}`,
+    `last active slot   ${s.last_active_slot}`
+  ].join("\n");
+}
+function micro(n) {
+  return (n / 1e6).toFixed(6);
+}
+program.exitOverride();
+program.parseAsync(process.argv).catch((err) => {
+  if (typeof err === "object" && err !== null && "code" in err) {
+    const code = err.code;
+    if (code === "commander.help" || code === "commander.helpDisplayed" || code === "commander.version") {
+      process.exit(0);
+    }
+  }
+  const msg = errMsg(err);
+  process.stderr.write(`agent-fuel: ${msg}
+`);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.cjs.map
+//# sourceMappingURL=cli.cjs.map