@axonfi/sdk 0.4.0 → 0.4.1

package/dist/index.cjs

@@ -0,0 +1,4325 @@
+'use strict';
+
+var viem = require('viem');
+var accounts = require('viem/accounts');
+var chains = require('viem/chains');
+var scrypt = require('@noble/hashes/scrypt');
+var sha3 = require('@noble/hashes/sha3');
+var aes = require('@noble/ciphers/aes');
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var PAYMENT_INTENT_TYPEHASH = viem.keccak256(
+  viem.stringToBytes("PaymentIntent(address bot,address to,address token,uint256 amount,uint256 deadline,bytes32 ref)")
+);
+var EXECUTE_INTENT_TYPEHASH = viem.keccak256(
+  viem.stringToBytes(
+    "ExecuteIntent(address bot,address protocol,bytes32 calldataHash,address token,uint256 amount,uint256 deadline,bytes32 ref)"
+  )
+);
+var SWAP_INTENT_TYPEHASH = viem.keccak256(
+  viem.stringToBytes("SwapIntent(address bot,address toToken,uint256 minToAmount,uint256 deadline,bytes32 ref)")
+);
+var EIP712_DOMAIN_NAME = "AxonVault";
+var EIP712_DOMAIN_VERSION = "1";
+var NATIVE_ETH = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+var USDC = {
+  // Base mainnet
+  8453: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+  // Base Sepolia
+  84532: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+  // Arbitrum One
+  42161: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+  // Arbitrum Sepolia
+  421614: "0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d"
+};
+var Chain = /* @__PURE__ */ ((Chain2) => {
+  Chain2[Chain2["Base"] = 8453] = "Base";
+  Chain2[Chain2["BaseSepolia"] = 84532] = "BaseSepolia";
+  Chain2[Chain2["Arbitrum"] = 42161] = "Arbitrum";
+  Chain2[Chain2["ArbitrumSepolia"] = 421614] = "ArbitrumSepolia";
+  return Chain2;
+})(Chain || {});
+var SUPPORTED_CHAIN_IDS = [8453, 84532, 42161, 421614];
+var CHAIN_NAMES = {
+  [8453 /* Base */]: "Base",
+  [84532 /* BaseSepolia */]: "Base Sepolia",
+  [42161 /* Arbitrum */]: "Arbitrum One",
+  [421614 /* ArbitrumSepolia */]: "Arbitrum Sepolia",
+  // Future v1 chains (metadata only — not in SUPPORTED_CHAIN_IDS yet)
+  10: "Optimism",
+  11155420: "OP Sepolia",
+  137: "Polygon",
+  80002: "Polygon Amoy"
+};
+var EXPLORER_TX = {
+  [8453 /* Base */]: "https://basescan.org/tx/",
+  [84532 /* BaseSepolia */]: "https://sepolia.basescan.org/tx/",
+  [42161 /* Arbitrum */]: "https://arbiscan.io/tx/",
+  [421614 /* ArbitrumSepolia */]: "https://sepolia.arbiscan.io/tx/",
+  10: "https://optimistic.etherscan.io/tx/",
+  11155420: "https://sepolia-optimism.etherscan.io/tx/",
+  137: "https://polygonscan.com/tx/",
+  80002: "https://amoy.polygonscan.com/tx/"
+};
+var EXPLORER_ADDR = {
+  [8453 /* Base */]: "https://basescan.org/address/",
+  [84532 /* BaseSepolia */]: "https://sepolia.basescan.org/address/",
+  [42161 /* Arbitrum */]: "https://arbiscan.io/address/",
+  [421614 /* ArbitrumSepolia */]: "https://sepolia.arbiscan.io/address/",
+  10: "https://optimistic.etherscan.io/address/",
+  11155420: "https://sepolia-optimism.etherscan.io/address/",
+  137: "https://polygonscan.com/address/",
+  80002: "https://amoy.polygonscan.com/address/"
+};
+var DEFAULT_DEADLINE_SECONDS = 300;
+var WINDOW = {
+  ONE_HOUR: 3600n,
+  ONE_DAY: 86400n,
+  ONE_WEEK: 604800n,
+  THIRTY_DAYS: 2592000n
+};
+var PaymentErrorCode = {
+  /** Payment destination is the vault itself */
+  SELF_PAYMENT: "SELF_PAYMENT",
+  /** Payment destination is the zero address */
+  ZERO_ADDRESS: "ZERO_ADDRESS",
+  /** Payment amount is zero */
+  ZERO_AMOUNT: "ZERO_AMOUNT",
+  /** Vault does not hold enough of the requested token */
+  INSUFFICIENT_BALANCE: "INSUFFICIENT_BALANCE",
+  /** EIP-712 signature verification failed */
+  INVALID_SIGNATURE: "INVALID_SIGNATURE",
+  /** Payment intent deadline has passed */
+  DEADLINE_EXPIRED: "DEADLINE_EXPIRED",
+  /** Bot is temporarily paused by the operator */
+  BOT_PAUSED: "BOT_PAUSED",
+  /** Bot address is not registered/active in the vault */
+  BOT_NOT_ACTIVE: "BOT_NOT_ACTIVE",
+  /** Destination address is on the global or vault blacklist */
+  BLACKLISTED: "BLACKLISTED",
+  /** Rolling-window spending limit (USD amount) exceeded */
+  SPENDING_LIMIT_EXCEEDED: "SPENDING_LIMIT_EXCEEDED",
+  /** Rolling-window transaction count limit exceeded */
+  TX_COUNT_EXCEEDED: "TX_COUNT_EXCEEDED",
+  /** Single transaction exceeds the bot's on-chain maxPerTxAmount */
+  MAX_PER_TX_EXCEEDED: "MAX_PER_TX_EXCEEDED",
+  /** Vault-level daily aggregate spending limit exceeded */
+  VAULT_AGGREGATE_EXCEEDED: "VAULT_AGGREGATE_EXCEEDED",
+  /** eth_call simulation of the on-chain transaction reverted */
+  SIMULATION_FAILED: "SIMULATION_FAILED",
+  /** Routed to human review (AI scan flagged or no consensus) */
+  PENDING_REVIEW: "PENDING_REVIEW",
+  /** Relayer wallet has insufficient gas to submit the transaction */
+  RELAYER_OUT_OF_GAS: "RELAYER_OUT_OF_GAS",
+  /** On-chain transaction submission failed */
+  SUBMISSION_FAILED: "SUBMISSION_FAILED",
+  /** Destination not in the vault/bot whitelist */
+  DESTINATION_NOT_WHITELISTED: "DESTINATION_NOT_WHITELISTED",
+  /** Vault address is not a valid AxonVault or was not deployed by a known factory */
+  INVALID_VAULT: "INVALID_VAULT",
+  /** Rebalance output token is not in the whitelist (on-chain or relayer default) */
+  REBALANCE_TOKEN_NOT_ALLOWED: "REBALANCE_TOKEN_NOT_ALLOWED",
+  /** Rebalance input amount exceeds the bot's maxRebalanceAmount cap */
+  MAX_REBALANCE_AMOUNT_EXCEEDED: "MAX_REBALANCE_AMOUNT_EXCEEDED",
+  /** Unknown or internal error */
+  INTERNAL_ERROR: "INTERNAL_ERROR"
+};
+var RELAYER_API = {
+  PAYMENTS: "/v1/payments",
+  payment: (requestId) => `/v1/payments/${requestId}`,
+  EXECUTE: "/v1/execute",
+  execute: (requestId) => `/v1/execute/${requestId}`,
+  SWAP: "/v1/swap",
+  swap: (requestId) => `/v1/swap/${requestId}`,
+  // Vault read endpoints (relayer reads chain on behalf of bots)
+  vaultBalance: (vault, token, chainId) => `/v1/vault/${vault}/balance/${token}?chainId=${chainId}`,
+  vaultBalances: (vault, chainId) => `/v1/vault/${vault}/balances`,
+  vaultInfo: (vault, chainId) => `/v1/vault/${vault}/info?chainId=${chainId}`,
+  botStatus: (vault, bot, chainId) => `/v1/vault/${vault}/bot/${bot}/status?chainId=${chainId}`,
+  destinationCheck: (vault, bot, destination, chainId) => `/v1/vault/${vault}/bot/${bot}/destination/${destination}?chainId=${chainId}`,
+  protocolCheck: (vault, protocol, chainId) => `/v1/vault/${vault}/protocol/${protocol}?chainId=${chainId}`,
+  rebalanceTokens: (vault, chainId) => `/v1/vault/${vault}/rebalance-tokens?chainId=${chainId}`,
+  rebalanceTokenCheck: (vault, token, chainId) => `/v1/vault/${vault}/rebalance-token/${token}?chainId=${chainId}`,
+  // TOS endpoints
+  tosStatus: (wallet) => `/v1/tos/status?wallet=${wallet}`,
+  TOS_ACCEPT: "/v1/tos/accept"
+};
+
+// src/signer.ts
+var PAYMENT_INTENT_TYPES = {
+  PaymentIntent: [
+    { name: "bot", type: "address" },
+    { name: "to", type: "address" },
+    { name: "token", type: "address" },
+    { name: "amount", type: "uint256" },
+    { name: "deadline", type: "uint256" },
+    { name: "ref", type: "bytes32" }
+  ]
+};
+var EXECUTE_INTENT_TYPES = {
+  ExecuteIntent: [
+    { name: "bot", type: "address" },
+    { name: "protocol", type: "address" },
+    { name: "calldataHash", type: "bytes32" },
+    { name: "token", type: "address" },
+    { name: "amount", type: "uint256" },
+    { name: "deadline", type: "uint256" },
+    { name: "ref", type: "bytes32" }
+  ]
+};
+var SWAP_INTENT_TYPES = {
+  SwapIntent: [
+    { name: "bot", type: "address" },
+    { name: "toToken", type: "address" },
+    { name: "minToAmount", type: "uint256" },
+    { name: "deadline", type: "uint256" },
+    { name: "ref", type: "bytes32" }
+  ]
+};
+function makeDomain(vaultAddress, chainId) {
+  return {
+    name: EIP712_DOMAIN_NAME,
+    version: EIP712_DOMAIN_VERSION,
+    chainId,
+    verifyingContract: vaultAddress
+  };
+}
+async function signPayment(walletClient, vaultAddress, chainId, intent) {
+  if (!walletClient.account) {
+    throw new Error("walletClient has no account attached");
+  }
+  return walletClient.signTypedData({
+    account: walletClient.account,
+    domain: makeDomain(vaultAddress, chainId),
+    types: PAYMENT_INTENT_TYPES,
+    primaryType: "PaymentIntent",
+    message: {
+      bot: intent.bot,
+      to: intent.to,
+      token: intent.token,
+      amount: intent.amount,
+      deadline: intent.deadline,
+      ref: intent.ref
+    }
+  });
+}
+async function signExecuteIntent(walletClient, vaultAddress, chainId, intent) {
+  if (!walletClient.account) {
+    throw new Error("walletClient has no account attached");
+  }
+  return walletClient.signTypedData({
+    account: walletClient.account,
+    domain: makeDomain(vaultAddress, chainId),
+    types: EXECUTE_INTENT_TYPES,
+    primaryType: "ExecuteIntent",
+    message: {
+      bot: intent.bot,
+      protocol: intent.protocol,
+      calldataHash: intent.calldataHash,
+      token: intent.token,
+      amount: intent.amount,
+      deadline: intent.deadline,
+      ref: intent.ref
+    }
+  });
+}
+async function signSwapIntent(walletClient, vaultAddress, chainId, intent) {
+  if (!walletClient.account) {
+    throw new Error("walletClient has no account attached");
+  }
+  return walletClient.signTypedData({
+    account: walletClient.account,
+    domain: makeDomain(vaultAddress, chainId),
+    types: SWAP_INTENT_TYPES,
+    primaryType: "SwapIntent",
+    message: {
+      bot: intent.bot,
+      toToken: intent.toToken,
+      minToAmount: intent.minToAmount,
+      deadline: intent.deadline,
+      ref: intent.ref
+    }
+  });
+}
+function encodeRef(memo) {
+  return viem.keccak256(viem.stringToBytes(memo));
+}
+
+// src/abis/AxonVault.ts
+var AxonVaultAbi = [
+  {
+    "type": "constructor",
+    "inputs": [
+      {
+        "name": "_owner",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "_axonRegistry",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "receive",
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "DOMAIN_SEPARATOR",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "MAX_SPENDING_LIMITS",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint8",
+        "internalType": "uint8"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "NATIVE_ETH",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "VERSION",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint16",
+        "internalType": "uint16"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "acceptOwnership",
+    "inputs": [],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "addBot",
+    "inputs": [
+      {
+        "name": "bot",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "params",
+        "type": "tuple",
+        "internalType": "struct AxonVault.BotConfigParams",
+        "components": [
+          {
+            "name": "maxPerTxAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "maxRebalanceAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "spendingLimits",
+            "type": "tuple[]",
+            "internalType": "struct AxonVault.SpendingLimit[]",
+            "components": [
+              {
+                "name": "amount",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "maxCount",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "windowSeconds",
+                "type": "uint256",
+                "internalType": "uint256"
+              }
+            ]
+          },
+          {
+            "name": "aiTriggerThreshold",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "requireAiVerification",
+            "type": "bool",
+            "internalType": "bool"
+          }
+        ]
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "addBotDestination",
+    "inputs": [
+      {
+        "name": "bot",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "destination",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "addGlobalBlacklist",
+    "inputs": [
+      {
+        "name": "destination",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "addGlobalDestination",
+    "inputs": [
+      {
+        "name": "destination",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "addProtocol",
+    "inputs": [
+      {
+        "name": "protocol",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "addRebalanceTokens",
+    "inputs": [
+      {
+        "name": "tokens",
+        "type": "address[]",
+        "internalType": "address[]"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "approvedProtocolCount",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "approvedProtocols",
+    "inputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "axonRegistry",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "botAddedByOperator",
+    "inputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "botDestinationCount",
+    "inputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "botDestinationWhitelist",
+    "inputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "deposit",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "ref",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "eip712Domain",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "fields",
+        "type": "bytes1",
+        "internalType": "bytes1"
+      },
+      {
+        "name": "name",
+        "type": "string",
+        "internalType": "string"
+      },
+      {
+        "name": "version",
+        "type": "string",
+        "internalType": "string"
+      },
+      {
+        "name": "chainId",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "verifyingContract",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "salt",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "extensions",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "executePayment",
+    "inputs": [
+      {
+        "name": "intent",
+        "type": "tuple",
+        "internalType": "struct AxonVault.PaymentIntent",
+        "components": [
+          {
+            "name": "bot",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "to",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "token",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "amount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "deadline",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "ref",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      },
+      {
+        "name": "signature",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "fromToken",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "maxFromAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "swapRouter",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "swapCalldata",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "executeProtocol",
+    "inputs": [
+      {
+        "name": "intent",
+        "type": "tuple",
+        "internalType": "struct AxonVault.ExecuteIntent",
+        "components": [
+          {
+            "name": "bot",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "protocol",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "calldataHash",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "token",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "amount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "deadline",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "ref",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      },
+      {
+        "name": "signature",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "callData",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "fromToken",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "maxFromAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "swapRouter",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "swapCalldata",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "executeSwap",
+    "inputs": [
+      {
+        "name": "intent",
+        "type": "tuple",
+        "internalType": "struct AxonVault.SwapIntent",
+        "components": [
+          {
+            "name": "bot",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "toToken",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "minToAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "deadline",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "ref",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      },
+      {
+        "name": "signature",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "fromToken",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "maxFromAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "swapRouter",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "swapCalldata",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "getBotConfig",
+    "inputs": [
+      {
+        "name": "bot",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "tuple",
+        "internalType": "struct AxonVault.BotConfig",
+        "components": [
+          {
+            "name": "isActive",
+            "type": "bool",
+            "internalType": "bool"
+          },
+          {
+            "name": "registeredAt",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "maxPerTxAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "maxRebalanceAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "spendingLimits",
+            "type": "tuple[]",
+            "internalType": "struct AxonVault.SpendingLimit[]",
+            "components": [
+              {
+                "name": "amount",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "maxCount",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "windowSeconds",
+                "type": "uint256",
+                "internalType": "uint256"
+              }
+            ]
+          },
+          {
+            "name": "aiTriggerThreshold",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "requireAiVerification",
+            "type": "bool",
+            "internalType": "bool"
+          }
+        ]
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "globalBlacklistCount",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "globalDestinationBlacklist",
+    "inputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "globalDestinationCount",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "globalDestinationWhitelist",
+    "inputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "isBotActive",
+    "inputs": [
+      {
+        "name": "bot",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "isProtocolApproved",
+    "inputs": [
+      {
+        "name": "protocol",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "operator",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "operatorBotCount",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "operatorCeilings",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "maxPerTxAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "maxBotDailyLimit",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "maxOperatorBots",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "vaultDailyAggregate",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "minAiTriggerFloor",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "operatorMaxDrainPerDay",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "owner",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "pause",
+    "inputs": [],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "paused",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "pendingOwner",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "rebalanceTokenCount",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "rebalanceTokenWhitelist",
+    "inputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "removeBot",
+    "inputs": [
+      {
+        "name": "bot",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "removeBotDestination",
+    "inputs": [
+      {
+        "name": "bot",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "destination",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "removeGlobalBlacklist",
+    "inputs": [
+      {
+        "name": "destination",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "removeGlobalDestination",
+    "inputs": [
+      {
+        "name": "destination",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "removeProtocol",
+    "inputs": [
+      {
+        "name": "protocol",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "removeRebalanceTokens",
+    "inputs": [
+      {
+        "name": "tokens",
+        "type": "address[]",
+        "internalType": "address[]"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "renounceOwnership",
+    "inputs": [],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "setOperator",
+    "inputs": [
+      {
+        "name": "_operator",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "setOperatorCeilings",
+    "inputs": [
+      {
+        "name": "ceilings",
+        "type": "tuple",
+        "internalType": "struct AxonVault.OperatorCeilings",
+        "components": [
+          {
+            "name": "maxPerTxAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "maxBotDailyLimit",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "maxOperatorBots",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "vaultDailyAggregate",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "minAiTriggerFloor",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "transferOwnership",
+    "inputs": [
+      {
+        "name": "newOwner",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "unpause",
+    "inputs": [],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "updateBotConfig",
+    "inputs": [
+      {
+        "name": "bot",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "params",
+        "type": "tuple",
+        "internalType": "struct AxonVault.BotConfigParams",
+        "components": [
+          {
+            "name": "maxPerTxAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "maxRebalanceAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "spendingLimits",
+            "type": "tuple[]",
+            "internalType": "struct AxonVault.SpendingLimit[]",
+            "components": [
+              {
+                "name": "amount",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "maxCount",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "windowSeconds",
+                "type": "uint256",
+                "internalType": "uint256"
+              }
+            ]
+          },
+          {
+            "name": "aiTriggerThreshold",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "requireAiVerification",
+            "type": "bool",
+            "internalType": "bool"
+          }
+        ]
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "usedIntents",
+    "inputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "withdraw",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "event",
+    "name": "BotAdded",
+    "inputs": [
+      {
+        "name": "bot",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "addedBy",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "BotConfigUpdated",
+    "inputs": [
+      {
+        "name": "bot",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "updatedBy",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "BotDestinationAdded",
+    "inputs": [
+      {
+        "name": "bot",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "destination",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "BotDestinationRemoved",
+    "inputs": [
+      {
+        "name": "bot",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "destination",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "BotRemoved",
+    "inputs": [
+      {
+        "name": "bot",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "removedBy",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Deposited",
+    "inputs": [
+      {
+        "name": "from",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "token",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "ref",
+        "type": "bytes32",
+        "indexed": false,
+        "internalType": "bytes32"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "EIP712DomainChanged",
+    "inputs": [],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "GlobalBlacklistAdded",
+    "inputs": [
+      {
+        "name": "destination",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "GlobalBlacklistRemoved",
+    "inputs": [
+      {
+        "name": "destination",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "GlobalDestinationAdded",
+    "inputs": [
+      {
+        "name": "destination",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "GlobalDestinationRemoved",
+    "inputs": [
+      {
+        "name": "destination",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "OperatorCeilingsUpdated",
+    "inputs": [
+      {
+        "name": "ceilings",
+        "type": "tuple",
+        "indexed": false,
+        "internalType": "struct AxonVault.OperatorCeilings",
+        "components": [
+          {
+            "name": "maxPerTxAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "maxBotDailyLimit",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "maxOperatorBots",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "vaultDailyAggregate",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "minAiTriggerFloor",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "OperatorSet",
+    "inputs": [
+      {
+        "name": "oldOperator",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "newOperator",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "OwnershipTransferStarted",
+    "inputs": [
+      {
+        "name": "previousOwner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "newOwner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "OwnershipTransferred",
+    "inputs": [
+      {
+        "name": "previousOwner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "newOwner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Paused",
+    "inputs": [
+      {
+        "name": "account",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "PaymentExecuted",
+    "inputs": [
+      {
+        "name": "bot",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "token",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "ref",
+        "type": "bytes32",
+        "indexed": false,
+        "internalType": "bytes32"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "ProtocolAdded",
+    "inputs": [
+      {
+        "name": "protocol",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "ProtocolExecuted",
+    "inputs": [
+      {
+        "name": "bot",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "protocol",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "token",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "ref",
+        "type": "bytes32",
+        "indexed": false,
+        "internalType": "bytes32"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "ProtocolRemoved",
+    "inputs": [
+      {
+        "name": "protocol",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "RebalanceTokenAdded",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "RebalanceTokenRemoved",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "SwapExecuted",
+    "inputs": [
+      {
+        "name": "bot",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "fromToken",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "toToken",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "fromAmount",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "toAmount",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "ref",
+        "type": "bytes32",
+        "indexed": false,
+        "internalType": "bytes32"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "SwapPaymentExecuted",
+    "inputs": [
+      {
+        "name": "bot",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "fromToken",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "toToken",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "fromAmount",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "toAmount",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "ref",
+        "type": "bytes32",
+        "indexed": false,
+        "internalType": "bytes32"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Unpaused",
+    "inputs": [
+      {
+        "name": "account",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Withdrawn",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "error",
+    "name": "AlreadyApprovedProtocol",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "AmountMismatch",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "BotAlreadyExists",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "BotDoesNotExist",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "BotNotActive",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "CalldataHashMismatch",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "DeadlineExpired",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "DestinationBlacklisted",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "DestinationNotWhitelisted",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "ECDSAInvalidSignature",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "ECDSAInvalidSignatureLength",
+    "inputs": [
+      {
+        "name": "length",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "ECDSAInvalidSignatureS",
+    "inputs": [
+      {
+        "name": "s",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "EnforcedPause",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "ExceedsOperatorCeiling",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "ExpectedPause",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InsufficientBalance",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "IntentAlreadyUsed",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidShortString",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidSignature",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "MaxPerTxExceeded",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "MaxRebalanceAmountExceeded",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "NativeTransferFailed",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "NotAuthorized",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "NotAuthorizedRelayer",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "OperatorBotLimitReached",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "OperatorCannotBeOwner",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "OracleNotConfigured",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "OracleUnavailable",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "OwnableInvalidOwner",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "OwnableUnauthorizedAccount",
+    "inputs": [
+      {
+        "name": "account",
+        "type": "address",
+        "internalType": "address"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "OwnerCannotBeBot",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "PaymentToZeroAddress",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "ProtocolCallFailed",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "ProtocolNotApproved",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "ProtocolNotInList",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "RebalanceTokenNotAllowed",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "ReentrancyGuardReentrantCall",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "RouterNotApproved",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "SafeERC20FailedOperation",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "SameTokenSwap",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "SelfPayment",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "StringTooLong",
+    "inputs": [
+      {
+        "name": "str",
+        "type": "string",
+        "internalType": "string"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "SwapFailed",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "SwapOutputInsufficient",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "TooManySpendingLimits",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "UnexpectedETH",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "ZeroAddress",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "ZeroAmount",
+    "inputs": []
+  }
+];
+
+// src/abis/AxonVaultFactory.ts
+var AxonVaultFactoryAbi = [
+  {
+    "type": "constructor",
+    "inputs": [
+      {
+        "name": "_axonRegistry",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "factoryOwner",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "acceptOwnership",
+    "inputs": [],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "allVaults",
+    "inputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "axonRegistry",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "deployVault",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "vault",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "owner",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "ownerVaultCount",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "ownerVaults",
+    "inputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "pendingOwner",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "renounceOwnership",
+    "inputs": [],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "transferOwnership",
+    "inputs": [
+      {
+        "name": "newOwner",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "vaultCount",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "event",
+    "name": "OwnershipTransferStarted",
+    "inputs": [
+      {
+        "name": "previousOwner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "newOwner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "OwnershipTransferred",
+    "inputs": [
+      {
+        "name": "previousOwner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "newOwner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "VaultDeployed",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "vault",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "version",
+        "type": "uint16",
+        "indexed": false,
+        "internalType": "uint16"
+      },
+      {
+        "name": "axonRegistry",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "error",
+    "name": "OwnableInvalidOwner",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "OwnableUnauthorizedAccount",
+    "inputs": [
+      {
+        "name": "account",
+        "type": "address",
+        "internalType": "address"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "ZeroAddress",
+    "inputs": []
+  }
+];
+
+// src/vault.ts
+function getChain(chainId) {
+  switch (chainId) {
+    case 8453:
+      return chains.base;
+    case 84532:
+      return chains.baseSepolia;
+    case 42161:
+      return chains.arbitrum;
+    case 421614:
+      return chains.arbitrumSepolia;
+    default:
+      throw new Error(
+        `Unsupported chainId: ${chainId}. Supported: 8453 (Base), 84532 (Base Sepolia), 42161 (Arbitrum), 421614 (Arbitrum Sepolia)`
+      );
+  }
+}
+function createAxonPublicClient(chainId, rpcUrl) {
+  return viem.createPublicClient({
+    chain: getChain(chainId),
+    transport: viem.http(rpcUrl)
+  });
+}
+function createAxonWalletClient(privateKey, chainId) {
+  const account = accounts.privateKeyToAccount(privateKey);
+  return viem.createWalletClient({
+    account,
+    chain: getChain(chainId),
+    transport: viem.http()
+    // signing is local — transport is unused but required by viem
+  });
+}
+async function getBotConfig(publicClient, vaultAddress, botAddress) {
+  const result = await publicClient.readContract({
+    address: vaultAddress,
+    abi: AxonVaultAbi,
+    functionName: "getBotConfig",
+    args: [botAddress]
+  });
+  return {
+    isActive: result.isActive,
+    registeredAt: result.registeredAt,
+    maxPerTxAmount: result.maxPerTxAmount,
+    maxRebalanceAmount: result.maxRebalanceAmount,
+    spendingLimits: result.spendingLimits.map((sl) => ({
+      amount: sl.amount,
+      maxCount: sl.maxCount,
+      windowSeconds: sl.windowSeconds
+    })),
+    aiTriggerThreshold: result.aiTriggerThreshold,
+    requireAiVerification: result.requireAiVerification
+  };
+}
+async function isBotActive(publicClient, vaultAddress, botAddress) {
+  return publicClient.readContract({
+    address: vaultAddress,
+    abi: AxonVaultAbi,
+    functionName: "isBotActive",
+    args: [botAddress]
+  });
+}
+async function getOperatorCeilings(publicClient, vaultAddress) {
+  const result = await publicClient.readContract({
+    address: vaultAddress,
+    abi: AxonVaultAbi,
+    functionName: "operatorCeilings"
+  });
+  const [maxPerTxAmount, maxBotDailyLimit, maxOperatorBots, vaultDailyAggregate, minAiTriggerFloor] = result;
+  return {
+    maxPerTxAmount,
+    maxBotDailyLimit,
+    maxOperatorBots,
+    vaultDailyAggregate,
+    minAiTriggerFloor
+  };
+}
+async function operatorMaxDrainPerDay(publicClient, vaultAddress) {
+  return publicClient.readContract({
+    address: vaultAddress,
+    abi: AxonVaultAbi,
+    functionName: "operatorMaxDrainPerDay"
+  });
+}
+async function isVaultPaused(publicClient, vaultAddress) {
+  return publicClient.readContract({
+    address: vaultAddress,
+    abi: AxonVaultAbi,
+    functionName: "paused"
+  });
+}
+async function getDomainSeparator(publicClient, vaultAddress) {
+  return publicClient.readContract({
+    address: vaultAddress,
+    abi: AxonVaultAbi,
+    functionName: "DOMAIN_SEPARATOR"
+  });
+}
+async function getVaultVersion(publicClient, vaultAddress) {
+  const version = await publicClient.readContract({
+    address: vaultAddress,
+    abi: AxonVaultAbi,
+    functionName: "VERSION"
+  });
+  return Number(version);
+}
+async function getVaultOwner(publicClient, vaultAddress) {
+  return publicClient.readContract({
+    address: vaultAddress,
+    abi: AxonVaultAbi,
+    functionName: "owner"
+  });
+}
+async function getVaultOperator(publicClient, vaultAddress) {
+  return publicClient.readContract({
+    address: vaultAddress,
+    abi: AxonVaultAbi,
+    functionName: "operator"
+  });
+}
+async function isDestinationAllowed(publicClient, vaultAddress, botAddress, destination) {
+  const isBlacklisted = await publicClient.readContract({
+    address: vaultAddress,
+    abi: AxonVaultAbi,
+    functionName: "globalDestinationBlacklist",
+    args: [destination]
+  });
+  if (isBlacklisted) {
+    return { allowed: false, reason: "Destination is on the global blacklist" };
+  }
+  const globalCount = await publicClient.readContract({
+    address: vaultAddress,
+    abi: AxonVaultAbi,
+    functionName: "globalDestinationCount"
+  });
+  if (globalCount > 0n) {
+    const isGlobalWhitelisted = await publicClient.readContract({
+      address: vaultAddress,
+      abi: AxonVaultAbi,
+      functionName: "globalDestinationWhitelist",
+      args: [destination]
+    });
+    if (!isGlobalWhitelisted) {
+      return { allowed: false, reason: "Destination is not on the global whitelist" };
+    }
+  }
+  const botCount = await publicClient.readContract({
+    address: vaultAddress,
+    abi: AxonVaultAbi,
+    functionName: "botDestinationCount",
+    args: [botAddress]
+  });
+  if (botCount > 0n) {
+    const isBotWhitelisted = await publicClient.readContract({
+      address: vaultAddress,
+      abi: AxonVaultAbi,
+      functionName: "botDestinationWhitelist",
+      args: [botAddress, destination]
+    });
+    if (!isBotWhitelisted) {
+      return { allowed: false, reason: "Destination is not on the bot whitelist" };
+    }
+  }
+  return { allowed: true };
+}
+async function getRebalanceTokenCount(publicClient, vaultAddress) {
+  const count = await publicClient.readContract({
+    address: vaultAddress,
+    abi: AxonVaultAbi,
+    functionName: "rebalanceTokenCount"
+  });
+  return Number(count);
+}
+async function isRebalanceTokenWhitelisted(publicClient, vaultAddress, token) {
+  return publicClient.readContract({
+    address: vaultAddress,
+    abi: AxonVaultAbi,
+    functionName: "rebalanceTokenWhitelist",
+    args: [token]
+  });
+}
+async function deployVault(walletClient, publicClient, factoryAddress) {
+  if (!walletClient.account) {
+    throw new Error("walletClient has no account attached");
+  }
+  const hash = await walletClient.writeContract({
+    address: factoryAddress,
+    abi: AxonVaultFactoryAbi,
+    functionName: "deployVault",
+    args: [],
+    account: walletClient.account,
+    chain: walletClient.chain ?? null
+  });
+  const receipt = await publicClient.waitForTransactionReceipt({ hash });
+  for (const log of receipt.logs) {
+    try {
+      if (log.topics.length >= 3 && log.topics[2]) {
+        const vaultAddress = `0x${log.topics[2].slice(26)}`;
+        return vaultAddress;
+      }
+    } catch {
+    }
+  }
+  throw new Error("VaultDeployed event not found in transaction receipt");
+}
+
+// src/tokens.ts
+var Token = /* @__PURE__ */ ((Token2) => {
+  Token2["USDC"] = "USDC";
+  Token2["USDT"] = "USDT";
+  Token2["DAI"] = "DAI";
+  Token2["WETH"] = "WETH";
+  Token2["WBTC"] = "WBTC";
+  Token2["cbBTC"] = "cbBTC";
+  Token2["cbETH"] = "cbETH";
+  Token2["wstETH"] = "wstETH";
+  Token2["rETH"] = "rETH";
+  Token2["LINK"] = "LINK";
+  Token2["UNI"] = "UNI";
+  Token2["AAVE"] = "AAVE";
+  Token2["COMP"] = "COMP";
+  Token2["CRV"] = "CRV";
+  Token2["SNX"] = "SNX";
+  Token2["ARB"] = "ARB";
+  Token2["AERO"] = "AERO";
+  Token2["GMX"] = "GMX";
+  return Token2;
+})(Token || {});
+var KNOWN_TOKENS = {
+  // ── Core stables + wrapped ──────────────────────────────
+  USDC: {
+    symbol: "USDC",
+    name: "USD Coin",
+    decimals: 6,
+    addresses: {
+      8453: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+      84532: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+      42161: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+      421614: "0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d"
+    }
+  },
+  USDT: {
+    symbol: "USDT",
+    name: "Tether USD",
+    decimals: 6,
+    addresses: {
+      8453: "0xfde4C96c8593536E31F229EA8f37b2ADa2699bb2",
+      84532: "0x323e78f944A9a1FcF3a10efcC5319DBb0bB6e673",
+      42161: "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9"
+    }
+  },
+  DAI: {
+    symbol: "DAI",
+    name: "Dai Stablecoin",
+    decimals: 18,
+    addresses: {
+      8453: "0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb",
+      84532: "0x819ffecd4e64f193e959944bcd57eedc7755e17a",
+      42161: "0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1"
+    }
+  },
+  WETH: {
+    symbol: "WETH",
+    name: "Wrapped Ether",
+    decimals: 18,
+    addresses: {
+      8453: "0x4200000000000000000000000000000000000006",
+      84532: "0x4200000000000000000000000000000000000006",
+      42161: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
+      421614: "0x980B62Da83eFf3D4576C647993b0c1D7faf17c73"
+    }
+  },
+  WBTC: {
+    symbol: "WBTC",
+    name: "Wrapped BTC",
+    decimals: 8,
+    addresses: {
+      8453: "0x0555E30da8f98308EdB960aa94C0Db47230d2B9c",
+      42161: "0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f"
+    }
+  },
+  cbBTC: {
+    symbol: "cbBTC",
+    name: "Coinbase Wrapped BTC",
+    decimals: 8,
+    addresses: {
+      8453: "0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf",
+      42161: "0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf"
+    }
+  },
+  // ── Liquid staking ──────────────────────────────────────
+  cbETH: {
+    symbol: "cbETH",
+    name: "Coinbase Staked ETH",
+    decimals: 18,
+    addresses: {
+      8453: "0x2Ae3F1Ec7F1F5012CFEab0185bfc7aa3cf0DEc22",
+      42161: "0x1DEBd73E752bEaF79865Fd6446b0c970EaE7732f"
+    }
+  },
+  wstETH: {
+    symbol: "wstETH",
+    name: "Lido Wrapped stETH",
+    decimals: 18,
+    addresses: {
+      8453: "0xc1CBa3fCea344f92D9239c08C0568f6F2F0ee452",
+      42161: "0x5979D7b546E38E414F7E9822514be443A4800529"
+    }
+  },
+  rETH: {
+    symbol: "rETH",
+    name: "Rocket Pool ETH",
+    decimals: 18,
+    addresses: {
+      42161: "0xEC70Dcb4A1EFa46b8F2D97C310C9c4790ba5ffA8"
+    }
+  },
+  // ── DeFi blue-chips ─────────────────────────────────────
+  LINK: {
+    symbol: "LINK",
+    name: "Chainlink",
+    decimals: 18,
+    addresses: {
+      8453: "0x88Fb150BDc53A65fe94Dea0c9BA0a6dAf8C6e196",
+      84532: "0xE4aB69C077896252FAFBD49EFD26B5D171A32410",
+      42161: "0xf97f4df75117a78c1A5a0DBb814Af92458539FB4"
+    }
+  },
+  UNI: {
+    symbol: "UNI",
+    name: "Uniswap",
+    decimals: 18,
+    addresses: {
+      8453: "0xc3De830EA07524a0761646a6a4e4be0e114a3C83",
+      42161: "0xFa7F8980b0f1E64A2062791cc3b0871572f1F7f0"
+    }
+  },
+  AAVE: {
+    symbol: "AAVE",
+    name: "Aave",
+    decimals: 18,
+    addresses: {
+      8453: "0x63706e401c06ac8513145b7687A14804d17f814b",
+      42161: "0xba5DdD1f9d7F570dc94a51479a000E3BCE967196"
+    }
+  },
+  COMP: {
+    symbol: "COMP",
+    name: "Compound",
+    decimals: 18,
+    addresses: {
+      8453: "0x9e1028F5F1D5eDE59748FFceE5532509976840E0",
+      42161: "0x354A6dA3fcde098F8389cad84b0182725c6C91dE"
+    }
+  },
+  CRV: {
+    symbol: "CRV",
+    name: "Curve DAO",
+    decimals: 18,
+    addresses: {
+      8453: "0x8Ee73c484A26e0A5df2Ee2a4960B789967dd0415",
+      42161: "0x11cDb42B0EB46D95f990BeDD4695A6e3fA034978"
+    }
+  },
+  SNX: {
+    symbol: "SNX",
+    name: "Synthetix",
+    decimals: 18,
+    addresses: {
+      8453: "0x22e6966B799c4D5B13BE962E1D117b56327FDa66"
+    }
+  },
+  // ── Chain-native governance ─────────────────────────────
+  ARB: {
+    symbol: "ARB",
+    name: "Arbitrum",
+    decimals: 18,
+    addresses: {
+      42161: "0x912CE59144191C1204E64559FE8253a0e49E6548"
+    }
+  },
+  AERO: {
+    symbol: "AERO",
+    name: "Aerodrome",
+    decimals: 18,
+    addresses: {
+      8453: "0x940181a94A35A4569E4529A3CDfB74e38FD98631"
+    }
+  },
+  GMX: {
+    symbol: "GMX",
+    name: "GMX",
+    decimals: 18,
+    addresses: {
+      42161: "0xfc5A1A6EB076a2C7aD06eD22C90d7E710E35ad0a"
+    }
+  }
+};
+var addressToSymbol = /* @__PURE__ */ new Map();
+for (const token of Object.values(KNOWN_TOKENS)) {
+  for (const addr of Object.values(token.addresses)) {
+    addressToSymbol.set(addr.toLowerCase(), token.symbol);
+  }
+}
+function getKnownTokensForChain(chainId) {
+  const result = [];
+  for (const token of Object.values(KNOWN_TOKENS)) {
+    const addr = token.addresses[chainId];
+    if (addr) {
+      result.push({ ...token, address: addr });
+    }
+  }
+  return result;
+}
+function getTokenSymbolByAddress(address) {
+  return addressToSymbol.get(address.toLowerCase()) ?? null;
+}
+function resolveToken(token, chainId) {
+  if (typeof token === "string" && token.startsWith("0x")) {
+    if (token === "0x0000000000000000000000000000000000000000") {
+      throw new Error("Token address cannot be the zero address");
+    }
+    return token;
+  }
+  const entry = KNOWN_TOKENS[token];
+  if (!entry) {
+    throw new Error(`Unknown token symbol: ${token}`);
+  }
+  const addr = entry.addresses[chainId];
+  if (!addr) {
+    throw new Error(`Token ${token} is not available on chain ${chainId}`);
+  }
+  return addr;
+}
+function resolveTokenDecimals(token, chainId) {
+  if (typeof token === "string" && token.startsWith("0x")) {
+    const symbol = getTokenSymbolByAddress(token);
+    if (!symbol) {
+      throw new Error(
+        `Unknown token address ${token} \u2014 cannot determine decimals. Use a bigint amount instead, or pass a known token symbol.`
+      );
+    }
+    const entry2 = KNOWN_TOKENS[symbol];
+    return entry2.decimals;
+  }
+  const entry = KNOWN_TOKENS[token];
+  if (!entry) {
+    throw new Error(
+      `Unknown token symbol "${token}" \u2014 cannot determine decimals. Use a bigint amount instead, or use a known symbol (${Object.keys(KNOWN_TOKENS).join(", ")}).`
+    );
+  }
+  return entry.decimals;
+}
+function parseAmount(amount, token, chainId) {
+  if (typeof amount === "bigint") {
+    return amount;
+  }
+  const decimals = resolveTokenDecimals(token);
+  const str = typeof amount === "number" ? amount.toString() : amount;
+  const dotIndex = str.indexOf(".");
+  if (dotIndex !== -1) {
+    const decimalPlaces = str.length - dotIndex - 1;
+    if (decimalPlaces > decimals) {
+      throw new Error(
+        `Amount "${str}" has ${decimalPlaces} decimal places, but ${typeof token === "string" && token.startsWith("0x") ? "this token" : token} only supports ${decimals}. Truncate or round your amount.`
+      );
+    }
+  }
+  return viem.parseUnits(str, decimals);
+}
+
+// src/utils.ts
+function generateUuid() {
+  const bytes = new Uint8Array(16);
+  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+    crypto.getRandomValues(bytes);
+  } else {
+    const { randomBytes } = __require("crypto");
+    const buf = randomBytes(16);
+    for (let i = 0; i < 16; i++) bytes[i] = buf[i] ?? 0;
+  }
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+
+// src/x402.ts
+function parsePaymentRequired(headerValue) {
+  let decoded;
+  try {
+    decoded = atob(headerValue);
+  } catch {
+    decoded = headerValue;
+  }
+  const parsed = JSON.parse(decoded);
+  if (!parsed.accepts || !Array.isArray(parsed.accepts) || parsed.accepts.length === 0) {
+    throw new Error("x402: no payment options in PAYMENT-REQUIRED header");
+  }
+  if (!parsed.resource) {
+    throw new Error("x402: missing resource in PAYMENT-REQUIRED header");
+  }
+  return parsed;
+}
+function parseChainId(network) {
+  const parts = network.split(":");
+  if (parts.length !== 2 || parts[0] !== "eip155") {
+    throw new Error(`x402: unsupported network format "${network}" (expected "eip155:<chainId>")`);
+  }
+  const chainId = parseInt(parts[1], 10);
+  if (isNaN(chainId)) {
+    throw new Error(`x402: invalid chain ID in network "${network}"`);
+  }
+  return chainId;
+}
+function findMatchingOption(accepts, chainId) {
+  const matchingOptions = [];
+  for (const option of accepts) {
+    try {
+      const optionChainId = parseChainId(option.network);
+      if (optionChainId === chainId) {
+        matchingOptions.push(option);
+      }
+    } catch {
+      continue;
+    }
+  }
+  if (matchingOptions.length === 0) return null;
+  const usdcAddress = USDC[chainId]?.toLowerCase();
+  if (usdcAddress) {
+    const usdcOption = matchingOptions.find((opt) => opt.asset.toLowerCase() === usdcAddress);
+    if (usdcOption) return usdcOption;
+  }
+  return matchingOptions[0] ?? null;
+}
+function extractX402Metadata(parsed, selectedOption) {
+  const metadata = {};
+  if (parsed.x402Version !== void 0) {
+    metadata.x402_version = String(parsed.x402Version);
+  }
+  if (selectedOption.scheme) {
+    metadata.x402_scheme = selectedOption.scheme;
+  }
+  if (parsed.resource.mimeType) {
+    metadata.x402_mime_type = parsed.resource.mimeType;
+  }
+  if (selectedOption.payTo) {
+    metadata.x402_merchant = selectedOption.payTo;
+  }
+  if (parsed.resource.description) {
+    metadata.x402_resource_description = parsed.resource.description;
+  }
+  return {
+    resourceUrl: parsed.resource.url,
+    memo: parsed.resource.description ?? null,
+    recipientLabel: selectedOption.payTo ? `${selectedOption.payTo.slice(0, 6)}...${selectedOption.payTo.slice(-4)}` : null,
+    metadata
+  };
+}
+function formatPaymentSignature(payload) {
+  const json = JSON.stringify(payload);
+  return btoa(json);
+}
+var USDC_EIP712_DOMAIN = {
+  // Base mainnet
+  8453: { name: "USD Coin", version: "2" },
+  // Base Sepolia
+  84532: { name: "USDC", version: "2" },
+  // Arbitrum One
+  42161: { name: "USD Coin", version: "2" },
+  // Arbitrum Sepolia (same as mainnet convention)
+  421614: { name: "USDC", version: "2" }
+};
+var TRANSFER_WITH_AUTHORIZATION_TYPES = {
+  TransferWithAuthorization: [
+    { name: "from", type: "address" },
+    { name: "to", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "validAfter", type: "uint256" },
+    { name: "validBefore", type: "uint256" },
+    { name: "nonce", type: "bytes32" }
+  ]
+};
+function randomNonce() {
+  const bytes = new Uint8Array(32);
+  crypto.getRandomValues(bytes);
+  return `0x${Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("")}`;
+}
+async function signTransferWithAuthorization(privateKey, chainId, auth) {
+  const domainConfig = USDC_EIP712_DOMAIN[chainId];
+  if (!domainConfig) {
+    throw new Error(`EIP-3009 not configured for chain ${chainId}`);
+  }
+  const usdcAddress = USDC[chainId];
+  if (!usdcAddress) {
+    throw new Error(`USDC address not known for chain ${chainId}`);
+  }
+  const account = accounts.privateKeyToAccount(privateKey);
+  return account.signTypedData({
+    domain: {
+      name: domainConfig.name,
+      version: domainConfig.version,
+      chainId,
+      verifyingContract: usdcAddress
+    },
+    types: TRANSFER_WITH_AUTHORIZATION_TYPES,
+    primaryType: "TransferWithAuthorization",
+    message: {
+      from: auth.from,
+      to: auth.to,
+      value: auth.value,
+      validAfter: auth.validAfter,
+      validBefore: auth.validBefore,
+      nonce: auth.nonce
+    }
+  });
+}
+var PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+var X402_PROXY_ADDRESS = "0x4020CD856C882D5fb903D99CE35316A085Bb0001";
+var WITNESS_TYPE_STRING = "TransferDetails witness)TokenPermissions(address token,uint256 amount)TransferDetails(address to,uint256 requestedAmount)";
+var PERMIT_WITNESS_TRANSFER_FROM_TYPES = {
+  PermitWitnessTransferFrom: [
+    { name: "permitted", type: "TokenPermissions" },
+    { name: "spender", type: "address" },
+    { name: "nonce", type: "uint256" },
+    { name: "deadline", type: "uint256" },
+    { name: "witness", type: "TransferDetails" }
+  ],
+  TokenPermissions: [
+    { name: "token", type: "address" },
+    { name: "amount", type: "uint256" }
+  ],
+  TransferDetails: [
+    { name: "to", type: "address" },
+    { name: "requestedAmount", type: "uint256" }
+  ]
+};
+function randomPermit2Nonce() {
+  const bytes = new Uint8Array(32);
+  crypto.getRandomValues(bytes);
+  let n = 0n;
+  for (const b of bytes) {
+    n = n << 8n | BigInt(b);
+  }
+  return n;
+}
+async function signPermit2WitnessTransfer(privateKey, chainId, permit) {
+  const account = accounts.privateKeyToAccount(privateKey);
+  return account.signTypedData({
+    domain: {
+      name: "Permit2",
+      chainId,
+      verifyingContract: PERMIT2_ADDRESS
+    },
+    types: PERMIT_WITNESS_TRANSFER_FROM_TYPES,
+    primaryType: "PermitWitnessTransferFrom",
+    message: {
+      permitted: {
+        token: permit.token,
+        amount: permit.amount
+      },
+      spender: permit.spender,
+      nonce: permit.nonce,
+      deadline: permit.deadline,
+      witness: {
+        to: permit.witnessTo,
+        requestedAmount: permit.witnessRequestedAmount
+      }
+    }
+  });
+}
+
+// src/client.ts
+var AxonClient = class {
+  constructor(config) {
+    // ============================================================================
+    // x402 — HTTP 402 Payment Required
+    // ============================================================================
+    /**
+     * x402 utilities for handling HTTP 402 Payment Required responses.
+     *
+     * The x402 flow:
+     * 1. Bot hits an API that returns HTTP 402 + PAYMENT-REQUIRED header
+     * 2. SDK parses the header, finds a matching payment option
+     * 3. SDK funds the bot's EOA from the vault (full Axon pipeline applies)
+     * 4. Bot signs an EIP-3009 or Permit2 authorization
+     * 5. SDK returns a PAYMENT-SIGNATURE header for the bot to retry with
+     *
+     * @example
+     * ```ts
+     * const response = await fetch('https://api.example.com/data');
+     * if (response.status === 402) {
+     *   const result = await client.x402.handlePaymentRequired(response.headers);
+     *   const data = await fetch('https://api.example.com/data', {
+     *     headers: { 'PAYMENT-SIGNATURE': result.paymentSignature },
+     *   });
+     * }
+     * ```
+     */
+    this.x402 = {
+      /**
+       * Fund the bot's EOA from the vault for x402 settlement.
+       *
+       * This is a regular Axon payment (to = bot's own address) that goes through
+       * the full pipeline: policy engine, AI scan, human review if needed.
+       *
+       * @param amount - Amount in token base units
+       * @param token - Token address (defaults to USDC on this chain)
+       * @param metadata - Optional metadata for the payment record
+       */
+      fund: async (amount, token, metadata) => {
+        const tokenAddress = token ?? USDC[this.chainId];
+        if (!tokenAddress) {
+          throw new Error(`No default USDC address for chain ${this.chainId}`);
+        }
+        return this.pay({
+          to: this.botAddress,
+          token: tokenAddress,
+          amount,
+          x402Funding: true,
+          ...metadata
+        });
+      },
+      /**
+       * Handle a full x402 flow: parse header, fund bot, sign authorization, return header.
+       *
+       * Supports both EIP-3009 (USDC) and Permit2 (any ERC-20) settlement.
+       * The bot's EOA is funded from the vault first (full Axon pipeline applies).
+       *
+       * @param headers - Response headers from the 402 response (must contain PAYMENT-REQUIRED)
+       * @param maxTimeoutMs - Maximum time to wait for pending_review resolution (default: 120s)
+       * @param pollIntervalMs - Polling interval for pending_review (default: 5s)
+       * @returns Payment signature header value + funding details
+       */
+      handlePaymentRequired: async (headers, maxTimeoutMs = 12e4, pollIntervalMs = 5e3) => {
+        const headerValue = headers instanceof Headers ? headers.get("payment-required") ?? headers.get("PAYMENT-REQUIRED") : headers["payment-required"] ?? headers["PAYMENT-REQUIRED"];
+        if (!headerValue) {
+          throw new Error("x402: no PAYMENT-REQUIRED header found");
+        }
+        const parsed = parsePaymentRequired(headerValue);
+        const option = findMatchingOption(parsed.accepts, this.chainId);
+        if (!option) {
+          throw new Error(
+            `x402: no payment option matches chain ${this.chainId}. Available: ${parsed.accepts.map((a) => a.network).join(", ")}`
+          );
+        }
+        const x402Meta = extractX402Metadata(parsed, option);
+        const amount = BigInt(option.amount);
+        const tokenAddress = option.asset;
+        const payInput = {
+          to: this.botAddress,
+          token: tokenAddress,
+          amount,
+          x402Funding: true,
+          resourceUrl: x402Meta.resourceUrl,
+          metadata: x402Meta.metadata
+        };
+        if (x402Meta.memo) payInput.memo = x402Meta.memo;
+        if (x402Meta.recipientLabel) payInput.recipientLabel = x402Meta.recipientLabel;
+        let fundingResult = await this.pay(payInput);
+        if (fundingResult.status === "pending_review") {
+          const deadline = Date.now() + maxTimeoutMs;
+          while (fundingResult.status === "pending_review" && Date.now() < deadline) {
+            await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+            fundingResult = await this.poll(fundingResult.requestId);
+          }
+          if (fundingResult.status === "pending_review") {
+            throw new Error(`x402: funding timed out after ${maxTimeoutMs}ms (still pending_review)`);
+          }
+        }
+        if (fundingResult.status === "rejected") {
+          throw new Error(`x402: funding rejected \u2014 ${fundingResult.reason ?? "unknown reason"}`);
+        }
+        const botPrivateKey = this.botPrivateKey;
+        const payTo = option.payTo;
+        const usdcAddress = USDC[this.chainId]?.toLowerCase();
+        const isUsdc = tokenAddress.toLowerCase() === usdcAddress;
+        let signaturePayload;
+        if (isUsdc && USDC_EIP712_DOMAIN[this.chainId]) {
+          const nonce = randomNonce();
+          const validAfter = 0n;
+          const validBefore = BigInt(Math.floor(Date.now() / 1e3) + 300);
+          const sig = await signTransferWithAuthorization(botPrivateKey, this.chainId, {
+            from: this.botAddress,
+            to: payTo,
+            value: amount,
+            validAfter,
+            validBefore,
+            nonce
+          });
+          signaturePayload = {
+            scheme: "exact",
+            signature: sig,
+            authorization: {
+              from: this.botAddress,
+              to: payTo,
+              value: amount.toString(),
+              validAfter: validAfter.toString(),
+              validBefore: validBefore.toString(),
+              nonce
+            }
+          };
+        } else {
+          const nonce = randomPermit2Nonce();
+          const deadline = BigInt(Math.floor(Date.now() / 1e3) + 300);
+          const sig = await signPermit2WitnessTransfer(botPrivateKey, this.chainId, {
+            token: tokenAddress,
+            amount,
+            spender: X402_PROXY_ADDRESS,
+            nonce,
+            deadline,
+            witnessTo: payTo,
+            witnessRequestedAmount: amount
+          });
+          signaturePayload = {
+            scheme: "permit2",
+            signature: sig,
+            permit: {
+              permitted: { token: tokenAddress, amount: amount.toString() },
+              spender: X402_PROXY_ADDRESS,
+              nonce: nonce.toString(),
+              deadline: deadline.toString()
+            },
+            witness: {
+              to: payTo,
+              requestedAmount: amount.toString()
+            }
+          };
+        }
+        const paymentSignature = formatPaymentSignature(signaturePayload);
+        const handleResult = {
+          paymentSignature,
+          selectedOption: option,
+          fundingResult: {
+            requestId: fundingResult.requestId,
+            status: fundingResult.status
+          }
+        };
+        if (fundingResult.txHash) {
+          handleResult.fundingResult.txHash = fundingResult.txHash;
+        }
+        return handleResult;
+      }
+    };
+    this.vaultAddress = config.vaultAddress;
+    this.chainId = config.chainId;
+    this.relayerUrl = config.relayerUrl ?? "https://relay.axonfi.xyz";
+    if (!config.botPrivateKey) {
+      throw new Error("botPrivateKey is required in AxonClientConfig");
+    }
+    this.botPrivateKey = config.botPrivateKey;
+    this.walletClient = createAxonWalletClient(config.botPrivateKey, config.chainId);
+  }
+  // ============================================================================
+  // Bot address
+  // ============================================================================
+  /** Returns the bot's address derived from the configured private key. */
+  get botAddress() {
+    const account = this.walletClient.account;
+    if (!account) throw new Error("No account on walletClient");
+    return account.address;
+  }
+  // ============================================================================
+  // pay()
+  // ============================================================================
+  /**
+   * Create, sign, and submit a payment intent to the Axon relayer.
+   *
+   * Three possible outcomes (all included in PaymentResult.status):
+   * - `"approved"`: fast path — txHash available immediately
+   * - `"pending_review"`: AI scan or human review in progress — poll for status
+   * - `"rejected"`: payment was rejected — reason field explains why
+   */
+  async pay(input) {
+    const intent = this._buildPaymentIntent(input);
+    const signature = await signPayment(this.walletClient, this.vaultAddress, this.chainId, intent);
+    return this._submitPayment(intent, signature, input);
+  }
+  // ============================================================================
+  // execute()
+  // ============================================================================
+  /**
+   * Sign and submit a DeFi protocol execution to the Axon relayer.
+   *
+   * The vault approves `token` to `protocol`, calls it with `callData`,
+   * then revokes the approval. Tokens stay in the vault or go to the protocol
+   * as specified by the calldata.
+   */
+  async execute(input) {
+    const intent = this._buildExecuteIntent(input);
+    const signature = await signExecuteIntent(this.walletClient, this.vaultAddress, this.chainId, intent);
+    return this._submitExecute(intent, signature, input);
+  }
+  // ============================================================================
+  // swap()
+  // ============================================================================
+  /**
+   * Sign and submit an in-vault token swap to the Axon relayer.
+   *
+   * Swaps tokens within the vault (no external recipient). Useful for
+   * rebalancing vault holdings.
+   */
+  async swap(input) {
+    const intent = this._buildSwapIntent(input);
+    const signature = await signSwapIntent(this.walletClient, this.vaultAddress, this.chainId, intent);
+    return this._submitSwap(intent, signature, input);
+  }
+  // ============================================================================
+  // getBalance() — via relayer
+  // ============================================================================
+  /** Read the vault's ERC-20 balance for a given token (via relayer). */
+  async getBalance(token) {
+    const path = RELAYER_API.vaultBalance(this.vaultAddress, token, this.chainId);
+    const data = await this._get(path);
+    return BigInt(data.balance);
+  }
+  // ============================================================================
+  // getBalances() — via relayer
+  // ============================================================================
+  /**
+   * Read the vault's ERC-20 balances for multiple tokens in a single call (via relayer).
+   * Returns a record mapping token address → balance.
+   */
+  async getBalances(tokens) {
+    const path = RELAYER_API.vaultBalances(this.vaultAddress, this.chainId);
+    const url = `${this.relayerUrl}${path}?chainId=${this.chainId}&tokens=${tokens.join(",")}`;
+    const response = await fetch(url, {
+      method: "GET",
+      headers: { "Content-Type": "application/json" }
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(`Relayer request failed [${response.status}]: ${body}`);
+    }
+    const data = await response.json();
+    const result = {};
+    for (const [addr, val] of Object.entries(data.balances)) {
+      result[addr] = BigInt(val);
+    }
+    return result;
+  }
+  // ============================================================================
+  // isActive() — via relayer
+  // ============================================================================
+  /** Returns whether this bot is registered and active in the vault (via relayer). */
+  async isActive() {
+    const path = RELAYER_API.botStatus(this.vaultAddress, this.botAddress, this.chainId);
+    const data = await this._get(path);
+    return data.isActive;
+  }
+  // ============================================================================
+  // isPaused() — via relayer
+  // ============================================================================
+  /** Returns whether the vault is currently paused (via relayer). */
+  async isPaused() {
+    const path = RELAYER_API.vaultInfo(this.vaultAddress, this.chainId);
+    const data = await this._get(path);
+    return data.paused;
+  }
+  // ============================================================================
+  // getVaultInfo() — via relayer
+  // ============================================================================
+  /** Returns high-level vault info (owner, operator, paused, version) via relayer. */
+  async getVaultInfo() {
+    const path = RELAYER_API.vaultInfo(this.vaultAddress, this.chainId);
+    return this._get(path);
+  }
+  // ============================================================================
+  // canPayTo() — via relayer
+  // ============================================================================
+  /**
+   * Check whether this bot can pay to a given destination address (via relayer).
+   * Checks blacklist → global whitelist → bot whitelist, matching on-chain logic.
+   */
+  async canPayTo(destination) {
+    const path = RELAYER_API.destinationCheck(this.vaultAddress, this.botAddress, destination, this.chainId);
+    return this._get(path);
+  }
+  // ============================================================================
+  // isProtocolApproved() — via relayer
+  // ============================================================================
+  /** Returns whether a protocol address is approved for executeProtocol() calls (via relayer). */
+  async isProtocolApproved(protocol) {
+    const path = RELAYER_API.protocolCheck(this.vaultAddress, protocol, this.chainId);
+    const data = await this._get(path);
+    return data.approved;
+  }
+  // ============================================================================
+  // getRebalanceTokens() — via relayer
+  // ============================================================================
+  /**
+   * Returns the effective rebalance token whitelist for this vault.
+   *
+   * If the owner set tokens on-chain, those override entirely.
+   * If no on-chain whitelist, returns relayer defaults (USDC, WETH, USDT).
+   * Use this before calling swap() to check which output tokens are allowed.
+   */
+  async getRebalanceTokens() {
+    const path = RELAYER_API.rebalanceTokens(this.vaultAddress, this.chainId);
+    return this._get(path);
+  }
+  // ============================================================================
+  // isRebalanceTokenAllowed() — via relayer
+  // ============================================================================
+  /** Check if a specific token is allowed for rebalancing (executeSwap output) on this vault. */
+  async isRebalanceTokenAllowed(token) {
+    const path = RELAYER_API.rebalanceTokenCheck(this.vaultAddress, token, this.chainId);
+    return this._get(path);
+  }
+  // ============================================================================
+  // TOS (Terms of Service)
+  // ============================================================================
+  /** Check if a wallet has accepted the current TOS version. */
+  async getTosStatus(wallet) {
+    return this._get(RELAYER_API.tosStatus(wallet));
+  }
+  /**
+   * Sign and submit TOS acceptance. Uses the owner's wallet (not the bot key).
+   *
+   * @param signer - Object with a `signMessage` method (e.g. a viem WalletClient
+   *   or ethers Signer). This should be the vault owner's wallet, not the bot key.
+   * @param wallet - The owner's wallet address (must match the signer).
+   */
+  async acceptTos(signer, wallet) {
+    const { tosVersion } = await this.getTosStatus(wallet);
+    const timestamp = Math.floor(Date.now() / 1e3);
+    const message = `I accept the Axon Terms of Service (${tosVersion}).
+Wallet: ${wallet}
+Timestamp: ${timestamp}`;
+    const signature = await signer.signMessage({ message });
+    const url = `${this.relayerUrl}${RELAYER_API.TOS_ACCEPT}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ wallet, signature, tosVersion, timestamp })
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(`TOS acceptance failed [${response.status}]: ${body}`);
+    }
+    return response.json();
+  }
+  // ============================================================================
+  // poll() / pollExecute() / pollSwap()
+  // ============================================================================
+  /**
+   * Poll the relayer for the status of an async payment.
+   *
+   * Use this when pay() returns `status: "pending_review"`. Poll until
+   * status is `"approved"` or `"rejected"`.
+   *
+   * Recommended polling interval: 5–10 seconds.
+   */
+  async poll(requestId) {
+    return this._get(RELAYER_API.payment(requestId));
+  }
+  /** Poll the relayer for the status of an async protocol execution. */
+  async pollExecute(requestId) {
+    return this._get(RELAYER_API.execute(requestId));
+  }
+  /** Poll the relayer for the status of an async swap. */
+  async pollSwap(requestId) {
+    return this._get(RELAYER_API.swap(requestId));
+  }
+  // ============================================================================
+  // signPayment() — low-level access
+  // ============================================================================
+  /**
+   * Sign a PaymentIntent directly without submitting to the relayer.
+   *
+   * Use this if you want to build the intent yourself and pass the signature
+   * to another system (e.g. a custom relayer integration).
+   */
+  async signPayment(intent) {
+    return signPayment(this.walletClient, this.vaultAddress, this.chainId, intent);
+  }
+  // ============================================================================
+  // Internal helpers
+  // ============================================================================
+  async _get(path) {
+    const url = `${this.relayerUrl}${path}`;
+    const response = await fetch(url, {
+      method: "GET",
+      headers: { "Content-Type": "application/json" }
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(`Relayer request failed [${response.status}]: ${body}`);
+    }
+    return response.json();
+  }
+  _defaultDeadline() {
+    return BigInt(Math.floor(Date.now() / 1e3) + DEFAULT_DEADLINE_SECONDS);
+  }
+  _resolveRef(memo, ref) {
+    if (ref) return ref;
+    if (memo) return encodeRef(memo);
+    return "0x0000000000000000000000000000000000000000000000000000000000000000";
+  }
+  _buildPaymentIntent(input) {
+    if (input.to === "0x0000000000000000000000000000000000000000") {
+      throw new Error("Payment recipient cannot be the zero address");
+    }
+    return {
+      bot: this.botAddress,
+      to: input.to,
+      token: resolveToken(input.token, this.chainId),
+      amount: parseAmount(input.amount, input.token, this.chainId),
+      deadline: input.deadline ?? this._defaultDeadline(),
+      ref: this._resolveRef(input.memo, input.ref)
+    };
+  }
+  _buildExecuteIntent(input) {
+    return {
+      bot: this.botAddress,
+      protocol: input.protocol,
+      calldataHash: viem.keccak256(input.callData),
+      token: resolveToken(input.token, this.chainId),
+      amount: parseAmount(input.amount, input.token, this.chainId),
+      deadline: input.deadline ?? this._defaultDeadline(),
+      ref: this._resolveRef(input.memo, input.ref)
+    };
+  }
+  _buildSwapIntent(input) {
+    return {
+      bot: this.botAddress,
+      toToken: resolveToken(input.toToken, this.chainId),
+      minToAmount: parseAmount(input.minToAmount, input.toToken, this.chainId),
+      deadline: input.deadline ?? this._defaultDeadline(),
+      ref: this._resolveRef(input.memo, input.ref)
+    };
+  }
+  async _submitPayment(intent, signature, input) {
+    const idempotencyKey = input.idempotencyKey ?? generateUuid();
+    const body = {
+      // Routing
+      chainId: this.chainId,
+      vaultAddress: this.vaultAddress,
+      // Flat intent fields (matches relayer DTO)
+      bot: intent.bot,
+      to: intent.to,
+      token: intent.token,
+      amount: intent.amount.toString(),
+      deadline: intent.deadline.toString(),
+      ref: intent.ref,
+      signature,
+      // Off-chain metadata
+      idempotencyKey,
+      ...input.memo !== void 0 && { memo: input.memo },
+      ...input.resourceUrl !== void 0 && { resourceUrl: input.resourceUrl },
+      ...input.invoiceId !== void 0 && { invoiceId: input.invoiceId },
+      ...input.orderId !== void 0 && { orderId: input.orderId },
+      ...input.recipientLabel !== void 0 && { recipientLabel: input.recipientLabel },
+      ...input.metadata !== void 0 && { metadata: input.metadata },
+      ...input.x402Funding !== void 0 && { x402Funding: input.x402Funding }
+    };
+    return this._post(RELAYER_API.PAYMENTS, idempotencyKey, body);
+  }
+  async _submitExecute(intent, signature, input) {
+    const idempotencyKey = input.idempotencyKey ?? generateUuid();
+    const fromToken = input.fromToken !== void 0 ? resolveToken(input.fromToken, this.chainId) : void 0;
+    const maxFromAmount = input.maxFromAmount !== void 0 ? parseAmount(input.maxFromAmount, input.fromToken ?? input.token, this.chainId) : void 0;
+    const body = {
+      chainId: this.chainId,
+      vaultAddress: this.vaultAddress,
+      // Flat intent fields
+      bot: intent.bot,
+      protocol: intent.protocol,
+      calldataHash: intent.calldataHash,
+      token: intent.token,
+      amount: intent.amount.toString(),
+      deadline: intent.deadline.toString(),
+      ref: intent.ref,
+      signature,
+      // Protocol calldata
+      callData: input.callData,
+      // Optional pre-swap
+      ...fromToken !== void 0 && { fromToken },
+      ...maxFromAmount !== void 0 && { maxFromAmount: maxFromAmount.toString() },
+      // Off-chain metadata
+      idempotencyKey,
+      ...input.memo !== void 0 && { memo: input.memo },
+      ...input.protocolName !== void 0 && { protocolName: input.protocolName },
+      ...input.metadata !== void 0 && { metadata: input.metadata }
+    };
+    return this._post(RELAYER_API.EXECUTE, idempotencyKey, body);
+  }
+  async _submitSwap(intent, signature, input) {
+    const idempotencyKey = input.idempotencyKey ?? generateUuid();
+    const fromToken = input.fromToken !== void 0 ? resolveToken(input.fromToken, this.chainId) : void 0;
+    const maxFromAmount = input.maxFromAmount !== void 0 ? parseAmount(input.maxFromAmount, input.fromToken ?? input.toToken, this.chainId) : void 0;
+    const body = {
+      chainId: this.chainId,
+      vaultAddress: this.vaultAddress,
+      // Flat intent fields
+      bot: intent.bot,
+      toToken: intent.toToken,
+      minToAmount: intent.minToAmount.toString(),
+      deadline: intent.deadline.toString(),
+      ref: intent.ref,
+      signature,
+      // Optional source token
+      ...fromToken !== void 0 && { fromToken },
+      ...maxFromAmount !== void 0 && { maxFromAmount: maxFromAmount.toString() },
+      // Off-chain metadata
+      idempotencyKey,
+      ...input.memo !== void 0 && { memo: input.memo }
+    };
+    return this._post(RELAYER_API.SWAP, idempotencyKey, body);
+  }
+  async _post(path, idempotencyKey, body) {
+    const url = `${this.relayerUrl}${path}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Idempotency-Key": idempotencyKey
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const responseBody = await response.text();
+      throw new Error(`Relayer request failed [${response.status}]: ${responseBody}`);
+    }
+    return response.json();
+  }
+};
+var SCRYPT_N = 262144;
+var SCRYPT_R = 8;
+var SCRYPT_P = 1;
+var SCRYPT_DKLEN = 32;
+function getRandomBytes(length) {
+  const bytes = new Uint8Array(length);
+  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+    crypto.getRandomValues(bytes);
+  } else {
+    const { randomBytes } = __require("crypto");
+    const buf = randomBytes(length);
+    for (let i = 0; i < length; i++) bytes[i] = buf[i] ?? 0;
+  }
+  return bytes;
+}
+function hexToBytes(hex) {
+  const clean = hex.startsWith("0x") ? hex.slice(2) : hex;
+  const bytes = new Uint8Array(clean.length / 2);
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = parseInt(clean.slice(i * 2, i * 2 + 2), 16);
+  }
+  return bytes;
+}
+function bytesToHex(bytes) {
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function encryptKeystore(privateKey, passphrase) {
+  if (!passphrase) throw new Error("Passphrase must not be empty");
+  const keyBytes = hexToBytes(privateKey);
+  const account = accounts.privateKeyToAccount(privateKey);
+  const address = account.address.slice(2).toLowerCase();
+  const salt = getRandomBytes(32);
+  const iv = getRandomBytes(16);
+  const derivedKey = await scrypt.scryptAsync(new TextEncoder().encode(passphrase), salt, {
+    N: SCRYPT_N,
+    r: SCRYPT_R,
+    p: SCRYPT_P,
+    dkLen: SCRYPT_DKLEN
+  });
+  const encryptionKey = derivedKey.slice(0, 16);
+  const cipher = aes.ctr(encryptionKey, iv);
+  const ciphertext = cipher.encrypt(keyBytes);
+  const macInput = new Uint8Array(16 + ciphertext.length);
+  macInput.set(derivedKey.slice(16, 32), 0);
+  macInput.set(ciphertext, 16);
+  const mac = sha3.keccak_256(macInput);
+  return {
+    version: 3,
+    id: generateUuid(),
+    address,
+    crypto: {
+      ciphertext: bytesToHex(ciphertext),
+      cipherparams: { iv: bytesToHex(iv) },
+      cipher: "aes-128-ctr",
+      kdf: "scrypt",
+      kdfparams: {
+        dklen: SCRYPT_DKLEN,
+        salt: bytesToHex(salt),
+        n: SCRYPT_N,
+        r: SCRYPT_R,
+        p: SCRYPT_P
+      },
+      mac: bytesToHex(mac)
+    }
+  };
+}
+async function decryptKeystore(keystore, passphrase) {
+  let ks;
+  if (typeof keystore === "string") {
+    try {
+      ks = JSON.parse(keystore);
+    } catch {
+      throw new Error("Invalid keystore: could not parse JSON");
+    }
+  } else {
+    ks = keystore;
+  }
+  if (ks.version !== 3) throw new Error(`Unsupported keystore version: ${ks.version}`);
+  if (!ks.crypto) throw new Error("Invalid keystore: missing crypto field");
+  if (ks.crypto.kdf !== "scrypt") throw new Error(`Unsupported KDF: ${ks.crypto.kdf}`);
+  if (ks.crypto.cipher !== "aes-128-ctr") throw new Error(`Unsupported cipher: ${ks.crypto.cipher}`);
+  const { kdfparams, ciphertext: ctHex, cipherparams, mac: expectedMacHex } = ks.crypto;
+  const salt = hexToBytes(kdfparams.salt);
+  const derivedKey = await scrypt.scryptAsync(new TextEncoder().encode(passphrase), salt, {
+    N: kdfparams.n,
+    r: kdfparams.r,
+    p: kdfparams.p,
+    dkLen: kdfparams.dklen
+  });
+  const ciphertextBytes = hexToBytes(ctHex);
+  const macInput = new Uint8Array(16 + ciphertextBytes.length);
+  macInput.set(derivedKey.slice(16, 32), 0);
+  macInput.set(ciphertextBytes, 16);
+  const computedMac = bytesToHex(sha3.keccak_256(macInput));
+  if (computedMac !== expectedMacHex) {
+    throw new Error("Wrong passphrase: MAC mismatch");
+  }
+  const iv = hexToBytes(cipherparams.iv);
+  const encryptionKey = derivedKey.slice(0, 16);
+  const cipher = aes.ctr(encryptionKey, iv);
+  const plaintext = cipher.decrypt(ciphertextBytes);
+  return `0x${bytesToHex(plaintext)}`;
+}
+
+// src/abis/AxonRegistry.ts
+var AxonRegistryAbi = [
+  {
+    "type": "constructor",
+    "inputs": [
+      {
+        "name": "initialOwner",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "acceptOwnership",
+    "inputs": [],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "addRelayer",
+    "inputs": [
+      {
+        "name": "relayer",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "addSwapRouter",
+    "inputs": [
+      {
+        "name": "router",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "isApprovedSwapRouter",
+    "inputs": [
+      {
+        "name": "router",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "isAuthorized",
+    "inputs": [
+      {
+        "name": "relayer",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "owner",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "pendingOwner",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "removeRelayer",
+    "inputs": [
+      {
+        "name": "relayer",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "removeSwapRouter",
+    "inputs": [
+      {
+        "name": "router",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "renounceOwnership",
+    "inputs": [],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "setOracleConfig",
+    "inputs": [
+      {
+        "name": "uniV3Factory",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "usdc",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "weth",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "transferOwnership",
+    "inputs": [
+      {
+        "name": "newOwner",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "uniswapV3Factory",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "usdcAddress",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "wethAddress",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "event",
+    "name": "OracleConfigUpdated",
+    "inputs": [
+      {
+        "name": "uniswapV3Factory",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "usdc",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "weth",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "OwnershipTransferStarted",
+    "inputs": [
+      {
+        "name": "previousOwner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "newOwner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "OwnershipTransferred",
+    "inputs": [
+      {
+        "name": "previousOwner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "newOwner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "RelayerAdded",
+    "inputs": [
+      {
+        "name": "relayer",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "RelayerRemoved",
+    "inputs": [
+      {
+        "name": "relayer",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "SwapRouterAdded",
+    "inputs": [
+      {
+        "name": "router",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "SwapRouterRemoved",
+    "inputs": [
+      {
+        "name": "router",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "error",
+    "name": "AlreadyApproved",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "AlreadyAuthorized",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "NotApproved",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "NotAuthorized",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "OwnableInvalidOwner",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "OwnableUnauthorizedAccount",
+    "inputs": [
+      {
+        "name": "account",
+        "type": "address",
+        "internalType": "address"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "ZeroAddress",
+    "inputs": []
+  }
+];
+
+exports.AxonClient = AxonClient;
+exports.AxonRegistryAbi = AxonRegistryAbi;
+exports.AxonVaultAbi = AxonVaultAbi;
+exports.AxonVaultFactoryAbi = AxonVaultFactoryAbi;
+exports.CHAIN_NAMES = CHAIN_NAMES;
+exports.Chain = Chain;
+exports.DEFAULT_DEADLINE_SECONDS = DEFAULT_DEADLINE_SECONDS;
+exports.EIP712_DOMAIN_NAME = EIP712_DOMAIN_NAME;
+exports.EIP712_DOMAIN_VERSION = EIP712_DOMAIN_VERSION;
+exports.EXECUTE_INTENT_TYPEHASH = EXECUTE_INTENT_TYPEHASH;
+exports.EXPLORER_ADDR = EXPLORER_ADDR;
+exports.EXPLORER_TX = EXPLORER_TX;
+exports.KNOWN_TOKENS = KNOWN_TOKENS;
+exports.NATIVE_ETH = NATIVE_ETH;
+exports.PAYMENT_INTENT_TYPEHASH = PAYMENT_INTENT_TYPEHASH;
+exports.PERMIT2_ADDRESS = PERMIT2_ADDRESS;
+exports.PaymentErrorCode = PaymentErrorCode;
+exports.RELAYER_API = RELAYER_API;
+exports.SUPPORTED_CHAIN_IDS = SUPPORTED_CHAIN_IDS;
+exports.SWAP_INTENT_TYPEHASH = SWAP_INTENT_TYPEHASH;
+exports.Token = Token;
+exports.USDC = USDC;
+exports.USDC_EIP712_DOMAIN = USDC_EIP712_DOMAIN;
+exports.WINDOW = WINDOW;
+exports.WITNESS_TYPE_STRING = WITNESS_TYPE_STRING;
+exports.X402_PROXY_ADDRESS = X402_PROXY_ADDRESS;
+exports.createAxonPublicClient = createAxonPublicClient;
+exports.createAxonWalletClient = createAxonWalletClient;
+exports.decryptKeystore = decryptKeystore;
+exports.deployVault = deployVault;
+exports.encodeRef = encodeRef;
+exports.encryptKeystore = encryptKeystore;
+exports.extractX402Metadata = extractX402Metadata;
+exports.findMatchingOption = findMatchingOption;
+exports.formatPaymentSignature = formatPaymentSignature;
+exports.getBotConfig = getBotConfig;
+exports.getChain = getChain;
+exports.getDomainSeparator = getDomainSeparator;
+exports.getKnownTokensForChain = getKnownTokensForChain;
+exports.getOperatorCeilings = getOperatorCeilings;
+exports.getRebalanceTokenCount = getRebalanceTokenCount;
+exports.getTokenSymbolByAddress = getTokenSymbolByAddress;
+exports.getVaultOperator = getVaultOperator;
+exports.getVaultOwner = getVaultOwner;
+exports.getVaultVersion = getVaultVersion;
+exports.isBotActive = isBotActive;
+exports.isDestinationAllowed = isDestinationAllowed;
+exports.isRebalanceTokenWhitelisted = isRebalanceTokenWhitelisted;
+exports.isVaultPaused = isVaultPaused;
+exports.operatorMaxDrainPerDay = operatorMaxDrainPerDay;
+exports.parseAmount = parseAmount;
+exports.parseChainId = parseChainId;
+exports.parsePaymentRequired = parsePaymentRequired;
+exports.randomNonce = randomNonce;
+exports.randomPermit2Nonce = randomPermit2Nonce;
+exports.resolveToken = resolveToken;
+exports.resolveTokenDecimals = resolveTokenDecimals;
+exports.signExecuteIntent = signExecuteIntent;
+exports.signPayment = signPayment;
+exports.signPermit2WitnessTransfer = signPermit2WitnessTransfer;
+exports.signSwapIntent = signSwapIntent;
+exports.signTransferWithAuthorization = signTransferWithAuthorization;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map