@stableflow/core 3.0.0-beta-02a59f37a0-20260515

package/dist/index.d.ts

@@ -0,0 +1,749 @@
+import { AxiosInstance } from 'axios';
+import Big from 'big.js';
+
+type ApiRequestOptions = {
+    readonly method: 'GET' | 'PUT' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD' | 'PATCH';
+    readonly url: string;
+    readonly path?: Record<string, any>;
+    readonly cookies?: Record<string, any>;
+    readonly headers?: Record<string, any>;
+    readonly query?: Record<string, any>;
+    readonly formData?: Record<string, any>;
+    readonly body?: any;
+    readonly mediaType?: string;
+    readonly responseHeader?: string;
+    readonly errors?: Record<number, string>;
+};
+
+type ApiResult = {
+    readonly url: string;
+    readonly ok: boolean;
+    readonly status: number;
+    readonly statusText: string;
+    readonly body: any;
+};
+
+declare class ApiError extends Error {
+    readonly url: string;
+    readonly status: number;
+    readonly statusText: string;
+    readonly body: any;
+    readonly request: ApiRequestOptions;
+    constructor(request: ApiRequestOptions, response: ApiResult, message: string);
+}
+
+declare class CancelError extends Error {
+    constructor(message: string);
+    get isCancelled(): boolean;
+}
+interface OnCancel {
+    readonly isResolved: boolean;
+    readonly isRejected: boolean;
+    readonly isCancelled: boolean;
+    (cancelHandler: () => void): void;
+}
+declare class CancelablePromise<T> implements Promise<T> {
+    #private;
+    constructor(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void, onCancel: OnCancel) => void);
+    get [Symbol.toStringTag](): string;
+    then<TResult1 = T, TResult2 = never>(onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onRejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult>;
+    finally(onFinally?: (() => void) | null): Promise<T>;
+    cancel(): void;
+    get isCancelled(): boolean;
+}
+
+type Resolver<T> = (options: ApiRequestOptions) => Promise<T>;
+type Headers = Record<string, string>;
+type OpenAPIConfig = {
+    BASE: string;
+    VERSION: string;
+    WITH_CREDENTIALS: boolean;
+    CREDENTIALS: 'include' | 'omit' | 'same-origin';
+    TOKEN?: string | Resolver<string> | undefined;
+    USERNAME?: string | Resolver<string> | undefined;
+    PASSWORD?: string | Resolver<string> | undefined;
+    HEADERS?: Headers | Resolver<Headers> | undefined;
+    ENCODE_PATH?: ((path: string) => string) | undefined;
+    DEBUG: boolean;
+};
+declare const OpenAPI: OpenAPIConfig;
+
+/**
+ * Request method
+ * @param config The OpenAPI configuration object
+ * @param options The request options from the service
+ * @param axiosClient The axios client instance to use
+ * @returns CancelablePromise<T>
+ * @throws ApiError
+ */
+declare const request: <T>(config: OpenAPIConfig, options: ApiRequestOptions, axiosClient?: AxiosInstance) => CancelablePromise<T>;
+
+declare enum SendType {
+    SEND = "SEND",
+    TRANSFER = "TRANSFER"
+}
+
+/**
+ * @deprecated Please use Service instead
+ */
+type ServiceType = "oneclick" | "usdt0" | "cctp" | "fraxzero" | "fraxzero-oneclick" | "oneclick-fraxzero" | "usdt0-oneclick" | "oneclick-usdt0" | "native";
+declare const Service: {
+    readonly OneClick: "oneclick";
+    readonly Usdt0: "usdt0";
+    readonly CCTP: "cctp";
+    readonly FraxZero: "fraxzero";
+    readonly FraxZeroOneClick: "fraxzero-oneclick";
+    readonly OneClickFraxZero: "oneclick-fraxzero";
+    readonly Usdt0OneClick: "usdt0-oneclick";
+    readonly OneClickUsdt0: "oneclick-usdt0";
+    readonly Native: "native";
+};
+type Service = (typeof Service)[keyof typeof Service];
+declare const ServiceBackend: Record<Service, string>;
+
+type AppFee = {
+    /**
+     * Account ID within Intents to which this fee will be transferred
+     */
+    recipient: string;
+    /**
+     * Fee for this recipient as part of amountIn in basis points (1/100th of a percent), e.g. 100 for 1% fee
+     */
+    fee: number;
+};
+
+type BadRequestResponse = {
+    message: string;
+};
+
+type Quote = {
+    /**
+     * The deposit address on the chain of `originAsset` when `depositType` is `ORIGIN_CHAIN`.
+     *
+     * The deposit address inside NEAR Intents (the verifier smart contract) when `depositType` is `INTENTS`.
+     */
+    depositAddress?: string;
+    /**
+     * Some of the deposit addresses **REQUIRE** to also include the `memo` for the deposit to be processed
+     */
+    depositMemo?: string;
+    /**
+     * Amount of the origin asset
+     */
+    amountIn: string;
+    /**
+     * Amount of the origin asset in readable format
+     */
+    amountInFormatted: string;
+    /**
+     * Amount of the origin assets equivalent in USD
+     */
+    amountInUsd: string;
+    /**
+     * Minimum amount of the origin asset that will be used for the swap
+     */
+    minAmountIn: string;
+    /**
+     * Amount of the destination asset
+     */
+    amountOut: string;
+    /**
+     * Amount of the destination asset in readable format
+     */
+    amountOutFormatted: string;
+    /**
+     * Amount of the destination asset equivalent in USD
+     */
+    amountOutUsd: string;
+    /**
+     * Minimum output amount after slippage is applied
+     */
+    minAmountOut: string;
+    /**
+     * Time when the deposit address becomes inactive and funds may be lost
+     */
+    deadline?: string;
+    /**
+     * Time when the deposit address becomes cold, causing swap processing to take longer
+     */
+    timeWhenInactive?: string;
+    /**
+     * Estimated time in seconds for the swap to be executed after the deposit transaction is confirmed
+     */
+    timeEstimate: number;
+    /**
+     * EVM address of a transfer recipient in a virtual chain
+     */
+    virtualChainRecipient?: string;
+    /**
+     * EVM address of a refund recipient in a virtual chain
+     */
+    virtualChainRefundRecipient?: string;
+};
+
+type QuoteRequest = {
+    /**
+     * Flag indicating whether this is a dry run request.
+     * If `true`, the response will **NOT** contain the following fields:
+     * - `depositAddress`
+     * - `timeWhenInactive`
+     * - `deadline`
+     */
+    dry: boolean;
+    /**
+     * What deposit address mode you will get in the response, most chain supports only `SIMPLE` and some(for example `stellar`) only `MEMO`:
+     * - `SIMPLE` - usual deposit with only deposit address.
+     * - `MEMO` - some chains will **REQUIRE** the `memo` together with `depositAddress` for swap to work.
+     */
+    depositMode?: QuoteRequest.depositMode;
+    /**
+     * How to interpret `amount` when performing the swap:
+     * - `EXACT_INPUT` - requests the output amount for an exact input.
+     * - `EXACT_OUTPUT` - requests the input amount for an exact output. The `refundTo` address always receives any excess tokens after the swap is complete.
+     * - `FLEX_INPUT` - a flexible input amount that allows for partial deposits and variable amounts.
+     */
+    swapType: QuoteRequest.swapType;
+    /**
+     * Slippage tolerance for the swap. This value is in basis points (1/100th of a percent), e.g. 100 for 1% slippage.
+     */
+    slippageTolerance: number;
+    /**
+     * ID of the origin asset.
+     */
+    originAsset: string;
+    /**
+     * Type of deposit address:
+     * - `ORIGIN_CHAIN` - deposit address on the origin chain.
+     * - `INTENTS` - the account ID within NEAR Intents to which you should transfer assets.
+     */
+    depositType: QuoteRequest.depositType;
+    /**
+     * ID of the destination asset.
+     */
+    destinationAsset: string;
+    /**
+     * Amount to swap as the base amount. It is interpreted as the input or output amount based on the `swapType` flag and is specified in the smallest unit of the currency (e.g., wei for ETH).
+     */
+    amount: string;
+    /**
+     * Address used for refunds.
+     */
+    refundTo: string;
+    /**
+     * Type of refund address:
+     * - `ORIGIN_CHAIN` - assets are refunded to the `refundTo` address on the origin chain.
+     * - `INTENTS` - assets are refunded to the `refundTo` Intents account.
+     */
+    refundType: QuoteRequest.refundType;
+    /**
+     * Recipient address. The format must match `recipientType`.
+     */
+    recipient: string;
+    /**
+     * EVM address of a transfer recipient in a virtual chain
+     */
+    virtualChainRecipient?: string;
+    /**
+     * EVM address of a refund recipient in a virtual chain
+     */
+    virtualChainRefundRecipient?: string;
+    /**
+     * Type of recipient address:
+     * - `DESTINATION_CHAIN` - assets are transferred to the chain of `destinationAsset`.
+     * - `INTENTS` - assets are transferred to an account inside Intents
+     */
+    recipientType: QuoteRequest.recipientType;
+    /**
+     * Timestamp in ISO format that identifies when the user refund begins if the swap isn't completed by then. It must exceed the time required for the deposit transaction to be mined. For example, Bitcoin may require around one hour depending on the fees paid.
+     */
+    deadline: string;
+    /**
+     * Referral identifier (lowercase only). It will be reflected in the on-chain data and displayed on public analytics platforms.
+     */
+    referral?: string;
+    /**
+     * Time in milliseconds the user is willing to wait for a quote from the relay.
+     */
+    quoteWaitingTimeMs?: number;
+    /**
+     * List of recipients and their fees
+     */
+    appFees?: Array<AppFee>;
+};
+declare namespace QuoteRequest {
+    /**
+     * What deposit address mode you will get in the response, most chain supports only `SIMPLE` and some(for example `stellar`) only `MEMO`:
+     * - `SIMPLE` - usual deposit with only deposit address.
+     * - `MEMO` - some chains will **REQUIRE** the `memo` together with `depositAddress` for swap to work.
+     */
+    enum depositMode {
+        SIMPLE = "SIMPLE",
+        MEMO = "MEMO"
+    }
+    /**
+     * How to interpret `amount` when performing the swap:
+     * - `EXACT_INPUT` - requests the output amount for an exact input.
+     * - `EXACT_OUTPUT` - requests the input amount for an exact output. The `refundTo` address always receives any excess tokens after the swap is complete.
+     * - `FLEX_INPUT` - a flexible input amount that allows for partial deposits and variable amounts.
+     */
+    enum swapType {
+        EXACT_INPUT = "EXACT_INPUT",
+        EXACT_OUTPUT = "EXACT_OUTPUT",
+        FLEX_INPUT = "FLEX_INPUT"
+    }
+    /**
+     * Type of deposit address:
+     * - `ORIGIN_CHAIN` - deposit address on the origin chain.
+     * - `INTENTS` - the account ID within NEAR Intents to which you should transfer assets.
+     */
+    enum depositType {
+        ORIGIN_CHAIN = "ORIGIN_CHAIN",
+        INTENTS = "INTENTS"
+    }
+    /**
+     * Type of refund address:
+     * - `ORIGIN_CHAIN` - assets are refunded to the `refundTo` address on the origin chain.
+     * - `INTENTS` - assets are refunded to the `refundTo` Intents account.
+     */
+    enum refundType {
+        ORIGIN_CHAIN = "ORIGIN_CHAIN",
+        INTENTS = "INTENTS"
+    }
+    /**
+     * Type of recipient address:
+     * - `DESTINATION_CHAIN` - assets are transferred to the chain of `destinationAsset`.
+     * - `INTENTS` - assets are transferred to an account inside Intents
+     */
+    enum recipientType {
+        DESTINATION_CHAIN = "DESTINATION_CHAIN",
+        INTENTS = "INTENTS"
+    }
+}
+
+type QuoteResponse = {
+    /**
+     * Timestamp in ISO format that was used to derive the deposit address
+     */
+    timestamp: string;
+    /**
+     * Signature of the StableFlow service confirming the quote for the specific deposit address. Must be saved on the client side (along with the whole quote) in order to resolve any disputes or mistakes.
+     */
+    signature: string;
+    /**
+     * User request
+     */
+    quoteRequest: QuoteRequest;
+    /**
+     * Response containing the deposit address for sending the `amount` of `originAsset` and the expected output amount.
+     */
+    quote: Quote;
+};
+
+type TransactionDetails = {
+    /**
+     * Transaction hash
+     */
+    hash: string;
+    /**
+     * Explorer URL for the transaction
+     */
+    explorerUrl: string;
+};
+
+type SwapDetails = {
+    /**
+     * All intent hashes that took part in this swap
+     */
+    intentHashes: Array<string>;
+    /**
+     * All NEAR transactions executed for this swap
+     */
+    nearTxHashes: Array<string>;
+    /**
+     * Exact amount of `originToken` after the trade was settled
+     */
+    amountIn?: string;
+    /**
+     * Exact amount of `originToken` in readable format after the trade was settled
+     */
+    amountInFormatted?: string;
+    /**
+     * Exact amount of `originToken` equivalent in USD
+     */
+    amountInUsd?: string;
+    /**
+     * Exact amount of `destinationToken` after the trade was settled
+     */
+    amountOut?: string;
+    /**
+     * Exact amount of `destinationToken` in readable format after the trade was settled
+     */
+    amountOutFormatted?: string;
+    /**
+     * Exact amount of `destinationToken` equivalent in USD
+     */
+    amountOutUsd?: string;
+    /**
+     * Actual slippage
+     */
+    slippage?: number;
+    /**
+     * Hashes and explorer URLs for all transactions on the origin chain
+     */
+    originChainTxHashes: Array<TransactionDetails>;
+    /**
+     * Hashes and explorer URLs for all transactions on the destination chain
+     */
+    destinationChainTxHashes: Array<TransactionDetails>;
+    /**
+     * Amount of `originAsset` transferred to `refundTo`
+     */
+    refundedAmount?: string;
+    /**
+     * Refunded amount in readable format
+     */
+    refundedAmountFormatted?: string;
+    /**
+     * Refunded amount equivalent in USD
+     */
+    refundedAmountUsd?: string;
+};
+
+type GetExecutionStatusResponse = {
+    /**
+     * Quote response from the original request
+     */
+    quoteResponse: QuoteResponse;
+    status: GetExecutionStatusResponse.status;
+    /**
+     * Last time the state was updated
+     */
+    updatedAt: string;
+    /**
+     * Details of actual swaps and withdrawals
+     */
+    swapDetails: SwapDetails;
+};
+declare namespace GetExecutionStatusResponse {
+    enum status {
+        KNOWN_DEPOSIT_TX = "KNOWN_DEPOSIT_TX",
+        PENDING_DEPOSIT = "PENDING_DEPOSIT",
+        INCOMPLETE_DEPOSIT = "INCOMPLETE_DEPOSIT",
+        PROCESSING = "PROCESSING",
+        SUCCESS = "SUCCESS",
+        REFUNDED = "REFUNDED",
+        FAILED = "FAILED"
+    }
+}
+
+type SubmitDepositTxRequest = {
+    /**
+     * Transaction hash of your deposit
+     */
+    txHash: string;
+    /**
+     * Deposit address for the quote
+     */
+    depositAddress: string;
+};
+
+type SubmitDepositTxResponse = {
+    /**
+     * Quote response from the original request
+     */
+    quoteResponse: QuoteResponse;
+    status: SubmitDepositTxResponse.status;
+    /**
+     * Last time the state was updated
+     */
+    updatedAt: string;
+    /**
+     * Details of actual swaps and withdrawals
+     */
+    swapDetails: SwapDetails;
+};
+declare namespace SubmitDepositTxResponse {
+    enum status {
+        KNOWN_DEPOSIT_TX = "KNOWN_DEPOSIT_TX",
+        PENDING_DEPOSIT = "PENDING_DEPOSIT",
+        INCOMPLETE_DEPOSIT = "INCOMPLETE_DEPOSIT",
+        PROCESSING = "PROCESSING",
+        SUCCESS = "SUCCESS",
+        REFUNDED = "REFUNDED",
+        FAILED = "FAILED"
+    }
+}
+
+type TokenResponse = {
+    /**
+     * Unique asset identifier
+     */
+    assetId: string;
+    /**
+     * Number of decimals for the token
+     */
+    decimals: number;
+    /**
+     * Blockchain associated with the token
+     */
+    blockchain: TokenResponse.blockchain;
+    /**
+     * Token symbol (e.g. BTC, ETH)
+     */
+    symbol: string;
+    /**
+     * Current price of the token in USD
+     */
+    price: number;
+    /**
+     * Date when the token price was last updated
+     */
+    priceUpdatedAt: string;
+    /**
+     * Contract address of the token
+     */
+    contractAddress?: string;
+};
+declare namespace TokenResponse {
+    /**
+     * Blockchain associated with the token
+     */
+    enum blockchain {
+        NEAR = "near",
+        ETH = "eth",
+        BASE = "base",
+        ARB = "arb",
+        BTC = "btc",
+        SOL = "sol",
+        TON = "ton",
+        DOGE = "doge",
+        XRP = "xrp",
+        ZEC = "zec",
+        GNOSIS = "gnosis",
+        BERA = "bera",
+        BSC = "bsc",
+        POL = "pol",
+        TRON = "tron",
+        SUI = "sui",
+        OP = "op",
+        AVAX = "avax",
+        CARDANO = "cardano"
+    }
+}
+
+interface ChainConfig {
+    chainName: string;
+    chainId?: number;
+    /**
+     * SDA.getTokens() blockchain
+     */
+    blockchain: string;
+    chainIcon: string;
+    chainIconGray: string;
+    chainType: string;
+    blockExplorerUrl: string;
+    blockExplorerUrls: string[];
+    primaryColor: string;
+    nativeToken: {
+        symbol: string;
+        decimals: number;
+    };
+    rpcUrls: string[];
+    rpcUrl: string;
+}
+
+interface TokenConfig extends ChainConfig {
+    name: string;
+    symbol: string;
+    decimals: number;
+    icon: string;
+    assetId: string;
+    contractAddress: string;
+    services: Service[];
+}
+
+interface WalletConfig {
+    transfer(params: {
+        originAsset: string;
+        depositAddress: string;
+        amount: string;
+    }): Promise<string>;
+    getBalance(token: TokenConfig, account: string): Promise<string>;
+    balanceOf(token: TokenConfig, account: string): Promise<string>;
+    allowance?(params: {
+        contractAddress: string;
+        spender: string;
+        address: string;
+        amountWei: string | number | BigInt;
+    }): Promise<{
+        allowance: string;
+        needApprove: boolean;
+    }>;
+    approve?(params: {
+        contractAddress: string;
+        spender: string;
+        amountWei: string | number | BigInt;
+        isApproveMax?: boolean;
+    }): Promise<boolean>;
+    quote(type: Service, params: {}): Promise<{
+        needApprove?: boolean;
+        approveSpender?: string;
+        sendParam?: any;
+        quoteParam: any;
+        fees?: Record<string, string>;
+        totalFeesUsd?: string;
+        estimateSourceGas?: BigInt;
+        estimateSourceGasUsd?: string;
+        estimateTime?: number;
+        outputAmount?: string;
+    }>;
+    send(type: SendType, params: any): Promise<string>;
+}
+
+declare enum TransactionStatus {
+    Pending = "pending",
+    Success = "success",
+    Failed = "failed"
+}
+
+/**
+ * StableFlow AI Service — HTTP API helpers.
+ *
+ * For full cross-chain bridge flows (multi-route quote, send, per-bridge status),
+ * install and use `@stableflow/bridges` (`BridgeSFA`).
+ */
+declare class SFA {
+    /**
+     * Get supported tokens
+     * Retrieves a list of tokens currently supported by the StableFlow AI API for asset swaps.
+     */
+    static getTokens(): CancelablePromise<Array<TokenResponse>>;
+    /**
+     * Request a swap quote
+     * Generates a swap quote based on input parameters such as the assets, amount, slippage tolerance, and recipient/refund information.
+     */
+    static getQuote(requestBody: QuoteRequest): CancelablePromise<QuoteResponse>;
+    /**
+     * Check swap execution status
+     * Retrieves the current status of a swap using the unique deposit address from the quote.
+     */
+    static getExecutionStatus(depositAddress: string, depositMemo?: string): CancelablePromise<GetExecutionStatusResponse>;
+    /**
+     * Submit deposit transaction hash (OneClick)
+     * Optionally notifies the service that a deposit has been sent to the specified address.
+     */
+    static submitDepositTx: (requestBody: SubmitDepositTxRequest) => CancelablePromise<SubmitDepositTxResponse>;
+}
+
+declare const tokens: TokenConfig[];
+declare const usdtTokens: TokenConfig[];
+declare const usdcTokens: TokenConfig[];
+declare const frxusdTokens: TokenConfig[];
+
+declare const usdtChains: Record<string, TokenConfig>;
+
+declare const usdcChains: Record<string, TokenConfig>;
+
+declare const frxusdChains: Record<string, TokenConfig>;
+
+declare const usdt0Chains: Record<string, TokenConfig>;
+
+declare const NetworkRpcUrlsMap: Record<string, string[]>;
+/**
+ * @deprecated Please use getChainRpcUrl instead
+ * @param blockchain
+ * @returns
+ */
+declare const getRpcUrls: (blockchain: string) => string[];
+declare const getChainRpcUrl: (blockchain: string) => {
+    rpcUrls: string[];
+    rpcUrl: string;
+};
+declare const setRpcUrls: (urls: Record<string, string[]>) => Record<string, string[]>;
+
+type ChainType = "near" | "sol" | "evm" | "tron" | "aptos" | "ton" | "sui";
+
+declare const DefaultAddresses: Record<ChainType, string>;
+
+declare const _default: {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+}[];
+
+declare function getPrice(prices: Record<string, string>, symbol: string): string;
+
+declare const formatNumber: (value: string | number | Big.Big | undefined, precision: number, isSimple?: boolean, options?: {
+    prefix?: string;
+    isLTIntegerZero?: boolean;
+    isZeroPrecision?: boolean;
+    isShort?: boolean;
+    isShortUppercase?: boolean;
+    round?: Big.RoundingMode;
+    isLessPrecision?: boolean;
+}) => any;
+declare const numberRemoveEndZero: (value: string) => string;
+
+declare function addressToBytes32(chainType: string, address: string): string;
+
+type StyleScale = 50 | 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900 | 950;
+type StyleColor = "red" | "yellow" | "green" | "blue" | "sky" | "teal" | "purple" | "pink" | "rose" | "gray" | "indigo" | "fuchsia" | "stone" | "lime";
+declare class Csl {
+    private isDebug;
+    constructor(isDebug: boolean);
+    log: (type: string, style: `${StyleColor}-${StyleScale}`, str: string, ...args: any[]) => void;
+    info: (type: string, str: string, ...args: any[]) => void;
+    error: (type: string, str: string, ...args: any[]) => void;
+    success: (type: string, str: string, ...args: any[]) => void;
+    simple: (str: string, ...args: any[]) => void;
+}
+
+declare class ExecTime {
+    private isDebug;
+    private type;
+    private logStyle;
+    private startTimestamp;
+    private currentTimestamp;
+    private isPerformance;
+    private readonly performanceThreshold;
+    private csl;
+    constructor(options: {
+        type: string;
+        logStyle?: `${StyleColor}-${StyleScale}`;
+        isPerformance?: boolean;
+        isDebug: boolean;
+    });
+    breakpoint(): void;
+    log(subType: string, str?: string, ...params: any[]): void;
+    logTotal(subType: string, str?: string, ...params: any[]): void;
+}
+
+declare const formatQuoteError: (error: any, options: {
+    service: Service;
+    fromToken: TokenConfig;
+}) => {
+    serviceType: "oneclick";
+    error: string;
+} | {
+    serviceType: "usdt0" | "cctp" | "fraxzero" | "fraxzero-oneclick" | "oneclick-fraxzero" | "usdt0-oneclick" | "oneclick-usdt0" | "native";
+    error: any;
+};
+
+declare const getRouteStatus: (service: Service, disabledServices?: Service[]) => {
+    disabled: boolean;
+};
+
+declare function quoteSignature(params: any): Promise<any>;
+
+export { ApiError, type AppFee, type BadRequestResponse, CancelError, CancelablePromise, type ChainType, Csl, DefaultAddresses, ExecTime, GetExecutionStatusResponse, NetworkRpcUrlsMap, OpenAPI, type OpenAPIConfig, type Quote, QuoteRequest, type QuoteResponse, SFA, SendType, Service, ServiceBackend, type ServiceType, type SubmitDepositTxRequest, SubmitDepositTxResponse, type SwapDetails, type TokenConfig, TokenResponse, type TransactionDetails, TransactionStatus, type WalletConfig, addressToBytes32, _default as erc20Abi, formatNumber, formatQuoteError, frxusdChains, frxusdTokens, getChainRpcUrl, getPrice, getRouteStatus, getRpcUrls, numberRemoveEndZero, quoteSignature, request, setRpcUrls, tokens, usdcChains, usdcTokens, usdt0Chains, usdtChains, usdtTokens };