@paxoslabs/amplify-sdk 0.0.1-alpha.1

package/dist/index.d.ts

@@ -0,0 +1,3236 @@
+import { Address, erc20Abi, Hex } from 'viem';
+import { A as AmplifyVault, S as SupportedAsset, a as AssetFilterOptions, V as VaultFilterOptions, W as WithdrawSupportedAsset } from './amplify-sdk-api-B5hBTGrB.js';
+export { b as APIError } from './amplify-sdk-api-B5hBTGrB.js';
+export { g as getDepositExchangeRate, a as getWithdrawExchangeRate, i as isDepositSpendApproved, b as isWithdrawalSpendApproved } from './exchange-rate-D3_FVgqa.js';
+import { Y as YieldType } from './config-B-u3VqEX.js';
+import { C as ChainId } from './vault-config-BNzhv3QV.js';
+import './config-BQynVNDC.js';
+
+/**
+ * Vault Cache Layer
+ *
+ * In-memory cache for vault and asset data with TTL-based expiration.
+ * Provides fast lookups and automatic refresh on expiry.
+ *
+ * @module lib/vault-cache
+ */
+
+/**
+ * VaultCache class
+ *
+ * Manages in-memory cache for vault and asset data with TTL-based expiration.
+ * Automatically refreshes expired cache on queries.
+ *
+ * @example
+ * ```typescript
+ * // Initialize cache with default 10-minute TTL
+ * const cache = new VaultCache();
+ *
+ * // Initialize cache with custom TTL (5 minutes)
+ * const customCache = new VaultCache(300000);
+ *
+ * // Get vaults by deposit token address
+ * const vaults = cache.getVault("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48");
+ *
+ * // Get asset by token address
+ * const asset = cache.getAsset("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48");
+ *
+ * // Get all cached vaults
+ * const allVaults = cache.getAllVaults();
+ *
+ * // Check if cache is expired
+ * const expired = cache.isExpired();
+ *
+ * // Manually refresh cache
+ * await cache.refresh();
+ * ```
+ */
+declare class VaultCache {
+    /**
+     * Vaults keyed by baseTokenAddress
+     * One key can map to multiple vaults (different chains/yield types)
+     */
+    private vaults;
+    /**
+     * Assets keyed by token address
+     */
+    private assets;
+    /**
+     * Unix timestamp (milliseconds) of last successful fetch
+     */
+    private lastFetch;
+    /**
+     * Time-to-live in milliseconds
+     */
+    private readonly ttl;
+    /**
+     * Flag to prevent concurrent refresh operations
+     */
+    private refreshing;
+    /**
+     * Creates a new VaultCache instance
+     *
+     * @param ttl - Time-to-live in milliseconds (default: 600000 = 10 minutes)
+     */
+    constructor(ttl?: number);
+    /**
+     * Gets vaults by deposit token address
+     *
+     * Returns undefined if no vaults found for the given token address.
+     * Does NOT automatically refresh if cache is expired; use refresh() for that.
+     *
+     * @param tokenAddress - Deposit token address (baseTokenAddress)
+     * @returns Array of AmplifyVault objects, or undefined if not found
+     */
+    getVault(tokenAddress: string): AmplifyVault[] | undefined;
+    /**
+     * Gets asset by token address
+     *
+     * Returns undefined if asset not found.
+     * Does NOT automatically refresh if cache is expired; use refresh() for that.
+     *
+     * @param tokenAddress - Token address
+     * @returns SupportedAsset object, or undefined if not found
+     */
+    getAsset(tokenAddress: string): SupportedAsset | undefined;
+    /**
+     * Gets all cached vaults
+     *
+     * Returns an array of all vaults across all deposit tokens.
+     * Does NOT automatically refresh if cache is expired; use refresh() for that.
+     *
+     * @returns Array of all AmplifyVault objects
+     */
+    getAllVaults(): AmplifyVault[];
+    /**
+     * Gets all cached assets
+     *
+     * Returns an array of all assets.
+     * Does NOT automatically refresh if cache is expired; use refresh() for that.
+     *
+     * @returns Array of all SupportedAsset objects
+     */
+    getAllAssets(): SupportedAsset[];
+    /**
+     * Checks if cache is expired
+     *
+     * Cache is considered expired if current time exceeds lastFetch + ttl.
+     *
+     * @returns true if cache is expired, false otherwise
+     */
+    isExpired(): boolean;
+    /**
+     * Gets the time until cache expires
+     *
+     * @returns Milliseconds until expiry, or 0 if already expired
+     */
+    getTimeUntilExpiry(): number;
+    /**
+     * Checks if cache is empty (never populated)
+     *
+     * @returns true if cache has never been populated, false otherwise
+     */
+    isEmpty(): boolean;
+    /**
+     * Manually refreshes the cache
+     *
+     * Fetches fresh data from the API and updates both vaults and assets maps.
+     * Updates lastFetch timestamp on success.
+     *
+     * If a refresh is already in progress, this method waits for it to complete
+     * instead of starting a concurrent refresh.
+     *
+     * @throws {APIError} If the API request fails
+     */
+    refresh(): Promise<void>;
+    /**
+     * Clears the cache
+     *
+     * Removes all cached data and resets lastFetch timestamp.
+     * Does not affect TTL setting.
+     */
+    clear(): void;
+    /**
+     * Gets cache statistics
+     *
+     * @returns Object with cache statistics
+     */
+    getStats(): {
+        vaultCount: number;
+        assetCount: number;
+        tokenCount: number;
+        lastFetch: number;
+        ttl: number;
+        isExpired: boolean;
+        isEmpty: boolean;
+        timeUntilExpiry: number;
+    };
+}
+
+/**
+ * Amplify SDK API Client
+ *
+ * Provides functions to fetch vault and asset data from the Amplify SDK backend API.
+ * Handles input validation, error handling, and response parsing.
+ * Includes cache integration for performance optimization.
+ *
+ * @module api/amplify-sdk-client
+ */
+
+/**
+ * Fetches vaults from the Earn SDK API
+ *
+ * @param options - Optional filter options for vault queries
+ * @returns Promise resolving to array of AmplifyVault objects
+ * @throws {APIError} If the request fails, times out, or returns invalid data
+ *
+ * @example
+ * ```typescript
+ * // Fetch all vaults
+ * const allVaults = await fetchVaults();
+ *
+ * // Fetch PRIME vaults on Ethereum
+ * const ethPrimes = await fetchVaults({
+ *   chainId: 1,
+ *   yieldType: "PRIME"
+ * });
+ *
+ * // Fetch vaults accepting USDC
+ * const usdcVaults = await fetchVaults({
+ *   depositTokenAddress: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
+ * });
+ * ```
+ */
+declare function fetchVaults(options?: VaultFilterOptions): Promise<AmplifyVault[]>;
+/**
+ * Fetches supported assets from the Earn SDK API
+ *
+ * @param options - Optional filter options for asset queries
+ * @returns Promise resolving to array of SupportedAsset objects
+ * @throws {APIError} If the request fails, times out, or returns invalid data
+ *
+ * @example
+ * ```typescript
+ * // Fetch all supported assets
+ * const allAssets = await fetchSupportedAssets();
+ *
+ * // Fetch assets supported on Ethereum and Base
+ * const ethAssets = await fetchSupportedAssets({
+ *   chains: [1, 8453]
+ * });
+ *
+ * // Fetch PRIME yield type assets
+ * const primeAssets = await fetchSupportedAssets({
+ *   yieldType: "PRIME"
+ * });
+ *
+ * // Combine filters
+ * const ethPrimeAssets = await fetchSupportedAssets({
+ *   chains: [1],
+ *   yieldType: "PRIME"
+ * });
+ * ```
+ */
+declare function fetchSupportedAssets(options?: AssetFilterOptions): Promise<SupportedAsset[]>;
+/**
+ * Initializes the global vault cache
+ *
+ * Creates a new VaultCache instance with the specified TTL.
+ * If a cache already exists, it will be replaced with a new instance.
+ *
+ * @param ttl - Time-to-live in milliseconds (default: 600000 = 10 minutes)
+ * @returns The initialized VaultCache instance
+ *
+ * @example
+ * ```typescript
+ * // Initialize cache with default 10-minute TTL
+ * const cache = initializeCache();
+ *
+ * // Initialize cache with custom 5-minute TTL
+ * const customCache = initializeCache(300000);
+ * ```
+ */
+declare function initializeCache(ttl?: number): VaultCache;
+/**
+ * Gets the global vault cache instance
+ *
+ * If no cache exists, creates one with default TTL.
+ *
+ * @returns The global VaultCache instance
+ */
+declare function getCache(): VaultCache;
+/**
+ * Manually refreshes the global vault cache
+ *
+ * Fetches fresh data from the API and updates the cache.
+ * This is the public SDK method for cache refresh.
+ *
+ * @throws {APIError} If the API request fails
+ *
+ * @example
+ * ```typescript
+ * // Manually refresh cache
+ * await refreshVaultCache();
+ * ```
+ */
+declare function refreshVaultCache(): Promise<void>;
+/**
+ * Gets supported assets from cache with automatic refresh on expiry
+ *
+ * @param options - Optional filter options for asset queries
+ * @returns Promise resolving to array of SupportedAsset objects
+ * @throws {APIError} If the request fails or returns invalid data
+ *
+ * @remarks
+ * Note: yieldType filtering is not supported in the cache layer because
+ * SupportedAsset objects don't have a yieldType property. For yieldType
+ * filtering, use fetchSupportedAssets() which queries the API directly.
+ *
+ * @example
+ * ```typescript
+ * // Get all supported assets (cache-first)
+ * const allAssets = await getAssetsFromCache();
+ *
+ * // Get assets supported on Ethereum and Base (cache-first)
+ * const ethAssets = await getAssetsFromCache({
+ *   chains: [1, 8453]
+ * });
+ *
+ * // Get USDC by address (cache-first)
+ * const usdc = await getAssetsFromCache({
+ *   address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
+ * });
+ *
+ * // Get asset by symbol (cache-first)
+ * const usdcBySymbol = await getAssetsFromCache({
+ *   symbol: "USDC"
+ * });
+ * ```
+ */
+declare function getAssetsFromCache(options?: AssetFilterOptions): Promise<SupportedAsset[]>;
+/**
+ * Finds a vault by configuration criteria
+ *
+ * Resolves the correct vault using multi-criteria filtering based on:
+ * - assetAddress: The asset token address (baseTokenAddress)
+ * - yieldType: The yield strategy (PRIME, TBILL, LENDING)
+ * - chainId: The blockchain network
+ *
+ * Automatically refreshes cache if expired.
+ * Returns the first matching vault or null if no match found.
+ *
+ * @param params - Configuration parameters
+ * @param params.assetAddress - Asset token address (viem Address)
+ * @param params.yieldType - Yield strategy type (PRIME, TBILL, or LENDING)
+ * @param params.chainId - Blockchain network ID
+ * @returns Promise resolving to AmplifyVault or null if no match found
+ * @throws {APIError} If parameters are invalid or API request fails
+ *
+ * @example
+ * ```typescript
+ * // Find PRIME vault on Ethereum for USDC
+ * const vault = await findVaultByConfig({
+ *   assetAddress: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+ *   yieldType: "PRIME",
+ *   chainId: 1
+ * });
+ *
+ * if (vault) {
+ *   console.log("Found vault:", vault.id);
+ * } else {
+ *   console.log("No matching vault found");
+ * }
+ * ```
+ */
+declare function findVaultByConfig(params: {
+    assetAddress: Address;
+    yieldType: string;
+    chainId: number;
+}): Promise<AmplifyVault | null>;
+/**
+ * Gets supported assets grouped by token with available vaults
+ *
+ * Fetches and caches vault data, then transforms it into WithdrawSupportedAsset objects.
+ * Each asset shows all vaults that support withdrawals of that token.
+ *
+ * Automatically populates cache on first call if empty.
+ * Reuses cached data on subsequent calls (if not expired).
+ *
+ * @returns Promise resolving to array of WithdrawSupportedAsset objects
+ * @throws {APIError} If the API request fails or returns invalid data
+ *
+ * @example
+ * ```typescript
+ * // Get all supported assets with available vaults
+ * const assets = await getWithdrawSupportedAssets();
+ *
+ * // Display options to user
+ * for (const asset of assets) {
+ *   console.log(`${asset.symbol}: ${asset.vaults.length} vaults available`);
+ *   for (const vault of asset.vaults) {
+ *     console.log(`  - ${vault.yieldType} on chain ${vault.chainId}`);
+ *   }
+ * }
+ * ```
+ */
+declare function getWithdrawSupportedAssets(): Promise<WithdrawSupportedAsset[]>;
+
+/**
+ * SDK Configuration Types
+ *
+ * Type definitions for SDK initialization and configuration management.
+ */
+/**
+ * SDK Configuration State
+ *
+ * Stores the API key and initialization status for the SDK.
+ * This configuration is maintained at the module level in src/lib/sdk-config.ts
+ */
+interface SDKConfig {
+    /**
+     * API key for Paxos Labs API authentication
+     * Set during initialization, used in all API requests
+     * Format: pxl_<type>_<random_string>
+     */
+    apiKey: string | null;
+    /**
+     * Indicates whether SDK has been successfully initialized
+     * Set to true after init completes, false on clear
+     */
+    isInitialized: boolean;
+    /**
+     * Timestamp when SDK was initialized
+     * Used for debugging and telemetry
+     */
+    initializedAt: Date | null;
+    /**
+     * Flag to track if initialization is currently in progress
+     * Prevents concurrent initialization attempts
+     */
+    isInitializing: boolean;
+    /**
+     * Promise for ongoing initialization
+     * Allows concurrent calls to wait for same initialization
+     */
+    initPromise: Promise<void> | null;
+}
+/**
+ * Request headers for Paxos Labs API
+ *
+ * Standard headers used in all API requests, including authentication.
+ */
+type RequestHeaders = Record<string, string>;
+/**
+ * Initialization error codes
+ *
+ * Specific error codes for different initialization failure scenarios.
+ * Use these codes for programmatic error handling.
+ */
+type InitErrorCode = "INVALID_API_KEY" | "EMPTY_API_KEY" | "AUTH_FAILED" | "NETWORK_TIMEOUT" | "CACHE_INIT_FAILED" | "CONCURRENT_INIT" | "UNKNOWN_ERROR";
+
+/**
+ * SDK Configuration Module
+ *
+ * Manages SDK initialization state and API key storage.
+ * Provides core initialization function and helper utilities.
+ */
+
+/**
+ * Initialize Amplify SDK with API key
+ *
+ * Validates API key, configures authentication headers, and pre-populates
+ * the cache with vault and asset data.
+ *
+ * @param apiKey - API key obtained from Paxos Labs
+ * @throws {APIError} If initialization fails
+ *
+ * @example
+ * ```typescript
+ * import { initAmplifySDK } from "@paxoslabs/amplify-sdk";
+ *
+ * await initAmplifySDK("pxl_internal_your_api_key_here");
+ * ```
+ */
+declare function initAmplifySDK(apiKey: string): Promise<void>;
+
+/**
+ * @file Approve Asset for deposit functionality for Paxos Labs vaults
+ * @module vaults/deposit
+ */
+
+/**
+ * Parameters required for preparing an approval transaction
+ * @interface PrepareApproveDepositTokenTxParams
+ * @property {Address} depositToken - Token contract address to approve
+ * @property {Address} boringVaultAddress - Address of the BoringVault to approve spending
+ * @property {string} [approvalAmount] - Optional amount to approve (defaults to maximum approval)
+ * @property {number | string} chainId - ID of the chain where the approval will occur
+ */
+interface PrepareApproveDepositTokenTxParams {
+    yieldType: YieldType;
+    depositToken: Address;
+    approvalAmount?: string;
+    chainId: ChainId;
+}
+/**
+ * Result object containing transaction data for an ERC20 approval operation
+ * @interface ApproveDepositTokenTxData
+ * @property {typeof erc20Abi} abi - ABI for the ERC20 token contract
+ * @property {Address} address - Address of the ERC20 token being approved
+ * @property {'approve'} functionName - Name of the function to call
+ * @property {[Address, bigint]} args - Arguments for the approve function:
+ *   [spender (boringVault address), amount]
+ */
+interface ApproveDepositTokenTxData {
+    abi: typeof erc20Abi;
+    address: Address;
+    functionName: "approve";
+    args: [Address, bigint];
+}
+/**
+ * Prepares the transaction data needed to approve a deposit token for the vault
+ *
+ * This function prepares an ERC20 approval transaction that allows the vault's
+ * BoringVault contract to spend the user's deposit tokens.
+ *
+ * @example
+ * ```typescript
+ * const approveData = await prepareApproveDepositToken({
+ *   depositToken: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', // USDC
+ *   boringVaultAddress: '0x1234...',
+ *   approvalAmount: "1000.0", // Approve 1000 USDC
+ *   chainId: 1,
+ * });
+ * ```
+ *
+ * @param {PrepareApproveDepositTokenTxParams} params - Parameters for the approval operation
+ * @returns {Promise<ApproveDepositTokenTxData>} Promise resolving to the prepared transaction data
+ * @throws {APIError} If parameters are invalid
+ */
+declare function prepareApproveDepositTokenTxData({ yieldType, depositToken, approvalAmount, chainId, }: PrepareApproveDepositTokenTxParams): Promise<ApproveDepositTokenTxData>;
+
+declare const TellerAbi: readonly [{
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "_owner";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "_vault";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "_accountant";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "_endpoint";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "constructor";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "InvalidDelegate";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "InvalidEndpointCall";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint16";
+        readonly name: "optionType";
+        readonly type: "uint16";
+    }];
+    readonly name: "InvalidOptionType";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "LzTokenUnavailable";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "MultiChainLayerZeroTellerWithMultiAssetSupport_InvalidToken";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "MultiChainTellerBase_DestinationChainReceiverIsZeroAddress";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "MultiChainTellerBase_GasLimitExceeded";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "MultiChainTellerBase_GasTooLow";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint32";
+        readonly name: "chainSelector";
+        readonly type: "uint32";
+    }];
+    readonly name: "MultiChainTellerBase_MessagesNotAllowedFrom";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "chainSelector";
+        readonly type: "uint256";
+    }];
+    readonly name: "MultiChainTellerBase_MessagesNotAllowedTo";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "MultiChainTellerBase_TargetTellerIsZeroAddress";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "MultiChainTellerBase_ZeroMessageGasLimit";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint32";
+        readonly name: "eid";
+        readonly type: "uint32";
+    }];
+    readonly name: "NoPeer";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "msgValue";
+        readonly type: "uint256";
+    }];
+    readonly name: "NotEnoughNative";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "addr";
+        readonly type: "address";
+    }];
+    readonly name: "OnlyEndpoint";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint32";
+        readonly name: "eid";
+        readonly type: "uint32";
+    }, {
+        readonly internalType: "bytes32";
+        readonly name: "sender";
+        readonly type: "bytes32";
+    }];
+    readonly name: "OnlyPeer";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint8";
+        readonly name: "bits";
+        readonly type: "uint8";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "value";
+        readonly type: "uint256";
+    }];
+    readonly name: "SafeCastOverflowedUintDowncast";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "token";
+        readonly type: "address";
+    }];
+    readonly name: "SafeERC20FailedOperation";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "TellerWithMultiAssetSupport__AssetNotSupported";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "TellerWithMultiAssetSupport__BadDepositHash";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "TellerWithMultiAssetSupport__MinimumAssetsNotMet";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "TellerWithMultiAssetSupport__MinimumMintNotMet";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "TellerWithMultiAssetSupport__Paused";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "TellerWithMultiAssetSupport__PermitFailedAndAllowanceTooLow";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "TellerWithMultiAssetSupport__ShareLockPeriodTooLong";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "TellerWithMultiAssetSupport__SharesAreLocked";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "TellerWithMultiAssetSupport__SharesAreUnLocked";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "TellerWithMultiAssetSupport__ZeroAssets";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "TellerWithMultiAssetSupport__ZeroShares";
+    readonly type: "error";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "asset";
+        readonly type: "address";
+    }];
+    readonly name: "AssetAdded";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "asset";
+        readonly type: "address";
+    }];
+    readonly name: "AssetRemoved";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "user";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "contract Authority";
+        readonly name: "newAuthority";
+        readonly type: "address";
+    }];
+    readonly name: "AuthorityUpdated";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "asset";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "depositAmount";
+        readonly type: "uint256";
+    }];
+    readonly name: "BulkDeposit";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "asset";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "shareAmount";
+        readonly type: "uint256";
+    }];
+    readonly name: "BulkWithdraw";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "chainSelector";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "bool";
+        readonly name: "allowMessagesFrom";
+        readonly type: "bool";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "bool";
+        readonly name: "allowMessagesTo";
+        readonly type: "bool";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "address";
+        readonly name: "targetTeller";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint64";
+        readonly name: "messageGasLimit";
+        readonly type: "uint64";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint64";
+        readonly name: "messageGasMin";
+        readonly type: "uint64";
+    }];
+    readonly name: "ChainAdded";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "chainSelector";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "address";
+        readonly name: "targetTeller";
+        readonly type: "address";
+    }];
+    readonly name: "ChainAllowMessagesFrom";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "chainSelector";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "address";
+        readonly name: "targetTeller";
+        readonly type: "address";
+    }];
+    readonly name: "ChainAllowMessagesTo";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "chainSelector";
+        readonly type: "uint256";
+    }];
+    readonly name: "ChainRemoved";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "chainSelector";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint64";
+        readonly name: "messageGasLimit";
+        readonly type: "uint64";
+    }];
+    readonly name: "ChainSetGasLimit";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "chainSelector";
+        readonly type: "uint256";
+    }];
+    readonly name: "ChainStopMessagesFrom";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "chainSelector";
+        readonly type: "uint256";
+    }];
+    readonly name: "ChainStopMessagesTo";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "uint256";
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "receiver";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "depositAsset";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "depositAmount";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "shareAmount";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "depositTimestamp";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "shareLockPeriodAtTimeOfDeposit";
+        readonly type: "uint256";
+    }];
+    readonly name: "Deposit";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "uint256";
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "bytes32";
+        readonly name: "depositHash";
+        readonly type: "bytes32";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "user";
+        readonly type: "address";
+    }];
+    readonly name: "DepositRefunded";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: false;
+        readonly internalType: "bytes32";
+        readonly name: "messageId";
+        readonly type: "bytes32";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "shareAmount";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "address";
+        readonly name: "to";
+        readonly type: "address";
+    }];
+    readonly name: "MessageReceived";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: false;
+        readonly internalType: "bytes32";
+        readonly name: "messageId";
+        readonly type: "bytes32";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "shareAmount";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "address";
+        readonly name: "to";
+        readonly type: "address";
+    }];
+    readonly name: "MessageSent";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "user";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "newOwner";
+        readonly type: "address";
+    }];
+    readonly name: "OwnershipTransferred";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [];
+    readonly name: "Paused";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: false;
+        readonly internalType: "uint32";
+        readonly name: "eid";
+        readonly type: "uint32";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "bytes32";
+        readonly name: "peer";
+        readonly type: "bytes32";
+    }];
+    readonly name: "PeerSet";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [];
+    readonly name: "Unpaused";
+    readonly type: "event";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "accountant";
+    readonly outputs: readonly [{
+        readonly internalType: "contract AccountantWithRateProviders";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "contract ERC20";
+        readonly name: "asset";
+        readonly type: "address";
+    }];
+    readonly name: "addAsset";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint32";
+        readonly name: "chainSelector";
+        readonly type: "uint32";
+    }, {
+        readonly internalType: "bool";
+        readonly name: "allowMessagesFrom";
+        readonly type: "bool";
+    }, {
+        readonly internalType: "bool";
+        readonly name: "allowMessagesTo";
+        readonly type: "bool";
+    }, {
+        readonly internalType: "address";
+        readonly name: "targetTeller";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint64";
+        readonly name: "messageGasLimit";
+        readonly type: "uint64";
+    }, {
+        readonly internalType: "uint64";
+        readonly name: "messageGasMin";
+        readonly type: "uint64";
+    }];
+    readonly name: "addChain";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly components: readonly [{
+            readonly internalType: "uint32";
+            readonly name: "srcEid";
+            readonly type: "uint32";
+        }, {
+            readonly internalType: "bytes32";
+            readonly name: "sender";
+            readonly type: "bytes32";
+        }, {
+            readonly internalType: "uint64";
+            readonly name: "nonce";
+            readonly type: "uint64";
+        }];
+        readonly internalType: "struct Origin";
+        readonly name: "origin";
+        readonly type: "tuple";
+    }];
+    readonly name: "allowInitializePath";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint32";
+        readonly name: "chainSelector";
+        readonly type: "uint32";
+    }, {
+        readonly internalType: "address";
+        readonly name: "targetTeller";
+        readonly type: "address";
+    }];
+    readonly name: "allowMessagesFromChain";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint32";
+        readonly name: "chainSelector";
+        readonly type: "uint32";
+    }, {
+        readonly internalType: "address";
+        readonly name: "targetTeller";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint64";
+        readonly name: "messageGasLimit";
+        readonly type: "uint64";
+    }];
+    readonly name: "allowMessagesToChain";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "authority";
+    readonly outputs: readonly [{
+        readonly internalType: "contract Authority";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "from";
+        readonly type: "address";
+    }];
+    readonly name: "beforeTransfer";
+    readonly outputs: readonly [];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "shareAmount";
+        readonly type: "uint256";
+    }, {
+        readonly components: readonly [{
+            readonly internalType: "uint32";
+            readonly name: "chainSelector";
+            readonly type: "uint32";
+        }, {
+            readonly internalType: "address";
+            readonly name: "destinationChainReceiver";
+            readonly type: "address";
+        }, {
+            readonly internalType: "contract ERC20";
+            readonly name: "bridgeFeeToken";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint64";
+            readonly name: "messageGas";
+            readonly type: "uint64";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "data";
+            readonly type: "bytes";
+        }];
+        readonly internalType: "struct BridgeData";
+        readonly name: "data";
+        readonly type: "tuple";
+    }];
+    readonly name: "bridge";
+    readonly outputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "messageId";
+        readonly type: "bytes32";
+    }];
+    readonly stateMutability: "payable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "contract ERC20";
+        readonly name: "depositAsset";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "depositAmount";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "minimumMint";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "address";
+        readonly name: "to";
+        readonly type: "address";
+    }];
+    readonly name: "bulkDeposit";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "shares";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "contract ERC20";
+        readonly name: "withdrawAsset";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "shareAmount";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "minimumAssets";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "address";
+        readonly name: "to";
+        readonly type: "address";
+    }];
+    readonly name: "bulkWithdraw";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "assetsOut";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "contract ERC20";
+        readonly name: "depositAsset";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "depositAmount";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "minimumMint";
+        readonly type: "uint256";
+    }];
+    readonly name: "deposit";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "shares";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "contract ERC20";
+        readonly name: "depositAsset";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "depositAmount";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "minimumMint";
+        readonly type: "uint256";
+    }, {
+        readonly components: readonly [{
+            readonly internalType: "uint32";
+            readonly name: "chainSelector";
+            readonly type: "uint32";
+        }, {
+            readonly internalType: "address";
+            readonly name: "destinationChainReceiver";
+            readonly type: "address";
+        }, {
+            readonly internalType: "contract ERC20";
+            readonly name: "bridgeFeeToken";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint64";
+            readonly name: "messageGas";
+            readonly type: "uint64";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "data";
+            readonly type: "bytes";
+        }];
+        readonly internalType: "struct BridgeData";
+        readonly name: "data";
+        readonly type: "tuple";
+    }];
+    readonly name: "depositAndBridge";
+    readonly outputs: readonly [];
+    readonly stateMutability: "payable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "depositNonce";
+    readonly outputs: readonly [{
+        readonly internalType: "uint96";
+        readonly name: "";
+        readonly type: "uint96";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "contract ERC20";
+        readonly name: "depositAsset";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "depositAmount";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "minimumMint";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "deadline";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint8";
+        readonly name: "v";
+        readonly type: "uint8";
+    }, {
+        readonly internalType: "bytes32";
+        readonly name: "r";
+        readonly type: "bytes32";
+    }, {
+        readonly internalType: "bytes32";
+        readonly name: "s";
+        readonly type: "bytes32";
+    }];
+    readonly name: "depositWithPermit";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "shares";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "endpoint";
+    readonly outputs: readonly [{
+        readonly internalType: "contract ILayerZeroEndpointV2";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly components: readonly [{
+            readonly internalType: "uint32";
+            readonly name: "srcEid";
+            readonly type: "uint32";
+        }, {
+            readonly internalType: "bytes32";
+            readonly name: "sender";
+            readonly type: "bytes32";
+        }, {
+            readonly internalType: "uint64";
+            readonly name: "nonce";
+            readonly type: "uint64";
+        }];
+        readonly internalType: "struct Origin";
+        readonly name: "";
+        readonly type: "tuple";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "";
+        readonly type: "bytes";
+    }, {
+        readonly internalType: "address";
+        readonly name: "_sender";
+        readonly type: "address";
+    }];
+    readonly name: "isComposeMsgSender";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "isPaused";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "contract ERC20";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly name: "isSupported";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly components: readonly [{
+            readonly internalType: "uint32";
+            readonly name: "srcEid";
+            readonly type: "uint32";
+        }, {
+            readonly internalType: "bytes32";
+            readonly name: "sender";
+            readonly type: "bytes32";
+        }, {
+            readonly internalType: "uint64";
+            readonly name: "nonce";
+            readonly type: "uint64";
+        }];
+        readonly internalType: "struct Origin";
+        readonly name: "_origin";
+        readonly type: "tuple";
+    }, {
+        readonly internalType: "bytes32";
+        readonly name: "_guid";
+        readonly type: "bytes32";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "_message";
+        readonly type: "bytes";
+    }, {
+        readonly internalType: "address";
+        readonly name: "_executor";
+        readonly type: "address";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "_extraData";
+        readonly type: "bytes";
+    }];
+    readonly name: "lzReceive";
+    readonly outputs: readonly [];
+    readonly stateMutability: "payable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint32";
+        readonly name: "";
+        readonly type: "uint32";
+    }, {
+        readonly internalType: "bytes32";
+        readonly name: "";
+        readonly type: "bytes32";
+    }];
+    readonly name: "nextNonce";
+    readonly outputs: readonly [{
+        readonly internalType: "uint64";
+        readonly name: "nonce";
+        readonly type: "uint64";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "oAppVersion";
+    readonly outputs: readonly [{
+        readonly internalType: "uint64";
+        readonly name: "senderVersion";
+        readonly type: "uint64";
+    }, {
+        readonly internalType: "uint64";
+        readonly name: "receiverVersion";
+        readonly type: "uint64";
+    }];
+    readonly stateMutability: "pure";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "owner";
+    readonly outputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "pause";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint32";
+        readonly name: "eid";
+        readonly type: "uint32";
+    }];
+    readonly name: "peers";
+    readonly outputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "peer";
+        readonly type: "bytes32";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "shareAmount";
+        readonly type: "uint256";
+    }, {
+        readonly components: readonly [{
+            readonly internalType: "uint32";
+            readonly name: "chainSelector";
+            readonly type: "uint32";
+        }, {
+            readonly internalType: "address";
+            readonly name: "destinationChainReceiver";
+            readonly type: "address";
+        }, {
+            readonly internalType: "contract ERC20";
+            readonly name: "bridgeFeeToken";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint64";
+            readonly name: "messageGas";
+            readonly type: "uint64";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "data";
+            readonly type: "bytes";
+        }];
+        readonly internalType: "struct BridgeData";
+        readonly name: "data";
+        readonly type: "tuple";
+    }];
+    readonly name: "previewFee";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "fee";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly name: "publicDepositHistory";
+    readonly outputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "";
+        readonly type: "bytes32";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "address";
+        readonly name: "receiver";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "depositAsset";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "depositAmount";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "shareAmount";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "depositTimestamp";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "shareLockUpPeriodAtTimeOfDeposit";
+        readonly type: "uint256";
+    }];
+    readonly name: "refundDeposit";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "contract ERC20";
+        readonly name: "asset";
+        readonly type: "address";
+    }];
+    readonly name: "removeAsset";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint32";
+        readonly name: "chainSelector";
+        readonly type: "uint32";
+    }];
+    readonly name: "removeChain";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint32";
+        readonly name: "";
+        readonly type: "uint32";
+    }];
+    readonly name: "selectorToChains";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "allowMessagesFrom";
+        readonly type: "bool";
+    }, {
+        readonly internalType: "bool";
+        readonly name: "allowMessagesTo";
+        readonly type: "bool";
+    }, {
+        readonly internalType: "address";
+        readonly name: "targetTeller";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint64";
+        readonly name: "messageGasLimit";
+        readonly type: "uint64";
+    }, {
+        readonly internalType: "uint64";
+        readonly name: "minimumMessageGas";
+        readonly type: "uint64";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "contract Authority";
+        readonly name: "newAuthority";
+        readonly type: "address";
+    }];
+    readonly name: "setAuthority";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint32";
+        readonly name: "chainSelector";
+        readonly type: "uint32";
+    }, {
+        readonly internalType: "uint64";
+        readonly name: "messageGasLimit";
+        readonly type: "uint64";
+    }];
+    readonly name: "setChainGasLimit";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "_delegate";
+        readonly type: "address";
+    }];
+    readonly name: "setDelegate";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint32";
+        readonly name: "_eid";
+        readonly type: "uint32";
+    }, {
+        readonly internalType: "bytes32";
+        readonly name: "_peer";
+        readonly type: "bytes32";
+    }];
+    readonly name: "setPeer";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint64";
+        readonly name: "_shareLockPeriod";
+        readonly type: "uint64";
+    }];
+    readonly name: "setShareLockPeriod";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "shareLockPeriod";
+    readonly outputs: readonly [{
+        readonly internalType: "uint64";
+        readonly name: "";
+        readonly type: "uint64";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly name: "shareUnlockTime";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint32";
+        readonly name: "chainSelector";
+        readonly type: "uint32";
+    }];
+    readonly name: "stopMessagesFromChain";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint32";
+        readonly name: "chainSelector";
+        readonly type: "uint32";
+    }];
+    readonly name: "stopMessagesToChain";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "newOwner";
+        readonly type: "address";
+    }];
+    readonly name: "transferOwnership";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "unpause";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "vault";
+    readonly outputs: readonly [{
+        readonly internalType: "contract BoringVault";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}];
+
+/**
+ * @file Deposit functionality for Nucleus vaults
+ * @module vaults/deposit
+ */
+
+/**
+ * Result object containing transaction data for a deposit operation
+ * @interface DepositTxData
+ * @property {typeof TellerAbi} abi - ABI for the Teller contract
+ * @property {Address} address - Address of the Teller contract
+ * @property {'deposit'} functionName - Name of the function to call
+ * @property {[Address, bigint, bigint]} args - Arguments for the deposit function:
+ *   [depositAsset, depositAmount, minimumMint]
+ * @property {number} chainId - ID of the chain where the transaction should be executed
+ */
+interface DepositTxData {
+    abi: typeof TellerAbi;
+    address: Address;
+    functionName: "deposit";
+    args: [Address, bigint, bigint];
+    chainId: number;
+}
+/**
+ * Parameters for prepareDepositTransactionData()
+ * Accepts yieldType, recipientAddress, depositToken, and chainId for automatic vault resolution
+ * @interface PrepareDepositTxDataParams
+ * @property {YieldType} yieldType - Yield strategy type (e.g., "PRIME", "TBILL", "LENDING")
+ * @property {Address} recipientAddress - Ethereum address of the user (recipient of vault shares)
+ * @property {Address} depositToken - Token contract address to deposit (matches vault's baseTokenAddress)
+ * @property {string} depositAmount - Amount of assets to deposit as a decimal string (e.g., "1.5")
+ * @property {number | string} chainId - ID of the chain where the deposit will occur
+ * @property {number} [slippage] - Maximum acceptable slippage in basis points (e.g., 100 for 1%)
+ */
+interface PrepareDepositTxDataParams {
+    yieldType: YieldType;
+    recipientAddress: Address;
+    depositToken: Address;
+    depositAmount: string;
+    chainId: ChainId;
+    slippage?: number;
+}
+/**
+ * Prepares the transaction data needed to deposit assets into a vault
+ *
+ * This function calculates the minimum amount of vault tokens to be minted based on
+ * the current exchange rate and the specified slippage tolerance. It automatically
+ * resolves the vault from yieldType, depositToken, and chainId parameters.
+ *
+ * ```typescript
+ * const depositData = await prepareDepositTransactionData({
+ *   yieldType: 'PRIME',
+ *   recipientAddress: '0x1234...',
+ *   depositToken: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', // USDC
+ *   depositAmount: "1.0",
+ *   chainId: 1,
+ *   slippage: 100, // 1% slippage (100 bps)
+ * });
+ * ```
+ *
+ * @param {PrepareDepositTransactionDataParams} params - Parameters for the deposit operation
+ * @returns {Promise<DepositTransactionData>} Promise resolving to the prepared transaction data
+ * @throws {APIError} If vault cannot be resolved, asset not found, or contracts not configured
+ */
+declare function prepareDepositTxData(params: PrepareDepositTxDataParams): Promise<DepositTxData>;
+
+/**
+ * @file Deposit with permit functionality for Nucleus vaults
+ * @module vaults/deposit/deposit-with-permit
+ */
+
+/**
+ * EIP-712 domain separator conforming to the EIP-712 TypedData JSON schema
+ * Compatible with standard EIP-712 signing libraries (Privy, wagmi, ethers)
+ *
+ * This interface matches the domain type from SignTypedDataParams as defined in
+ * the EIP-712 specification and implemented by signing libraries.
+ *
+ * @see {@link https://eips.ethereum.org/EIPS/eip-712#specification-of-the-eth_signtypeddata-json-rpc EIP-712 Specification}
+ *
+ * @property name - Human-readable name of the signing domain
+ * @property version - Version of the signing domain
+ * @property chainId - Ethereum chain ID as a number (not bigint)
+ * @property verifyingContract - Address of the contract that will verify the signature
+ * @property salt - Optional salt for disambiguation
+ */
+interface EIP712Domain {
+    name?: string;
+    version?: string;
+    chainId?: number;
+    verifyingContract?: string;
+    salt?: ArrayBuffer;
+}
+/**
+ * T008: EIP-2612 Permit type definition
+ * Standard structure for permit typed data per EIP-2612 specification
+ */
+declare const PERMIT_TYPES: {
+    Permit: {
+        name: string;
+        type: string;
+    }[];
+};
+/**
+ * T009: Complete EIP-712 typed data for permit signature
+ * Returned by prepareDepositPermitSignature() ready for wallet signing
+ *
+ * @property domain - EIP-712 domain separator with numeric chainId
+ * @property types - EIP-2612 Permit type structure (mutable for compatibility)
+ * @property message - Permit message fields
+ * @property primaryType - Always "Permit" for EIP-2612
+ */
+interface PermitSignatureData {
+    domain: EIP712Domain;
+    types: {
+        Permit: Array<{
+            name: string;
+            type: string;
+        }>;
+    };
+    message: {
+        owner: Address;
+        spender: Address;
+        value: bigint;
+        nonce: bigint;
+        deadline: bigint;
+    };
+    primaryType: "Permit";
+}
+/**
+ * T009: Parsed permit signature components
+ * Returned by parsePermitSignature() after converting hex signature
+ *
+ * @property v - Recovery ID (27 or 28)
+ * @property r - First 32 bytes of signature
+ * @property s - Second 32 bytes of signature
+ */
+interface ParsedPermitSignature {
+    v: number;
+    r: Hex;
+    s: Hex;
+}
+/**
+ * T009: Parameters for prepareDepositPermitSignature
+ * Input parameters for generating permit typed data
+ *
+ * @property yieldType - Vault yield strategy
+ * @property depositToken - Token contract address to deposit
+ * @property depositAmount - Deposit amount as decimal string
+ * @property recipientAddress - User address (permit owner)
+ * @property chainId - Blockchain network ID
+ * @property deadline - Optional permit expiration (defaults to 1 hour)
+ */
+interface PrepareDepositPermitSignatureParams {
+    yieldType: YieldType;
+    depositToken: Address;
+    depositAmount: string;
+    recipientAddress: Address;
+    chainId: number;
+    deadline?: bigint;
+}
+/**
+ * T009: Encoded transaction data for permit deposit
+ * Returned by updated prepareDepositWithPermitTransactionData()
+ *
+ * @property abi - Contract ABI
+ * @property functionName - Function name to call
+ * @property args - Function arguments
+ * @property address - Teller contract address
+ * @property chainId - Chain ID for transaction
+ */
+interface UnencodedDepositWithPermitData {
+    data: {
+        abi: typeof TellerAbi;
+        functionName: "depositWithPermit";
+        args: [Address, bigint, bigint, bigint, number, Hex, Hex];
+    };
+    address: Address;
+    chainId: number;
+}
+/**
+ * T018-T030: Prepare complete EIP-712 typed data for permit signature
+ *
+ * Reads token metadata (name, version, nonce) from the blockchain and
+ * constructs the complete EIP-712 structure for wallet signing.
+ *
+ * @param params - Permit signature parameters
+ * @returns Complete EIP-712 typed data ready for signing
+ * @throws {APIError} If token doesn't support EIP-2612, vault not found, or chain unsupported
+ *
+ * @example
+ * ```typescript
+ * const permitData = await prepareDepositPermitSignature({
+ *   yieldType: 'PRIME',
+ *   depositToken: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', // USDC
+ *   depositAmount: '1000.0',
+ *   recipientAddress: userAddress,
+ *   chainId: 1,
+ *   deadline: BigInt(Math.floor(Date.now() / 1000) + 3600),
+ * });
+ *
+ * // Sign with wallet
+ * const signature = await signTypedData(permitData);
+ * ```
+ */
+declare function prepareDepositPermitSignature(params: PrepareDepositPermitSignatureParams): Promise<PermitSignatureData>;
+/**
+ * T036-T040: Parse raw hex signature into v, r, s components
+ *
+ * Handles both v-based and yParity-based signature formats.
+ * Converts yParity to v by adding 27 if needed.
+ *
+ * @param signature - Raw hex signature from wallet
+ * @returns Parsed signature components (v, r, s)
+ * @throws {APIError} If signature format is invalid
+ *
+ * @example
+ * ```typescript
+ * const signature = await signTypedData(permitData);
+ * const { v, r, s } = parsePermitSignature(signature);
+ * // Use v, r, s in smart contract call
+ * ```
+ */
+declare function parsePermitSignature(signature: Hex): ParsedPermitSignature;
+/**
+ * T048: Updated parameters for prepareDepositWithPermitTransactionData()
+ * Now accepts raw signature and deadline for complete transaction encoding
+ *
+ * @interface PrepareDepositWithPermitTxDataParams
+ * @property {YieldType} yieldType - Yield strategy type (e.g., "PRIME", "TBILL")
+ * @property {Address} recipientAddress - Ethereum address of the user (recipient of vault shares)
+ * @property {Address} depositToken - Token contract address to deposit (matches vault's baseTokenAddress)
+ * @property {string} depositAmount - Amount of assets to deposit as a decimal string (e.g., "100.25")
+ * @property {number | ChainId} chainId - ID of the chain where the deposit will occur
+ * @property {Hex} signature - Raw hex signature from wallet signing
+ * @property {bigint} deadline - Deadline timestamp (must match permit signature deadline)
+ * @property {number} [slippage] - Maximum acceptable slippage in basis points (default: 100 for 1%)
+ *
+ * @example
+ * ```typescript
+ * const permitData = await prepareDepositPermitSignature({ ... });
+ * const signature = await signTypedData(permitData);
+ *
+ * const params: PrepareDepositWithPermitTransactionDataParams = {
+ *   yieldType: "PRIME",
+ *   recipientAddress: "0x1234567890123456789012345678901234567890",
+ *   depositToken: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
+ *   depositAmount: "100.25",
+ *   chainId: 1,
+ *   signature,
+ *   deadline: permitData.message.deadline,
+ *   slippage: 100, // 1%
+ * };
+ * ```
+ */
+interface PrepareDepositWithPermitTxDataParams {
+    yieldType: YieldType;
+    recipientAddress: Address;
+    depositToken: Address;
+    depositAmount: string;
+    chainId: number | ChainId;
+    signature: Hex;
+    deadline: bigint;
+    slippage?: number;
+}
+/**
+ * T048-T057: Prepare complete deposit transaction with permit signature
+ *
+ * Accepts raw signature and deadline, parses signature internally,
+ * resolves vault, calculates minimum mint with slippage, and
+ * encodes the complete depositWithPermit function call.
+ *
+ * @param {PrepareDepositWithPermitTransactionDataParams} params - Deposit parameters including signature and deadline
+ * @returns {Promise<UnencodedDepositWithPermitData>} Encoded transaction data ready for submission
+ * @throws {APIError} If vault not found, invalid signature, or parameter validation fails
+ *
+ * // Submit transaction
+ * await sendTransaction({
+ *   to: txData.address,
+ *   data: txData.data,
+ * });
+ * ```
+ */
+declare function prepareDepositWithPermitTransactionData(params: PrepareDepositWithPermitTxDataParams): Promise<UnencodedDepositWithPermitData>;
+
+declare const BoringVaultAbi: readonly [{
+    readonly type: "constructor";
+    readonly inputs: readonly [{
+        readonly name: "_owner";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "_name";
+        readonly type: "string";
+        readonly internalType: "string";
+    }, {
+        readonly name: "_symbol";
+        readonly type: "string";
+        readonly internalType: "string";
+    }, {
+        readonly name: "_decimals";
+        readonly type: "uint8";
+        readonly internalType: "uint8";
+    }];
+    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: "allowance";
+    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: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "approve";
+    readonly inputs: readonly [{
+        readonly name: "spender";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+        readonly internalType: "bool";
+    }];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "authority";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "contract Authority";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "balanceOf";
+    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: "decimals";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint8";
+        readonly internalType: "uint8";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "enter";
+    readonly inputs: readonly [{
+        readonly name: "from";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "asset";
+        readonly type: "address";
+        readonly internalType: "contract ERC20";
+    }, {
+        readonly name: "assetAmount";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "to";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "shareAmount";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "exit";
+    readonly inputs: readonly [{
+        readonly name: "to";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "asset";
+        readonly type: "address";
+        readonly internalType: "contract ERC20";
+    }, {
+        readonly name: "assetAmount";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "from";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "shareAmount";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "hook";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "contract BeforeTransferHook";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "manage";
+    readonly inputs: readonly [{
+        readonly name: "targets";
+        readonly type: "address[]";
+        readonly internalType: "address[]";
+    }, {
+        readonly name: "data";
+        readonly type: "bytes[]";
+        readonly internalType: "bytes[]";
+    }, {
+        readonly name: "values";
+        readonly type: "uint256[]";
+        readonly internalType: "uint256[]";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "results";
+        readonly type: "bytes[]";
+        readonly internalType: "bytes[]";
+    }];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "manage";
+    readonly inputs: readonly [{
+        readonly name: "target";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "data";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }, {
+        readonly name: "value";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "result";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "name";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "string";
+        readonly internalType: "string";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "nonces";
+    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: "onERC1155BatchReceived";
+    readonly inputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "";
+        readonly type: "uint256[]";
+        readonly internalType: "uint256[]";
+    }, {
+        readonly name: "";
+        readonly type: "uint256[]";
+        readonly internalType: "uint256[]";
+    }, {
+        readonly name: "";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bytes4";
+        readonly internalType: "bytes4";
+    }];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "onERC1155Received";
+    readonly inputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bytes4";
+        readonly internalType: "bytes4";
+    }];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "onERC721Received";
+    readonly inputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bytes4";
+        readonly internalType: "bytes4";
+    }];
+    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: "permit";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "spender";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "value";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "deadline";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "v";
+        readonly type: "uint8";
+        readonly internalType: "uint8";
+    }, {
+        readonly name: "r";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }, {
+        readonly name: "s";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "setAuthority";
+    readonly inputs: readonly [{
+        readonly name: "newAuthority";
+        readonly type: "address";
+        readonly internalType: "contract Authority";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "setBeforeTransferHook";
+    readonly inputs: readonly [{
+        readonly name: "_hook";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "supportsInterface";
+    readonly inputs: readonly [{
+        readonly name: "interfaceId";
+        readonly type: "bytes4";
+        readonly internalType: "bytes4";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+        readonly internalType: "bool";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "symbol";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "string";
+        readonly internalType: "string";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "totalSupply";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "transfer";
+    readonly inputs: readonly [{
+        readonly name: "to";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+        readonly internalType: "bool";
+    }];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "transferFrom";
+    readonly inputs: readonly [{
+        readonly name: "from";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "to";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+        readonly internalType: "bool";
+    }];
+    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: "event";
+    readonly name: "Approval";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "spender";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+        readonly indexed: false;
+        readonly internalType: "uint256";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "AuthorityUpdated";
+    readonly inputs: readonly [{
+        readonly name: "user";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "newAuthority";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "contract Authority";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "Enter";
+    readonly inputs: readonly [{
+        readonly name: "from";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "asset";
+        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 name: "shares";
+        readonly type: "uint256";
+        readonly indexed: false;
+        readonly internalType: "uint256";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "Exit";
+    readonly inputs: readonly [{
+        readonly name: "to";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "asset";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+        readonly indexed: false;
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "from";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "shares";
+        readonly type: "uint256";
+        readonly indexed: false;
+        readonly internalType: "uint256";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "OwnershipTransferred";
+    readonly inputs: readonly [{
+        readonly name: "user";
+        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: "Transfer";
+    readonly inputs: readonly [{
+        readonly name: "from";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "to";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+        readonly indexed: false;
+        readonly internalType: "uint256";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "error";
+    readonly name: "AddressEmptyCode";
+    readonly inputs: readonly [{
+        readonly name: "target";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+}, {
+    readonly type: "error";
+    readonly name: "AddressInsufficientBalance";
+    readonly inputs: readonly [{
+        readonly name: "account";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+}, {
+    readonly type: "error";
+    readonly name: "FailedInnerCall";
+    readonly inputs: readonly [];
+}];
+
+/**
+ * Parameters required for preparing an approval transaction (NEW AmplifyVault schema)
+ * @interface PrepareApproveWithdrawTokenTxParams
+ * @property {YieldType} yieldType - Yield strategy type (PRIME, TBILL, or LENDING)
+ * @property {Address} wantAssetAddress - Address of the want token
+ * @property {string} [withdrawAmount] - Optional amount to approve (defaults to maximum approval)
+ * @property {ChainId} chainId - ID of the chain where the approval will occur
+ */
+interface PrepareApproveWithdrawTokenTxParams {
+    yieldType: YieldType;
+    wantAssetAddress: Address;
+    withdrawAmount?: string;
+    chainId: ChainId;
+}
+/**
+ * Result object containing transaction data for a vault shares approval operation
+ * @interface ApproveWithdrawTokenTxData
+ * @property {typeof BoringVaultAbi} abi - ABI for the BoringVault contract
+ * @property {Address} address - Address of the BoringVault (shares token)
+ * @property {'approve'} functionName - Name of the function to call
+ * @property {[Address, bigint]} args - Arguments for the approve function:
+ *   [spender (AtomicQueue address), amount]
+ */
+interface ApproveWithdrawTokenTxData {
+    abi: typeof BoringVaultAbi;
+    address: Address;
+    functionName: "approve";
+    args: [Address, bigint];
+}
+/**
+ * Prepares the transaction data needed to approve vault shares for the AtomicQueue contract
+ *
+ * This function prepares an ERC20 approval transaction that allows the AtomicQueue
+ * contract to spend the user's vault shares. It uses the new AmplifyVault schema
+ * with asset decimals from the API (no on-chain calls).
+ *
+ * @example
+ * ```typescript
+ * const vaults = await fetchVaults({ chainId: 1 });
+ * const approveData = await prepareApproveWithdrawToken({
+ *   yieldType: 'PRIME',
+ *   wantAssetAddress: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', // USDC
+ *   withdrawAmount: "10.0", // Approve 10 vault shares
+ *   chainId: 1,
+ * });
+ * ```
+ *
+ * @param {PrepareApproveWithdrawTokenTxParams} params - Parameters for the approval operation
+ * @param {YieldType} params.yieldType - Yield strategy type (PRIME, TBILL, or LENDING)
+ * @param {Address} params.wantAssetAddress - Address of the want token
+ * @param {string} [params.withdrawAmount] - Optional amount to approve as a decimal string (defaults to maximum approval)
+ * @param {number | string} params.chainId - ID of the chain where the approval will occur
+ *
+ * @returns {Promise<ApproveWithdrawTokenTxData>} Promise resolving to the prepared transaction data
+ * @throws {APIError} If the vault is not on the correct chain or contracts not configured
+ */
+declare function prepareApproveWithdrawTxData({ yieldType, wantAssetAddress, withdrawAmount, chainId, }: PrepareApproveWithdrawTokenTxParams): Promise<ApproveWithdrawTokenTxData>;
+
+interface BulkWithdrawTxData {
+    abi: typeof TellerAbi;
+    address: Address;
+    functionName: "bulkWithdraw";
+    args: [
+        withdrawAsset: Address,
+        shareAmount: bigint,
+        minimumAssets: bigint,
+        to: Address
+    ];
+    chainId: number;
+}
+interface PrepareBulkWithdrawTxDataParams {
+    yieldType: YieldType;
+    shareAmount: string;
+    wantAssetAddress: Address;
+    chainId: ChainId;
+    slippage?: number;
+    userAddress: Address;
+}
+/**
+ * Prepares the transaction data needed to withdraw assets from a vault
+ *
+ * This function calculates the appropriate exchange rate with slippage protection
+ * and prepares a user request for the AtomicQueue contract. It uses the new
+ * AmplifyVault schema with asset decimals from the API (no on-chain calls).
+ *
+ * @example
+ * ```typescript
+ * const vaults = await fetchVaults({ chainId: 1 });
+ * const wantAssets = await fetchSupportedAssets({ symbol: 'WETH' });
+ * const withdrawData = await prepareBulkWithdrawTransactionData({
+ *   vault: vaults[0],
+ *   wantAsset: wantAssets[0],
+ *   chainId: 1,
+ *   userAddress: '0x1234...',
+ *   offerAmount: "1.0", // 1 vault share
+ *   deadline: Math.floor(Date.now() / 1000) + 3600, // 1 hour from now
+ *   slippage: 100, // 1% slippage (100 bps)
+ * });
+ * ```
+ *
+ * @param {PrepareBulkWithdrawTxDataParams} params - Parameters for the withdraw operation
+ * @param {AmplifyVault} params.vault - Vault configuration from fetchVaults()
+ * @param {SupportedAsset} params.wantAsset - Asset metadata from fetchSupportedAssets()
+ * @param {ChainId} params.chainId - ID of the chain where the withdrawal will occur
+ * @param {Address} params.userAddress - Ethereum address of the user making the withdrawal
+ * @param {string} params.offerAmount - Amount of vault shares to withdraw as a decimal string
+ * @param {number} [params.deadline] - Unix timestamp when the request expires
+ * @param {number} [params.slippage] - Maximum acceptable slippage in basis points
+ *
+ * @returns {Promise<BulkWithdrawTxData>} Promise resolving to the prepared transaction data
+ * @throws {APIError} If the vault is not on the correct chain, asset not supported, or contracts not configured
+ */
+declare function prepareBulkWithdrawTxData(params: PrepareBulkWithdrawTxDataParams): Promise<BulkWithdrawTxData>;
+
+declare const AtomicQueueAbi: readonly [{
+    readonly type: "function";
+    readonly name: "getUserAtomicRequest";
+    readonly inputs: readonly [{
+        readonly name: "user";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "offer";
+        readonly type: "address";
+        readonly internalType: "contract ERC20";
+    }, {
+        readonly name: "want";
+        readonly type: "address";
+        readonly internalType: "contract ERC20";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "tuple";
+        readonly internalType: "struct AtomicQueue.AtomicRequest";
+        readonly components: readonly [{
+            readonly name: "deadline";
+            readonly type: "uint64";
+            readonly internalType: "uint64";
+        }, {
+            readonly name: "atomicPrice";
+            readonly type: "uint88";
+            readonly internalType: "uint88";
+        }, {
+            readonly name: "offerAmount";
+            readonly type: "uint96";
+            readonly internalType: "uint96";
+        }, {
+            readonly name: "inSolve";
+            readonly type: "bool";
+            readonly internalType: "bool";
+        }];
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "isAtomicRequestValid";
+    readonly inputs: readonly [{
+        readonly name: "offer";
+        readonly type: "address";
+        readonly internalType: "contract ERC20";
+    }, {
+        readonly name: "user";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "userRequest";
+        readonly type: "tuple";
+        readonly internalType: "struct AtomicQueue.AtomicRequest";
+        readonly components: readonly [{
+            readonly name: "deadline";
+            readonly type: "uint64";
+            readonly internalType: "uint64";
+        }, {
+            readonly name: "atomicPrice";
+            readonly type: "uint88";
+            readonly internalType: "uint88";
+        }, {
+            readonly name: "offerAmount";
+            readonly type: "uint96";
+            readonly internalType: "uint96";
+        }, {
+            readonly name: "inSolve";
+            readonly type: "bool";
+            readonly internalType: "bool";
+        }];
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+        readonly internalType: "bool";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "solve";
+    readonly inputs: readonly [{
+        readonly name: "offer";
+        readonly type: "address";
+        readonly internalType: "contract ERC20";
+    }, {
+        readonly name: "want";
+        readonly type: "address";
+        readonly internalType: "contract ERC20";
+    }, {
+        readonly name: "users";
+        readonly type: "address[]";
+        readonly internalType: "address[]";
+    }, {
+        readonly name: "runData";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }, {
+        readonly name: "solver";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "updateAtomicRequest";
+    readonly inputs: readonly [{
+        readonly name: "offer";
+        readonly type: "address";
+        readonly internalType: "contract ERC20";
+    }, {
+        readonly name: "want";
+        readonly type: "address";
+        readonly internalType: "contract ERC20";
+    }, {
+        readonly name: "userRequest";
+        readonly type: "tuple";
+        readonly internalType: "struct AtomicQueue.AtomicRequest";
+        readonly components: readonly [{
+            readonly name: "deadline";
+            readonly type: "uint64";
+            readonly internalType: "uint64";
+        }, {
+            readonly name: "atomicPrice";
+            readonly type: "uint88";
+            readonly internalType: "uint88";
+        }, {
+            readonly name: "offerAmount";
+            readonly type: "uint96";
+            readonly internalType: "uint96";
+        }, {
+            readonly name: "inSolve";
+            readonly type: "bool";
+            readonly internalType: "bool";
+        }];
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "userAtomicRequest";
+    readonly inputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "contract ERC20";
+    }, {
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "contract ERC20";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "deadline";
+        readonly type: "uint64";
+        readonly internalType: "uint64";
+    }, {
+        readonly name: "atomicPrice";
+        readonly type: "uint88";
+        readonly internalType: "uint88";
+    }, {
+        readonly name: "offerAmount";
+        readonly type: "uint96";
+        readonly internalType: "uint96";
+    }, {
+        readonly name: "inSolve";
+        readonly type: "bool";
+        readonly internalType: "bool";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "viewSolveMetaData";
+    readonly inputs: readonly [{
+        readonly name: "offer";
+        readonly type: "address";
+        readonly internalType: "contract ERC20";
+    }, {
+        readonly name: "want";
+        readonly type: "address";
+        readonly internalType: "contract ERC20";
+    }, {
+        readonly name: "users";
+        readonly type: "address[]";
+        readonly internalType: "address[]";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "metaData";
+        readonly type: "tuple[]";
+        readonly internalType: "struct AtomicQueue.SolveMetaData[]";
+        readonly components: readonly [{
+            readonly name: "user";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "flags";
+            readonly type: "uint8";
+            readonly internalType: "uint8";
+        }, {
+            readonly name: "assetsToOffer";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "assetsForWant";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }];
+    }, {
+        readonly name: "totalAssetsForWant";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "totalAssetsToOffer";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "event";
+    readonly name: "AtomicRequestFulfilled";
+    readonly inputs: readonly [{
+        readonly name: "user";
+        readonly type: "address";
+        readonly indexed: false;
+        readonly internalType: "address";
+    }, {
+        readonly name: "offerToken";
+        readonly type: "address";
+        readonly indexed: false;
+        readonly internalType: "address";
+    }, {
+        readonly name: "wantToken";
+        readonly type: "address";
+        readonly indexed: false;
+        readonly internalType: "address";
+    }, {
+        readonly name: "offerAmountSpent";
+        readonly type: "uint256";
+        readonly indexed: false;
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "wantAmountReceived";
+        readonly type: "uint256";
+        readonly indexed: false;
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "timestamp";
+        readonly type: "uint256";
+        readonly indexed: false;
+        readonly internalType: "uint256";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "AtomicRequestUpdated";
+    readonly inputs: readonly [{
+        readonly name: "user";
+        readonly type: "address";
+        readonly indexed: false;
+        readonly internalType: "address";
+    }, {
+        readonly name: "offerToken";
+        readonly type: "address";
+        readonly indexed: false;
+        readonly internalType: "address";
+    }, {
+        readonly name: "wantToken";
+        readonly type: "address";
+        readonly indexed: false;
+        readonly internalType: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+        readonly indexed: false;
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "deadline";
+        readonly type: "uint256";
+        readonly indexed: false;
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "minPrice";
+        readonly type: "uint256";
+        readonly indexed: false;
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "timestamp";
+        readonly type: "uint256";
+        readonly indexed: false;
+        readonly internalType: "uint256";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "error";
+    readonly name: "AtomicQueue__RequestDeadlineExceeded";
+    readonly inputs: readonly [{
+        readonly name: "user";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+}, {
+    readonly type: "error";
+    readonly name: "AtomicQueue__UserNotInSolve";
+    readonly inputs: readonly [{
+        readonly name: "user";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+}, {
+    readonly type: "error";
+    readonly name: "AtomicQueue__UserRepeated";
+    readonly inputs: readonly [{
+        readonly name: "user";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+}, {
+    readonly type: "error";
+    readonly name: "AtomicQueue__ZeroOfferAmount";
+    readonly inputs: readonly [{
+        readonly name: "user";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+}];
+
+/**
+ * @file Withdraw functionality for Paxos Labs vaults
+ * @module vaults/withdraw
+ */
+
+/**
+ * User request details for an atomic swap
+ * @typedef {Object} UserRequest
+ * @property {number} deadline - Unix timestamp when the request expires
+ * @property {bigint} atomicPrice - Rate in quote with fee applied
+ * @property {bigint} offerAmount - Amount of shares token to redeem
+ * @property {boolean} inSolve - Whether the request is in solve mode (always false for new requests)
+ */
+type UserRequest = {
+    deadline: bigint;
+    atomicPrice: bigint;
+    offerAmount: bigint;
+    inSolve: boolean;
+};
+/**
+ * Parameters for preparing a withdrawal transaction from a vault (NEW AmplifyVault schema)
+ * @interface PrepareWithdrawTxDataParams
+ * @property {YieldType} yieldType - Yield strategy type (PRIME, TBILL, or LENDING)
+ * @property {Address} wantAssetAddress - Address of the want token
+ * @property {ChainId} chainId - ID of the chain where the withdrawal will occur
+ * @property {string} offerAmount - Amount of vault shares to withdraw as a decimal string
+ * @property {Address} userAddress - Ethereum address of the user making the withdrawal
+ * @property {number} [deadline] - Unix timestamp when the request expires (optional)
+ * @property {number} [slippage] - Maximum acceptable slippage in basis points (optional, default: 100 for 1%)
+ *
+ * **Slippage Protection**:
+ * The slippage parameter protects users from unfavorable price movements during the withdrawal.
+ * It defines the maximum acceptable loss as a percentage of the initial share amount.
+ *
+ * - Default: 100 basis points (1% slippage tolerance)
+ * - Range: 0-10000 basis points (0-100%)
+ * - Formula: minimumAssets = shareAmount * (10000 - slippage) / 10000
+ *
+ * @example
+ * ```typescript
+ * // 1% slippage (default) - allows price to move 1% unfavorably
+ * { slippage: 100 }
+ *
+ * // 0.5% slippage - conservative, tighter protection
+ * { slippage: 50 }
+ *
+ * // 5% slippage - aggressive, more lenient
+ * { slippage: 500 }
+ *
+ * // No slippage tolerance - transaction reverts if price changes at all
+ * { slippage: 0 }
+ * ```
+ */
+interface PrepareWithdrawTxDataParams {
+    yieldType: YieldType;
+    wantAssetAddress: Address;
+    chainId: ChainId;
+    offerAmount: string;
+    userAddress: Address;
+    deadline?: number;
+    slippage?: number;
+}
+/**
+ * Result object containing transaction data for a withdrawal operation
+ * @interface WithdrawTxData
+ * @property {typeof AtomicQueueAbi} abi - ABI for the AtomicQueue contract
+ * @property {Address} address - Address of the AtomicQueue contract
+ * @property {'updateAtomicRequest'} functionName - Name of the function to call
+ * @property {[Address, Address, UserRequest]} args - Arguments for the updateAtomicRequest function:
+ *   [offer (vault shares address), want (want asset address), userRequest]
+ * @property {number} chainId - ID of the chain where the transaction should be executed
+ */
+interface WithdrawTxData {
+    abi: typeof AtomicQueueAbi;
+    address: Address;
+    functionName: "updateAtomicRequest";
+    args: [offer: Address, want: Address, userRequest: UserRequest];
+    chainId: number;
+}
+/**
+ * Prepares the transaction data needed to withdraw assets from a vault
+ *
+ * This function calculates the appropriate exchange rate with slippage protection
+ * and prepares a user request for the AtomicQueue contract. It uses the new
+ * AmplifyVault schema with asset decimals from the API (no on-chain calls).
+ *
+ * @example
+ * ```typescript
+ * const withdrawData = await prepareWithdrawTransactionData({
+ *   yieldType: 'PRIME',
+ *   wantAssetAddress: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', // USDC
+ *   chainId: 1,
+ *   userAddress: '0x1234...',
+ *   offerAmount: "1.0", // 1 vault share
+ *   deadline: Math.floor(Date.now() / 1000) + 3600, // 1 hour from now
+ *   slippage: 100, // 1% slippage (100 bps)
+ * });
+ * ```
+ *
+ * @param {PrepareWithdrawTxDataParams} params - Parameters for the withdraw operation
+ * @param {YieldType} params.yieldType - Yield strategy type (PRIME, TBILL, or LENDING)
+ * @param {Address} params.wantAssetAddress - Address of the want token
+ * @param {ChainId} params.chainId - ID of the chain where the withdrawal will occur
+ * @param {Address} params.userAddress - Ethereum address of the user making the withdrawal
+ * @param {string} params.offerAmount - Amount of vault shares to withdraw as a decimal string
+ * @param {number} [params.deadline] - Unix timestamp when the request expires
+ * @param {number} [params.slippage] - Maximum acceptable slippage in basis points
+ *
+ * @returns {Promise<WithdrawTxData>} Promise resolving to the prepared transaction data
+ * @throws {APIError} If the vault is not on the correct chain, asset not supported, or contracts not configured
+ */
+declare const prepareWithdrawTxData: ({ yieldType, wantAssetAddress, chainId, offerAmount, deadline, slippage, }: PrepareWithdrawTxDataParams) => Promise<WithdrawTxData>;
+
+export { AmplifyVault, type ApproveDepositTokenTxData, type ApproveWithdrawTokenTxData, AssetFilterOptions, type BulkWithdrawTxData, type DepositTxData, type EIP712Domain, type InitErrorCode, PERMIT_TYPES, type ParsedPermitSignature, type PermitSignatureData, type PrepareDepositPermitSignatureParams, type PrepareDepositWithPermitTxDataParams, type RequestHeaders, type SDKConfig, SupportedAsset, type UnencodedDepositWithPermitData, VaultFilterOptions, WithdrawSupportedAsset, type WithdrawTxData, YieldType, fetchSupportedAssets, fetchVaults, findVaultByConfig, getAssetsFromCache, getCache, getWithdrawSupportedAssets, initAmplifySDK, initializeCache, parsePermitSignature, prepareApproveDepositTokenTxData, prepareApproveWithdrawTxData, prepareBulkWithdrawTxData, prepareDepositPermitSignature, prepareDepositTxData, prepareDepositWithPermitTransactionData, prepareWithdrawTxData, refreshVaultCache };