@zerodev/smart-recipes 0.2.0

package/dist/index.d.cts

@@ -0,0 +1,625 @@
+import { Address, Hex } from 'viem';
+
+/**
+ * Vault discovery query types. The data source is vaults.fyi (server-side); the SDK speaks in
+ * `Vault` (see `contract.ts`). `listOpportunities` is a thin alias of `listVaults` kept for
+ * back-compat — both return `Vault[]`.
+ */
+type ChainId = number;
+/**
+ * Vault category discriminator. vaults.fyi serves yield/lending vaults today (mapped to `lend`);
+ * `liquid-staking` / `fixed-yield` remain in the union so future upstream categories slot in.
+ */
+type VaultCategory = 'lend' | 'liquid-staking' | 'fixed-yield';
+/** Discovery filter for `listOpportunities` / `listVaults`. All fields optional. */
+interface OpportunitiesQuery {
+    category?: VaultCategory;
+    chainId?: ChainId;
+    /** Minimum TVL in USD. */
+    minTvl?: number;
+    /** Minimum APY (percentage, e.g. `5` for 5%). */
+    minApy?: number;
+}
+interface ListOpportunitiesArgs extends OpportunitiesQuery {
+    /** Filter to a single protocol (e.g. `aave`, `fluid`). */
+    protocol?: string;
+}
+/** SDK-facing alias of {@link ListOpportunitiesArgs}. */
+type ListOpportunitiesParams = ListOpportunitiesArgs;
+
+/**
+ * The full HTTP wire contract between the Smart Recipes server and the SDK.
+ *
+ * Every amount is a base-10 `string` (uint256 serialized) — JSON has no bigint, so the wire is
+ * the single source of truth and the SDK returns it verbatim. Callers parse to `bigint` themselves.
+ */
+/** A single on-chain call. `value` is a decimal `string` (bigint-safe over the wire). */
+interface OnChainCall {
+    to: Address;
+    data: Hex;
+    value: string;
+}
+/** Legacy alias of {@link OnChainCall}; kept for server importers mid-rebuild. */
+type OnChainCallWire = OnChainCall;
+/**
+ * ERC-4337 intent, callData-only. The server encodes a Kernel v3 / ERC-7579
+ * `executeBatch(calls)` into `callData`; the consumer's kernel client fills
+ * sender / nonce / gas / signature. No bundler dependency server-side.
+ */
+interface UserOpIntent {
+    callData: Hex;
+    calls: OnChainCall[];
+    chainId: number;
+}
+/** Src-chain transaction intent: a batch of calls on one chain. */
+interface QuoteTransaction {
+    chainId: number;
+    calls: OnChainCall[];
+}
+interface QuoteFeeBreakdown {
+    totalFeeUsd: string;
+    perChain: {
+        chainId: number;
+        feeUsd: string;
+    }[];
+}
+/**
+ * Resolved deposit flow for a quote. The four cross-chain quadrants derive from
+ * `requiresSrcSwap` × `requiresDestSwap`; same-chain quotes set `sameChain: true`
+ * (no bridge, `bridgeTokenType: null`). Lets the UI surface which flow a deposit takes.
+ */
+interface QuoteRoute {
+    /** SRA bridge token type; `null` for same-chain (no bridge). */
+    bridgeTokenType: string | null;
+    /** Bridge token address on the src chain (cross-chain only). */
+    bridgeTokenSrc?: Address;
+    /** Bridge token address on the dest chain (cross-chain only). */
+    bridgeTokenDest?: Address;
+    /** Funding token swapped to the bridge token on the src chain. */
+    requiresSrcSwap: boolean;
+    /** Bridged token swapped to the vault asset on the dest chain. */
+    requiresDestSwap: boolean;
+    /** True when src == dest chain (no bridge step). */
+    sameChain: boolean;
+    /**
+     * True when a same-chain deposit swaps the funding token into the vault asset before
+     * depositing (no bridge; plain owner-signed swap + deposit). `sameChain` is also true.
+     */
+    sameChainSwap?: boolean;
+}
+/** Unified return type for all recipes. Same-chain quotes have `sra: null`. */
+interface Quote {
+    quoteId: string;
+    expiresAt: string;
+    sra: Address | null;
+    transaction: QuoteTransaction;
+    userOp: UserOpIntent;
+    srcTransactions?: QuoteTransaction[];
+    estimatedFees: QuoteFeeBreakdown;
+    estimatedReceiveAmount: string;
+    estimatedShares?: string;
+    vaultApy?: number;
+    swapMinOutput?: string;
+    /** Resolved deposit flow (bridge token + src/dest swap flags). */
+    route?: QuoteRoute;
+    recipeVersion: number;
+    /** Server diagnostics — present only in debug builds. */
+    debug?: QuoteDebug;
+}
+/** Body for `POST /recipes/deposit-into-vault` and `/recipes/bridge-and-deposit`. */
+interface DepositRecipeRequest {
+    owner: Address;
+    amount: number | string;
+    /** Funding token: symbol (e.g. `USDC`) or raw address. */
+    token: string;
+    srcChainId: number;
+    destChainId: number;
+    /** Multi-vault facades: vault id (from `listVaults`) or raw ERC-4626 address. */
+    into?: string;
+    /** bps; default 100. */
+    slippage?: number;
+    /**
+     * Required protocol selector — picks the adapter that builds the deposit calldata
+     * (`aave` | `morpho` | `fluid` | `yearn` | `erc4626`). Unknown → UNKNOWN_PROTOCOL.
+     */
+    protocol: string;
+}
+/** Body for `POST /recipes/bridge-and-swap`. */
+interface BridgeAndSwapRequest {
+    owner: Address;
+    amount: number | string;
+    token: string;
+    /** Destination token to swap into. */
+    toToken: string;
+    srcChainId: number;
+    destChainId: number;
+    slippage?: number;
+}
+interface DepositIntoVaultRequest {
+    owner: Address;
+    destChainId: number;
+    amount: string;
+    vaultId: string;
+    category?: VaultCategory;
+    slippageBps?: number;
+}
+interface DepositIntoVaultResponse {
+    quoteId: `0x${string}`;
+    sra: null;
+    transaction: {
+        chainId: number;
+        calls: OnChainCallWire[];
+    };
+    estimatedReceiveAmount: string | null;
+    estimatedGas: string;
+    canExecute: boolean;
+    expiresAt: string;
+}
+interface BridgeDepositRequest {
+    owner: Address;
+    srcChainId: number;
+    destChainId: number;
+    srcToken: Address;
+    amount: string;
+    vaultId: Address;
+    slippageBps?: number;
+}
+interface RouteInfoWire {
+    bridgeTokenType: string;
+    requiresSrcSwap: boolean;
+    requiresDestSwap: boolean;
+}
+interface BridgeDepositResponse {
+    quoteId: `0x${string}`;
+    route: RouteInfoWire;
+    sra: Address;
+    transaction: {
+        chainId: number;
+        calls: OnChainCallWire[];
+    };
+    srcTransactions: {
+        chainId: number;
+        calls: OnChainCallWire[];
+    }[] | null;
+    estimatedReceiveAmount: string;
+    estimatedFees: unknown;
+    canExecute: boolean;
+    expiresAt: string;
+    swapMinOutput: string | null;
+    debug?: QuoteDebug;
+}
+/** Full decoded call map for a bridge-deposit quote — src tx + dest SRA action + fallback. */
+interface QuoteDebug {
+    route: {
+        bridgeTokenType: string;
+        bridgeTokenSrc: Address;
+        bridgeTokenDest: Address;
+        requiresSrcSwap: boolean;
+        requiresDestSwap: boolean;
+    };
+    amounts: {
+        input: string;
+        bridgeInput: string;
+        minAmountOut: string;
+        swapMinOutput: string | null;
+        estimatedReceive: string;
+    };
+    /** Calls signed by the owner on the src chain (approve? + swap? + transfer-to-SRA). */
+    srcCalls: DebugCall[];
+    /** What the SRA runs on the dest chain once bridged funds land. */
+    destAction: {
+        /** 2-call batch: [transfer(FLEX) -> executor], [executor.executeComposable(steps)]. */
+        calls: DebugCall[];
+        /** Decoded composable recipe steps run inside the SmartRecipeExecutor. */
+        steps: DebugStep[];
+    };
+    /** Refund path if the dest action reverts: transfer(FLEX) -> owner. */
+    fallBack: DebugCall[];
+}
+interface DebugCall {
+    to: Address | string;
+    selector: string;
+    fn: string;
+    value: string;
+    dataBytes: number;
+    note?: string;
+}
+interface DebugStep {
+    index: number;
+    fn: string;
+    selector: string;
+    inputs: string[];
+}
+/** Alias of {@link DepositIntoVaultResponse}. */
+type DepositIntoVaultQuote = DepositIntoVaultResponse;
+/** Alias of {@link BridgeDepositResponse}. */
+type BridgeDepositQuote = BridgeDepositResponse;
+interface PreflightParams {
+    owner: Address;
+    destChainId: number;
+    vaultId: Address;
+    amount: string;
+    srcChainId?: number;
+    srcToken?: Address;
+}
+interface PreflightResult {
+    asset: Address;
+    /** ERC-4626 `maxDeposit(owner)`; `null` for kinds with no per-owner pool cap (e.g. Aave). */
+    maxDeposit: string | null;
+    route: {
+        bridgeTokenType: string;
+        requiresSrcSwap: boolean;
+        requiresDestSwap: boolean;
+    } | null;
+    vaultEntry: {
+        symbol: string;
+        protocol: string;
+        asset: Address;
+        tokenType: string;
+        decimals: number;
+    };
+}
+interface BalancesParams {
+    chainId: number;
+    owner: Address;
+    tokens: Address[];
+}
+interface TokenBalance {
+    token: Address;
+    balance: string;
+    decimals: number;
+}
+interface BalancesResult {
+    balances: TokenBalance[];
+}
+interface SraStatusParams {
+    sra: Address;
+    page?: number;
+    pageSize?: number;
+}
+interface DepositInfo {
+    chainId: number;
+    token: Address;
+    amount: string;
+    blockNumber: string;
+    transactionHash: Hex;
+}
+interface BridgeInfo {
+    blockNumber: string;
+    transactionHash: Hex;
+}
+interface ExecutionInfo {
+    blockNumber: string;
+    chainId: number | null;
+    outputToken: Address;
+    transactionHash: Hex;
+    outputAmount: string;
+}
+interface DepositedToken {
+    deposit: DepositInfo;
+    bridge: BridgeInfo | null;
+    execution: ExecutionInfo | null;
+}
+interface SraStatusResult {
+    deposits: DepositedToken[];
+    totalCount: number;
+    nextPage: number | null;
+    totalPages: number;
+}
+interface SraInfoParams {
+    sra: Address;
+}
+interface SraInfoResult {
+    executionChainId: number;
+    owner: Address;
+    smartRoutingAddress: Address;
+    smartRoutingAddressManager: Address;
+    slippage: number;
+    srcTokens: {
+        token: Address;
+        chainId: number;
+        minAmount: string;
+    }[];
+    actions: {
+        asset: Address;
+        isNative: boolean;
+        calls: {
+            target: Address;
+            data: Hex;
+            value: string;
+        }[];
+        fallBack: {
+            target: Address;
+            data: Hex;
+            value: string;
+        }[];
+    }[];
+    createdAt: string;
+    updatedAt: string;
+}
+interface WithdrawCallsParams {
+    sra: Address;
+    tokens: {
+        chainId: number;
+        token: Address;
+    }[];
+}
+interface WithdrawCallsResult {
+    data: {
+        chainId: number;
+        calls: unknown[];
+    }[];
+    receiver: Address;
+}
+interface SraFeeEstimatesParams {
+    sra: Address;
+}
+interface EstimatedFeeData {
+    token: Address;
+    name: string;
+    decimal: number;
+    fee: Hex;
+    minDeposit: Hex;
+    maxDeposit?: Hex;
+}
+interface EstimatedFee {
+    chainId: number;
+    data: EstimatedFeeData[];
+}
+interface SraFeeEstimatesResult {
+    estimatedFees: EstimatedFee[];
+}
+interface DepositStatusParams {
+    sra: Address;
+    owner: Address;
+    destChainId: number;
+    vaultId: Address;
+}
+type DepositPhase = 'pending' | 'bridging' | 'deposited' | 'failed';
+interface DepositStatusResult {
+    phase: DepositPhase;
+    deposits: DepositedToken[];
+    vaultBalance: string | null;
+}
+interface ChainInfo {
+    id: number;
+    nativeTokenSupported: boolean;
+}
+interface TokenInfo {
+    chainId: number;
+    tokenType: string;
+    address: Address;
+    decimals: number;
+}
+interface VaultInfo {
+    chainId: number;
+    address: Address;
+    symbol: string;
+    protocol: string;
+    asset: Address;
+    tokenType: string;
+    decimals: number;
+}
+interface VaultAsset {
+    symbol: string;
+    address: Address;
+    decimals: number;
+}
+/** Fields shared by every vault category. Slim projection of a vaults.fyi detailed vault. */
+interface VaultCommon {
+    /** Server vault id — what `into` keys on. */
+    id: string;
+    /** Vault contract (its `asset()` is the deposit target). */
+    address: Address;
+    chainId: number;
+    protocol: string;
+    asset: VaultAsset;
+    apy: number | null;
+    tvlUsd: number | null;
+    name?: string;
+}
+/**
+ * Discriminated union on `category` — `maturity` is reachable only after narrowing
+ * on `category === 'fixed-yield'`.
+ */
+type Vault = (VaultCommon & {
+    category: 'lend';
+}) | (VaultCommon & {
+    category: 'liquid-staking';
+}) | (VaultCommon & {
+    category: 'fixed-yield';
+    maturity: string;
+});
+interface VaultDetailsExtra {
+    apyBreakdown?: {
+        base?: number;
+        reward?: number;
+        total?: number;
+    };
+    apy7day?: number;
+    apy30day?: number;
+    description?: string;
+}
+/** Detail view returned by `getVault(id)`; still `into`-compatible. */
+type VaultDetails = Vault & VaultDetailsExtra;
+type RecipeState = 'PENDING' | 'BRIDGING' | 'EXECUTING' | 'COMPLETED' | 'FAILED';
+interface RecipeStatus {
+    sra: Address;
+    state: RecipeState;
+    deposits: DepositedToken[];
+    totalCount: number;
+}
+interface ErrorResponse {
+    error: {
+        code: string;
+        message: string;
+        details: unknown;
+    };
+}
+
+/**
+ * Canonical funding-token symbols. A `token` param accepts a `TokenSymbol` (resolved by the server
+ * to the canonical per-chain address) or a raw `Address` (to disambiguate variants like USDC.e or
+ * to use an arbitrary token). Aligned to the server's `TokenType` (`apps/server/src/lib/token-type.ts`),
+ * minus `WRAPPED_NATIVE` which is an internal routing type, not a public funding symbol.
+ */
+declare const TOKENS: {
+    readonly USDC: "USDC";
+    readonly USDT: "USDT";
+    readonly DAI: "DAI";
+    readonly WETH: "WETH";
+    readonly WBTC: "WBTC";
+    readonly EURC: "EURC";
+    readonly NATIVE: "NATIVE";
+};
+type TokenSymbol = (typeof TOKENS)[keyof typeof TOKENS];
+/** Runtime guard: is `value` a known funding-token symbol? */
+declare function isTokenSymbol(value: string): value is TokenSymbol;
+
+/** A funding token: a canonical symbol or a raw address. */
+type TokenInput = TokenSymbol | Address;
+/** Where a multi-vault deposit goes: a vault id / address (string), or a `Vault` from `listVaults()`. */
+type DepositTarget = string | Vault;
+/**
+ * Core deposit shape (SMART_RECIPES_SDK.md § Shared param vocabulary). Facades narrow it:
+ * Aave drops `into`; Morpho/Fluid/Yearn require it.
+ */
+interface DepositParams {
+    /** Funds + signs + receives shares + gets refunds (single role). */
+    owner: Address;
+    /** Display units; server scales by token decimals (string math, no float). */
+    amount: number | string;
+    /** Source funding token; symbol → canonical per-chain address, or raw address. */
+    token: TokenInput;
+    /** Chain the user funds from. */
+    srcChainId: number;
+    /**
+     * Chain the recipe executes on. `srcChainId === destChainId` ⇒ same-chain (no bridge).
+     * Optional when `into` is a `Vault` object — derived from `vault.chainId`. Required
+     * otherwise (Aave, or `into` given as a string id/address).
+     */
+    destChainId?: number;
+    /** Multi-vault facades only: raw address or a `Vault` from `listVaults()`. */
+    into?: DepositTarget;
+    /** Slippage in bps; default 100 (1%). */
+    slippage?: number;
+}
+/**
+ * Aave V3 supply. `destChainId` required (pool implied by `destChainId`). `into` OPTIONAL: pass an
+ * Aave Earn listing (id or `Vault` from `listVaults({ protocol: 'aave' })`) to pick WHICH reserve to
+ * supply — the funding `token` then bridges + dest-swaps into that reserve. Omit `into` to supply the
+ * funding token's own reserve directly.
+ */
+type AaveDepositParams = Omit<DepositParams, 'destChainId'> & {
+    destChainId: number;
+};
+/** Morpho / Fluid / Yearn / generic 4626: `into` is required. */
+type VaultDepositParams = DepositParams & {
+    into: DepositTarget;
+};
+/** Params for `sr.bridgeAndSwap`. */
+interface BridgeAndSwapParams {
+    owner: Address;
+    amount: number | string;
+    /** Source funding token. */
+    token: TokenInput;
+    /** Destination token to swap into. */
+    toToken: TokenInput;
+    srcChainId: number;
+    destChainId: number;
+    slippage?: number;
+}
+/** Discovery filter for `sr.listVaults`. */
+interface ListVaultsParams {
+    asset?: TokenInput;
+    chains?: number[];
+    protocol?: string;
+}
+/** Options for `sr.watchStatus`. */
+interface WatchStatusOptions {
+    /** Poll interval in ms; default 4000. */
+    interval?: number;
+    onStatusChange: (status: RecipeStatus) => void;
+}
+
+interface SmartRecipesConfig {
+    serverUrl: string;
+    projectId: string;
+    fetch?: typeof globalThis.fetch;
+}
+/**
+ * Smart Recipes client (SMART_RECIPES_SDK.md). Protocol facades (`sr.aave`, `sr.morpho`, …) bind a
+ * mechanism and pick the same-chain vs cross-chain endpoint; the server does friendly→wire
+ * resolution (token symbols, decimal scaling). All amounts in responses stay as wire `string`s.
+ */
+declare function createSmartRecipes(config: SmartRecipesConfig): {
+    aave: {
+        /** Aave V3 supply. Optional `into` = an Aave Earn listing selecting the reserve to supply. */
+        deposit: (p: AaveDepositParams) => Promise<Quote>;
+    };
+    morpho: {
+        deposit: (p: VaultDepositParams) => Promise<Quote>;
+    };
+    fluid: {
+        deposit: (p: VaultDepositParams) => Promise<Quote>;
+    };
+    yearn: {
+        deposit: (p: VaultDepositParams) => Promise<Quote>;
+    };
+    erc4626: {
+        deposit: (p: VaultDepositParams) => Promise<Quote>;
+    };
+    depositIntoVault: (p: VaultDepositParams & {
+        protocol: string;
+    }) => Promise<Quote>;
+    bridgeAndSwap: (p: BridgeAndSwapParams) => Promise<Quote>;
+    listVaults: (params?: ListVaultsParams) => Promise<Vault[]>;
+    getVault: (vaultId: string) => Promise<VaultDetails>;
+    getStatus: (sra: string) => Promise<RecipeStatus>;
+    watchStatus: (sra: string, opts: WatchStatusOptions) => () => void;
+    getSraInfo: (params: SraInfoParams) => Promise<SraInfoResult>;
+    getWithdrawCalls: (params: WithdrawCallsParams) => Promise<WithdrawCallsResult>;
+    getSraFeeEstimates: (params: SraFeeEstimatesParams) => Promise<SraFeeEstimatesResult>;
+    getDepositStatus: (params: DepositStatusParams) => Promise<DepositStatusResult>;
+    preflight: (params: PreflightParams) => Promise<PreflightResult>;
+    getBalances: (params: BalancesParams) => Promise<BalancesResult>;
+    getChains: () => Promise<ChainInfo[]>;
+    getTokens: (params?: {
+        chainId?: number;
+    }) => Promise<TokenInfo[]>;
+    listOpportunities: (params?: ListOpportunitiesParams) => Promise<Vault[]>;
+};
+
+declare class SmartRecipeError extends Error {
+    readonly code: string;
+    readonly details?: unknown | undefined;
+    constructor(code: string, message: string, details?: unknown | undefined);
+}
+type SmartRecipeErrorCtor = new (message: string, details?: unknown) => SmartRecipeError;
+declare const InvalidRequestError: SmartRecipeErrorCtor;
+declare const ServiceUnavailableError: SmartRecipeErrorCtor;
+declare const InternalError: SmartRecipeErrorCtor;
+declare const SraNotFoundError: SmartRecipeErrorCtor;
+declare const SraUnavailableError: SmartRecipeErrorCtor;
+declare const ChainNotSupportedError: SmartRecipeErrorCtor;
+declare const VaultCapExceededError: SmartRecipeErrorCtor;
+declare const AssetMismatchError: SmartRecipeErrorCtor;
+declare const UnknownProtocolError: SmartRecipeErrorCtor;
+declare const VaultTypeMismatchError: SmartRecipeErrorCtor;
+declare const RpcUnavailableError: SmartRecipeErrorCtor;
+declare const QuoterUnavailableError: SmartRecipeErrorCtor;
+declare const UnsupportedTokenError: SmartRecipeErrorCtor;
+declare const InsufficientAmountError: SmartRecipeErrorCtor;
+declare const SwapRouteNotFoundError: SmartRecipeErrorCtor;
+declare const QuoteExpiredError: SmartRecipeErrorCtor;
+declare const SanctionedAddressError: SmartRecipeErrorCtor;
+declare const VaultBlockedError: SmartRecipeErrorCtor;
+declare function mapErrorCode(code: string, message: string, details?: unknown): SmartRecipeError;
+
+/** Every error `code` the server can put on the wire. Single source of truth for server + SDK. */
+declare const ERROR_CODES: readonly ["INVALID_REQUEST", "SERVICE_UNAVAILABLE", "QUOTER_UNAVAILABLE", "SRA_UNAVAILABLE", "SRA_NOT_FOUND", "VAULT_NOT_ALLOWLISTED", "CHAIN_NOT_SUPPORTED", "VAULT_CAP_EXCEEDED", "ASSET_MISMATCH", "UNKNOWN_PROTOCOL", "VAULT_TYPE_MISMATCH", "RPC_UNAVAILABLE", "INTERNAL_ERROR", "UNSUPPORTED_TOKEN", "INSUFFICIENT_AMOUNT", "SWAP_ROUTE_NOT_FOUND", "QUOTE_EXPIRED", "SANCTIONED_ADDRESS", "VAULT_BLOCKED"];
+type ErrorCode = (typeof ERROR_CODES)[number];
+/** Runtime guard: is `code` one of the known wire error codes? */
+declare function isErrorCode(code: string): code is ErrorCode;
+
+export { type AaveDepositParams, AssetMismatchError, type BalancesParams, type BalancesResult, type BridgeAndSwapParams, type BridgeAndSwapRequest, type BridgeDepositQuote, type BridgeDepositRequest, type BridgeDepositResponse, type BridgeInfo, type ChainId, type ChainInfo, ChainNotSupportedError, type DebugCall, type DebugStep, type DepositInfo, type DepositIntoVaultQuote, type DepositIntoVaultRequest, type DepositIntoVaultResponse, type DepositParams, type DepositPhase, type DepositRecipeRequest, type DepositStatusParams, type DepositStatusResult, type DepositTarget, type DepositedToken, ERROR_CODES, type ErrorCode, type ErrorResponse, type EstimatedFee, type EstimatedFeeData, type ExecutionInfo, InsufficientAmountError, InternalError, InvalidRequestError, type ListOpportunitiesArgs, type ListOpportunitiesParams, type ListVaultsParams, type OnChainCall, type OnChainCallWire, type OpportunitiesQuery, type PreflightParams, type PreflightResult, type Quote, type QuoteDebug, QuoteExpiredError, type QuoteFeeBreakdown, type QuoteRoute, type QuoteTransaction, QuoterUnavailableError, type RecipeState, type RecipeStatus, type RouteInfoWire, RpcUnavailableError, SanctionedAddressError, ServiceUnavailableError, SmartRecipeError, type SmartRecipesConfig, type SraFeeEstimatesParams, type SraFeeEstimatesResult, type SraInfoParams, type SraInfoResult, SraNotFoundError, type SraStatusParams, type SraStatusResult, SraUnavailableError, SwapRouteNotFoundError, TOKENS, type TokenBalance, type TokenInfo, type TokenInput, type TokenSymbol, UnknownProtocolError, UnsupportedTokenError, type UserOpIntent, type Vault, type VaultAsset, VaultBlockedError, VaultCapExceededError, type VaultCategory, type VaultCommon, type VaultDepositParams, type VaultDetails, type VaultDetailsExtra, type VaultInfo, VaultTypeMismatchError, type WatchStatusOptions, type WithdrawCallsParams, type WithdrawCallsResult, createSmartRecipes, isErrorCode, isTokenSymbol, mapErrorCode };