@agent-fuel/sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,3361 @@
+'use strict';
+
+var anchor = require('@coral-xyz/anchor');
+var web3_js = require('@solana/web3.js');
+
+// src/client.ts
+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)
+  };
+}
+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;
+  }
+};
+
+// 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: "service",
+          writable: true,
+          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: "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
+            ]
+          }
+        }
+      ]
+    }
+  ],
+  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: "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"
+    }
+  ],
+  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: "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: "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: "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: "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: "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: "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: "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"
+    }
+  ],
+  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: "_padding",
+            type: {
+              array: [
+                "u8",
+                64
+              ]
+            }
+          }
+        ]
+      }
+    },
+    {
+      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: "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: "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 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/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 });
+    }
+  }
+  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/x402.ts
+var HEADER = "X-Payment-Required";
+var PAYMENT_HEADER = "X-Payment";
+var PaymentParseError = class extends AgentFuelError {
+  constructor(message) {
+    super(message);
+    this.name = "PaymentParseError";
+  }
+};
+function paymentRequired(fuel, opts = {}) {
+  const baseFetch = opts.fetch ?? ((input, init) => fetch(input, init));
+  return async (input, init) => {
+    const first = await baseFetch(input, init);
+    if (first.status !== 402) return first;
+    const req = await parseRequirement(first);
+    if (opts.onPaymentRequired) await opts.onPaymentRequired(req);
+    const { signature } = await fuel.spend({
+      service: req.recipient,
+      amountUsdc: req.amountUsdc
+    });
+    if (opts.onPaid) await opts.onPaid(signature, req);
+    const headers = new Headers(init?.headers);
+    headers.set(PAYMENT_HEADER, signature);
+    return baseFetch(input, { ...init, headers });
+  };
+}
+async function parseRequirement(res) {
+  const header = res.headers.get(HEADER);
+  if (header) return parseJson(header);
+  let bodyText;
+  try {
+    bodyText = await res.clone().text();
+  } catch {
+    throw new PaymentParseError(`402 response has no ${HEADER} header and the body is unreadable`);
+  }
+  if (!bodyText.trim()) {
+    throw new PaymentParseError(`402 response has no ${HEADER} header and an empty body`);
+  }
+  return parseJson(bodyText);
+}
+function parseJson(text) {
+  let obj;
+  try {
+    obj = JSON.parse(text);
+  } catch {
+    throw new PaymentParseError(`payment payload is not valid JSON: ${truncate(text)}`);
+  }
+  if (typeof obj !== "object" || obj === null) {
+    throw new PaymentParseError(`payment payload is not an object`);
+  }
+  const r = obj;
+  const recipient = stringField(r, "recipient") ?? stringField(r, "payTo");
+  if (!recipient) {
+    throw new PaymentParseError(`payment payload missing 'recipient' or 'payTo'`);
+  }
+  const amount = numericField(r, "amountUsdc") ?? numericField(r, "maxAmountRequired");
+  if (amount === null || amount <= 0) {
+    throw new PaymentParseError(
+      `payment payload missing positive 'amountUsdc' or 'maxAmountRequired'`
+    );
+  }
+  const out = { recipient, amountUsdc: amount };
+  const network = stringField(r, "network");
+  if (network) out.network = network;
+  const resource = stringField(r, "resource");
+  if (resource) out.resource = resource;
+  return out;
+}
+function stringField(r, key) {
+  const v = r[key];
+  return typeof v === "string" && v.length > 0 ? v : void 0;
+}
+function numericField(r, key) {
+  const v = r[key];
+  if (typeof v === "number" && Number.isFinite(v)) return v;
+  if (typeof v === "string") {
+    const n = Number(v);
+    if (Number.isFinite(n)) return n;
+  }
+  return null;
+}
+function truncate(s) {
+  return s.length > 80 ? `${s.slice(0, 80)}\u2026` : s;
+}
+
+exports.ASSOCIATED_TOKEN_PROGRAM_ID = ASSOCIATED_TOKEN_PROGRAM_ID;
+exports.AccountNotFoundError = AccountNotFoundError;
+exports.AgentFuel = AgentFuel;
+exports.AgentFuelError = AgentFuelError;
+exports.HourlyLimitExceededError = HourlyLimitExceededError;
+exports.HttpError = HttpError;
+exports.LifetimeLimitExceededError = LifetimeLimitExceededError;
+exports.NotWhitelistedError = NotWhitelistedError;
+exports.OwnerNotConfiguredError = OwnerNotConfiguredError;
+exports.PROGRAM_IDS = PROGRAM_IDS;
+exports.PaymentParseError = PaymentParseError;
+exports.PerTxLimitExceededError = PerTxLimitExceededError;
+exports.SLOTS_PER_HOUR = SLOTS_PER_HOUR;
+exports.SpendPolicyError = SpendPolicyError;
+exports.TOKEN_PROGRAM_ID = TOKEN_PROGRAM_ID;
+exports.VaultFrozenError = VaultFrozenError;
+exports.ZeroAmountError = ZeroAmountError;
+exports.createAssociatedTokenAccountIdempotentInstruction = createAssociatedTokenAccountIdempotentInstruction;
+exports.getAssociatedTokenAddress = getAssociatedTokenAddress;
+exports.paymentRequired = paymentRequired;
+exports.policyPda = policyPda;
+exports.serviceRegistryPda = serviceRegistryPda;
+exports.vaultPda = vaultPda;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map