@cetusprotocol/aggregator-sdk 0.0.0-experimental-20240719182939

package/dist/src/client.d.ts

@@ -0,0 +1,88 @@
+import type { AggregatorConfig } from "./config";
+import Decimal from "decimal.js";
+import { CoinAsset } from "./types/sui";
+import { Transaction } from "@mysten/sui/transactions";
+import { Signer } from "@mysten/sui/dist/cjs/cryptography";
+import BN from "bn.js";
+export type ExtendedDetails = {
+    aftermathPoolFlatness?: number;
+    aftermathLpSupplyType?: string;
+    turbosFeeType?: string;
+};
+export type Path = {
+    id: string;
+    a2b: boolean;
+    provider: string;
+    from: string;
+    target: string;
+    feeRate: number;
+    amountIn: number;
+    amountOut: number;
+    extendedDetails?: ExtendedDetails;
+    version?: string;
+};
+export type Router = {
+    path: Path[];
+    amountIn: BN;
+    amountOut: BN;
+    initialPrice: Decimal;
+};
+export type RouterData = {
+    amountIn: BN;
+    amountOut: BN;
+    routes: Router[];
+    insufficientLiquidity: boolean;
+};
+export type AggregatorResponse = {
+    code: number;
+    msg: string;
+    data: RouterData;
+};
+export type BuildRouterSwapParams = {
+    routers: Router[];
+    amountIn: BN;
+    amountOut: BN;
+    byAmountIn: boolean;
+    slippage: number;
+    fromCoinType: string;
+    targetCoinType: string;
+    partner?: string;
+    isMergeTragetCoin?: boolean;
+    refreshAllCoins?: boolean;
+};
+export interface FindRouterParams {
+    from: string;
+    target: string;
+    amount: BN;
+    byAmountIn: boolean;
+    depth: number | null;
+    splitAlgorithm: string | null;
+    splitFactor: number | null;
+    splitCount: number | null;
+    providers: string[] | null;
+}
+export interface SwapInPoolsParams {
+    from: string;
+    target: string;
+    amount: BN;
+    byAmountIn: boolean;
+    pools: string[];
+}
+export interface SwapInPoolsResult {
+    isExceed: boolean;
+    routeData?: RouterData;
+}
+export declare class AggregatorClient {
+    private config;
+    private wallet;
+    private client;
+    private allCoins;
+    constructor(config: AggregatorConfig);
+    getAllCoins(): Promise<CoinAsset[]>;
+    findRouter(fromRouterParams: FindRouterParams): Promise<RouterData | null>;
+    swapInPools(params: SwapInPoolsParams): Promise<SwapInPoolsResult | null>;
+    routerSwap(params: BuildRouterSwapParams): Promise<Transaction>;
+    signAndExecuteTransaction(txb: Transaction, signer: Signer): Promise<import("@mysten/sui/client").SuiTransactionBlockResponse>;
+    devInspectTransactionBlock(txb: Transaction, signer: Signer): Promise<import("@mysten/sui/client").DevInspectResults>;
+    sendTransaction(txb: Transaction, signer: Signer): Promise<import("@mysten/sui/client").SuiTransactionBlockResponse>;
+}

package/dist/src/config.d.ts

@@ -0,0 +1,26 @@
+export type Package = {
+    packageName: string;
+    packageId: string;
+    publishedAt: string;
+};
+export declare enum ENV {
+    MAINNET = 0,
+    TESTNET = 1
+}
+export declare class AggregatorConfig {
+    private aggregatorUrl;
+    private fullNodeUrl;
+    private wallet;
+    private packages;
+    private env;
+    constructor(aggregatorUrl: string, fullNodeUrl: string, wallet: string, packages: Package[], env: ENV);
+    getAggregatorUrl(): string;
+    getFullNodeUrl(): string;
+    getWallet(): string;
+    getENV(): ENV;
+    getPackages(): Package[];
+    getPackage(packageName: string): Package | undefined;
+    addPackage(newPackage: Package): void;
+    removePackageById(packageId: string): void;
+    findPackageById(packageId: string): Package | undefined;
+}

package/dist/src/const.d.ts

@@ -0,0 +1,75 @@
+import BN from "bn.js";
+/**
+ * The address representing the clock in the system.
+ */
+export declare const CLOCK_ADDRESS = "0x0000000000000000000000000000000000000000000000000000000000000006";
+/**
+ * The address for CoinInfo module.
+ */
+export declare const CoinInfoAddress = "0x1::coin::CoinInfo";
+/**
+ * The address for CoinStore module.
+ */
+export declare const CoinStoreAddress = "0x1::coin::CoinStore";
+export declare const SuiZeroCoinFn = "0x2::coin::zero";
+export declare const AGGREGATOR = "aggregator";
+export declare const CETUS_DEX = "CETUS";
+export declare const DEEPBOOK_DEX = "DEEPBOOK";
+export declare const KRIYA_DEX = "KRIYA";
+export declare const FLOWX_AMM = "FLOWX";
+export declare const TURBOS_DEX = "TURBOS";
+export declare const AFTERMATH_AMM = "AFTERMATH";
+export declare const INTEGRATE = "integrate";
+export declare const CETUS_MODULE = "cetus";
+export declare const DEEPBOOK_MODULE = "deepbook";
+export declare const KRIYA_MODULE = "kriya";
+export declare const UTILS_MODULE = "utils";
+export declare const POOL_MODULT = "pool";
+export declare const PAY_MODULE = "pay";
+export declare const FLOWX_AMM_MODULE = "flowx_amm";
+export declare const TURBOS_MODULE = "turbos";
+export declare const AFTERMATH_MODULE = "aftermath";
+export declare const DEEPBOOK_CUSTODIAN_V2_MODULE = "custodian_v2";
+export declare const DEEPBOOK_CLOB_V2_MODULE = "clob_v2";
+export declare const FlashSwapFunc = "flash_swap";
+export declare const FlashSwapWithPartnerFunc = "flash_swap_with_partner";
+export declare const RepayFalshSwapFunc = "repay_flash_swap";
+export declare const RepayFlashSwapWithPartnerFunc = "repay_flash_swap_with_partner";
+export declare const FlashSwapA2BFunc = "flash_swap_a2b";
+export declare const FlashSwapB2AFunc = "flash_swap_b2a";
+export declare const FlashSwapWithPartnerA2BFunc = "flash_swap_with_partner_a2b";
+export declare const FlashSwapWithPartnerB2AFunc = "flash_swap_with_partner_b2a";
+export declare const REPAY_FLASH_SWAP_A2B_FUNC = "repay_flash_swap_a2b";
+export declare const REPAY_FLASH_SWAP_B2A_FUNC = "repay_flash_swap_b2a";
+export declare const REPAY_FLASH_SWAP_WITH_PARTNER_A2B_FUNC = "repay_flash_swap_with_partner_a2b";
+export declare const REPAY_FLASH_SWAP_WITH_PARTNER_B2A_FUNC = "repay_flash_swap_with_partner_b2a";
+export declare const SWAP_A2B_FUNC = "swap_a2b";
+export declare const SWAP_B2A_FUNC = "swap_b2a";
+export declare const TRANSFER_OR_DESTORY_COIN_FUNC = "transfer_or_destroy_coin";
+export declare const CHECK_COINS_THRESHOLD_FUNC = "check_coins_threshold";
+export declare const JOIN_FUNC = "join_vec";
+export declare const TRANSFER_ACCOUNT_CAP = "transfer_account_cap";
+export declare const DEEPBOOK_PACKAGE_ID = "0x000000000000000000000000000000000000000000000000000000000000dee9";
+export declare const DEEPBOOK_PUBLISHED_AT = "0x000000000000000000000000000000000000000000000000000000000000dee9";
+export declare const CETUS_PUBLISHED_AT = "0x70968826ad1b4ba895753f634b0aea68d0672908ca1075a2abdf0fc9e0b2fc6a";
+export declare const MAINNET_CETUS_GLOBAL_CONFIG_ID = "0xdaa46292632c3c4d8f31f23ea0f9b36a28ff3677e9684980e4438403a67a3d8f";
+export declare const TESTNET_CETUS_GLOBAL_CONFIG_ID = "0x6f4149091a5aea0e818e7243a13adcfb403842d670b9a2089de058512620687a";
+export declare const ZERO: BN;
+export declare const ONE: BN;
+export declare const TWO: BN;
+export declare const U128: BN;
+export declare const U64_MAX_BN: BN;
+export declare const U64_MAX = "18446744073709551615";
+export declare const MAINNET_FLOWX_AMM_CONTAINER_ID = "0xb65dcbf63fd3ad5d0ebfbf334780dc9f785eff38a4459e37ab08fa79576ee511";
+export declare const TESTNET_FLOWX_AMM_CONTAINER_ID = "";
+export declare const TURBOS_VERSIONED = "0xf1cf0e81048df168ebeb1b8030fad24b3e0b53ae827c25053fff0779c1445b6f";
+export declare const MAINNET_AFTERMATH_REGISTRY_ID = "0xfcc774493db2c45c79f688f88d28023a3e7d98e4ee9f48bbf5c7990f651577ae";
+export declare const TESTNET_AFTERMATH_REGISTRY_ID = "";
+export declare const MAINNET_AFTERMATH_PROTOCOL_FEE_VAULT_ID = "0xf194d9b1bcad972e45a7dd67dd49b3ee1e3357a00a50850c52cd51bb450e13b4";
+export declare const TESTNET_AFTERMATH_PROTOCOL_FEE_VAULT_ID = "";
+export declare const MAINNET_AFTERMATH_TREASURY_ID = "0x28e499dff5e864a2eafe476269a4f5035f1c16f338da7be18b103499abf271ce";
+export declare const TESTNET_AFTERMATH_TREASURY_ID = "";
+export declare const MAINNET_AFTERMATH_INSURANCE_FUND_ID = "0xf0c40d67b078000e18032334c3325c47b9ec9f3d9ae4128be820d54663d14e3b";
+export declare const TESTNET_AFTERMATH_INSURANCE_FUND_ID = "";
+export declare const MAINNET_AFTERMATH_REFERRAL_VAULT_ID = "0x35d35b0e5b177593d8c3a801462485572fc30861e6ce96a55af6dc4730709278";
+export declare const TESTNET_AFTERMATH_REFERRAL_VAULT_ID = "";

package/dist/src/errors.d.ts

@@ -0,0 +1,31 @@
+export declare enum TypesErrorCode {
+    InvalidType = "InvalidType"
+}
+export declare enum ConfigErrorCode {
+    MissAggregatorPackage = "MissAggregatorPackage",
+    MissGlobalConfig = "MissGlobalConfig",
+    InvalidWallet = "InvalidWallet",
+    SimulateError = "SimulateError"
+}
+export declare enum TransactionErrorCode {
+    InsufficientBalance = "InsufficientBalance",
+    SimulateEventError = "simulateEventError",
+    CannotGetDecimals = "CannotGetDecimals",
+    MissCoinA = "MissCoinA",
+    MissCoinB = "MissCoinB",
+    MissTurbosFeeType = "MissTurbosFeeType",
+    MissAftermathLpSupplyType = "MissAftermathLpSupplyType"
+}
+export type AggregatorErrorCode = TypesErrorCode;
+/**
+ * AggregatorError is a custom error class that extends the built-in Error class. It is used to represent errors that occur during aggregation operations.
+ * The key functionality of this code includes:
+ * - Defining the AggregatorError class that represents an error during aggregation. It includes a message property and an optional errorCode property.
+ * - Providing a static method isAggregatorErrorCode() that checks if a given error instance is an instance of AggregatorError and has a specific error code.
+ */
+export declare class AggregatorError extends Error {
+    message: string;
+    errorCode?: AggregatorErrorCode;
+    constructor(message: string, errorCode?: AggregatorErrorCode);
+    static isAggregatorErrorCode(e: any, code: AggregatorErrorCode): boolean;
+}

package/dist/src/index.d.ts

@@ -0,0 +1,5 @@
+export * from './client';
+export * from './transaction';
+export * from './config';
+export * from './utils';
+export * from './const';

package/dist/src/math.d.ts

@@ -0,0 +1,5 @@
+import BN from "bn.js";
+import Decimal from "decimal.js";
+export declare function CalculateAmountLimit(expectAmount: BN, byAmountIn: boolean, slippage: number): number;
+export declare function GetDefaultSqrtPriceLimit(a2b: boolean): BN;
+export declare function sqrtPriceX64ToPrice(sqrtPriceStr: string, decimalsA: number, decimalsB: number): Decimal;

package/dist/src/test_data.test.d.ts

@@ -0,0 +1,8 @@
+export declare const T_USDC = "";
+export declare const M_USDC = "0x5d4b302506645c37ff133b98c4b50a5ae14841659738d6d733d59d0d217a93bf::coin::COIN";
+export declare const M_CETUS = "0x06864a6f921804860930db6ddbe2e16acdf8504495ea7481637a1c8b9a8fe54b::cetus::CETUS";
+export declare const M_NAVI = "0xa99b8952d4f7d947ea77fe0ecdcc9e5fc0bcab2841d6e2a5aa00c3044e5544b5::navx::NAVX";
+export declare const M_SUI = "0x2::sui::SUI";
+export declare const M_VSUI = "0x549e8b69270defbfafd4f94e17ec44cdbdd99820b33bda2278dea3b9a32d3f55::cert::CERT";
+export declare const M_VAPOR = "0xa1f2c11169f32165ad4efb4468ec5bdfc880cd66b22094024b32ab7b76d14d30::vapor::VAPOR";
+export declare const M_HASUI = "0xbde4ba4c2e274a60ce15c1cfff9e5c42e41654ac8b6d906a57efa4bd3c29f47d::hasui::HASUI";

package/dist/src/transaction/aftermath.d.ts

@@ -0,0 +1,24 @@
+import { TransactionArgument, Transaction, TransactionObjectArgument } from "@mysten/sui/transactions";
+import { AggregatorConfig } from "../config";
+export type AftermathSwapParams = {
+    poolId: string;
+    amount: TransactionArgument;
+    amountOut: number;
+    amountLimit: number;
+    a2b: boolean;
+    byAmountIn: boolean;
+    coinA?: TransactionObjectArgument;
+    coinB?: TransactionObjectArgument;
+    useFullInputCoinAmount: boolean;
+    coinAType: string;
+    coinBType: string;
+    slippage: number;
+    lpSupplyType: string;
+};
+export type AftermathSwapResult = {
+    targetCoin: TransactionObjectArgument;
+    amountIn: TransactionArgument;
+    amountOut: TransactionArgument;
+    txb: Transaction;
+};
+export declare function AftermathAmmSwapMovecall(swapParams: AftermathSwapParams, txb: Transaction, config: AggregatorConfig): Promise<AftermathSwapResult>;

package/dist/src/transaction/cetus.d.ts

@@ -0,0 +1,39 @@
+import { Transaction, TransactionArgument, TransactionObjectArgument } from "@mysten/sui/transactions";
+import { AggregatorConfig } from "../config";
+import BN from "bn.js";
+export type CetusSwapParams = {
+    poolId: string;
+    amount: TransactionArgument;
+    amountLimit: string;
+    a2b: boolean;
+    byAmountIn: boolean;
+    sqrtPriceLimit: BN;
+    partner?: string;
+    coinAType: string;
+    coinBType: string;
+};
+export type CetusFlashSwapResult = {
+    targetCoin: TransactionObjectArgument;
+    flashReceipt: TransactionObjectArgument;
+    payAmount: TransactionArgument;
+    swapedAmount: TransactionArgument;
+    txb: Transaction;
+};
+export declare function cetusFlashSwapMovecall(swapParams: CetusSwapParams, txb: Transaction, config: AggregatorConfig): CetusFlashSwapResult;
+export type repayParams = {
+    poolId: string;
+    a2b: boolean;
+    coinA?: TransactionObjectArgument;
+    coinB?: TransactionObjectArgument;
+    receipt: TransactionObjectArgument;
+    coinAType: string;
+    coinBType: string;
+    partner?: string;
+};
+export type SwapResult = {
+    repayTargetCoin: TransactionObjectArgument;
+    nextInputAmount?: TransactionArgument;
+    flashTargetCoin?: TransactionObjectArgument;
+};
+export declare function cetusRepayFlashSwapMovecall(repayParams: repayParams, txb: Transaction, config: AggregatorConfig): Promise<SwapResult>;
+export declare function cetusSwapWithOutLimit(swapParams: CetusSwapParams, fromCoin: TransactionObjectArgument, txb: Transaction, config: AggregatorConfig): Promise<SwapResult>;

package/dist/src/transaction/common.d.ts

@@ -0,0 +1,12 @@
+import { CoinAsset } from "../types/sui";
+import { AggregatorConfig } from "../config";
+import { Transaction, TransactionArgument, TransactionObjectArgument } from "@mysten/sui/transactions";
+export declare function mintZeroCoin(txb: Transaction, coinType: string): TransactionObjectArgument;
+export type BuildCoinResult = {
+    targetCoin: TransactionObjectArgument;
+    isMintZeroCoin: boolean;
+    targetCoinAmount: number;
+};
+export declare function buildInputCoin(txb: Transaction, allCoins: CoinAsset[], amount: bigint, coinType: string): BuildCoinResult;
+export declare function transferOrDestoryCoin(txb: Transaction, coinObject: TransactionObjectArgument, coinType: string, config: AggregatorConfig): void;
+export declare function checkCoinThresholdAndMergeCoin(txb: Transaction, coins: TransactionObjectArgument[], coinType: string, amountLimit: number, config: AggregatorConfig): TransactionArgument;

package/dist/src/transaction/deepbook.d.ts

@@ -0,0 +1,21 @@
+import { TransactionArgument, Transaction, TransactionObjectArgument } from "@mysten/sui/transactions";
+import { AggregatorConfig } from "../config";
+import { SuiClient } from "@mysten/sui/client";
+export type DeepbookSwapParams = {
+    poolId: string;
+    a2b: boolean;
+    amount: TransactionArgument;
+    amountLimit: number;
+    coinA?: TransactionObjectArgument;
+    coinB?: TransactionObjectArgument;
+    useFullInputCoinAmount: boolean;
+    coinAType: string;
+    coinBType: string;
+};
+export type DeepbookSwapResult = {
+    targetCoin: TransactionObjectArgument;
+    amountIn: TransactionArgument;
+    amountOut: TransactionArgument;
+    txb: Transaction;
+};
+export declare function deepbookSwapMovecall(swapParams: DeepbookSwapParams, client: SuiClient, txb: Transaction, config: AggregatorConfig): Promise<DeepbookSwapResult>;

package/dist/src/transaction/flowx.d.ts

@@ -0,0 +1,20 @@
+import { TransactionArgument, Transaction, TransactionObjectArgument } from "@mysten/sui/transactions";
+import { AggregatorConfig } from "../config";
+export type FlowxSwapParams = {
+    amount: TransactionArgument;
+    amountLimit: number;
+    a2b: boolean;
+    byAmountIn: boolean;
+    coinA?: TransactionObjectArgument;
+    coinB?: TransactionObjectArgument;
+    useFullInputCoinAmount: boolean;
+    coinAType: string;
+    coinBType: string;
+};
+export type FlowxSwapResult = {
+    targetCoin: TransactionObjectArgument;
+    amountIn: TransactionArgument;
+    amountOut: TransactionArgument;
+    txb: Transaction;
+};
+export declare function flowxAmmSwapMovecall(swapParams: FlowxSwapParams, txb: Transaction, config: AggregatorConfig): Promise<FlowxSwapResult>;

package/dist/src/transaction/index.d.ts

@@ -0,0 +1 @@
+export * from "./router";

package/dist/src/transaction/kriya.d.ts

@@ -0,0 +1,21 @@
+import { TransactionArgument, Transaction, TransactionObjectArgument } from "@mysten/sui/transactions";
+import { AggregatorConfig } from "../config";
+export type KriyaSwapParams = {
+    poolId: string;
+    amount: TransactionArgument;
+    amountLimit: number;
+    a2b: boolean;
+    byAmountIn: boolean;
+    coinA?: TransactionObjectArgument;
+    coinB?: TransactionObjectArgument;
+    useFullInputCoinAmount: boolean;
+    coinAType: string;
+    coinBType: string;
+};
+export type KriyaSwapResult = {
+    targetCoin: TransactionObjectArgument;
+    amountIn: TransactionArgument;
+    amountOut: TransactionArgument;
+    txb: Transaction;
+};
+export declare function kriyaSwapMovecall(swapParams: KriyaSwapParams, txb: Transaction, config: AggregatorConfig): Promise<KriyaSwapResult>;

package/dist/src/transaction/router.d.ts

@@ -0,0 +1,6 @@
+import { Transaction, TransactionObjectArgument } from "@mysten/sui/transactions";
+import type { BuildRouterSwapParams } from "../client";
+import { AggregatorConfig } from "../config";
+import { SuiClient } from "@mysten/sui/client";
+export declare function expectInputRouterSwap(client: SuiClient, params: BuildRouterSwapParams, txb: Transaction, fromCoin: TransactionObjectArgument, config: AggregatorConfig, partner?: string): Promise<TransactionObjectArgument[]>;
+export declare function expectOutputRouterSwap(params: BuildRouterSwapParams, txb: Transaction, fromCoin: TransactionObjectArgument, config: AggregatorConfig, partner?: string): Promise<TransactionObjectArgument[]>;

package/dist/src/transaction/swap.d.ts

@@ -0,0 +1,5 @@
+import { SwapInPoolsParams } from "~/client";
+import { AggregatorConfig } from "~/config";
+import { SwapInPoolsResult } from "..";
+import { SuiClient } from "@mysten/sui/client";
+export declare function swapInPools(client: SuiClient, params: SwapInPoolsParams, config: AggregatorConfig): Promise<SwapInPoolsResult>;

package/dist/src/transaction/turbos.d.ts

@@ -0,0 +1,22 @@
+import { TransactionArgument, Transaction, TransactionObjectArgument } from "@mysten/sui/transactions";
+import { AggregatorConfig } from "../config";
+export type TurbosSwapParams = {
+    poolId: string;
+    amount: TransactionArgument;
+    amountLimit: number;
+    a2b: boolean;
+    byAmountIn: boolean;
+    coinA?: TransactionObjectArgument;
+    coinB?: TransactionObjectArgument;
+    useFullInputCoinAmount: boolean;
+    coinAType: string;
+    coinBType: string;
+    feeType: string;
+};
+export type TurbosSwapResult = {
+    targetCoin: TransactionObjectArgument;
+    amountIn: TransactionArgument;
+    amountOut: TransactionArgument;
+    txb: Transaction;
+};
+export declare function turbosSwapMovecall(swapParams: TurbosSwapParams, txb: Transaction, config: AggregatorConfig): Promise<TurbosSwapResult>;

package/dist/src/types/CoinAssist.d.ts

@@ -0,0 +1,122 @@
+import type { SuiMoveObject } from '@mysten/sui/client';
+import type { CoinAsset, SuiAddress } from './sui';
+export declare const DEFAULT_GAS_BUDGET_FOR_SPLIT = 1000;
+export declare const DEFAULT_GAS_BUDGET_FOR_MERGE = 500;
+export declare const DEFAULT_GAS_BUDGET_FOR_TRANSFER = 100;
+export declare const DEFAULT_GAS_BUDGET_FOR_TRANSFER_SUI = 100;
+export declare const DEFAULT_GAS_BUDGET_FOR_STAKE = 1000;
+export declare const GAS_TYPE_ARG = "0x2::sui::SUI";
+export declare const GAS_TYPE_ARG_LONG = "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI";
+export declare const GAS_SYMBOL = "SUI";
+export declare const DEFAULT_NFT_TRANSFER_GAS_FEE = 450;
+export declare const SUI_SYSTEM_STATE_OBJECT_ID = "0x0000000000000000000000000000000000000005";
+/**
+ * This class provides helper methods for working with coins.
+ */
+export declare class CoinUtils {
+    /**
+     * Get the coin type argument from a SuiMoveObject.
+     *
+     * @param obj The SuiMoveObject to get the coin type argument from.
+     * @returns The coin type argument, or null if it is not found.
+     */
+    static getCoinTypeArg(obj: SuiMoveObject): string | null;
+    /**
+     * Get whether a SuiMoveObject is a SUI coin.
+     *
+     * @param obj The SuiMoveObject to check.
+     * @returns Whether the SuiMoveObject is a SUI coin.
+     */
+    static isSUI(obj: SuiMoveObject): boolean;
+    /**
+     * Get the coin symbol from a coin type argument.
+     *
+     * @param coinTypeArg The coin type argument to get the symbol from.
+     * @returns The coin symbol.
+     */
+    static getCoinSymbol(coinTypeArg: string): string;
+    /**
+     * Get the balance of a SuiMoveObject.
+     *
+     * @param obj The SuiMoveObject to get the balance from.
+     * @returns The balance of the SuiMoveObject.
+     */
+    static getBalance(obj: SuiMoveObject): bigint;
+    /**
+     * Get the total balance of a list of CoinAsset objects for a given coin address.
+     *
+     * @param objs The list of CoinAsset objects to get the total balance for.
+     * @param coinAddress The coin address to get the total balance for.
+     * @returns The total balance of the CoinAsset objects for the given coin address.
+     */
+    static totalBalance(objs: CoinAsset[], coinAddress: SuiAddress): bigint;
+    /**
+     * Get the ID of a SuiMoveObject.
+     *
+     * @param obj The SuiMoveObject to get the ID from.
+     * @returns The ID of the SuiMoveObject.
+     */
+    static getID(obj: SuiMoveObject): string;
+    /**
+     * Get the coin type from a coin type argument.
+     *
+     * @param coinTypeArg The coin type argument to get the coin type from.
+     * @returns The coin type.
+     */
+    static getCoinTypeFromArg(coinTypeArg: string): string;
+    /**
+     * Get the CoinAsset objects for a given coin type.
+     *
+     * @param coinType The coin type to get the CoinAsset objects for.
+     * @param allSuiObjects The list of all SuiMoveObjects.
+     * @returns The CoinAsset objects for the given coin type.
+     */
+    static getCoinAssets(coinType: string, allSuiObjects: CoinAsset[]): CoinAsset[];
+    /**
+     * Get whether a coin address is a SUI coin.
+     *
+     * @param coinAddress The coin address to check.
+     * @returns Whether the coin address is a SUI coin.
+     */
+    static isSuiCoin(coinAddress: SuiAddress): boolean;
+    /**
+     * Select the CoinAsset objects from a list of CoinAsset objects that have a balance greater than or equal to a given amount.
+     *
+     * @param coins The list of CoinAsset objects to select from.
+     * @param amount The amount to select CoinAsset objects with a balance greater than or equal to.
+     * @param exclude A list of CoinAsset objects to exclude from the selection.
+     * @returns The CoinAsset objects that have a balance greater than or equal to the given amount.
+     */
+    static selectCoinObjectIdGreaterThanOrEqual(coins: CoinAsset[], amount: bigint, exclude?: string[]): {
+        objectArray: string[];
+        remainCoins: CoinAsset[];
+        amountArray: string[];
+    };
+    /**
+     * Select the CoinAsset objects from a list of CoinAsset objects that have a balance greater than or equal to a given amount.
+     *
+     * @param coins The list of CoinAsset objects to select from.
+     * @param amount The amount to select CoinAsset objects with a balance greater than or equal to.
+     * @param exclude A list of CoinAsset objects to exclude from the selection.
+     * @returns The CoinAsset objects that have a balance greater than or equal to the given amount.
+     */
+    static selectCoinAssetGreaterThanOrEqual(coins: CoinAsset[], amount: bigint, exclude?: string[]): {
+        selectedCoins: CoinAsset[];
+        remainingCoins: CoinAsset[];
+    };
+    /**
+     * Sort the CoinAsset objects by their balance.
+     *
+     * @param coins The CoinAsset objects to sort.
+     * @returns The sorted CoinAsset objects.
+     */
+    static sortByBalance(coins: CoinAsset[]): CoinAsset[];
+    static sortByBalanceDes(coins: CoinAsset[]): CoinAsset[];
+    /**
+     * Calculate the total balance of a list of CoinAsset objects.
+     *
+     * @param coins The list of CoinAsset objects to calculate the total balance for.
+     * @returns The total balance of the CoinAsset objects.
+     */
+    static calculateTotalBalance(coins: CoinAsset[]): bigint;
+}

package/dist/src/types/sui.d.ts

@@ -0,0 +1,112 @@
+import type { TransactionArgument } from '@mysten/sui/transactions';
+import Decimal from 'decimal.js';
+/**
+ * Represents a SUI address, which is a string.
+ */
+export type SuiAddress = string;
+/**
+ * Represents a SUI object identifier, which is a string.
+ */
+export type SuiObjectIdType = string;
+/**
+ * Represents a BigNumber, which can be a Decimal.Value, number, or string.
+ */
+export type BigNumber = Decimal.Value | number | string;
+/**
+ * Represents a SUI resource, which can be of any type.
+ */
+export type SuiResource = any;
+/**
+ * Represents a Non-Fungible Token (NFT) with associated metadata.
+ */
+export type NFT = {
+    /**
+     * The address or identifier of the creator of the NFT.
+     */
+    creator: string;
+    /**
+     * A description providing additional information about the NFT.
+     */
+    description: string;
+    /**
+     * The URL to the image representing the NFT visually.
+     */
+    image_url: string;
+    /**
+     * A link associated with the NFT, providing more details or interactions.
+     */
+    link: string;
+    /**
+     * The name or title of the NFT.
+     */
+    name: string;
+    /**
+     * The URL to the project or collection associated with the NFT.
+     */
+    project_url: string;
+};
+/**
+ * Represents a SUI struct tag.
+ */
+export type SuiStructTag = {
+    /**
+     * The full address of the struct.
+     */
+    full_address: string;
+    /**
+     * The source address of the struct.
+     */
+    source_address: string;
+    /**
+     * The address of the struct.
+     */
+    address: SuiAddress;
+    /**
+     * The module to which the struct belongs.
+     */
+    module: string;
+    /**
+     * The name of the struct.
+     */
+    name: string;
+    /**
+     * An array of type arguments (SUI addresses) for the struct.
+     */
+    type_arguments: SuiAddress[];
+};
+/**
+ * Represents basic SUI data types.
+ */
+export type SuiBasicTypes = 'address' | 'bool' | 'u8' | 'u16' | 'u32' | 'u64' | 'u128' | 'u256';
+/**
+ * Represents a SUI transaction argument, which can be of various types.
+ */
+export type SuiTxArg = TransactionArgument | string | number | bigint | boolean;
+/**
+ * Represents input types for SUI data.
+ */
+export type SuiInputTypes = 'object' | SuiBasicTypes;
+/**
+ * Gets the default SUI input type based on the provided value.
+ * @param value - The value to determine the default input type for.
+ * @returns The default SUI input type.
+ * @throws Error if the type of the value is unknown.
+ */
+export declare const getDefaultSuiInputType: (value: any) => SuiInputTypes;
+/**
+ * Represents a coin asset with address, object ID, and balance information.
+ */
+export type CoinAsset = {
+    /**
+     * The address type of the coin asset.
+     */
+    coinAddress: SuiAddress;
+    /**
+     * The object identifier of the coin asset.
+     */
+    coinObjectId: SuiObjectIdType;
+    /**
+     * The balance amount of the coin asset.
+     */
+    balance: bigint;
+};