@7kprotocol/sdk-ts 3.6.1-beta.0 → 3.6.1-beta.2

package/dist/index.d.mts

@@ -0,0 +1,536 @@
+import { SourceDex, QuoteResponse } from '@bluefin-exchange/bluefin7k-aggregator-sdk';
+import { PreSwapLpChangeParams, RouterDataV3 } from '@cetusprotocol/aggregator-sdk';
+import { Protocol, AggregatorQuoter } from '@flowx-finance/sdk';
+import { GasCostSummary, SuiClient, GetTransactionBlockParams, SuiTransactionBlockResponse } from '@mysten/sui/client';
+import { SignatureWithBytes } from '@mysten/sui/cryptography';
+import { Transaction, TransactionObjectArgument } from '@mysten/sui/transactions';
+
+/**
+ * Swap mode options
+ */
+type SwapMode = "exactIn" | "exactOut";
+/**
+ * Token information
+ */
+interface OkxTokenInfo {
+    /** Token contract address */
+    tokenContractAddress: string;
+    /** Token symbol (e.g., "USDC") */
+    tokenSymbol: string;
+    /** Token unit price in USD (may be null for special cases) */
+    tokenUnitPrice: string | null;
+    /** Decimal number defining smallest unit */
+    decimal: string;
+    /** Whether the token is a honeypot token */
+    isHoneyPot: boolean;
+    /** Token tax rate (0-1, where 0.01 = 1%) */
+    taxRate: string;
+}
+/**
+ * DEX Protocol information
+ */
+interface OkxDexProtocol {
+    /** Name of the liquidity protocol (e.g., "Uniswap V3") */
+    dexName: string;
+    /** Percentage of assets handled by the protocol */
+    percent: string;
+}
+/**
+ * Sub-router information
+ */
+interface OkxSubRouter {
+    /** Liquidity protocol used on the path */
+    dexProtocol: OkxDexProtocol;
+    /** Index of the from token */
+    fromTokenIndex: string;
+    /** Index of the to token */
+    toTokenIndex: string;
+    /** Information of token to be sold */
+    fromToken: OkxTokenInfo;
+    /** Information of token to be bought */
+    toToken: OkxTokenInfo;
+}
+/**
+ * Quote comparison information
+ */
+interface OkxQuoteCompare {
+    /** DEX name of the quote route */
+    dexName: string;
+    /** DEX logo of the quote route */
+    dexLogo: string;
+    /** Estimated network fee (USD) of the quote route */
+    tradeFee: string;
+    /** Received amount of the quote route */
+    amountOut: string;
+    /** Price impact percentage */
+    priceImpactPercentage: string;
+}
+/**
+ * Transaction data model
+ */
+interface OkxTransactionData {
+    /** Additional signing data (if required). When tips is specified, represents calldata of jito tips transfer */
+    signatureData?: string[];
+    /** User's wallet address */
+    from: string;
+    /** Estimated amount of the gas limit (increase by 50% for accurate data) */
+    gas: string;
+    /** Gas price in wei */
+    gasPrice?: string;
+    /** EIP-1559: Recommended priority cost of gas per unit */
+    maxPriorityFeePerGas?: string;
+    /** The contract address of OKX DEX router */
+    to: string;
+    /** The amount of native tokens (in wei) to be sent to the contract */
+    value: string;
+    /** The maximum amount of a token to spend when price reaches upper limit of slippage (applies to exactOut mode) */
+    maxSpendAmount?: string;
+    /** The minimum amount of a token to buy when price reaches upper limit of slippage */
+    minReceiveAmount: string;
+    /** Call data */
+    data: string;
+    /** Current transaction slippage value */
+    slippagePercent: string;
+}
+/**
+ * Router result data
+ */
+interface OkxRouterResult {
+    /** Unique identifier for the chain */
+    chainIndex: string;
+    /** Context slot (for Solana) */
+    contextSlot?: number;
+    /** Quote path data set - array of sub-routers */
+    dexRouterList: OkxSubRouter[];
+    /** Estimated gas consumption in smallest units (e.g., wei) */
+    estimateGasFee: string;
+    /** Information of token to be sold */
+    fromToken: OkxTokenInfo;
+    /** The input amount of a token to be sold */
+    fromTokenAmount: string;
+    /** Price impact percentage = (Received value – Paid value) / Paid value. Can be positive if received value exceeds paid value */
+    priceImpactPercent: string;
+    /** Router identifier */
+    router: string;
+    /** Swap mode: "exactIn" or "exactOut" */
+    swapMode: SwapMode;
+    /** Information of token to be bought */
+    toToken: OkxTokenInfo;
+    /** The resulting amount of a token to be bought */
+    toTokenAmount: string;
+    /** Estimated network fee (USD) of the quote route */
+    tradeFee: string;
+    /** Comparison of quote routes */
+    quoteCompareList?: OkxQuoteCompare[];
+}
+/**
+ * Swap API Response Data
+ */
+interface OkxSwapResponseData {
+    /** Quote path data */
+    routerResult: OkxRouterResult;
+    /** Contract data model */
+    tx: OkxTransactionData;
+}
+
+declare enum EProvider {
+    BLUEFIN7K = "bluefin7k",
+    CETUS = "cetus",
+    FLOWX = "flowx",
+    OKX = "okx"
+}
+type ProviderBaseOptions = {
+    api?: string;
+    apiKey?: string;
+    disabled?: boolean;
+};
+type Bluefin7kProviderOptions = ProviderBaseOptions & {
+    sources?: SourceDex[];
+    excludedPools?: string[];
+    targetPools?: string[];
+};
+type FlowxProviderOptions = ProviderBaseOptions & {
+    sources?: Protocol[];
+    excludePools?: string[];
+    excludeSources?: Protocol[];
+    maxHops?: number;
+    splitDistributionPercent?: number;
+};
+type CetusProviderOptions = ProviderBaseOptions & {
+    sources?: string[];
+    splitCount?: number;
+    splitAlgorithm?: string;
+    splitFactor?: number;
+    depth?: number;
+    liquidityChanges?: PreSwapLpChangeParams[];
+};
+type OkxProviderOptions = Required<Omit<ProviderBaseOptions, "api">> & {
+    api?: string;
+    secretKey: string;
+    apiPassphrase: string;
+    projectId: string;
+};
+interface MetaAgOptions {
+    /**If not specified, all providers will be used */
+    providers?: {
+        [EProvider.BLUEFIN7K]?: Bluefin7kProviderOptions;
+        [EProvider.FLOWX]?: FlowxProviderOptions;
+        [EProvider.CETUS]?: CetusProviderOptions;
+        [EProvider.OKX]?: OkxProviderOptions;
+    };
+    /**Mainnet Json Rpc url, if not specified, the default mainnet url will be used */
+    fullnodeUrl?: string;
+    /**Hermes Api url, if not specified, the default hermes api url will be used */
+    hermesApi?: string;
+    /**Address to receive commission, if not specified, the commission will not be used */
+    partner?: string;
+    /**@default 0 */
+    partnerCommissionBps?: number;
+    /**@default 100 */
+    slippageBps?: number;
+    /**
+     * Tip to support 7k
+     * @default 0 */
+    tipBps?: number;
+}
+interface MetaQuoteOptions {
+    coinTypeIn: string;
+    coinTypeOut: string;
+    amountIn: string;
+    /** Required for api-tx providers (ie: Okx) */
+    signer?: string;
+    /**
+     * Timeout for quote operation in milliseconds
+     * @default 2000ms
+     */
+    timeout?: number;
+}
+interface MetaSimulationOptions {
+    sender: string;
+    /**
+     * Timeout for simulation operation in milliseconds
+     * @default 2000ms
+     */
+    timeout?: number;
+    /** If specify, defer the simulation that could reduce the time to display quote result, you must update the quote via the id on callback
+     * else await all quote and simulation before return
+     */
+    onSimulated?: (payload: MetaQuote) => void;
+}
+interface MetaFastSwapOptions {
+    /** Quote object from the quote operation */
+    quote: MetaQuote;
+    /** Signer address (owner of `coinIn`) */
+    signer: string;
+    /** If true, use the gas coin for the swap
+     * @default true */
+    useGasCoin?: boolean;
+    /**
+     * Sign the transaction bytes
+     * @param txBytes - base64 transaction bytes
+     * @returns - signature with bytes
+     */
+    signTransaction: (txBytes: string) => Promise<SignatureWithBytes>;
+}
+interface MetaSwapOptions {
+    /** Quote object from the quote operation */
+    quote: MetaQuote;
+    /** Signer address (owner of `coinIn`) */
+    signer: string;
+    /** Transaction object to add the swap operation */
+    tx: Transaction;
+    /**
+     * Coin object used for the swap, must be consumed completely, no `coinIn` left, user must pass the coinIn object with the balance required for the swap - ie in quote `amountIn`
+     * @warning `coinIn` value must match the quote `amountIn` */
+    coinIn: TransactionObjectArgument;
+}
+type FlowxQuoteResponse = Awaited<ReturnType<AggregatorQuoter["getRoutes"]>>;
+type MetaQuote = ({
+    provider: EProvider.BLUEFIN7K;
+    quote: QuoteResponse;
+} | {
+    provider: EProvider.CETUS;
+    quote: RouterDataV3;
+} | {
+    provider: EProvider.FLOWX;
+    quote: FlowxQuoteResponse;
+} | {
+    provider: EProvider.OKX;
+    quote: OkxSwapResponseData;
+}) & {
+    /** uuid to keep track the quote result, used to apply simulation result on quote on callback `onSimulated`*/
+    id: string;
+    /** coin type: ie 0x2::sui::SUI */
+    coinTypeIn: string;
+    /** coin type: ie 0x2::sui::SUI */
+    coinTypeOut: string;
+    /** Amount in as u64 */
+    amountIn: string;
+    /** Amount out as u64 if there're no commission be applied to the amount out */
+    rawAmountOut: string;
+    /** Amount as u64 after minus any commission kind */
+    amountOut: string;
+    /** Simulated amount out if the transaction is executed */
+    simulatedAmountOut?: string;
+    /** Estimate gas consumption if the transaction is executed */
+    gasUsed?: GasCostSummary;
+};
+interface QuoteProvider {
+    readonly kind: EProvider;
+    quote(_quoteOptions: MetaQuoteOptions): Promise<MetaQuote | null>;
+}
+interface SwapAPIProvider extends QuoteProvider {
+    readonly kind: EProvider.OKX;
+    fastSwap(options: MetaFastSwapOptions): Promise<string>;
+}
+interface AggregatorProvider extends QuoteProvider {
+    readonly kind: EProvider.BLUEFIN7K | EProvider.CETUS | EProvider.FLOWX;
+    swap(options: MetaSwapOptions): Promise<TransactionObjectArgument>;
+}
+declare const isAggregatorProvider: (provider: QuoteProvider) => provider is AggregatorProvider;
+declare const isSwapAPIProvider: (provider: QuoteProvider) => provider is SwapAPIProvider;
+
+declare class MetaAg {
+    client: SuiClient;
+    private providers;
+    private inspector;
+    private options;
+    constructor(options?: MetaAgOptions);
+    private _getProvider;
+    private _simulate;
+    private _quote;
+    private _fastSwap;
+    /**
+     * Get quotes from all providers
+     * @param options - quote options
+     * @param simulation - if present, the quote will be simulated
+     * @returns quotes from all providers
+     */
+    quote(options: MetaQuoteOptions, simulation?: MetaSimulationOptions): Promise<MetaQuote[]>;
+    /**
+     * Build transaction from quote
+     * @info Use this function to build composable transaction (ie: add more commands after the swap, consume the coin out object)
+     * @warning Providers that build transaction on the fly (typically RFQ, Swap-API providers ie: Okx, ...) are not supported, please use `fastSwap` instead
+     * @param options - build tx options
+     * @param slippageBps - slippage bps if not specified, fallback to global slippage bps, if none of them specified, default to 100
+     * @returns coin out object, you must consume it by transferObjects, or other sub sequence commands
+     */
+    swap(options: MetaSwapOptions, slippageBps?: number): Promise<TransactionObjectArgument>;
+    /**
+     * Build, Sign, and Execute transaction in one step
+     * @param options - fast swap options
+     * @returns - txDigest of the transaction
+     */
+    fastSwap(options: MetaFastSwapOptions, getTransactionBlockParams?: Omit<GetTransactionBlockParams, "digest">): Promise<SuiTransactionBlockResponse>;
+    /**
+     * Update meta aggregator options
+     * @param options - update options payload
+     */
+    updateMetaAgOptions(options: MetaAgOptions): void;
+}
+
+/**
+ * Get price for a single token
+ * @param id - Token ID (coin type)
+ * @returns Token price, or 0 if not found or on error
+ */
+declare function getTokenPrice(id: string): Promise<number>;
+/**
+ * Get prices for multiple tokens
+ * @param ids - Array of token IDs (coin types)
+ * @returns Record mapping token IDs to their prices
+ */
+declare function getTokenPrices(ids: string[]): Promise<Record<string, number>>;
+/**
+ * Get the current SUI token price
+ * @returns SUI price, or 0 if not found or on error
+ */
+declare function getSuiPrice(): Promise<number>;
+
+interface PlaceLimitOrderParams {
+    accountAddress: string;
+    payCoinType: string;
+    targetCoinType: string;
+    payCoinAmount: bigint;
+    rate: bigint;
+    slippage: bigint;
+    expireTs: bigint;
+    devInspect?: boolean;
+}
+declare function placeLimitOrder({ accountAddress, payCoinType, targetCoinType, payCoinAmount, rate, slippage, expireTs, devInspect, }: PlaceLimitOrderParams): Promise<Transaction>;
+
+interface CancelLimitOrderParams {
+    orderId: string;
+    payCoinType: string;
+    targetCoinType: string;
+}
+declare function cancelLimitOrder({ orderId, payCoinType, targetCoinType, }: CancelLimitOrderParams): Promise<Transaction>;
+
+interface ClaimExpiredLimitOrderParams {
+    orderId: string;
+    payCoinType: string;
+    targetCoinType: string;
+}
+declare function claimExpiredLimitOrder({ orderId, payCoinType, targetCoinType, }: ClaimExpiredLimitOrderParams): Promise<Transaction>;
+
+declare enum LoDcaOrderStatus {
+    PENDING = "PENDING",
+    ACTIVE = "ACTIVE",
+    EXPIRED = "EXPIRED",
+    CANCELED = "CANCELED"
+}
+interface LimitOrder {
+    id: number;
+    createdAt: string;
+    updatedAt: string;
+    softDeleteAt: string;
+    orderId: string;
+    owner: string;
+    payCoinName: string;
+    targetCoinName: string;
+    totalPayAmount: string;
+    paidAmount: string;
+    obtainedAmount: string;
+    claimedAmount: string;
+    targetBalance: string;
+    createdTs: number;
+    expireTs: number;
+    canceledTs: number;
+    lastExecutedTs: number;
+    status: LoDcaOrderStatus;
+    payBalance: string;
+    rate: string;
+    slippageBps: string;
+    filled: number;
+    volume: number;
+    digest: string | null;
+}
+interface DcaOrder {
+    id: number;
+    createdAt: string;
+    updatedAt: string;
+    softDeletedAt: string;
+    orderId: string;
+    owner: string;
+    payCoinName: string;
+    targetCoinName: string;
+    totalPayAmount: string;
+    paidAmount: string;
+    obtainedAmount: string;
+    claimedAmount: string;
+    targetBalance: string;
+    createdTs: number;
+    expireTs: number;
+    canceledTs: number;
+    status: LoDcaOrderStatus;
+    slippage: number;
+    minRate: string;
+    maxRate: string;
+    amountPerOrder: string;
+    interval: number;
+    filled: number;
+    volume: number;
+    digest: string | null;
+    numOrders: number;
+}
+declare enum LoDcaOrderExecutionStatus {
+    PENDING = "PENDING",
+    SUCCESS = "SUCCESS",
+    FAILED = "FAILED"
+}
+interface LoDcaOrderExecution {
+    id: number;
+    createdAt: string;
+    updatedAt: string;
+    softDeletedAt: null;
+    orderId: string;
+    digest: string;
+    payCoinName: string;
+    targetCoinName: string;
+    payAmount: string;
+    repayAmount: string;
+    obtainedAmount: string;
+    executedTs: number;
+    slippage: number;
+    status: LoDcaOrderExecutionStatus;
+    orderType: string;
+    volume: number | null;
+}
+
+interface Params$4 {
+    owner: string;
+    offset: number;
+    limit: number;
+    tokenPair?: string;
+}
+declare function getOpenLimitOrders({ owner, offset, limit, tokenPair, }: Params$4): Promise<LimitOrder[]>;
+
+interface Params$3 {
+    owner: string;
+    offset: number;
+    limit: number;
+    tokenPair?: string;
+}
+declare function getClosedLimitOrders({ owner, offset, limit, tokenPair, }: Params$3): Promise<LimitOrder[]>;
+
+interface PlaceDcaOrderParams {
+    payCoinType: string;
+    targetCoinType: string;
+    payCoinAmountEach: bigint;
+    numOrders: number;
+    interval: number;
+    slippage: bigint;
+    minRate: bigint;
+    maxRate: bigint;
+}
+declare function placeDcaOrder({ payCoinType, targetCoinType, payCoinAmountEach, numOrders, interval, slippage, minRate, maxRate, }: PlaceDcaOrderParams): Promise<Transaction>;
+
+interface CancelDcaOrderParams {
+    orderId: string;
+    payCoinType: string;
+    targetCoinType: string;
+}
+declare function cancelDcaOrder({ orderId, payCoinType, targetCoinType, }: CancelDcaOrderParams): Promise<Transaction>;
+
+interface Params$2 {
+    owner: string;
+    offset: number;
+    limit: number;
+    tokenPair?: string;
+}
+declare function getOpenDcaOrders({ owner, offset, limit, tokenPair, }: Params$2): Promise<DcaOrder[]>;
+
+interface Params$1 {
+    owner: string;
+    offset: number;
+    limit: number;
+    tokenPair?: string;
+}
+declare function getClosedDcaOrders({ owner, offset, limit, tokenPair, }: Params$1): Promise<LoDcaOrderExecution[]>;
+
+interface Params {
+    owner: string;
+    orderId: string;
+    offset: number;
+    limit: number;
+}
+declare function getDcaOrderExecutions({ owner, orderId, offset, limit, }: Params): Promise<LoDcaOrderExecution[]>;
+
+declare const _default: {
+    getTokenPrice: typeof getTokenPrice;
+    getTokenPrices: typeof getTokenPrices;
+    getSuiPrice: typeof getSuiPrice;
+    placeLimitOrder: typeof placeLimitOrder;
+    getOpenLimitOrders: typeof getOpenLimitOrders;
+    cancelLimitOrder: typeof cancelLimitOrder;
+    claimExpiredLimitOrder: typeof claimExpiredLimitOrder;
+    getClosedLimitOrders: typeof getClosedLimitOrders;
+    placeDcaOrder: typeof placeDcaOrder;
+    getOpenDcaOrders: typeof getOpenDcaOrders;
+    cancelDcaOrder: typeof cancelDcaOrder;
+    getClosedDcaOrders: typeof getClosedDcaOrders;
+    getDcaOrderExecutions: typeof getDcaOrderExecutions;
+    MetaAg: typeof MetaAg;
+};
+
+export { type AggregatorProvider, type Bluefin7kProviderOptions, type CetusProviderOptions, EProvider, type FlowxProviderOptions, type FlowxQuoteResponse, MetaAg, type MetaAgOptions, type MetaFastSwapOptions, type MetaQuote, type MetaQuoteOptions, type MetaSimulationOptions, type MetaSwapOptions, type OkxProviderOptions, type QuoteProvider, type SwapAPIProvider, cancelDcaOrder, cancelLimitOrder, claimExpiredLimitOrder, _default as default, getClosedDcaOrders, getClosedLimitOrders, getDcaOrderExecutions, getOpenDcaOrders, getOpenLimitOrders, getSuiPrice, getTokenPrice, getTokenPrices, isAggregatorProvider, isSwapAPIProvider, placeDcaOrder, placeLimitOrder };