@axonfi/sdk 0.4.3 → 0.5.0

package/README.md

@@ -24,23 +24,109 @@ Your agents pay. You stay in control.
 npm install @axonfi/sdk
 ```
 
-## Prerequisites
+## Setup
 
-Before using the SDK, you need an Axon vault with a registered bot:
+There are two ways to set up an Axon vault: through the **dashboard** (UI) or entirely through the **SDK** (programmatic). Both produce the same on-chain result.
 
-1. **Deploy a vault** — Go to [app.axonfi.xyz](https://app.axonfi.xyz), connect your wallet, and deploy a vault on your target chain. The vault is a non-custodial smart contract — only you (the owner) can withdraw funds.
+### Option A: Dashboard Setup
 
-2. **Fund the vault** — Send USDC (or any ERC-20) to your vault address. Anyone can deposit directly to the contract.
+1. Go to [app.axonfi.xyz](https://app.axonfi.xyz), connect your wallet, deploy a vault
+2. Fund the vault — send USDC, ETH, or any ERC-20 to the vault address
+3. Register a bot — generate a keypair or bring your own key
+4. Configure policies — per-tx caps, daily limits, AI threshold
+5. Give the bot key to your agent
 
-3. **Register a bot** — In the dashboard, go to your vault → Bots → Add Bot. You can either:
-   - **Generate a new keypair** (recommended) — the dashboard creates a key and downloads an encrypted keystore JSON file. You set the passphrase.
-   - **Bring your own key** — paste an existing public key if you manage keys externally.
+### Option B: Full SDK Setup (Programmatic)
 
-4. **Configure policies** — Set per-transaction caps, daily spending limits, velocity windows, and destination whitelists. The bot can only operate within these bounds.
+Everything can be done from code — no dashboard needed. An agent can bootstrap its own vault end-to-end.
 
-5. **Get the bot key** — Your agent needs the bot's private key to sign payment intents. Use the keystore file + passphrase (recommended) or export the raw private key for quick testing.
+```typescript
+import {
+  AxonClient, deployVault, addBot, deposit,
+  createAxonPublicClient, createAxonWalletClient,
+  NATIVE_ETH, USDC, WINDOW, Chain,
+} from '@axonfi/sdk';
+import { parseUnits } from 'viem';
+import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
+
+// ── 1. Owner wallet (funded with ETH for gas) ─────────────────────
+const ownerKey = '0x...';  // or generate: generatePrivateKey()
+const chainId = Chain.BaseSepolia;
+const ownerWallet = createAxonWalletClient(ownerKey, chainId);
+const publicClient = createAxonPublicClient(chainId, 'https://sepolia.base.org');
+
+// ── 2. Deploy vault (on-chain tx, ~0.001 ETH gas) ─────────────────
+const FACTORY = '0x...'; // AxonVaultFactory address for your chain
+const vaultAddress = await deployVault(ownerWallet, publicClient, FACTORY);
+console.log('Vault deployed:', vaultAddress);
+
+// ── 3. Generate a bot keypair ──────────────────────────────────────
+const botKey = generatePrivateKey();
+const botAddress = privateKeyToAccount(botKey).address;
+
+// ── 4. Accept Terms of Service (wallet signature, no gas) ─────────
+const axon = new AxonClient({ vaultAddress, chainId, botPrivateKey: botKey });
+await axon.acceptTos(ownerWallet, ownerWallet.account!.address);
+
+// ── 5. Register the bot on the vault (on-chain tx, ~0.0005 ETH gas)
+await addBot(ownerWallet, publicClient, vaultAddress, botAddress, {
+  maxPerTxAmount: parseUnits('100', 6),       // $100 hard cap per tx
+  maxRebalanceAmount: 0n,                      // no rebalance cap
+  spendingLimits: [{
+    amount: parseUnits('1000', 6),             // $1,000/day rolling limit
+    maxCount: 0n,                              // no tx count limit
+    windowSeconds: WINDOW.ONE_DAY,
+  }],
+  aiTriggerThreshold: parseUnits('50', 6),     // AI scan above $50
+  requireAiVerification: false,
+});
+
+// ── 6. Deposit funds (on-chain tx, ~0.0005 ETH gas) ───────────────
+// Option A: Deposit ETH (vault accepts native ETH directly)
+await deposit(ownerWallet, publicClient, vaultAddress,
+  NATIVE_ETH, parseUnits('0.1', 18));
+
+// Option B: Deposit USDC (SDK handles approve + deposit)
+await deposit(ownerWallet, publicClient, vaultAddress,
+  USDC[chainId], parseUnits('500', 6));
+
+// ── 7. Bot is ready — gasless from here ────────────────────────────
+// Save botKey securely. The bot never needs ETH.
+```
+
+### What Needs Gas vs. What's Gasless
+
+| Step | Who pays gas | Notes |
+|------|-------------|-------|
+| Deploy vault | Owner | ~0.001 ETH. One-time. |
+| Accept ToS | Owner | Wallet signature only (no gas). |
+| Register bot | Owner | ~0.0005 ETH. One per bot. |
+| Configure bot | Owner | ~0.0003 ETH. Only when changing limits. |
+| Deposit ETH | Depositor | Anyone can deposit. ETH sent directly. |
+| Deposit ERC-20 | Depositor | Anyone can deposit. SDK handles approve + deposit. |
+| **Pay** | **Free (relayer)** | **Bot signs EIP-712 intent. Axon pays gas.** |
+| **Execute (DeFi)** | **Free (relayer)** | **Bot signs intent. Axon pays gas.** |
+| **Swap (rebalance)** | **Free (relayer)** | **Bot signs intent. Axon pays gas.** |
+| Pause/unpause | Owner | ~0.0002 ETH. Emergency only. |
+| Withdraw | Owner | ~0.0003 ETH. Owner-only. |
+
+**The key insight:** Setup operations (deploy, add bot, deposit) require gas from the owner. Once setup is complete, all bot operations (payments, DeFi, swaps) are gasless — the bot never needs ETH. The relayer pays all execution gas.
+
+### Depositing ETH
 
-The vault owner's wallet stays secure — the bot key can only sign intents within the policies you configure, and can be revoked instantly from the dashboard.
+Vaults accept native ETH directly — no wrapping needed. You can start a vault with only ETH:
+
+```typescript
+// Deploy vault + deposit ETH — no USDC needed
+const vault = await deployVault(ownerWallet, publicClient, factory);
+await addBot(ownerWallet, publicClient, vault, botAddress, config);
+await deposit(ownerWallet, publicClient, vault, NATIVE_ETH, parseUnits('0.5', 18));
+
+// Bot can now pay in any token — the relayer swaps ETH → USDC automatically
+await axon.pay({ to: '0x...', token: 'USDC', amount: 10 });
+```
+
+When a bot pays in a token the vault doesn't hold directly (e.g., USDC when the vault only has ETH), the relayer automatically routes through a swap. The bot doesn't need to know or care what tokens are in the vault.
 
 ## Quick Start
 
@@ -139,7 +225,7 @@ const result = await axon.swap({
 
 ### DeFi Protocol Execution
 
-Interact with DeFi and Web3 protocols (Uniswap, Aave, GMX, etc.) that need permission to access collateral from your vault. The bot signs an `ExecuteIntent` specifying the target contract and calldata. The relayer handles token approvals, execution, and revocation in a single atomic transaction. All executions are subject to the bot's per-transaction and daily spending limits.
+Interact with DeFi and Web3 protocols (Uniswap, Aave, GMX, Ostium, etc.) from your vault. The bot signs an `ExecuteIntent` specifying the target contract and calldata. The relayer handles token approvals, execution, and revocation in a single atomic transaction. All executions are subject to the bot's per-transaction and daily spending limits.
 
 ```typescript
 const result = await axon.execute({
@@ -150,6 +236,69 @@ const result = await axon.execute({
 });
 ```
 
+#### When the approval target differs from the call target
+
+In simple cases (Uniswap, Aave), the contract you call is the same contract that pulls your tokens — `execute()` handles this automatically in a single call.
+
+But many DeFi protocols split these into two contracts:
+
+- **Call target** (`protocol`) — the contract you send the transaction to (e.g., Ostium's `Trading` for `openTrade()`)
+- **Approval target** — the contract that actually calls `transferFrom()` to pull tokens from your vault (e.g., Ostium's `TradingStorage`)
+
+When these differ, you need a **two-step pattern**: first give the approval target a persistent token allowance, then call the action.
+
+**Example — Ostium perpetual futures:**
+
+Ostium's `openTrade()` lives on the Trading contract, but collateral gets pulled by TradingStorage. The vault must approve TradingStorage, not Trading.
+
+```typescript
+const USDC = '0x...';                // USDC on your chain
+const OSTIUM_TRADING = '0x...';      // calls openTrade()
+const OSTIUM_TRADING_STORAGE = '0x...'; // pulls USDC via transferFrom()
+
+// Step 1: Persistent approval (one-time) — call approve() on the token contract
+// This tells USDC to let TradingStorage spend from the vault.
+await axon.execute({
+  protocol: USDC,                    // call target: the token contract itself
+  callData: encodeApprove(OSTIUM_TRADING_STORAGE, MaxUint256),
+  token: USDC,
+  amount: 0,                         // no token spend, just setting an allowance
+  protocolName: 'USDC Approve',
+});
+
+// Step 2: Open trade — call the action contract
+await axon.execute({
+  protocol: OSTIUM_TRADING,          // call target: the Trading contract
+  callData: encodeOpenTrade(...),
+  token: USDC,
+  amount: 50_000_000,                // 50 USDC — passed for dashboard/AI visibility
+  protocolName: 'Ostium',
+});
+```
+
+**Vault setup (owner, one-time):** Two contracts must be approved via `approveProtocol()`:
+1. **USDC** (the token contract) — because the vault calls `approve()` on it directly
+2. **Trading** — because the vault calls `openTrade()` on it
+
+TradingStorage does *not* need to be approved — it's just an argument to `approve()`, not a contract the vault calls.
+
+> **Note:** Common tokens (USDC, USDT, WETH, etc.) are pre-approved globally via the Axon registry as default tokens, so you typically only need to approve the DeFi protocol contract itself. You only need to approve a token if it's uncommon and not in the registry defaults.
+
+> **Testnet note:** If the protocol uses a custom token that isn't on Uniswap (e.g., Ostium's testnet USDC), set the bot's `maxPerTxAmount` to `0` to skip TWAP oracle pricing.
+
+This pattern applies to any protocol where the approval target differs from the call target (GMX, some lending protocols, etc.).
+
+#### `ContractNotApproved` error
+
+If `execute()` reverts with `ContractNotApproved`, the `protocol` address you're calling isn't approved. Two possible causes:
+
+1. **The DeFi protocol contract isn't approved** — the vault owner must call `approveProtocol(address)` on the vault for the protocol contract (e.g., Uniswap Router, Ostium Trading, Lido stETH).
+2. **The token contract isn't approved** — when doing a token approval (Step 1 above), the token must either be approved on the vault via `approveProtocol(tokenAddress)` or be a registry default token. Common tokens (USDC, USDT, WETH, DAI, etc.) are pre-approved globally by Axon, but uncommon tokens (e.g., stETH, aUSDC, cTokens) may need manual approval.
+
+**Example — Lido staking/unstaking:** To unstake stETH, Lido's withdrawal contract calls `transferFrom()` to pull stETH from your vault. You need:
+- `approveProtocol(stETH)` — so the vault can call `approve()` on the stETH token to grant Lido an allowance
+- `approveProtocol(lidoWithdrawalQueue)` — so the vault can call `requestWithdrawals()` on Lido
+
 ### Vault Reads
 
 Query your vault's on-chain state — balances, bot status, pause state, and destination checks. All reads go through the relayer (no RPC connection needed).

package/dist/index.cjs

@@ -439,12 +439,12 @@ var AxonVaultAbi = [
   },
   {
     "type": "function",
-    "name": "addProtocol",
+    "name": "addRebalanceTokens",
     "inputs": [
       {
-        "name": "protocol",
-        "type": "address",
-        "internalType": "address"
+        "name": "tokens",
+        "type": "address[]",
+        "internalType": "address[]"
       }
     ],
     "outputs": [],
@@ -452,12 +452,12 @@ var AxonVaultAbi = [
   },
   {
     "type": "function",
-    "name": "addRebalanceTokens",
+    "name": "approveProtocol",
     "inputs": [
       {
-        "name": "tokens",
-        "type": "address[]",
-        "internalType": "address[]"
+        "name": "protocol",
+        "type": "address",
+        "internalType": "address"
       }
     ],
     "outputs": [],
@@ -1015,7 +1015,7 @@ var AxonVaultAbi = [
   },
   {
     "type": "function",
-    "name": "isProtocolApproved",
+    "name": "isContractApproved",
     "inputs": [
       {
         "name": "protocol",
@@ -1239,19 +1239,6 @@ var AxonVaultAbi = [
     "outputs": [],
     "stateMutability": "nonpayable"
   },
-  {
-    "type": "function",
-    "name": "removeProtocol",
-    "inputs": [
-      {
-        "name": "protocol",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
   {
     "type": "function",
     "name": "removeRebalanceTokens",
@@ -1272,6 +1259,19 @@ var AxonVaultAbi = [
     "outputs": [],
     "stateMutability": "nonpayable"
   },
+  {
+    "type": "function",
+    "name": "revokeProtocol",
+    "inputs": [
+      {
+        "name": "protocol",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
   {
     "type": "function",
     "name": "setOperator",
@@ -1782,7 +1782,7 @@ var AxonVaultAbi = [
   },
   {
     "type": "event",
-    "name": "ProtocolAdded",
+    "name": "ProtocolApproved",
     "inputs": [
       {
         "name": "protocol",
@@ -1832,7 +1832,7 @@ var AxonVaultAbi = [
   },
   {
     "type": "event",
-    "name": "ProtocolRemoved",
+    "name": "ProtocolRevoked",
     "inputs": [
       {
         "name": "protocol",
@@ -2029,6 +2029,11 @@ var AxonVaultAbi = [
     "name": "CalldataHashMismatch",
     "inputs": []
   },
+  {
+    "type": "error",
+    "name": "ContractNotApproved",
+    "inputs": []
+  },
   {
     "type": "error",
     "name": "DeadlineExpired",
@@ -2193,11 +2198,6 @@ var AxonVaultAbi = [
     "name": "ProtocolNotApproved",
     "inputs": []
   },
-  {
-    "type": "error",
-    "name": "ProtocolNotInList",
-    "inputs": []
-  },
   {
     "type": "error",
     "name": "RebalanceTokenNotAllowed",
@@ -2546,8 +2546,6 @@ var AxonVaultFactoryAbi = [
     "inputs": []
   }
 ];
-
-// src/vault.ts
 function getChain(chainId) {
   switch (chainId) {
     case 8453:
@@ -2751,6 +2749,79 @@ async function deployVault(walletClient, publicClient, factoryAddress) {
   }
   throw new Error("VaultDeployed event not found in transaction receipt");
 }
+async function addBot(walletClient, publicClient, vaultAddress, botAddress, config) {
+  if (!walletClient.account) {
+    throw new Error("walletClient has no account attached");
+  }
+  const hash = await walletClient.writeContract({
+    address: vaultAddress,
+    abi: AxonVaultAbi,
+    functionName: "addBot",
+    args: [botAddress, config],
+    account: walletClient.account,
+    chain: walletClient.chain ?? null
+  });
+  await publicClient.waitForTransactionReceipt({ hash });
+  return hash;
+}
+async function updateBotConfig(walletClient, publicClient, vaultAddress, botAddress, config) {
+  if (!walletClient.account) {
+    throw new Error("walletClient has no account attached");
+  }
+  const hash = await walletClient.writeContract({
+    address: vaultAddress,
+    abi: AxonVaultAbi,
+    functionName: "updateBotConfig",
+    args: [botAddress, config],
+    account: walletClient.account,
+    chain: walletClient.chain ?? null
+  });
+  await publicClient.waitForTransactionReceipt({ hash });
+  return hash;
+}
+async function removeBot(walletClient, publicClient, vaultAddress, botAddress) {
+  if (!walletClient.account) {
+    throw new Error("walletClient has no account attached");
+  }
+  const hash = await walletClient.writeContract({
+    address: vaultAddress,
+    abi: AxonVaultAbi,
+    functionName: "removeBot",
+    args: [botAddress],
+    account: walletClient.account,
+    chain: walletClient.chain ?? null
+  });
+  await publicClient.waitForTransactionReceipt({ hash });
+  return hash;
+}
+async function deposit(walletClient, publicClient, vaultAddress, token, amount, ref = "0x0000000000000000000000000000000000000000000000000000000000000000") {
+  if (!walletClient.account) {
+    throw new Error("walletClient has no account attached");
+  }
+  const isEth = token.toLowerCase() === NATIVE_ETH.toLowerCase();
+  if (!isEth) {
+    const approveTx = await walletClient.writeContract({
+      address: token,
+      abi: viem.erc20Abi,
+      functionName: "approve",
+      args: [vaultAddress, amount],
+      account: walletClient.account,
+      chain: walletClient.chain ?? null
+    });
+    await publicClient.waitForTransactionReceipt({ hash: approveTx });
+  }
+  const hash = await walletClient.writeContract({
+    address: vaultAddress,
+    abi: AxonVaultAbi,
+    functionName: "deposit",
+    args: [token, amount, ref],
+    account: walletClient.account,
+    chain: walletClient.chain ?? null,
+    ...isEth ? { value: amount } : {}
+  });
+  await publicClient.waitForTransactionReceipt({ hash });
+  return hash;
+}
 
 // src/tokens.ts
 var Token = /* @__PURE__ */ ((Token2) => {
@@ -2763,6 +2834,7 @@ var Token = /* @__PURE__ */ ((Token2) => {
   Token2["cbETH"] = "cbETH";
   Token2["wstETH"] = "wstETH";
   Token2["rETH"] = "rETH";
+  Token2["weETH"] = "weETH";
   Token2["LINK"] = "LINK";
   Token2["UNI"] = "UNI";
   Token2["AAVE"] = "AAVE";
@@ -2860,9 +2932,19 @@ var KNOWN_TOKENS = {
     name: "Rocket Pool ETH",
     decimals: 18,
     addresses: {
+      8453: "0xB6fe221Fe9EeF5aBa221c348bA20A1Bf5e73624c",
       42161: "0xEC70Dcb4A1EFa46b8F2D97C310C9c4790ba5ffA8"
     }
   },
+  weETH: {
+    symbol: "weETH",
+    name: "EtherFi Wrapped eETH",
+    decimals: 18,
+    addresses: {
+      8453: "0x04C0599Ae5A44757c0af6F9eC3b93da8976c150A",
+      42161: "0x35751007a407ca6FEFfE80b3cB397736D2cf4dbe"
+    }
+  },
   // ── DeFi blue-chips ─────────────────────────────────────
   LINK: {
     symbol: "LINK",
@@ -2944,6 +3026,27 @@ var KNOWN_TOKENS = {
     }
   }
 };
+var DEFAULT_APPROVED_TOKENS = [
+  "USDC",
+  "USDT",
+  "DAI",
+  "WETH",
+  "WBTC",
+  "cbBTC",
+  "wstETH",
+  "weETH",
+  "cbETH",
+  "rETH"
+];
+function getDefaultApprovedTokens(chainId) {
+  const addresses = [];
+  for (const symbol of DEFAULT_APPROVED_TOKENS) {
+    const entry = KNOWN_TOKENS[symbol];
+    const addr = entry.addresses[chainId];
+    if (addr) addresses.push(addr);
+  }
+  return addresses;
+}
 var addressToSymbol = /* @__PURE__ */ new Map();
 for (const token of Object.values(KNOWN_TOKENS)) {
   for (const addr of Object.values(token.addresses)) {
@@ -3525,10 +3628,10 @@ var AxonClient = class {
     return this._get(path);
   }
   // ============================================================================
-  // isProtocolApproved() — via relayer
+  // isContractApproved() — via relayer
   // ============================================================================
-  /** Returns whether a protocol address is approved for executeProtocol() calls (via relayer). */
-  async isProtocolApproved(protocol) {
+  /** Returns whether a contract address (protocol or token) is approved for executeProtocol() calls (via relayer). */
+  async isContractApproved(protocol) {
     const path = RELAYER_API.protocolCheck(this.vaultAddress, protocol, this.chainId);
     const data = await this._get(path);
     return data.approved;
@@ -3890,6 +3993,19 @@ var AxonRegistryAbi = [
     ],
     "stateMutability": "nonpayable"
   },
+  {
+    "type": "function",
+    "name": "VERSION",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
   {
     "type": "function",
     "name": "acceptOwnership",
@@ -3923,6 +4039,19 @@ var AxonRegistryAbi = [
     "outputs": [],
     "stateMutability": "nonpayable"
   },
+  {
+    "type": "function",
+    "name": "approveDefaultToken",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
   {
     "type": "function",
     "name": "isApprovedSwapRouter",
@@ -3961,6 +4090,25 @@ var AxonRegistryAbi = [
     ],
     "stateMutability": "view"
   },
+  {
+    "type": "function",
+    "name": "isDefaultToken",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
   {
     "type": "function",
     "name": "owner",
@@ -4020,6 +4168,19 @@ var AxonRegistryAbi = [
     "outputs": [],
     "stateMutability": "nonpayable"
   },
+  {
+    "type": "function",
+    "name": "revokeDefaultToken",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
   {
     "type": "function",
     "name": "setOracleConfig",
@@ -4095,6 +4256,32 @@ var AxonRegistryAbi = [
     ],
     "stateMutability": "view"
   },
+  {
+    "type": "event",
+    "name": "DefaultTokenApproved",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "DefaultTokenRevoked",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
   {
     "type": "event",
     "name": "OracleConfigUpdated",
@@ -4265,6 +4452,7 @@ exports.AxonVaultAbi = AxonVaultAbi;
 exports.AxonVaultFactoryAbi = AxonVaultFactoryAbi;
 exports.CHAIN_NAMES = CHAIN_NAMES;
 exports.Chain = Chain;
+exports.DEFAULT_APPROVED_TOKENS = DEFAULT_APPROVED_TOKENS;
 exports.DEFAULT_DEADLINE_SECONDS = DEFAULT_DEADLINE_SECONDS;
 exports.EIP712_DOMAIN_NAME = EIP712_DOMAIN_NAME;
 exports.EIP712_DOMAIN_VERSION = EIP712_DOMAIN_VERSION;
@@ -4285,10 +4473,12 @@ 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.addBot = addBot;
 exports.createAxonPublicClient = createAxonPublicClient;
 exports.createAxonWalletClient = createAxonWalletClient;
 exports.decryptKeystore = decryptKeystore;
 exports.deployVault = deployVault;
+exports.deposit = deposit;
 exports.encodeRef = encodeRef;
 exports.encryptKeystore = encryptKeystore;
 exports.extractX402Metadata = extractX402Metadata;
@@ -4296,6 +4486,7 @@ exports.findMatchingOption = findMatchingOption;
 exports.formatPaymentSignature = formatPaymentSignature;
 exports.getBotConfig = getBotConfig;
 exports.getChain = getChain;
+exports.getDefaultApprovedTokens = getDefaultApprovedTokens;
 exports.getDomainSeparator = getDomainSeparator;
 exports.getKnownTokensForChain = getKnownTokensForChain;
 exports.getOperatorCeilings = getOperatorCeilings;
@@ -4314,6 +4505,7 @@ exports.parseChainId = parseChainId;
 exports.parsePaymentRequired = parsePaymentRequired;
 exports.randomNonce = randomNonce;
 exports.randomPermit2Nonce = randomPermit2Nonce;
+exports.removeBot = removeBot;
 exports.resolveToken = resolveToken;
 exports.resolveTokenDecimals = resolveTokenDecimals;
 exports.signExecuteIntent = signExecuteIntent;
@@ -4321,5 +4513,6 @@ exports.signPayment = signPayment;
 exports.signPermit2WitnessTransfer = signPermit2WitnessTransfer;
 exports.signSwapIntent = signSwapIntent;
 exports.signTransferWithAuthorization = signTransferWithAuthorization;
+exports.updateBotConfig = updateBotConfig;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map