@jimmygu/sfa-sdk-test 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,1043 @@
+import { ethers } from 'ethers';
+import * as _solana_web3_js from '@solana/web3.js';
+import { Connection, PublicKey } from '@solana/web3.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;
+};
+declare const OpenAPI: OpenAPIConfig;
+
+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"
+    }
+}
+
+type ServiceType = "oneclick" | "usdt0" | "cctp";
+declare const Service: {
+    readonly OneClick: "oneclick";
+    readonly Usdt0: "usdt0";
+    readonly CCTP: "cctp";
+};
+
+type ChainType = "near" | "sol" | "evm" | "tron" | "aptos";
+
+interface ChainConfig {
+    chainName: string;
+    blockchain: string;
+    chainIcon: string;
+    chainIconGray: string;
+    chainType: ChainType;
+    chainId?: number;
+    blockExplorerUrl: string;
+    primaryColor: string;
+    nativeToken: {
+        symbol: string;
+        decimals: number;
+    };
+    rpcUrls: string[];
+}
+
+interface TokenConfig extends ChainConfig {
+    name: string;
+    symbol: string;
+    decimals: number;
+    icon: string;
+    assetId: string;
+    contractAddress: string;
+    services: ServiceType[];
+}
+
+declare enum SendType {
+    SEND = "SEND",
+    TRANSFER = "TRANSFER"
+}
+
+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: ServiceType, 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"
+}
+
+interface GetAllQuoteParams {
+    singleService?: ServiceType;
+    dry?: boolean;
+    prices: Record<string, string>;
+    fromToken: TokenConfig;
+    toToken: TokenConfig;
+    wallet: WalletConfig;
+    recipient: string;
+    refundTo: string;
+    amountWei: string;
+    slippageTolerance: number;
+    minInputAmount?: string;
+    oneclickParams?: {
+        appFees?: {
+            recipient: string;
+            fee: number;
+        }[];
+        swapType?: "EXACT_INPUT" | "EXACT_OUTPUT";
+    };
+}
+/**
+ * StableFlow AI Service
+ * Main service class for interacting with the StableFlow AI API
+ */
+declare class SFA {
+    /**
+     * Get supported tokens
+     * Retrieves a list of tokens currently supported by the StableFlow AI API for asset swaps.
+     *
+     * Each token entry includes its blockchain, contract address (if available), price in USD, and other metadata such as symbol and decimals.
+     * @returns TokenResponse
+     * @throws ApiError
+     * @deprecated Please use the import { tokens } from 'stableflow-ai-sdk';
+     */
+    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.
+     *
+     * Returns pricing details, estimated time, and a unique **deposit address** to which tokens must be transferred to initiate the swap.
+     *
+     * You can set the `dry` parameter to `true` to simulate the quote request **without generating a deposit address** or initiating the swap process. This is useful for previewing swap parameters or validating input data without committing to an actual swap.
+     *
+     * This endpoint is the first required step in the swap process.
+     * @param requestBody
+     * @returns QuoteResponse
+     * @throws ApiError
+     * @deprecated Please use the getAllQuote
+     */
+    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, if quote response included deposit memo, it is required as well.
+     *
+     * The response includes the state of the swap (e.g., pending, processing, success, refunded) and any associated swap and transaction details.
+     * @param depositAddress
+     * @param depositMemo
+     * @returns GetExecutionStatusResponse
+     * @throws ApiError
+     * @deprecated Please use the getStatus
+     */
+    static getExecutionStatus(depositAddress: string, depositMemo?: string): CancelablePromise<GetExecutionStatusResponse>;
+    /**
+     * Submit deposit transaction hash
+     * Optionally notifies the StableFlow AI service that a deposit has been sent to the specified address, using the blockchain transaction hash.
+     * Only for Oneclick project
+     *
+     * This step can speed up swap processing by allowing the system to preemptively verify the deposit.
+     * @param requestBody
+     * @returns SubmitDepositTxResponse
+     * @throws ApiError
+     * @deprecated the send method will submit the tx hash automatically
+     */
+    static submitDepositTx: (requestBody: SubmitDepositTxRequest) => CancelablePromise<SubmitDepositTxResponse>;
+    /**
+     * Get quotes from all available bridge services
+     * Retrieves quotes from all supported bridge services (OneClick, CCTP, USDT0) in parallel.
+     * Returns an array of quotes with their corresponding service types, allowing users to compare and select the best route.
+     *
+     * @param params Parameters for quote request including wallet, tokens, amount, etc.
+     * @returns Promise resolving to an array of quote results with service type information
+     * @throws Error if all bridge services fail or if required parameters are missing
+     */
+    static getAllQuote(params: GetAllQuoteParams): Promise<Array<{
+        serviceType: ServiceType;
+        quote?: any;
+        error?: string;
+    }>>;
+    /**
+     * Send transaction for the selected bridge route
+     * Executes the transaction using the specified bridge service based on the service type.
+     *
+     * @param serviceType The type of bridge service to use (oneclick, cctp, or usdt0)
+     * @param params Parameters for sending the transaction including wallet, tokens, deposit address, etc.
+     * @returns Promise resolving to the transaction hash or signature
+     * @throws Error if the service type is invalid or if the transaction fails
+     */
+    static send(serviceType: ServiceType, params: {
+        wallet: any;
+        quote: any;
+    }): Promise<string>;
+    /**
+     * Get transaction status for the selected bridge route
+     * Queries the transaction status from the specified bridge service.
+     *
+     * @param serviceType The type of bridge service used (oneclick, cctp, or usdt0)
+     * @param params Parameters for querying status including deposit address, transaction hash, etc.
+     * @returns Promise resolving to the transaction status response
+     * @throws Error if the service type is invalid or if the status query fails
+     */
+    static getStatus(serviceType: ServiceType, params: {
+        depositAddress?: string;
+        hash?: string;
+    }): Promise<{
+        status: TransactionStatus;
+        toChainTxHash?: string;
+    }>;
+}
+
+declare class EVMWallet {
+    provider: any;
+    signer: any;
+    constructor(_provider: any, _signer?: any);
+    transfer(data: {
+        originAsset: string;
+        depositAddress: string;
+        amount: string;
+    }): Promise<any>;
+    getBalance(token: any, account: string): Promise<any>;
+    balanceOf(token: any, account: string): Promise<any>;
+    /**
+     * Estimate gas limit for transfer transaction
+     * @param data Transfer data
+     * @returns Gas limit estimate, gas price, and estimated gas cost
+     */
+    estimateTransferGas(data: {
+        originAsset: string;
+        depositAddress: string;
+        amount: string;
+    }): Promise<{
+        gasLimit: bigint;
+        gasPrice: bigint;
+        estimateGas: bigint;
+    }>;
+    getContract(params: any): ethers.Contract;
+    allowance(params: any): Promise<{
+        contract: ethers.Contract;
+        allowance: string;
+        needApprove: boolean;
+    }>;
+    approve(params: any): Promise<boolean>;
+    getEstimateGas(params: any): Promise<{
+        gasPrice: any;
+        usd: string;
+        wei: bigint;
+        amount: string;
+    }>;
+    quoteOFT(params: any): Promise<any>;
+    sendTransaction(params: any): Promise<any>;
+    /**
+     * Unified quote method that routes to specific quote methods based on type
+     * @param type Service type from ServiceType
+     * @param params Parameters for the quote
+     */
+    quote(type: ServiceType, params: any): Promise<any>;
+    /**
+     * Unified send method that routes to specific send methods based on type
+     * @param type Send type from SendType enum
+     * @param params Parameters for the send transaction
+     */
+    send(type: SendType, params: any): Promise<any>;
+    quoteCCTP(params: any): Promise<any>;
+    quoteOneClickProxy(params: any): Promise<any>;
+    signTypedData(params: any): Promise<any>;
+}
+
+declare class HyperliquidService {
+    quote(params: HyperliquidQuoteParams): Promise<{
+        quote: any;
+        error: string | null;
+    }>;
+    transfer(params: HyperliquidTransferParams): Promise<string>;
+    deposit(params: HyperliquidDepositParams): Promise<void>;
+    getStatus(params: HyperliquidGetStatusParams): Promise<void>;
+    protected generatePermit(params: HyperliquidGeneratePermitParams): Promise<{
+        deadline: string;
+        owner: string;
+        r: string;
+        s: string;
+        spender: string;
+        token: string;
+        v: 28 | 27;
+        value: string;
+    }>;
+}
+declare const Hyperliquid: HyperliquidService;
+declare const HyperliquidFromTokens: TokenConfig[];
+declare const HyperliuquidToToken: TokenConfig;
+interface HyperliquidQuoteParams {
+    slippageTolerance: number;
+    refundTo: string;
+    recipient: string;
+    wallet: WalletConfig;
+    fromToken: TokenConfig;
+    prices: Record<string, string>;
+    amountWei: string;
+    dry?: boolean;
+    oneclickParams?: {
+        appFees?: {
+            recipient: string;
+            fee: number;
+        }[];
+    };
+}
+interface HyperliquidTransferParams {
+    wallet: WalletConfig;
+    evmWallet: EVMWallet;
+    evmWalletAddress: string;
+    quote: any;
+}
+interface HyperliquidGeneratePermitParams {
+    address: string;
+    evmWallet: EVMWallet;
+    amountWei: string;
+}
+interface HyperliquidDepositParams extends HyperliquidTransferParams {
+    txhash: string;
+}
+interface HyperliquidGetStatusParams {
+}
+
+declare const tokens: TokenConfig[];
+declare const usdtTokens: TokenConfig[];
+declare const usdcTokens: TokenConfig[];
+
+declare const usdtChains: Record<string, TokenConfig>;
+
+declare const usdcChains: Record<string, TokenConfig>;
+
+declare class NearWallet {
+    private selector;
+    private rpcUrl;
+    constructor(_selector: any);
+    private query;
+    transfer(data: {
+        originAsset: string;
+        depositAddress: string;
+        amount: string;
+    }): Promise<any>;
+    getBalance(token: any, _account: string): Promise<any>;
+    balanceOf(token: any, account: string): Promise<any>;
+    /**
+     * Get native NEAR balance
+     * @param account Account ID
+     * @returns NEAR balance in yoctoNEAR (smallest unit)
+     */
+    getNearBalance(account: string): Promise<string>;
+    /**
+     * Estimate gas limit for transfer transaction
+     * @param data Transfer data
+     * @returns Gas limit estimate, gas price, and estimated gas cost
+     */
+    estimateTransferGas(data: {
+        originAsset: string;
+        depositAddress: string;
+        amount: string;
+    }): Promise<{
+        gasLimit: bigint;
+        gasPrice: bigint;
+        estimateGas: bigint;
+    }>;
+    checkTransactionStatus(txHash: string): Promise<void>;
+    quoteOneClickProxy(params: any): Promise<any>;
+    sendTransaction(params: any): Promise<any>;
+    /**
+     * Unified quote method that routes to specific quote methods based on type
+     * @param type Service type from ServiceType
+     * @param params Parameters for the quote
+     */
+    quote(type: ServiceType, params: any): Promise<any>;
+    /**
+     * Unified send method that routes to specific send methods based on type
+     * @param type Send type from SendType enum
+     * @param params Parameters for the send transaction
+     */
+    send(type: SendType, params: any): Promise<any>;
+}
+
+declare class SolanaWallet {
+    connection: Connection;
+    private publicKey;
+    private signTransaction;
+    private signer;
+    constructor(options: {
+        publicKey: PublicKey | null;
+        signer: any;
+    });
+    transferSOL(to: string, amount: string): Promise<string>;
+    transferToken(tokenMint: string, to: string, amount: string): Promise<string>;
+    transfer(data: {
+        originAsset: string;
+        depositAddress: string;
+        amount: string;
+    }): Promise<string>;
+    getSOLBalance(account: string): Promise<number>;
+    getTokenBalance(tokenMint: string, account: string): Promise<bigint | 0>;
+    getBalance(token: any, account: string): Promise<number | bigint>;
+    balanceOf(token: any, account: string): Promise<number | bigint>;
+    /**
+     * Estimate gas limit for transfer transaction
+     * @param data Transfer data
+     * @returns Gas limit estimate, gas price, and estimated gas cost
+     */
+    estimateTransferGas(data: {
+        originAsset: string;
+        depositAddress: string;
+        amount: string;
+    }): Promise<{
+        gasLimit: bigint;
+        gasPrice: bigint;
+        estimateGas: bigint;
+    }>;
+    checkTransactionStatus(signature: string): Promise<boolean>;
+    simulateIx(ix: any): Promise<_solana_web3_js.SimulatedTransactionResponse>;
+    sendTransaction(params: any): Promise<string>;
+    /**
+     * Unified quote method that routes to specific quote methods based on type
+     * @param type Service type from ServiceType
+     * @param params Parameters for the quote
+     */
+    quote(type: ServiceType, params: any): Promise<any>;
+    /**
+     * Unified send method that routes to specific send methods based on type
+     * @param type Send type from SendType enum
+     * @param params Parameters for the send transaction
+     */
+    send(type: SendType, params: any): Promise<string>;
+    quoteOneClickProxy(params: any): Promise<any>;
+    quoteCCTP(params: any): Promise<any>;
+    quoteOFT(params: any): Promise<any>;
+    createAssociatedTokenAddress(params: any): Promise<PublicKey>;
+}
+
+declare class TronWallet {
+    private signAndSendTransaction;
+    private address;
+    private tronWeb;
+    constructor(options: any);
+    waitForTronWeb(): Promise<unknown>;
+    transfer(data: {
+        originAsset: string;
+        depositAddress: string;
+        amount: string;
+    }): Promise<any>;
+    transferTRX(to: string, amount: string): Promise<any>;
+    transferToken(contractAddress: string, to: string, amount: string): Promise<any>;
+    getBalance(token: any, account: string): Promise<any>;
+    getTRXBalance(account: string): Promise<any>;
+    getTokenBalance(contractAddress: string, account: string): Promise<any>;
+    balanceOf(token: any, account: string): Promise<any>;
+    /**
+      * Estimate gas limit for transfer transaction
+      * @param data Transfer data
+      * @returns Gas limit estimate (bandwidth or energy), gas price, and estimated gas cost
+      */
+    estimateTransferGas(data: {
+        originAsset: string;
+        depositAddress: string;
+        amount: string;
+    }): Promise<{
+        gasLimit: bigint;
+        gasPrice: bigint;
+        estimateGas: bigint;
+    }>;
+    checkTransactionStatus(txHash: string): Promise<boolean>;
+    getTransactionResult(txHash: string): Promise<any>;
+    allowance(params: any): Promise<{
+        contract: any;
+        allowance: string;
+        needApprove: boolean;
+    }>;
+    approve(params: any): Promise<any>;
+    getEnergyPrice(): Promise<any>;
+    toBytes32(addr: string): string;
+    quoteOFT(params: any): Promise<any>;
+    sendTransaction(params: any): Promise<any>;
+    /**
+     * Unified quote method that routes to specific quote methods based on type
+     * @param type Service type from ServiceType
+     * @param params Parameters for the quote
+     */
+    quote(type: ServiceType, params: any): Promise<any>;
+    /**
+     * Unified send method that routes to specific send methods based on type
+     * @param type Send type from SendType enum
+     * @param params Parameters for the send transaction
+     */
+    send(type: SendType, params: any): Promise<any>;
+    quoteOneClickProxy(params: any): Promise<any>;
+    getAccountResources(params: any): Promise<any>;
+}
+
+declare class AptosWallet {
+    connection: any;
+    private account;
+    private aptos;
+    private signAndSubmitTransaction;
+    constructor(options: {
+        account: any | null;
+        signAndSubmitTransaction: any;
+    });
+    transferAPT(to: string, amount: string): Promise<string>;
+    transferToken(contractAddress: string, to: string, amount: string): Promise<string>;
+    transfer(data: {
+        originAsset: string;
+        depositAddress: string;
+        amount: string;
+    }): Promise<string>;
+    getAPTBalance(account: string): Promise<string>;
+    getTokenBalance(contractAddress: string, account: string): Promise<string>;
+    getBalance(token: any, account: string): Promise<string>;
+    balanceOf(token: any, account: string): Promise<string>;
+    /**
+     * Estimate gas limit for transfer transaction
+     * @param data Transfer data
+     * @returns Gas limit estimate, gas price, and estimated gas cost
+     */
+    estimateTransferGas(data: {
+        originAsset: string;
+        depositAddress: string;
+        amount: string;
+    }): Promise<{
+        gasLimit: bigint;
+        gasPrice: bigint;
+        estimateGas: bigint;
+    }>;
+    checkTransactionStatus(signature: string): Promise<boolean>;
+    quoteOneClickProxy(params: any): Promise<any>;
+    sendTransaction(params: any): Promise<any>;
+    /**
+    * Unified quote method that routes to specific quote methods based on type
+    * @param type Service type from ServiceType
+    * @param params Parameters for the quote
+    */
+    quote(type: ServiceType, params: any): Promise<any>;
+    /**
+     * Unified send method that routes to specific send methods based on type
+     * @param type Send type from SendTypeSENDm
+     * @param params Parameters for the send transaction
+     */
+    send(type: SendType, params: any): Promise<any>;
+}
+
+declare const NetworkRpcUrlsMap: Record<string, string[]>;
+declare const getRpcUrls: (blockchain: string) => string[];
+declare const setRpcUrls: (urls: Record<string, string[]>) => Record<string, string[]>;
+
+export { ApiError, type AppFee, AptosWallet, type BadRequestResponse, CancelError, CancelablePromise, EVMWallet, type GetAllQuoteParams, GetExecutionStatusResponse, Hyperliquid, type HyperliquidDepositParams, HyperliquidFromTokens, type HyperliquidGetStatusParams, type HyperliquidQuoteParams, type HyperliquidTransferParams, HyperliuquidToToken, NearWallet, NetworkRpcUrlsMap, OpenAPI, type OpenAPIConfig, type Quote, QuoteRequest, type QuoteResponse, SFA, Service, type ServiceType, SolanaWallet, type SubmitDepositTxRequest, SubmitDepositTxResponse, type SwapDetails, type TokenConfig, TokenResponse, type TransactionDetails, TransactionStatus, TronWallet, getRpcUrls, setRpcUrls, tokens, usdcChains, usdcTokens, usdtChains, usdtTokens };