@nekoproject/swap/lib/index.d.ts

Cross-chain Swap Token

import { Network, BSCNetwork, ETHNetwork, SPLNetwork } from '@nekoproject/networks';
import { Wallet, ETHWallet, SPLWallet } from '@nekoproject/wallets';
import { BaseToken, SPLToken } from '@nekoproject/tokens';

declare type CreateOrder = {
    wallet_address: string;
    slippage: number;
    srcAmount: string;
    destAmount?: string;
    destToken: BaseToken;
    srcToken: BaseToken;
};
declare type SetApiParams = {
    createOrder: string;
    buildTransaction: string;
};
declare type SwapOrderRequest = {};
declare type SPLCreateBuildSwap = CreateOrder & {};
declare type SPLSwapTransaction = {
    setupTransaction?: string;
    swapTransaction: string;
    cleanupTransaction?: string;
};
declare type SPLBuildSwapTransaction = {
    inAmount: string;
    outAmount: string;
    transaction: SPLSwapTransaction;
};
declare type BSCSwapOrderRequest = SwapOrderRequest & {
    slippage?: number;
    id: string;
    src_token: string;
    src_amount: string;
    src_decimals: number;
    src_usd: string;
    dest_token: string;
    dest_amount: string;
    dest_decimals: number;
    dest_usd: string;
    gas_cost_usd: string;
    gas_cost: string;
    expired_at: string;
    updated_at: string;
    created_at: string;
    token_transfer_proxy: string;
    network: string;
};
declare type ETHSwapOrderRequest = BSCSwapOrderRequest;
declare type SPLSwapOrderRequest = BSCSwapOrderRequest & {
    transaction: SPLSwapTransaction;
};
declare type SwapConfig = {
    cluster: 'devnet' | 'testnet' | 'mainnet-beta';
    fee: Fee;
    slippage?: number;
};
declare type Fee = {
    feeOwner: string;
    fee: number;
};
declare type SwapOrder = {
    inputToken: SPLToken;
    outputToken: SPLToken;
    amount: number;
    slippage?: number;
};
declare type AggParams = {
    user: Wallet;
};
declare type SwapRequest = {
    aggregator: any;
    routes: any;
};
declare type SwapResponse = {
    tx?: string;
    inputAddress?: string;
    outputAddress?: string;
    inputAmount?: number;
    outputAmount?: number;
};

declare abstract class Swap {
    protected _network: Network;
    protected _endpoint: string;
    constructor(network: Network, endpoint: string, version?: string);
    get network(): Network;
    get endpoint(): string;
    set endpoint(endpoint: string);
    createSwapOrder(swapRequest: CreateOrder): Promise<SwapOrderRequest>;
    swapToken(swapRequest: SwapOrderRequest, wallet: Wallet): Promise<any | null>;
}

declare class BSCSwap extends Swap {
    private _createOrderApi;
    private _buildTransApi;
    constructor(network: BSCNetwork, endpoint: string);
    set endpoint(endpoint: string);
    get endpoint(): string;
    set api(params: SetApiParams);
    /**
     *
     * @param swapRequest
     * @returns
     */
    createSwapOrder(swapRequest: CreateOrder): Promise<BSCSwapOrderRequest | any>;
    /**
     *
     * @param swapRequest
     * @param wallet
     * @returns
     */
    swapToken(swapRequest: BSCSwapOrderRequest, wallet: ETHWallet): Promise<string>;
}

declare class ETHSwap extends Swap {
    private _createOrderApi;
    private _buildTransApi;
    constructor(network: ETHNetwork, endpoint: string);
    set endpoint(endpoint: string);
    get endpoint(): string;
    set api(params: SetApiParams);
    /**
     *
     * @param swapRequest
     * @returns
     */
    createSwapOrder(swapRequest: CreateOrder): Promise<ETHSwapOrderRequest>;
    /**
     *
     * @param swapRequest
     * @param wallet
     * @returns
     */
    swapToken(swapRequest: ETHSwapOrderRequest, wallet: ETHWallet): Promise<string>;
}

declare class SPLSwap extends Swap {
    private _createOrderApi;
    private _buildTransApi;
    constructor(network: SPLNetwork, endpoint: string);
    set endpoint(endpoint: string);
    get endpoint(): string;
    set api(params: SetApiParams);
    /**
     *
     * @param swapRequest
     * @returns
     */
    createSwapOrder(swapRequest: CreateOrder): Promise<SPLSwapOrderRequest>;
    /**
     *
     * @param swapRequest
     * @param wallet
     * @returns
     */
    swapToken(swapRequest: SPLSwapOrderRequest, wallet: SPLWallet): Promise<string>;
}

export { AggParams, BSCSwap, BSCSwapOrderRequest, CreateOrder, ETHSwap, ETHSwapOrderRequest, Fee, SPLBuildSwapTransaction, SPLCreateBuildSwap, SPLSwap, SPLSwapOrderRequest, SPLSwapTransaction, SetApiParams, Swap, SwapConfig, SwapOrder, SwapOrderRequest, SwapRequest, SwapResponse };