@axonfi/sdk 0.4.0 → 0.4.2

package/dist/index.d.cts

@@ -0,0 +1,3256 @@
+import { Address, Hex, WalletClient, PublicClient, Chain as Chain$1 } from 'viem';
+
+declare enum Token {
+    USDC = "USDC",
+    USDT = "USDT",
+    DAI = "DAI",
+    WETH = "WETH",
+    WBTC = "WBTC",
+    cbBTC = "cbBTC",
+    cbETH = "cbETH",
+    wstETH = "wstETH",
+    rETH = "rETH",
+    LINK = "LINK",
+    UNI = "UNI",
+    AAVE = "AAVE",
+    COMP = "COMP",
+    CRV = "CRV",
+    SNX = "SNX",
+    ARB = "ARB",
+    AERO = "AERO",
+    GMX = "GMX"
+}
+interface KnownToken {
+    symbol: string;
+    name: string;
+    decimals: number;
+    /** Address per chainId. Missing key = not available on that chain. */
+    addresses: Partial<Record<number, Address>>;
+}
+/**
+ * Master token registry keyed by symbol.
+ * At a glance you see which chains each token lives on.
+ *
+ * Chain IDs: 8453 = Base, 84532 = Base Sepolia, 42161 = Arbitrum One, 421614 = Arbitrum Sepolia
+ */
+declare const KNOWN_TOKENS: {
+    readonly USDC: {
+        readonly symbol: "USDC";
+        readonly name: "USD Coin";
+        readonly decimals: 6;
+        readonly addresses: {
+            readonly 8453: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+            readonly 84532: "0x036CbD53842c5426634e7929541eC2318f3dCF7e";
+            readonly 42161: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831";
+            readonly 421614: "0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d";
+        };
+    };
+    readonly USDT: {
+        readonly symbol: "USDT";
+        readonly name: "Tether USD";
+        readonly decimals: 6;
+        readonly addresses: {
+            readonly 8453: "0xfde4C96c8593536E31F229EA8f37b2ADa2699bb2";
+            readonly 84532: "0x323e78f944A9a1FcF3a10efcC5319DBb0bB6e673";
+            readonly 42161: "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9";
+        };
+    };
+    readonly DAI: {
+        readonly symbol: "DAI";
+        readonly name: "Dai Stablecoin";
+        readonly decimals: 18;
+        readonly addresses: {
+            readonly 8453: "0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb";
+            readonly 84532: "0x819ffecd4e64f193e959944bcd57eedc7755e17a";
+            readonly 42161: "0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1";
+        };
+    };
+    readonly WETH: {
+        readonly symbol: "WETH";
+        readonly name: "Wrapped Ether";
+        readonly decimals: 18;
+        readonly addresses: {
+            readonly 8453: "0x4200000000000000000000000000000000000006";
+            readonly 84532: "0x4200000000000000000000000000000000000006";
+            readonly 42161: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1";
+            readonly 421614: "0x980B62Da83eFf3D4576C647993b0c1D7faf17c73";
+        };
+    };
+    readonly WBTC: {
+        readonly symbol: "WBTC";
+        readonly name: "Wrapped BTC";
+        readonly decimals: 8;
+        readonly addresses: {
+            readonly 8453: "0x0555E30da8f98308EdB960aa94C0Db47230d2B9c";
+            readonly 42161: "0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f";
+        };
+    };
+    readonly cbBTC: {
+        readonly symbol: "cbBTC";
+        readonly name: "Coinbase Wrapped BTC";
+        readonly decimals: 8;
+        readonly addresses: {
+            readonly 8453: "0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf";
+            readonly 42161: "0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf";
+        };
+    };
+    readonly cbETH: {
+        readonly symbol: "cbETH";
+        readonly name: "Coinbase Staked ETH";
+        readonly decimals: 18;
+        readonly addresses: {
+            readonly 8453: "0x2Ae3F1Ec7F1F5012CFEab0185bfc7aa3cf0DEc22";
+            readonly 42161: "0x1DEBd73E752bEaF79865Fd6446b0c970EaE7732f";
+        };
+    };
+    readonly wstETH: {
+        readonly symbol: "wstETH";
+        readonly name: "Lido Wrapped stETH";
+        readonly decimals: 18;
+        readonly addresses: {
+            readonly 8453: "0xc1CBa3fCea344f92D9239c08C0568f6F2F0ee452";
+            readonly 42161: "0x5979D7b546E38E414F7E9822514be443A4800529";
+        };
+    };
+    readonly rETH: {
+        readonly symbol: "rETH";
+        readonly name: "Rocket Pool ETH";
+        readonly decimals: 18;
+        readonly addresses: {
+            readonly 42161: "0xEC70Dcb4A1EFa46b8F2D97C310C9c4790ba5ffA8";
+        };
+    };
+    readonly LINK: {
+        readonly symbol: "LINK";
+        readonly name: "Chainlink";
+        readonly decimals: 18;
+        readonly addresses: {
+            readonly 8453: "0x88Fb150BDc53A65fe94Dea0c9BA0a6dAf8C6e196";
+            readonly 84532: "0xE4aB69C077896252FAFBD49EFD26B5D171A32410";
+            readonly 42161: "0xf97f4df75117a78c1A5a0DBb814Af92458539FB4";
+        };
+    };
+    readonly UNI: {
+        readonly symbol: "UNI";
+        readonly name: "Uniswap";
+        readonly decimals: 18;
+        readonly addresses: {
+            readonly 8453: "0xc3De830EA07524a0761646a6a4e4be0e114a3C83";
+            readonly 42161: "0xFa7F8980b0f1E64A2062791cc3b0871572f1F7f0";
+        };
+    };
+    readonly AAVE: {
+        readonly symbol: "AAVE";
+        readonly name: "Aave";
+        readonly decimals: 18;
+        readonly addresses: {
+            readonly 8453: "0x63706e401c06ac8513145b7687A14804d17f814b";
+            readonly 42161: "0xba5DdD1f9d7F570dc94a51479a000E3BCE967196";
+        };
+    };
+    readonly COMP: {
+        readonly symbol: "COMP";
+        readonly name: "Compound";
+        readonly decimals: 18;
+        readonly addresses: {
+            readonly 8453: "0x9e1028F5F1D5eDE59748FFceE5532509976840E0";
+            readonly 42161: "0x354A6dA3fcde098F8389cad84b0182725c6C91dE";
+        };
+    };
+    readonly CRV: {
+        readonly symbol: "CRV";
+        readonly name: "Curve DAO";
+        readonly decimals: 18;
+        readonly addresses: {
+            readonly 8453: "0x8Ee73c484A26e0A5df2Ee2a4960B789967dd0415";
+            readonly 42161: "0x11cDb42B0EB46D95f990BeDD4695A6e3fA034978";
+        };
+    };
+    readonly SNX: {
+        readonly symbol: "SNX";
+        readonly name: "Synthetix";
+        readonly decimals: 18;
+        readonly addresses: {
+            readonly 8453: "0x22e6966B799c4D5B13BE962E1D117b56327FDa66";
+        };
+    };
+    readonly ARB: {
+        readonly symbol: "ARB";
+        readonly name: "Arbitrum";
+        readonly decimals: 18;
+        readonly addresses: {
+            readonly 42161: "0x912CE59144191C1204E64559FE8253a0e49E6548";
+        };
+    };
+    readonly AERO: {
+        readonly symbol: "AERO";
+        readonly name: "Aerodrome";
+        readonly decimals: 18;
+        readonly addresses: {
+            readonly 8453: "0x940181a94A35A4569E4529A3CDfB74e38FD98631";
+        };
+    };
+    readonly GMX: {
+        readonly symbol: "GMX";
+        readonly name: "GMX";
+        readonly decimals: 18;
+        readonly addresses: {
+            readonly 42161: "0xfc5A1A6EB076a2C7aD06eD22C90d7E710E35ad0a";
+        };
+    };
+};
+type KnownTokenSymbol = keyof typeof KNOWN_TOKENS;
+/** All known tokens available on a specific chain. */
+declare function getKnownTokensForChain(chainId: number): (KnownToken & {
+    address: Address;
+})[];
+/** Reverse-lookup: address → symbol (case-insensitive). Returns null if unknown. */
+declare function getTokenSymbolByAddress(address: string): string | null;
+/**
+ * Resolve a Token enum symbol to its on-chain address for a given chain.
+ * If an Address (0x...) is passed, it is returned as-is.
+ *
+ * @throws if the symbol has no address on the given chain.
+ */
+declare function resolveToken(token: Address | Token | KnownTokenSymbol, chainId: number): Address;
+
+/**
+ * keccak256 of the PaymentIntent type string — used for manual digest
+ * verification. viem's signTypedData computes this internally; you don't
+ * need this value for signing, only for low-level verification.
+ */
+declare const PAYMENT_INTENT_TYPEHASH: `0x${string}`;
+/** keccak256 of the ExecuteIntent type string for DeFi protocol interactions. */
+declare const EXECUTE_INTENT_TYPEHASH: `0x${string}`;
+/** keccak256 of the SwapIntent type string for in-vault token rebalancing. */
+declare const SWAP_INTENT_TYPEHASH: `0x${string}`;
+/** EIP-712 domain name and version for AxonVault. Matches the constructor. */
+declare const EIP712_DOMAIN_NAME: "AxonVault";
+declare const EIP712_DOMAIN_VERSION: "1";
+/** Sentinel address representing native ETH in PaymentIntents and deposits. */
+declare const NATIVE_ETH: Address;
+declare const USDC: Record<number, Address>;
+declare enum Chain {
+    Base = 8453,
+    BaseSepolia = 84532,
+    Arbitrum = 42161,
+    ArbitrumSepolia = 421614
+}
+declare const SUPPORTED_CHAIN_IDS: readonly [8453, 84532, 42161, 421614];
+type SupportedChainId = (typeof SUPPORTED_CHAIN_IDS)[number];
+/** Human-readable chain names. */
+declare const CHAIN_NAMES: Record<number, string>;
+/** Block explorer TX URL prefix per chain. */
+declare const EXPLORER_TX: Record<number, string>;
+/** Block explorer address URL prefix per chain. */
+declare const EXPLORER_ADDR: Record<number, string>;
+/** Default intent validity window when no deadline is specified. */
+declare const DEFAULT_DEADLINE_SECONDS = 300;
+/** Window presets for SpendingLimit.windowSeconds. */
+declare const WINDOW: {
+    readonly ONE_HOUR: 3600n;
+    readonly ONE_DAY: 86400n;
+    readonly ONE_WEEK: 604800n;
+    readonly THIRTY_DAYS: 2592000n;
+};
+/**
+ * Structured error codes returned by the relayer when a payment is rejected.
+ * Bots should import these to programmatically handle failures.
+ */
+declare const PaymentErrorCode: {
+    /** Payment destination is the vault itself */
+    readonly SELF_PAYMENT: "SELF_PAYMENT";
+    /** Payment destination is the zero address */
+    readonly ZERO_ADDRESS: "ZERO_ADDRESS";
+    /** Payment amount is zero */
+    readonly ZERO_AMOUNT: "ZERO_AMOUNT";
+    /** Vault does not hold enough of the requested token */
+    readonly INSUFFICIENT_BALANCE: "INSUFFICIENT_BALANCE";
+    /** EIP-712 signature verification failed */
+    readonly INVALID_SIGNATURE: "INVALID_SIGNATURE";
+    /** Payment intent deadline has passed */
+    readonly DEADLINE_EXPIRED: "DEADLINE_EXPIRED";
+    /** Bot is temporarily paused by the operator */
+    readonly BOT_PAUSED: "BOT_PAUSED";
+    /** Bot address is not registered/active in the vault */
+    readonly BOT_NOT_ACTIVE: "BOT_NOT_ACTIVE";
+    /** Destination address is on the global or vault blacklist */
+    readonly BLACKLISTED: "BLACKLISTED";
+    /** Rolling-window spending limit (USD amount) exceeded */
+    readonly SPENDING_LIMIT_EXCEEDED: "SPENDING_LIMIT_EXCEEDED";
+    /** Rolling-window transaction count limit exceeded */
+    readonly TX_COUNT_EXCEEDED: "TX_COUNT_EXCEEDED";
+    /** Single transaction exceeds the bot's on-chain maxPerTxAmount */
+    readonly MAX_PER_TX_EXCEEDED: "MAX_PER_TX_EXCEEDED";
+    /** Vault-level daily aggregate spending limit exceeded */
+    readonly VAULT_AGGREGATE_EXCEEDED: "VAULT_AGGREGATE_EXCEEDED";
+    /** eth_call simulation of the on-chain transaction reverted */
+    readonly SIMULATION_FAILED: "SIMULATION_FAILED";
+    /** Routed to human review (AI scan flagged or no consensus) */
+    readonly PENDING_REVIEW: "PENDING_REVIEW";
+    /** Relayer wallet has insufficient gas to submit the transaction */
+    readonly RELAYER_OUT_OF_GAS: "RELAYER_OUT_OF_GAS";
+    /** On-chain transaction submission failed */
+    readonly SUBMISSION_FAILED: "SUBMISSION_FAILED";
+    /** Destination not in the vault/bot whitelist */
+    readonly DESTINATION_NOT_WHITELISTED: "DESTINATION_NOT_WHITELISTED";
+    /** Vault address is not a valid AxonVault or was not deployed by a known factory */
+    readonly INVALID_VAULT: "INVALID_VAULT";
+    /** Rebalance output token is not in the whitelist (on-chain or relayer default) */
+    readonly REBALANCE_TOKEN_NOT_ALLOWED: "REBALANCE_TOKEN_NOT_ALLOWED";
+    /** Rebalance input amount exceeds the bot's maxRebalanceAmount cap */
+    readonly MAX_REBALANCE_AMOUNT_EXCEEDED: "MAX_REBALANCE_AMOUNT_EXCEEDED";
+    /** Unknown or internal error */
+    readonly INTERNAL_ERROR: "INTERNAL_ERROR";
+};
+type PaymentErrorCode = (typeof PaymentErrorCode)[keyof typeof PaymentErrorCode];
+declare const RELAYER_API: {
+    readonly PAYMENTS: "/v1/payments";
+    readonly payment: (requestId: string) => string;
+    readonly EXECUTE: "/v1/execute";
+    readonly execute: (requestId: string) => string;
+    readonly SWAP: "/v1/swap";
+    readonly swap: (requestId: string) => string;
+    readonly vaultBalance: (vault: string, token: string, chainId: number) => string;
+    readonly vaultBalances: (vault: string, chainId: number) => string;
+    readonly vaultInfo: (vault: string, chainId: number) => string;
+    readonly botStatus: (vault: string, bot: string, chainId: number) => string;
+    readonly destinationCheck: (vault: string, bot: string, destination: string, chainId: number) => string;
+    readonly protocolCheck: (vault: string, protocol: string, chainId: number) => string;
+    readonly rebalanceTokens: (vault: string, chainId: number) => string;
+    readonly rebalanceTokenCheck: (vault: string, token: string, chainId: number) => string;
+    readonly tosStatus: (wallet: string) => string;
+    readonly TOS_ACCEPT: "/v1/tos/accept";
+};
+
+/**
+ * Accepts any way to identify a token:
+ * - `Address` ('0x...') — raw contract address
+ * - `Token` enum (Token.USDC) — type-safe symbol
+ * - `KnownTokenSymbol` string ('USDC') — bare string shorthand
+ */
+type TokenInput = Address | Token | KnownTokenSymbol;
+/**
+ * Accepts amounts in any format:
+ * - `bigint` — raw base units (e.g. 5_000_000n for 5 USDC). Passed through as-is.
+ * - `number` — human-readable (e.g. 5.2 for 5.2 USDC). SDK converts using token decimals.
+ * - `string` — human-readable string (e.g. '5.2'). Recommended for computed values to avoid float precision issues.
+ */
+type AmountInput = bigint | number | string;
+/** Rolling window spending limit. Stored on-chain, enforced by relayer. */
+interface SpendingLimit {
+    /** Max spend in this window (token base units, e.g. USDC has 6 decimals). */
+    amount: bigint;
+    /** Max number of transactions in this window. 0 = no count limit. */
+    maxCount: bigint;
+    /** Window size: 3600=1h, 86400=1d, 604800=1w, 2592000=30d */
+    windowSeconds: bigint;
+}
+/** Per-bot configuration returned by getBotConfig(). */
+interface BotConfig {
+    isActive: boolean;
+    registeredAt: bigint;
+    /** Hard per-tx cap for payments, enforced on-chain. 0 = no cap. */
+    maxPerTxAmount: bigint;
+    /** Hard cap for rebalancing (executeSwap) input amount in USD. 0 = no cap. */
+    maxRebalanceAmount: bigint;
+    /** Rolling window limits — stored on-chain, enforced by relayer. */
+    spendingLimits: SpendingLimit[];
+    /** Relayer triggers AI scan above this amount. 0 = never by amount alone. */
+    aiTriggerThreshold: bigint;
+    /** Relayer always requires AI scan for this bot regardless of amount. */
+    requireAiVerification: boolean;
+}
+/** Parameters for addBot / updateBotConfig. */
+interface BotConfigParams {
+    maxPerTxAmount: bigint;
+    /** Hard cap for rebalancing (executeSwap) input amount in USD. 0 = no cap (default). */
+    maxRebalanceAmount: bigint;
+    spendingLimits: SpendingLimit[];
+    aiTriggerThreshold: bigint;
+    requireAiVerification: boolean;
+}
+/** Owner-set ceilings bounding operator actions. */
+interface OperatorCeilings {
+    /** Operator cannot set a bot's maxPerTxAmount above this. 0 = no ceiling. */
+    maxPerTxAmount: bigint;
+    /** Operator cannot set a bot's daily limit above this. 0 = no ceiling. */
+    maxBotDailyLimit: bigint;
+    /** 0 = operator CANNOT add bots. Must be explicitly set by owner. */
+    maxOperatorBots: bigint;
+    /** Total vault daily outflow cap — relayer reads and enforces. 0 = none. */
+    vaultDailyAggregate: bigint;
+    /** Operator cannot set aiTriggerThreshold above this. 0 = no floor. */
+    minAiTriggerFloor: bigint;
+}
+/**
+ * Signed payment intent. This is the core signed data unit.
+ *
+ * The bot signs this struct using EIP-712. The relayer submits it to
+ * executePayment() on-chain. The bot never interacts with the chain directly.
+ *
+ * Domain: { name: "AxonVault", version: "1", chainId, verifyingContract: vaultAddress }
+ * TypeHash: keccak256("PaymentIntent(address bot,address to,address token,uint256 amount,uint256 deadline,bytes32 ref)")
+ */
+interface PaymentIntent {
+    /** Bot's own address. Must be registered in the vault. */
+    bot: Address;
+    /** Payment recipient address. */
+    to: Address;
+    /** Desired output token address (e.g. USDC). Vault may hold this directly
+     *  or the relayer may swap to it transparently. */
+    token: Address;
+    /** Token amount in base units (USDC: 6 decimals, so 1 USDC = 1_000_000n). */
+    amount: bigint;
+    /** Unix timestamp after which this intent is invalid. */
+    deadline: bigint;
+    /** keccak256 of the off-chain memo. Full memo text stored by relayer. */
+    ref: Hex;
+}
+/**
+ * Input for AxonClient.pay(). The SDK fills in bot address, deadline,
+ * and ref (from memo). You provide the payment destination and metadata.
+ */
+interface PayInput {
+    /** Payment recipient. */
+    to: Address;
+    /** Desired output token — an address, Token enum, or bare symbol string ('USDC'). */
+    token: TokenInput;
+    /** Amount: bigint (raw base units), number (human-readable), or string (human-readable). */
+    amount: AmountInput;
+    /**
+     * Human-readable payment description. Stored in relayer's PostgreSQL.
+     * Gets keccak256-hashed to populate the on-chain `ref` field.
+     * Example: "API call #1234 — weather data lookup"
+     */
+    memo?: string;
+    /**
+     * Mandatory per-request unique key for idempotency. The relayer uses
+     * this to deduplicate retries — submitting the same idempotencyKey twice
+     * is safe and returns the original result. If omitted, the SDK generates
+     * a UUID automatically.
+     */
+    idempotencyKey?: string;
+    /**
+     * For x402 / HTTP 402 flows: the URL whose resource is being unlocked
+     * by this payment. Stored off-chain, not signed.
+     */
+    resourceUrl?: string;
+    /** Your external invoice ID. Stored off-chain for reconciliation. */
+    invoiceId?: string;
+    /** Your external order ID. Stored off-chain for reconciliation. */
+    orderId?: string;
+    /**
+     * Human-readable name for the recipient. Displayed on dashboards instead of
+     * the raw address. Example: "Weather Bot", "Alice", "OpenAI API".
+     */
+    recipientLabel?: string;
+    /** Arbitrary key-value metadata. Stored off-chain. Values must be strings. */
+    metadata?: Record<string, string>;
+    /**
+     * Intent expiry. Defaults to 5 minutes from now.
+     * Must be within the relayer's acceptance window (typically ±5 min).
+     */
+    deadline?: bigint;
+    /**
+     * Override the on-chain ref bytes32 directly. Use this when you need to
+     * match an exact ref value (e.g. for cross-chain deposit tracking).
+     * If set, `memo` is ignored for ref generation but still stored off-chain.
+     */
+    ref?: Hex;
+    /**
+     * Marks this payment as x402 bot-EOA funding. When true, the relayer
+     * records the flag for audit/context (e.g. "bot self-payment for x402").
+     * Does NOT bypass any policy checks — full pipeline still applies.
+     */
+    x402Funding?: boolean;
+}
+/**
+ * Signed execute intent for DeFi protocol interactions.
+ *
+ * The bot signs this struct using EIP-712. The relayer submits it to
+ * executeProtocol() on-chain. The contract approves `token` to `protocol`,
+ * calls it with `callData`, then revokes the approval.
+ *
+ * TypeHash: keccak256("ExecuteIntent(address bot,address protocol,bytes32 calldataHash,address token,uint256 amount,uint256 deadline,bytes32 ref)")
+ */
+interface ExecuteIntent {
+    /** Bot's own address. Must be registered in the vault. */
+    bot: Address;
+    /** Target DeFi protocol contract address. Must be in vault's approvedProtocols. */
+    protocol: Address;
+    /** keccak256 of the callData bytes. Verified by relayer before submission. */
+    calldataHash: Hex;
+    /** Token to approve to the protocol before calling. */
+    token: Address;
+    /** Amount to approve (in token base units). */
+    amount: bigint;
+    /** Unix timestamp after which this intent is invalid. */
+    deadline: bigint;
+    /** keccak256 of the off-chain memo. Full memo text stored by relayer. */
+    ref: Hex;
+}
+/**
+ * Signed swap intent for in-vault token rebalancing.
+ *
+ * The bot signs this struct using EIP-712. The relayer submits it to
+ * executeSwap() on-chain. Tokens stay in the vault (no recipient).
+ *
+ * TypeHash: keccak256("SwapIntent(address bot,address toToken,uint256 minToAmount,uint256 deadline,bytes32 ref)")
+ */
+interface SwapIntent {
+    /** Bot's own address. Must be registered in the vault. */
+    bot: Address;
+    /** Desired output token. */
+    toToken: Address;
+    /** Minimum output amount (slippage floor). */
+    minToAmount: bigint;
+    /** Unix timestamp after which this intent is invalid. */
+    deadline: bigint;
+    /** keccak256 of the off-chain memo. Full memo text stored by relayer. */
+    ref: Hex;
+}
+/**
+ * Input for AxonClient.execute(). Signs an ExecuteIntent and submits to
+ * the relayer's POST /v1/execute endpoint.
+ */
+interface ExecuteInput {
+    /** Target protocol contract address. */
+    protocol: Address;
+    /** The actual calldata bytes to send to the protocol. */
+    callData: Hex;
+    /** Token to approve to the protocol — an address, Token enum, or bare symbol string ('USDC'). */
+    token: TokenInput;
+    /** Amount to approve: bigint (raw base units), number (human-readable), or string (human-readable). */
+    amount: AmountInput;
+    /** Human-readable description. Gets keccak256-hashed to ref. */
+    memo?: string;
+    /**
+     * Human-readable name for the protocol interaction. Displayed on dashboards
+     * instead of the raw contract address. Example: "Uniswap Swap", "Aave Borrow".
+     */
+    protocolName?: string;
+    /** Override ref bytes32 directly. */
+    ref?: Hex;
+    /** Idempotency key (auto-generated if omitted). */
+    idempotencyKey?: string;
+    /** Intent expiry (defaults to 5 min). */
+    deadline?: bigint;
+    /** Arbitrary metadata stored off-chain. */
+    metadata?: Record<string, string>;
+    /** Source token for pre-swap — an address, Token enum, or bare symbol string. */
+    fromToken?: TokenInput;
+    /** Max input for pre-swap: bigint (raw), number (human), or string (human). */
+    maxFromAmount?: AmountInput;
+}
+/**
+ * Input for AxonClient.swap(). Signs a SwapIntent and submits to
+ * the relayer's POST /v1/swap endpoint.
+ */
+interface SwapInput {
+    /** Desired output token — an address, Token enum, or bare symbol string ('WETH'). */
+    toToken: TokenInput;
+    /** Minimum output amount (slippage floor): bigint (raw), number (human), or string (human). */
+    minToAmount: AmountInput;
+    /** Human-readable description. Gets keccak256-hashed to ref. */
+    memo?: string;
+    /** Override ref bytes32 directly. */
+    ref?: Hex;
+    /** Idempotency key (auto-generated if omitted). */
+    idempotencyKey?: string;
+    /** Intent expiry (defaults to 5 min). */
+    deadline?: bigint;
+    /** Source token to swap from — an address, Token enum, or bare symbol string. */
+    fromToken?: TokenInput;
+    /** Max input amount for swap: bigint (raw), number (human), or string (human). */
+    maxFromAmount?: AmountInput;
+}
+/** Possible statuses returned by the relayer. */
+type PaymentStatus = 'approved' | 'pending_review' | 'rejected';
+/** Result of AxonClient.pay() or AxonClient.poll(). */
+interface PaymentResult {
+    requestId: string;
+    status: PaymentStatus;
+    /** On-chain transaction hash. Present when status === 'approved'. */
+    txHash?: Hex;
+    /** URL to poll for async results. */
+    pollUrl?: string;
+    /** Estimated milliseconds until resolution (relayer hint). */
+    estimatedResolutionMs?: number;
+    /** Rejection reason. Present when status === 'rejected'. */
+    reason?: string;
+}
+/** High-level vault info returned by AxonClient.getVaultInfo(). */
+interface VaultInfo {
+    owner: Address;
+    operator: Address;
+    paused: boolean;
+    version: number;
+}
+/** Result of a destination check (canPayTo / isDestinationAllowed). */
+interface DestinationCheckResult {
+    allowed: boolean;
+    reason?: string;
+}
+/** Result of getRebalanceTokens() — the effective rebalance token whitelist. */
+interface RebalanceTokensResult {
+    /** "default" = relayer defaults (no on-chain whitelist), "on_chain" = owner-set override. */
+    source: 'default' | 'on_chain';
+    /** Lowercase token addresses allowed for rebalancing (executeSwap output). */
+    tokens: Address[];
+    /** Number of tokens set on-chain. 0 = using relayer defaults. */
+    rebalanceTokenCount: number;
+}
+/** TOS acceptance status for a wallet. */
+interface TosStatus {
+    accepted: boolean;
+    tosVersion: string;
+}
+/** Configuration for AxonClient. */
+interface AxonClientConfig {
+    /** Vault contract address to sign against. */
+    vaultAddress: Address;
+    /** Chain ID — a number or a Chain enum value (e.g. Chain.Base). */
+    chainId: Chain | number;
+    /**
+     * Bot's private key (hex, 0x-prefixed). Used to sign payment intents.
+     * The SDK constructs a local signer internally — no RPC connection needed.
+     * Provide either this or `account`.
+     */
+    botPrivateKey?: Hex;
+    /** Override the relayer URL (defaults to https://relay.axonfi.xyz). */
+    relayerUrl?: string;
+}
+
+/** Resource descriptor from the x402 PAYMENT-REQUIRED header. */
+interface X402Resource {
+    /** URL of the resource being unlocked. */
+    url: string;
+    /** Human-readable description of the resource. */
+    description?: string;
+    /** MIME type of the resource. */
+    mimeType?: string;
+}
+/** A single payment option from the `accepts` array. */
+interface X402PaymentOption {
+    /** Recipient address (merchant). */
+    payTo: string;
+    /** Amount in token base units (string). */
+    amount: string;
+    /** Token contract address. */
+    asset: string;
+    /** CAIP-2 network identifier, e.g. "eip155:8453". */
+    network: string;
+    /** Settlement scheme: "exact" (EIP-3009) or "permit2". */
+    scheme?: string;
+    /** Additional option-specific fields. */
+    extra?: Record<string, unknown>;
+}
+/** Parsed x402 PAYMENT-REQUIRED response. */
+interface X402PaymentRequired {
+    /** x402 protocol version. */
+    x402Version: number;
+    /** Resource being unlocked. */
+    resource: X402Resource;
+    /** Accepted payment options. */
+    accepts: X402PaymentOption[];
+}
+/** Result of handlePaymentRequired — contains everything needed to retry the request. */
+interface X402HandleResult {
+    /** Base64-encoded JSON for the PAYMENT-SIGNATURE header. */
+    paymentSignature: string;
+    /** The payment option that was selected and funded. */
+    selectedOption: X402PaymentOption;
+    /** Axon payment result (txHash, requestId, etc.). */
+    fundingResult: {
+        requestId: string;
+        status: string;
+        txHash?: string;
+    };
+}
+/**
+ * Parse the PAYMENT-REQUIRED header value (base64 JSON).
+ *
+ * The x402 spec encodes the payment requirements as a base64-encoded JSON
+ * string in the response header.
+ */
+declare function parsePaymentRequired(headerValue: string): X402PaymentRequired;
+/**
+ * Parse a CAIP-2 network identifier to a numeric chain ID.
+ *
+ * @example parseChainId("eip155:8453") // → 8453
+ * @example parseChainId("eip155:84532") // → 84532
+ */
+declare function parseChainId(network: string): number;
+/**
+ * Find a payment option matching the bot's chain ID.
+ *
+ * Prefers USDC options (EIP-3009 path — no gas needed from bot).
+ * Falls back to any matching chain option.
+ *
+ * @returns The best matching payment option, or null if none match.
+ */
+declare function findMatchingOption(accepts: X402PaymentOption[], chainId: number): X402PaymentOption | null;
+/**
+ * Extract metadata fields from a parsed x402 header for payment enrichment.
+ *
+ * These fields flow into the Axon payment record, giving vault owners
+ * full visibility into what their bots are accessing.
+ */
+declare function extractX402Metadata(parsed: X402PaymentRequired, selectedOption: X402PaymentOption): {
+    resourceUrl: string;
+    memo: string | null;
+    recipientLabel: string | null;
+    metadata: Record<string, string>;
+};
+/**
+ * Format a payment signature payload for the PAYMENT-SIGNATURE header.
+ *
+ * The x402 spec requires the header value to be base64-encoded JSON.
+ */
+declare function formatPaymentSignature(payload: Record<string, unknown>): string;
+
+/**
+ * Main entry point for bots interacting with Axon.
+ *
+ * Handles EIP-712 signing, relayer communication, and status polling.
+ * Bots never submit transactions directly — they sign intents and the relayer
+ * handles all on-chain execution.
+ *
+ * All chain reads (balances, bot status, vault info) go through the relayer
+ * API — bots never need an RPC endpoint.
+ *
+ * @example
+ * ```ts
+ * import { AxonClient, USDC } from '@axonfi/sdk'
+ *
+ * const client = new AxonClient({
+ *   vaultAddress: '0x...',
+ *   chainId: 84532,           // Base Sepolia
+ *   botPrivateKey: '0x...',
+ * })
+ *
+ * const result = await client.pay({
+ *   to: '0x...recipient...',
+ *   token: 'USDC',
+ *   amount: 5,                // 5 USDC — SDK handles decimals
+ *   memo: 'API call #1234 — weather data',
+ * })
+ *
+ * console.log(result.status, result.txHash)
+ * ```
+ */
+declare class AxonClient {
+    private readonly vaultAddress;
+    private readonly chainId;
+    private readonly relayerUrl;
+    private readonly walletClient;
+    private readonly botPrivateKey;
+    constructor(config: AxonClientConfig);
+    /** Returns the bot's address derived from the configured private key. */
+    get botAddress(): Address;
+    /**
+     * 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
+     */
+    pay(input: PayInput): Promise<PaymentResult>;
+    /**
+     * 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.
+     */
+    execute(input: ExecuteInput): Promise<PaymentResult>;
+    /**
+     * 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.
+     */
+    swap(input: SwapInput): Promise<PaymentResult>;
+    /** Read the vault's ERC-20 balance for a given token (via relayer). */
+    getBalance(token: Address): Promise<bigint>;
+    /**
+     * Read the vault's ERC-20 balances for multiple tokens in a single call (via relayer).
+     * Returns a record mapping token address → balance.
+     */
+    getBalances(tokens: Address[]): Promise<Record<Address, bigint>>;
+    /** Returns whether this bot is registered and active in the vault (via relayer). */
+    isActive(): Promise<boolean>;
+    /** Returns whether the vault is currently paused (via relayer). */
+    isPaused(): Promise<boolean>;
+    /** Returns high-level vault info (owner, operator, paused, version) via relayer. */
+    getVaultInfo(): Promise<VaultInfo>;
+    /**
+     * Check whether this bot can pay to a given destination address (via relayer).
+     * Checks blacklist → global whitelist → bot whitelist, matching on-chain logic.
+     */
+    canPayTo(destination: Address): Promise<DestinationCheckResult>;
+    /** Returns whether a protocol address is approved for executeProtocol() calls (via relayer). */
+    isProtocolApproved(protocol: Address): Promise<boolean>;
+    /**
+     * 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.
+     */
+    getRebalanceTokens(): Promise<RebalanceTokensResult>;
+    /** Check if a specific token is allowed for rebalancing (executeSwap output) on this vault. */
+    isRebalanceTokenAllowed(token: Address): Promise<{
+        allowed: boolean;
+        source: 'default' | 'on_chain';
+    }>;
+    /** Check if a wallet has accepted the current TOS version. */
+    getTosStatus(wallet: string): Promise<TosStatus>;
+    /**
+     * 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).
+     */
+    acceptTos(signer: {
+        signMessage: (args: {
+            message: string;
+        }) => Promise<Hex>;
+    }, wallet: string): Promise<TosStatus>;
+    /**
+     * 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.
+     */
+    poll(requestId: string): Promise<PaymentResult>;
+    /** Poll the relayer for the status of an async protocol execution. */
+    pollExecute(requestId: string): Promise<PaymentResult>;
+    /** Poll the relayer for the status of an async swap. */
+    pollSwap(requestId: string): Promise<PaymentResult>;
+    /**
+     * 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).
+     */
+    signPayment(intent: PaymentIntent): Promise<Hex>;
+    /**
+     * 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 },
+     *   });
+     * }
+     * ```
+     */
+    readonly 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: (amount: bigint, token?: Address, metadata?: {
+            resourceUrl?: string;
+            memo?: string;
+            recipientLabel?: string;
+            metadata?: Record<string, string>;
+        }) => Promise<PaymentResult>;
+        /**
+         * 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: (headers: Headers | Record<string, string>, maxTimeoutMs?: number, pollIntervalMs?: number) => Promise<X402HandleResult>;
+    };
+    private _get;
+    private _defaultDeadline;
+    private _resolveRef;
+    private _buildPaymentIntent;
+    private _buildExecuteIntent;
+    private _buildSwapIntent;
+    private _submitPayment;
+    private _submitExecute;
+    private _submitSwap;
+    private _post;
+}
+
+/**
+ * Sign a PaymentIntent using EIP-712 typed structured data.
+ *
+ * The resulting signature can be submitted to the Axon relayer API, which
+ * passes it to AxonVault.executePayment() on-chain.
+ */
+declare function signPayment(walletClient: WalletClient, vaultAddress: Address, chainId: number, intent: PaymentIntent): Promise<Hex>;
+/**
+ * Sign an ExecuteIntent using EIP-712 typed structured data.
+ *
+ * The resulting signature can be submitted to the Axon relayer API, which
+ * passes it to AxonVault.executeProtocol() on-chain.
+ */
+declare function signExecuteIntent(walletClient: WalletClient, vaultAddress: Address, chainId: number, intent: ExecuteIntent): Promise<Hex>;
+/**
+ * Sign a SwapIntent using EIP-712 typed structured data.
+ *
+ * The resulting signature can be submitted to the Axon relayer API, which
+ * passes it to AxonVault.executeSwap() on-chain.
+ */
+declare function signSwapIntent(walletClient: WalletClient, vaultAddress: Address, chainId: number, intent: SwapIntent): Promise<Hex>;
+/**
+ * Derive the on-chain `ref` bytes32 from a human-readable memo string.
+ *
+ * The full memo text is stored off-chain by the relayer (PostgreSQL), linked
+ * to the transaction. The keccak256 hash goes into the signed PaymentIntent
+ * and is emitted in the PaymentExecuted on-chain event.
+ *
+ * @param memo  Human-readable description, e.g. "API call #1234 — weather data"
+ * @returns     keccak256 hash of the UTF-8 encoded memo, as a bytes32 hex.
+ */
+declare function encodeRef(memo: string): Hex;
+
+/** Returns the viem Chain object for a supported Axon chain ID. */
+declare function getChain(chainId: number): Chain$1;
+/** Create a viem PublicClient for the given chain and RPC URL. */
+declare function createAxonPublicClient(chainId: number, rpcUrl: string): PublicClient;
+/** Create a viem WalletClient from a raw private key (signing-only, no RPC needed). */
+declare function createAxonWalletClient(privateKey: Hex, chainId: number): WalletClient;
+/**
+ * Returns the full BotConfig for a bot address from the vault.
+ * If the bot has never been added, isActive will be false and all
+ * numeric fields will be 0n.
+ */
+declare function getBotConfig(publicClient: PublicClient, vaultAddress: Address, botAddress: Address): Promise<BotConfig>;
+/** Returns whether a bot address is currently active in the vault. */
+declare function isBotActive(publicClient: PublicClient, vaultAddress: Address, botAddress: Address): Promise<boolean>;
+/** Returns the operator ceilings set by the vault owner. */
+declare function getOperatorCeilings(publicClient: PublicClient, vaultAddress: Address): Promise<OperatorCeilings>;
+/**
+ * Returns the maximum USDC an operator-compromised wallet could drain per day.
+ * Computed on-chain as: min(maxOperatorBots × maxBotDailyLimit, vaultDailyAggregate).
+ * Returns 0n if operator has no bot-add permission.
+ */
+declare function operatorMaxDrainPerDay(publicClient: PublicClient, vaultAddress: Address): Promise<bigint>;
+/** Returns whether the vault is currently paused. */
+declare function isVaultPaused(publicClient: PublicClient, vaultAddress: Address): Promise<boolean>;
+/** Returns the EIP-712 domain separator for this vault (for off-chain verification). */
+declare function getDomainSeparator(publicClient: PublicClient, vaultAddress: Address): Promise<Hex>;
+/** Returns the vault contract version number. */
+declare function getVaultVersion(publicClient: PublicClient, vaultAddress: Address): Promise<number>;
+/** Returns the vault owner address. */
+declare function getVaultOwner(publicClient: PublicClient, vaultAddress: Address): Promise<Address>;
+/** Returns the vault operator address (address(0) if no operator set). */
+declare function getVaultOperator(publicClient: PublicClient, vaultAddress: Address): Promise<Address>;
+/**
+ * Check whether a destination address is allowed for a given bot.
+ *
+ * Logic mirrors the on-chain enforcement order:
+ * 1. If destination is on the global blacklist → blocked
+ * 2. If global whitelist is non-empty → destination must be on it
+ * 3. If bot-specific whitelist is non-empty → destination must be on it
+ * 4. Otherwise → allowed
+ */
+declare function isDestinationAllowed(publicClient: PublicClient, vaultAddress: Address, botAddress: Address, destination: Address): Promise<DestinationCheckResult>;
+/** Returns the number of tokens in the vault's on-chain rebalance whitelist. 0 = no on-chain whitelist. */
+declare function getRebalanceTokenCount(publicClient: PublicClient, vaultAddress: Address): Promise<number>;
+/** Returns whether a token is in the vault's on-chain rebalance whitelist. */
+declare function isRebalanceTokenWhitelisted(publicClient: PublicClient, vaultAddress: Address, token: Address): Promise<boolean>;
+/**
+ * Deploy a new AxonVault via the factory.
+ *
+ * The vault is owned by the walletClient's account. Permissionless — any
+ * address can deploy, no Axon approval required.
+ *
+ * @param walletClient      Wallet that will own the deployed vault.
+ * @param factoryAddress    Address of the deployed AxonVaultFactory.
+ * @returns                 Address of the newly deployed vault.
+ */
+declare function deployVault(walletClient: WalletClient, publicClient: PublicClient, factoryAddress: Address): Promise<Address>;
+
+interface KeystoreV3 {
+    version: 3;
+    id: string;
+    address: string;
+    crypto: {
+        ciphertext: string;
+        cipherparams: {
+            iv: string;
+        };
+        cipher: 'aes-128-ctr';
+        kdf: 'scrypt';
+        kdfparams: {
+            dklen: number;
+            salt: string;
+            n: number;
+            r: number;
+            p: number;
+        };
+        mac: string;
+    };
+}
+/**
+ * Encrypt a raw private key into a V3 keystore JSON object.
+ *
+ * Uses scrypt KDF (n=262144, r=8, p=1) and AES-128-CTR cipher —
+ * the same format as MetaMask and Geth.
+ *
+ * @param privateKey - Raw private key as 0x-prefixed hex string
+ * @param passphrase - Passphrase to encrypt with (min 1 character)
+ * @returns V3 keystore object ready to serialize as JSON
+ *
+ * @example
+ * ```ts
+ * import { encryptKeystore } from '@axonfi/sdk';
+ *
+ * const keystore = await encryptKeystore('0xabc...', 'my-strong-passphrase');
+ * fs.writeFileSync('bot-keystore.json', JSON.stringify(keystore, null, 2));
+ * ```
+ */
+declare function encryptKeystore(privateKey: Hex, passphrase: string): Promise<KeystoreV3>;
+/**
+ * Decrypt a V3 keystore back to a raw private key.
+ *
+ * @param keystore - V3 keystore object or JSON string
+ * @param passphrase - Passphrase used during encryption
+ * @returns Raw private key as 0x-prefixed hex string
+ * @throws Error if passphrase is wrong (MAC mismatch) or keystore is invalid
+ *
+ * @example
+ * ```ts
+ * import { AxonClient, decryptKeystore } from '@axonfi/sdk';
+ *
+ * const keystore = JSON.parse(fs.readFileSync('bot-keystore.json', 'utf8'));
+ * const privateKey = await decryptKeystore(keystore, process.env.BOT_PASSPHRASE!);
+ * const client = new AxonClient({ botPrivateKey: privateKey, ... });
+ * ```
+ */
+declare function decryptKeystore(keystore: KeystoreV3 | string, passphrase: string): Promise<Hex>;
+
+/**
+ * Look up decimals for a token by symbol, Token enum, or address.
+ *
+ * @param token - A KnownTokenSymbol ('USDC'), Token enum (Token.USDC), or address ('0x...')
+ * @param chainId - Optional chain ID (unused for decimal lookup, but reserved for future use)
+ * @returns The number of decimals for the token
+ * @throws If the token is an unknown address with no entry in KNOWN_TOKENS
+ */
+declare function resolveTokenDecimals(token: Address | Token | KnownTokenSymbol, chainId?: number): number;
+/**
+ * Convert a human-friendly amount to raw base units (bigint).
+ *
+ * - **bigint** → passed through as-is (already in base units)
+ * - **number** → converted to string, then parsed via `parseUnits(str, decimals)`
+ * - **string** → parsed directly via `parseUnits(str, decimals)`
+ *
+ * @param amount - The amount as bigint (raw), number (human), or string (human)
+ * @param token - Token identifier used to look up decimals (symbol, enum, or address)
+ * @param chainId - Optional chain ID (passed to resolveTokenDecimals)
+ * @returns The amount in token base units as bigint
+ *
+ * @example
+ * ```ts
+ * parseAmount(5_000_000n, 'USDC')     // 5000000n (passthrough)
+ * parseAmount(5.2, 'USDC')            // 5200000n
+ * parseAmount('5.2', 'USDC')          // 5200000n
+ * parseAmount(0.001, 'WETH')          // 1000000000000000n
+ * ```
+ *
+ * @throws If the amount has more decimal places than the token supports
+ * @throws If the token is unknown and amount is not bigint
+ */
+declare function parseAmount(amount: bigint | number | string, token: Address | Token | KnownTokenSymbol, chainId?: number): bigint;
+
+/**
+ * Per-chain EIP-712 domain parameters for USDC's EIP-3009 implementation.
+ * These differ between testnets and mainnets (Circle uses different `name` values).
+ *
+ * Verified on-chain via `cast call <usdc> "name()(string)"` and
+ * `cast call <usdc> "version()(string)"`.
+ */
+declare const USDC_EIP712_DOMAIN: Record<number, {
+    name: string;
+    version: string;
+}>;
+/** Parameters for EIP-3009 TransferWithAuthorization. */
+interface TransferAuthorization {
+    /** Token holder (sender). */
+    from: Address;
+    /** Recipient of the transfer. */
+    to: Address;
+    /** Amount in token base units (USDC: 6 decimals). */
+    value: bigint;
+    /** Unix timestamp — transfer is invalid before this time. Usually 0. */
+    validAfter: bigint;
+    /** Unix timestamp — transfer is invalid after this time. */
+    validBefore: bigint;
+    /** Random bytes32 nonce (must not have been used before for this sender). */
+    nonce: Hex;
+}
+/**
+ * Generate a random bytes32 nonce for EIP-3009.
+ * Uses crypto.getRandomValues for cryptographic randomness.
+ */
+declare function randomNonce(): Hex;
+/**
+ * Sign an EIP-3009 TransferWithAuthorization for USDC.
+ *
+ * The resulting signature can be submitted to a facilitator contract that calls
+ * `USDC.transferWithAuthorization(from, to, value, validAfter, validBefore, nonce, v, r, s)`.
+ *
+ * @param privateKey - Signer's private key (must match auth.from)
+ * @param chainId - Chain ID (determines USDC domain name/version)
+ * @param auth - Transfer authorization parameters
+ * @returns EIP-712 signature (65 bytes, 0x-prefixed)
+ */
+declare function signTransferWithAuthorization(privateKey: Hex, chainId: number, auth: TransferAuthorization): Promise<Hex>;
+
+/** Canonical Permit2 contract address (same on all EVM chains). */
+declare const PERMIT2_ADDRESS: Address;
+/** x402 facilitator proxy contract address (same on all supported chains). */
+declare const X402_PROXY_ADDRESS: Address;
+/**
+ * Witness type string for x402's PermitWitnessTransferFrom.
+ * Must match what the x402 facilitator contract expects.
+ */
+declare const WITNESS_TYPE_STRING: "TransferDetails witness)TokenPermissions(address token,uint256 amount)TransferDetails(address to,uint256 requestedAmount)";
+/** Parameters for Permit2 PermitWitnessTransferFrom. */
+interface Permit2Authorization {
+    /** Token to transfer. */
+    token: Address;
+    /** Maximum amount the spender can transfer. */
+    amount: bigint;
+    /** Spender address (the x402 proxy). */
+    spender: Address;
+    /** Unique nonce (random uint256). */
+    nonce: bigint;
+    /** Unix timestamp — signature is invalid after this time. */
+    deadline: bigint;
+    /** Witness: recipient address. */
+    witnessTo: Address;
+    /** Witness: requested amount. */
+    witnessRequestedAmount: bigint;
+}
+/**
+ * Generate a random uint256 nonce for Permit2.
+ * Uses crypto.getRandomValues for cryptographic randomness.
+ */
+declare function randomPermit2Nonce(): bigint;
+/**
+ * Sign a Permit2 PermitWitnessTransferFrom for x402.
+ *
+ * The resulting signature is submitted to the x402 facilitator proxy,
+ * which calls `Permit2.permitWitnessTransferFrom(...)` to settle the payment.
+ *
+ * @param privateKey - Signer's private key (token holder)
+ * @param chainId - Chain ID
+ * @param permit - Permit2 authorization parameters
+ * @returns EIP-712 signature (65 bytes, 0x-prefixed)
+ */
+declare function signPermit2WitnessTransfer(privateKey: Hex, chainId: number, permit: Permit2Authorization): Promise<Hex>;
+
+declare const AxonVaultAbi: readonly [{
+    readonly type: "constructor";
+    readonly inputs: readonly [{
+        readonly name: "_owner";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "_axonRegistry";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "receive";
+    readonly stateMutability: "payable";
+}, {
+    readonly type: "function";
+    readonly name: "DOMAIN_SEPARATOR";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "MAX_SPENDING_LIMITS";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint8";
+        readonly internalType: "uint8";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "NATIVE_ETH";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "VERSION";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint16";
+        readonly internalType: "uint16";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "acceptOwnership";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "addBot";
+    readonly inputs: readonly [{
+        readonly name: "bot";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "params";
+        readonly type: "tuple";
+        readonly internalType: "struct AxonVault.BotConfigParams";
+        readonly components: readonly [{
+            readonly name: "maxPerTxAmount";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "maxRebalanceAmount";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "spendingLimits";
+            readonly type: "tuple[]";
+            readonly internalType: "struct AxonVault.SpendingLimit[]";
+            readonly components: readonly [{
+                readonly name: "amount";
+                readonly type: "uint256";
+                readonly internalType: "uint256";
+            }, {
+                readonly name: "maxCount";
+                readonly type: "uint256";
+                readonly internalType: "uint256";
+            }, {
+                readonly name: "windowSeconds";
+                readonly type: "uint256";
+                readonly internalType: "uint256";
+            }];
+        }, {
+            readonly name: "aiTriggerThreshold";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "requireAiVerification";
+            readonly type: "bool";
+            readonly internalType: "bool";
+        }];
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "addBotDestination";
+    readonly inputs: readonly [{
+        readonly name: "bot";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "destination";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "addGlobalBlacklist";
+    readonly inputs: readonly [{
+        readonly name: "destination";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "addGlobalDestination";
+    readonly inputs: readonly [{
+        readonly name: "destination";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "addProtocol";
+    readonly inputs: readonly [{
+        readonly name: "protocol";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "addRebalanceTokens";
+    readonly inputs: readonly [{
+        readonly name: "tokens";
+        readonly type: "address[]";
+        readonly internalType: "address[]";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "approvedProtocolCount";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "approvedProtocols";
+    readonly inputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+        readonly internalType: "bool";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "axonRegistry";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "botAddedByOperator";
+    readonly inputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+        readonly internalType: "bool";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "botDestinationCount";
+    readonly inputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "botDestinationWhitelist";
+    readonly inputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+        readonly internalType: "bool";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "deposit";
+    readonly inputs: readonly [{
+        readonly name: "token";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "ref";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "payable";
+}, {
+    readonly type: "function";
+    readonly name: "eip712Domain";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "fields";
+        readonly type: "bytes1";
+        readonly internalType: "bytes1";
+    }, {
+        readonly name: "name";
+        readonly type: "string";
+        readonly internalType: "string";
+    }, {
+        readonly name: "version";
+        readonly type: "string";
+        readonly internalType: "string";
+    }, {
+        readonly name: "chainId";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "verifyingContract";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "salt";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }, {
+        readonly name: "extensions";
+        readonly type: "uint256[]";
+        readonly internalType: "uint256[]";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "executePayment";
+    readonly inputs: readonly [{
+        readonly name: "intent";
+        readonly type: "tuple";
+        readonly internalType: "struct AxonVault.PaymentIntent";
+        readonly components: readonly [{
+            readonly name: "bot";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "to";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "token";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "amount";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "deadline";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "ref";
+            readonly type: "bytes32";
+            readonly internalType: "bytes32";
+        }];
+    }, {
+        readonly name: "signature";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }, {
+        readonly name: "fromToken";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "maxFromAmount";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "swapRouter";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "swapCalldata";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "executeProtocol";
+    readonly inputs: readonly [{
+        readonly name: "intent";
+        readonly type: "tuple";
+        readonly internalType: "struct AxonVault.ExecuteIntent";
+        readonly components: readonly [{
+            readonly name: "bot";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "protocol";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "calldataHash";
+            readonly type: "bytes32";
+            readonly internalType: "bytes32";
+        }, {
+            readonly name: "token";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "amount";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "deadline";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "ref";
+            readonly type: "bytes32";
+            readonly internalType: "bytes32";
+        }];
+    }, {
+        readonly name: "signature";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }, {
+        readonly name: "callData";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }, {
+        readonly name: "fromToken";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "maxFromAmount";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "swapRouter";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "swapCalldata";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "executeSwap";
+    readonly inputs: readonly [{
+        readonly name: "intent";
+        readonly type: "tuple";
+        readonly internalType: "struct AxonVault.SwapIntent";
+        readonly components: readonly [{
+            readonly name: "bot";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "toToken";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "minToAmount";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "deadline";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "ref";
+            readonly type: "bytes32";
+            readonly internalType: "bytes32";
+        }];
+    }, {
+        readonly name: "signature";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }, {
+        readonly name: "fromToken";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "maxFromAmount";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "swapRouter";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "swapCalldata";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "getBotConfig";
+    readonly inputs: readonly [{
+        readonly name: "bot";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "tuple";
+        readonly internalType: "struct AxonVault.BotConfig";
+        readonly components: readonly [{
+            readonly name: "isActive";
+            readonly type: "bool";
+            readonly internalType: "bool";
+        }, {
+            readonly name: "registeredAt";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "maxPerTxAmount";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "maxRebalanceAmount";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "spendingLimits";
+            readonly type: "tuple[]";
+            readonly internalType: "struct AxonVault.SpendingLimit[]";
+            readonly components: readonly [{
+                readonly name: "amount";
+                readonly type: "uint256";
+                readonly internalType: "uint256";
+            }, {
+                readonly name: "maxCount";
+                readonly type: "uint256";
+                readonly internalType: "uint256";
+            }, {
+                readonly name: "windowSeconds";
+                readonly type: "uint256";
+                readonly internalType: "uint256";
+            }];
+        }, {
+            readonly name: "aiTriggerThreshold";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "requireAiVerification";
+            readonly type: "bool";
+            readonly internalType: "bool";
+        }];
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "globalBlacklistCount";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "globalDestinationBlacklist";
+    readonly inputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+        readonly internalType: "bool";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "globalDestinationCount";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "globalDestinationWhitelist";
+    readonly inputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+        readonly internalType: "bool";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "isBotActive";
+    readonly inputs: readonly [{
+        readonly name: "bot";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+        readonly internalType: "bool";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "isProtocolApproved";
+    readonly inputs: readonly [{
+        readonly name: "protocol";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+        readonly internalType: "bool";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "operator";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "operatorBotCount";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "operatorCeilings";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "maxPerTxAmount";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "maxBotDailyLimit";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "maxOperatorBots";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "vaultDailyAggregate";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "minAiTriggerFloor";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "operatorMaxDrainPerDay";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "owner";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "pause";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "paused";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+        readonly internalType: "bool";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "pendingOwner";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "rebalanceTokenCount";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "rebalanceTokenWhitelist";
+    readonly inputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+        readonly internalType: "bool";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "removeBot";
+    readonly inputs: readonly [{
+        readonly name: "bot";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "removeBotDestination";
+    readonly inputs: readonly [{
+        readonly name: "bot";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "destination";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "removeGlobalBlacklist";
+    readonly inputs: readonly [{
+        readonly name: "destination";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "removeGlobalDestination";
+    readonly inputs: readonly [{
+        readonly name: "destination";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "removeProtocol";
+    readonly inputs: readonly [{
+        readonly name: "protocol";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "removeRebalanceTokens";
+    readonly inputs: readonly [{
+        readonly name: "tokens";
+        readonly type: "address[]";
+        readonly internalType: "address[]";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "renounceOwnership";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "setOperator";
+    readonly inputs: readonly [{
+        readonly name: "_operator";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "setOperatorCeilings";
+    readonly inputs: readonly [{
+        readonly name: "ceilings";
+        readonly type: "tuple";
+        readonly internalType: "struct AxonVault.OperatorCeilings";
+        readonly components: readonly [{
+            readonly name: "maxPerTxAmount";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "maxBotDailyLimit";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "maxOperatorBots";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "vaultDailyAggregate";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "minAiTriggerFloor";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }];
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "transferOwnership";
+    readonly inputs: readonly [{
+        readonly name: "newOwner";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "unpause";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "updateBotConfig";
+    readonly inputs: readonly [{
+        readonly name: "bot";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "params";
+        readonly type: "tuple";
+        readonly internalType: "struct AxonVault.BotConfigParams";
+        readonly components: readonly [{
+            readonly name: "maxPerTxAmount";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "maxRebalanceAmount";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "spendingLimits";
+            readonly type: "tuple[]";
+            readonly internalType: "struct AxonVault.SpendingLimit[]";
+            readonly components: readonly [{
+                readonly name: "amount";
+                readonly type: "uint256";
+                readonly internalType: "uint256";
+            }, {
+                readonly name: "maxCount";
+                readonly type: "uint256";
+                readonly internalType: "uint256";
+            }, {
+                readonly name: "windowSeconds";
+                readonly type: "uint256";
+                readonly internalType: "uint256";
+            }];
+        }, {
+            readonly name: "aiTriggerThreshold";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "requireAiVerification";
+            readonly type: "bool";
+            readonly internalType: "bool";
+        }];
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "usedIntents";
+    readonly inputs: readonly [{
+        readonly name: "";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+        readonly internalType: "bool";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "withdraw";
+    readonly inputs: readonly [{
+        readonly name: "token";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "to";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "event";
+    readonly name: "BotAdded";
+    readonly inputs: readonly [{
+        readonly name: "bot";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "addedBy";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "BotConfigUpdated";
+    readonly inputs: readonly [{
+        readonly name: "bot";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "updatedBy";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "BotDestinationAdded";
+    readonly inputs: readonly [{
+        readonly name: "bot";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "destination";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "BotDestinationRemoved";
+    readonly inputs: readonly [{
+        readonly name: "bot";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "destination";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "BotRemoved";
+    readonly inputs: readonly [{
+        readonly name: "bot";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "removedBy";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "Deposited";
+    readonly inputs: readonly [{
+        readonly name: "from";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "token";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+        readonly indexed: false;
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "ref";
+        readonly type: "bytes32";
+        readonly indexed: false;
+        readonly internalType: "bytes32";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "EIP712DomainChanged";
+    readonly inputs: readonly [];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "GlobalBlacklistAdded";
+    readonly inputs: readonly [{
+        readonly name: "destination";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "GlobalBlacklistRemoved";
+    readonly inputs: readonly [{
+        readonly name: "destination";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "GlobalDestinationAdded";
+    readonly inputs: readonly [{
+        readonly name: "destination";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "GlobalDestinationRemoved";
+    readonly inputs: readonly [{
+        readonly name: "destination";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "OperatorCeilingsUpdated";
+    readonly inputs: readonly [{
+        readonly name: "ceilings";
+        readonly type: "tuple";
+        readonly indexed: false;
+        readonly internalType: "struct AxonVault.OperatorCeilings";
+        readonly components: readonly [{
+            readonly name: "maxPerTxAmount";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "maxBotDailyLimit";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "maxOperatorBots";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "vaultDailyAggregate";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "minAiTriggerFloor";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }];
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "OperatorSet";
+    readonly inputs: readonly [{
+        readonly name: "oldOperator";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "newOperator";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "OwnershipTransferStarted";
+    readonly inputs: readonly [{
+        readonly name: "previousOwner";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "newOwner";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "OwnershipTransferred";
+    readonly inputs: readonly [{
+        readonly name: "previousOwner";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "newOwner";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "Paused";
+    readonly inputs: readonly [{
+        readonly name: "account";
+        readonly type: "address";
+        readonly indexed: false;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "PaymentExecuted";
+    readonly inputs: readonly [{
+        readonly name: "bot";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "to";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "token";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+        readonly indexed: false;
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "ref";
+        readonly type: "bytes32";
+        readonly indexed: false;
+        readonly internalType: "bytes32";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "ProtocolAdded";
+    readonly inputs: readonly [{
+        readonly name: "protocol";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "ProtocolExecuted";
+    readonly inputs: readonly [{
+        readonly name: "bot";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "protocol";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "token";
+        readonly type: "address";
+        readonly indexed: false;
+        readonly internalType: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+        readonly indexed: false;
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "ref";
+        readonly type: "bytes32";
+        readonly indexed: false;
+        readonly internalType: "bytes32";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "ProtocolRemoved";
+    readonly inputs: readonly [{
+        readonly name: "protocol";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "RebalanceTokenAdded";
+    readonly inputs: readonly [{
+        readonly name: "token";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "RebalanceTokenRemoved";
+    readonly inputs: readonly [{
+        readonly name: "token";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "SwapExecuted";
+    readonly inputs: readonly [{
+        readonly name: "bot";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "fromToken";
+        readonly type: "address";
+        readonly indexed: false;
+        readonly internalType: "address";
+    }, {
+        readonly name: "toToken";
+        readonly type: "address";
+        readonly indexed: false;
+        readonly internalType: "address";
+    }, {
+        readonly name: "fromAmount";
+        readonly type: "uint256";
+        readonly indexed: false;
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "toAmount";
+        readonly type: "uint256";
+        readonly indexed: false;
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "ref";
+        readonly type: "bytes32";
+        readonly indexed: false;
+        readonly internalType: "bytes32";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "SwapPaymentExecuted";
+    readonly inputs: readonly [{
+        readonly name: "bot";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "to";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "fromToken";
+        readonly type: "address";
+        readonly indexed: false;
+        readonly internalType: "address";
+    }, {
+        readonly name: "toToken";
+        readonly type: "address";
+        readonly indexed: false;
+        readonly internalType: "address";
+    }, {
+        readonly name: "fromAmount";
+        readonly type: "uint256";
+        readonly indexed: false;
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "toAmount";
+        readonly type: "uint256";
+        readonly indexed: false;
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "ref";
+        readonly type: "bytes32";
+        readonly indexed: false;
+        readonly internalType: "bytes32";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "Unpaused";
+    readonly inputs: readonly [{
+        readonly name: "account";
+        readonly type: "address";
+        readonly indexed: false;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "Withdrawn";
+    readonly inputs: readonly [{
+        readonly name: "token";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+        readonly indexed: false;
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "to";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "error";
+    readonly name: "AlreadyApprovedProtocol";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "AmountMismatch";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "BotAlreadyExists";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "BotDoesNotExist";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "BotNotActive";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "CalldataHashMismatch";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "DeadlineExpired";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "DestinationBlacklisted";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "DestinationNotWhitelisted";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "ECDSAInvalidSignature";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "ECDSAInvalidSignatureLength";
+    readonly inputs: readonly [{
+        readonly name: "length";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+}, {
+    readonly type: "error";
+    readonly name: "ECDSAInvalidSignatureS";
+    readonly inputs: readonly [{
+        readonly name: "s";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }];
+}, {
+    readonly type: "error";
+    readonly name: "EnforcedPause";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "ExceedsOperatorCeiling";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "ExpectedPause";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "InsufficientBalance";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "IntentAlreadyUsed";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "InvalidShortString";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "InvalidSignature";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "MaxPerTxExceeded";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "MaxRebalanceAmountExceeded";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "NativeTransferFailed";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "NotAuthorized";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "NotAuthorizedRelayer";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "OperatorBotLimitReached";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "OperatorCannotBeOwner";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "OracleNotConfigured";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "OracleUnavailable";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "OwnableInvalidOwner";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+}, {
+    readonly type: "error";
+    readonly name: "OwnableUnauthorizedAccount";
+    readonly inputs: readonly [{
+        readonly name: "account";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+}, {
+    readonly type: "error";
+    readonly name: "OwnerCannotBeBot";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "PaymentToZeroAddress";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "ProtocolCallFailed";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "ProtocolNotApproved";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "ProtocolNotInList";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "RebalanceTokenNotAllowed";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "ReentrancyGuardReentrantCall";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "RouterNotApproved";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "SafeERC20FailedOperation";
+    readonly inputs: readonly [{
+        readonly name: "token";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+}, {
+    readonly type: "error";
+    readonly name: "SameTokenSwap";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "SelfPayment";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "StringTooLong";
+    readonly inputs: readonly [{
+        readonly name: "str";
+        readonly type: "string";
+        readonly internalType: "string";
+    }];
+}, {
+    readonly type: "error";
+    readonly name: "SwapFailed";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "SwapOutputInsufficient";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "TooManySpendingLimits";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "UnexpectedETH";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "ZeroAddress";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "ZeroAmount";
+    readonly inputs: readonly [];
+}];
+
+declare const AxonVaultFactoryAbi: readonly [{
+    readonly type: "constructor";
+    readonly inputs: readonly [{
+        readonly name: "_axonRegistry";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "factoryOwner";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "acceptOwnership";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "allVaults";
+    readonly inputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "axonRegistry";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "deployVault";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "vault";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "owner";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "ownerVaultCount";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "ownerVaults";
+    readonly inputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "pendingOwner";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "renounceOwnership";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "transferOwnership";
+    readonly inputs: readonly [{
+        readonly name: "newOwner";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "vaultCount";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "event";
+    readonly name: "OwnershipTransferStarted";
+    readonly inputs: readonly [{
+        readonly name: "previousOwner";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "newOwner";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "OwnershipTransferred";
+    readonly inputs: readonly [{
+        readonly name: "previousOwner";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "newOwner";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "VaultDeployed";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "vault";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "version";
+        readonly type: "uint16";
+        readonly indexed: false;
+        readonly internalType: "uint16";
+    }, {
+        readonly name: "axonRegistry";
+        readonly type: "address";
+        readonly indexed: false;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "error";
+    readonly name: "OwnableInvalidOwner";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+}, {
+    readonly type: "error";
+    readonly name: "OwnableUnauthorizedAccount";
+    readonly inputs: readonly [{
+        readonly name: "account";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+}, {
+    readonly type: "error";
+    readonly name: "ZeroAddress";
+    readonly inputs: readonly [];
+}];
+
+declare const AxonRegistryAbi: readonly [{
+    readonly type: "constructor";
+    readonly inputs: readonly [{
+        readonly name: "initialOwner";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "acceptOwnership";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "addRelayer";
+    readonly inputs: readonly [{
+        readonly name: "relayer";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "addSwapRouter";
+    readonly inputs: readonly [{
+        readonly name: "router";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "isApprovedSwapRouter";
+    readonly inputs: readonly [{
+        readonly name: "router";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+        readonly internalType: "bool";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "isAuthorized";
+    readonly inputs: readonly [{
+        readonly name: "relayer";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+        readonly internalType: "bool";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "owner";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "pendingOwner";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "removeRelayer";
+    readonly inputs: readonly [{
+        readonly name: "relayer";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "removeSwapRouter";
+    readonly inputs: readonly [{
+        readonly name: "router";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "renounceOwnership";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "setOracleConfig";
+    readonly inputs: readonly [{
+        readonly name: "uniV3Factory";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "usdc";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "weth";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "transferOwnership";
+    readonly inputs: readonly [{
+        readonly name: "newOwner";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "uniswapV3Factory";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "usdcAddress";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "wethAddress";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "event";
+    readonly name: "OracleConfigUpdated";
+    readonly inputs: readonly [{
+        readonly name: "uniswapV3Factory";
+        readonly type: "address";
+        readonly indexed: false;
+        readonly internalType: "address";
+    }, {
+        readonly name: "usdc";
+        readonly type: "address";
+        readonly indexed: false;
+        readonly internalType: "address";
+    }, {
+        readonly name: "weth";
+        readonly type: "address";
+        readonly indexed: false;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "OwnershipTransferStarted";
+    readonly inputs: readonly [{
+        readonly name: "previousOwner";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "newOwner";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "OwnershipTransferred";
+    readonly inputs: readonly [{
+        readonly name: "previousOwner";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "newOwner";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "RelayerAdded";
+    readonly inputs: readonly [{
+        readonly name: "relayer";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "RelayerRemoved";
+    readonly inputs: readonly [{
+        readonly name: "relayer";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "SwapRouterAdded";
+    readonly inputs: readonly [{
+        readonly name: "router";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "SwapRouterRemoved";
+    readonly inputs: readonly [{
+        readonly name: "router";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "error";
+    readonly name: "AlreadyApproved";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "AlreadyAuthorized";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "NotApproved";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "NotAuthorized";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "OwnableInvalidOwner";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+}, {
+    readonly type: "error";
+    readonly name: "OwnableUnauthorizedAccount";
+    readonly inputs: readonly [{
+        readonly name: "account";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+}, {
+    readonly type: "error";
+    readonly name: "ZeroAddress";
+    readonly inputs: readonly [];
+}];
+
+export { type AmountInput, AxonClient, type AxonClientConfig, AxonRegistryAbi, AxonVaultAbi, AxonVaultFactoryAbi, type BotConfig, type BotConfigParams, CHAIN_NAMES, Chain, DEFAULT_DEADLINE_SECONDS, type DestinationCheckResult, EIP712_DOMAIN_NAME, EIP712_DOMAIN_VERSION, EXECUTE_INTENT_TYPEHASH, EXPLORER_ADDR, EXPLORER_TX, type ExecuteInput, type ExecuteIntent, KNOWN_TOKENS, type KeystoreV3, type KnownToken, type KnownTokenSymbol, NATIVE_ETH, type OperatorCeilings, PAYMENT_INTENT_TYPEHASH, PERMIT2_ADDRESS, type PayInput, PaymentErrorCode, type PaymentIntent, type PaymentResult, type PaymentStatus, type Permit2Authorization, RELAYER_API, type RebalanceTokensResult, SUPPORTED_CHAIN_IDS, SWAP_INTENT_TYPEHASH, type SpendingLimit, type SupportedChainId, type SwapInput, type SwapIntent, Token, type TokenInput, type TosStatus, type TransferAuthorization, USDC, USDC_EIP712_DOMAIN, type VaultInfo, WINDOW, WITNESS_TYPE_STRING, type X402HandleResult, type X402PaymentOption, type X402PaymentRequired, type X402Resource, X402_PROXY_ADDRESS, createAxonPublicClient, createAxonWalletClient, decryptKeystore, deployVault, encodeRef, encryptKeystore, extractX402Metadata, findMatchingOption, formatPaymentSignature, getBotConfig, getChain, getDomainSeparator, getKnownTokensForChain, getOperatorCeilings, getRebalanceTokenCount, getTokenSymbolByAddress, getVaultOperator, getVaultOwner, getVaultVersion, isBotActive, isDestinationAllowed, isRebalanceTokenWhitelisted, isVaultPaused, operatorMaxDrainPerDay, parseAmount, parseChainId, parsePaymentRequired, randomNonce, randomPermit2Nonce, resolveToken, resolveTokenDecimals, signExecuteIntent, signPayment, signPermit2WitnessTransfer, signSwapIntent, signTransferWithAuthorization };