@minswap/noodles-sdk 0.0.4 → 0.0.7

package/dist/index.d.ts

@@ -0,0 +1,908 @@
+import { Coin } from '@flowx-finance/sdk';
+import type { CoinStruct } from '@mysten/sui/client';
+import type { GetRoutesResult } from '@flowx-finance/sdk';
+import { MemezPumpSDK } from '@interest-protocol/memez-fun-sdk';
+import type { MoveStruct } from '@mysten/sui/client';
+import type { Quote } from '@naviprotocol/astros-aggregator-sdk';
+import type { QuoteResponse } from '@7kprotocol/sdk-ts';
+import type { RouterCompleteTradeRoute } from 'aftermath-ts-sdk';
+import type { RouterDataV3 } from '@cetusprotocol/aggregator-sdk';
+import { SuiClient } from '@mysten/sui/client';
+import { Transaction } from '@mysten/sui/transactions';
+import type { TransactionArgument } from '@mysten/sui/transactions';
+import { TransactionObjectArgument } from '@mysten/sui/transactions';
+import { TransactionResult } from '@mysten/sui/transactions';
+
+/**
+ * Adapter to make SuiClient v1.38 compatible with libraries expecting v1.34
+ * This works around TypeScript type incompatibilities between versions
+ */
+export declare function adaptSuiClient(client: SuiClient): SuiClient;
+
+/**
+ * Adapter to make Transaction v1.38 compatible with libraries expecting v1.34
+ * This works around TypeScript type incompatibilities between versions
+ */
+export declare function adaptTransaction(transaction: Transaction): Transaction;
+
+export declare function addGasFee(params: {
+    inheritTx?: Transaction;
+    sender: string;
+    feeAmount: bigint;
+    suiInputAmount?: bigint;
+}): Promise<Transaction>;
+
+/**
+ * Aftermath DEX aggregator client for routing trades across multiple pools
+ */
+export declare class AftermathAggregator {
+    /** Configuration settings for the aggregator */
+    private _config;
+    /** Aftermath SDK client instance (lazy-loaded on first use) */
+    private _aftermathClient;
+    /** Sui blockchain client */
+    private _suiClient;
+    /**
+     * Creates a new AftermathAggregator instance
+     * @param config - Aggregator configuration including optional API settings
+     * @param suiClient - Sui client for blockchain interactions
+     */
+    constructor(config: AftermathAggregatorConfig, suiClient: SuiClient);
+    /**
+     * Lazy-loads and returns the Aftermath client, initializing it on first use
+     * Handles authentication if API key is provided in config
+     * @returns Promise resolving to initialized Aftermath client
+     */
+    private aftermathClient;
+    /**
+     * Finds the optimal trade route for swapping tokens
+     * @param params - Trade route parameters
+     * @param params.coinInAmount - Amount of input token to swap
+     * @param params.coinInType - Type/address of input token
+     * @param params.coinOutType - Type/address of output token
+     * @returns Promise resolving to complete trade route with pricing and path information
+     */
+    getTradeRoute({ coinInAmount, coinInType, coinOutType, tradeFee, }: GetTradeRouteRequest_2): Promise<RouterCompleteTradeRoute>;
+    /**
+     * Builds a transaction for executing a trade route
+     * @param params - Transaction parameters
+     * @param params.completeRoute - Complete trade route from getTradeRoute()
+     * @param params.walletAddress - Address of the wallet executing the trade
+     * @param params.slippage - Maximum acceptable slippage (e.g., 0.01 for 1%)
+     * @returns Promise resolving to built transaction bytes ready for signing and execution
+     */
+    getTransaction({ completeRoute, walletAddress, slippage }: GetTransactionRequest_2): Promise<Uint8Array>;
+}
+
+export declare namespace AftermathAggregator {
+    export function toCommonTradeRoutes(tradeRoute: RouterCompleteTradeRoute): FinalTradeRoute | null;
+}
+
+/**
+ * Configuration options for the Aftermath aggregator
+ */
+export declare type AftermathAggregatorConfig = {
+    /** Default trade fee settings applied to each trade */
+    defaultTradeFee: TradeFeeOptions;
+    /** Optional API key for authenticated Aftermath API access */
+    aftermathApiKey?: string;
+    /** Optional custom Aftermath API endpoint (defaults to MAINNET if not provided) */
+    aftermathApiEndpoint?: string;
+};
+
+/**
+ * Astros DEX aggregator client for routing trades across multiple pools
+ * Provides access to liquidity aggregation from various DEX protocols
+ */
+export declare class AstrosAggregator {
+    /** Configuration settings for the aggregator */
+    private _config;
+    /** Sui blockchain client */
+    private _suiClient;
+    /**
+     * Creates a new AstrosAggregator instance
+     * @param config - Aggregator configuration including optional fee settings
+     * @param suiClient - Sui client for blockchain interactions
+     */
+    constructor(config: AstrosAggregatorConfig, suiClient: SuiClient);
+    /**
+     * Finds the optimal trade route for swapping tokens using Astros aggregator
+     * @param params - Trade route parameters
+     * @param params.coinInAmount - Amount of input token to swap
+     * @param params.coinInType - Type/address of input token
+     * @param params.coinOutType - Type/address of output token
+     * @returns Promise resolving to quote with pricing and route information, or null if no route found
+     */
+    getTradeRoute({ coinInAmount, coinInType, coinOutType, tradeFee, }: GetTradeRouteRequest_3): Promise<Quote | null>;
+    /**
+     * Merges multiple coin objects into a single coin for trading
+     * Optimizes coin usage by merging smaller coins into larger ones
+     * @param txb - Transaction builder instance
+     * @param coins - Array of coin objects to merge
+     * @param amount - Required amount for the trade
+     * @returns Transaction object reference for the merged coin
+     */
+    private returnMergedCoins;
+    /**
+     * Builds a transaction for executing a trade route from Astros aggregator
+     * @param params - Transaction parameters
+     * @param params.completeRoute - Complete quote from getTradeRoute() (aliased as quote)
+     * @param params.walletAddress - Address of the wallet executing the trade
+     * @param params.slippage - Maximum acceptable slippage (e.g., 0.01 for 1%)
+     * @returns Promise resolving to built transaction bytes ready for signing and execution
+     */
+    getTransaction({ completeRoute: quote, walletAddress, slippage, tradeFee, }: GetTransactionRequest_3): Promise<Uint8Array>;
+}
+
+export declare namespace AstrosAggregator {
+    export function toCommonTradeRoutes(tradeRoute: Quote, coinInType: string, coinOutType: string): FinalTradeRoute | null;
+}
+
+/**
+ * Configuration options for the Astros aggregator
+ */
+export declare type AstrosAggregatorConfig = {
+    /** Default trade fee settings applied to each trade */
+    defaultTradeFee: TradeFeeOptions;
+    /** Optional API key for Astros aggregator access */
+    astrosApiKey?: string;
+};
+
+/**
+ * Individual trade path within a route
+ */
+export declare type AstrosTradePath = {
+    /** Unique identifier for the path */
+    id: string;
+    /** Type of the trade path */
+    type: string;
+    /** Liquidity provider name */
+    provider: string;
+    /** Source token type */
+    from: string;
+    /** Target token type */
+    target: string;
+    /** Direction flag for A to B trade */
+    a2b: boolean;
+    /** Trade direction */
+    direction: boolean;
+    /** Fee rate for this path */
+    fee_rate: number;
+    /** Lot size for the trade */
+    lot_size: number;
+    /** Input amount for this path */
+    amount_in: number;
+    /** Output amount for this path */
+    amount_out: number;
+};
+
+/**
+ * Trade route information from Astros aggregator
+ */
+export declare type AstrosTradeRoute = {
+    /** Array of trade paths in the route */
+    path: AstrosTradePath[];
+    /** Total input amount */
+    amount_in: number;
+    /** Total output amount */
+    amount_out: number;
+    /** Initial price for the trade */
+    initial_price: number;
+};
+
+export declare type BalanceContent = {
+    balance: string;
+    id: {
+        id: string;
+    };
+};
+
+export declare const BASE_BPS = 10000;
+
+export declare namespace BlastFunConstants {
+    const PACKAGE_ID_V4 = "0x7e6aa6e179466ab2814425a780b122575296d011119fa69d27f289f5a28814bd";
+    const MEMEZ_AV_OBJECT_ID = "0x2319e3e76dfad73d8f4684bdbf42be4f32d8ce4521dd61becc8261dc918d82c0";
+}
+
+/**
+ * @deprecated Use `BlastFunSDKCalculation` instead.
+ */
+export declare namespace BlastFunCustomCalculation {
+    export function getCurveAmountAfterBuy(params: GetCurveAmountAfterBuyParams): Promise<bigint>;
+    export function getSuiAmountAfterSell(params: GetSuiAmountAfterSellParams): Promise<bigint>;
+}
+
+/**
+ * @deprecated Use `BlastFunSDKTransaction` instead.
+ */
+export declare namespace BlastFunCustomTransaction {
+    export function getAllowedVersions(_tx?: Transaction): Promise<TransactionResult>;
+    export function buildBuyTx(params: BuildSwapTxParams): Promise<BuildTxResult>;
+    export function buildSellTx(params: BuildSwapTxParams): Promise<BuildTxResult>;
+}
+
+export declare namespace BlastFunPackage {
+    export namespace MemezFun {
+        export type MemezFun = {
+            inner_state: string;
+            public_key: number[];
+            ipx_meme_coin_treasury: string;
+        };
+        export function isSniperProtectedMemezFun(poolId: string): Promise<boolean>;
+    }
+    export namespace MemezDistributor {
+        export type Recipient = {
+            address: string;
+            bps: MoveObjectStruct<Bps.BPS>;
+        };
+        export type Distributor = {
+            recipients: MoveObjectStruct<Recipient>[];
+        };
+    }
+    export namespace MemezFees {
+        export type FeeValue = {
+            pos0: string;
+            pos1: MoveObjectStruct<MemezDistributor.Distributor>;
+        };
+        export type FeePercentage = {
+            pos0: MoveObjectStruct<Bps.BPS>;
+            pos1: MoveObjectStruct<MemezDistributor.Distributor>;
+        };
+        export type FeeMoveStruct = MoveEnumObjectStruct<FeeValue, "Value"> | MoveEnumObjectStruct<FeePercentage, "Percentage">;
+        export function takeWithDiscount(fee: FeeMoveStruct, amount: bigint, discountBps: Bps.BPS): bigint;
+        export function calculateWithDiscount(fee: FeeMoveStruct, discountBps: Bps.BPS, amount: bigint): bigint;
+    }
+    export namespace MemezBurner {
+        export type MemezBurner = {
+            fee: MoveObjectStruct<Bps.BPS>;
+            target_liquidity: string;
+        };
+        export function calculate(burner: MemezBurner, poolMemeBalance: bigint): Bps.BPS;
+    }
+    export namespace MemezConstantProduct {
+        export type MemezConstantProduct = {
+            meme_balance: string;
+            quote_balance: string;
+            virtual_liquidity: string;
+            quote_swap_fee: MemezFees.FeeMoveStruct;
+            meme_swap_fee: MemezFees.FeeMoveStruct;
+            meme_referrer_fee: MoveObjectStruct<Bps.BPS>;
+            quote_referrer_fee: MoveObjectStruct<Bps.BPS>;
+            burner: MoveObjectStruct<MemezBurner.MemezBurner>;
+        };
+    }
+    export namespace MemezPump {
+        export type PumpState = {
+            constant_product: MoveObjectStruct<MemezConstantProduct.MemezConstantProduct>;
+        };
+        export function getPumpState(memezFun: MemezFun.MemezFun): Promise<PumpState>;
+        export function pump(pumpState: PumpState, quoteAmount: bigint): bigint;
+        export function dump(pumpState: PumpState, memeAmount: bigint): bigint;
+    }
+}
+
+export declare namespace BlastFunSDKCalculation {
+    export function getCurveAmountAfterBuy(params: GetCurveAmountAfterBuyParams): Promise<bigint>;
+    export function getSuiAmountAfterSell(params: GetSuiAmountAfterSellParams): Promise<bigint>;
+}
+
+export declare namespace BlastFunSDKTransaction {
+    export function buildBuyTx(params: BuildSwapTxParams): Promise<BuildTxResult>;
+    export function buildSellTx(params: BuildSwapTxParams): Promise<BuildTxResult>;
+    export function getBuyTransaction({ coinInAmount, coinInType, coinOutType, poolId, slippage, walletAddress, tradeFee }: GetTradeTransactionRequest, suiClient: SuiClient): Promise<Uint8Array>;
+    export function getSellTransaction({ coinInAmount, coinInType, coinOutType, poolId, slippage, walletAddress, tradeFee }: GetTradeTransactionRequest, suiClient: SuiClient): Promise<Uint8Array>;
+}
+
+export declare const BLUEFIN_PACKAGE_ID = "0x62412b7268c35f3808336aee57a52836501f40b8ba5d936f8ad275e672befd04";
+
+export declare namespace BluefinTx {
+    export function transferOrDestroyZeroCoin(tx: Transaction, coinType: string, coin: TransactionArgument, address: string): void;
+}
+
+export declare namespace Bps {
+    export type BPS = {
+        pos0: string;
+    };
+    export function calcUp(bps: BPS, amount: bigint): bigint;
+    export function sub(lhs: BPS, rhs: BPS): BPS;
+    export function value(bps: BPS): bigint;
+    export function new_(bps: number | string | bigint): BPS;
+    export function assertOverflow(bps: number | string | bigint): bigint;
+}
+
+export declare type BuildSwapTxParams = CommonTxParams & {
+    inputAmount: string;
+    minAmountOut: string;
+    inCoinType: string;
+    outCoinType: string;
+    poolId: string;
+};
+
+export declare type BuildTxResult = {
+    tx: Transaction;
+    coinOut?: TransactionObjectArgument;
+};
+
+/**
+ * Cetus DEX aggregator client for routing trades across multiple pools
+ * Cetus is a concentrated liquidity protocol that provides efficient trading
+ */
+export declare class CetusAggregator {
+    /** Configuration settings for the aggregator */
+    private _config;
+    /** Sui blockchain client */
+    private _suiClient;
+    /** Cetus aggregator client instance (lazy-loaded) */
+    private _cetusClient;
+    /**
+     * Creates a new CetusAggregator instance
+     * @param config - Aggregator configuration including fee settings and optional API credentials
+     * @param suiClient - Sui client for blockchain interactions
+     */
+    constructor(config: CetusAggregatorConfig, suiClient: SuiClient);
+    /**
+     * Lazy-loads and returns the Cetus aggregator client, initializing it on first use
+     * Configures the client with overlay fees, API credentials, and partner information
+     * @param walletAddress - Optional wallet address for signing transactions
+     * @param tradeFee - Optional custom trade fee settings for this client instance
+     * @returns Initialized Cetus AggregatorClient instance
+     */
+    private cetusClient;
+    /**
+     * Finds the optimal trade route for swapping tokens using Cetus aggregator
+     * @param params - Trade route parameters
+     * @param params.coinInAmount - Amount of input token to swap
+     * @param params.coinInType - Type/address of input token
+     * @param params.coinOutType - Type/address of output token
+     * @returns Promise resolving to router data with pricing and route information, or null if no route found
+     */
+    getTradeRoute({ coinInAmount, coinInType, coinOutType, tradeFee, }: GetTradeRouteRequest_4): Promise<RouterDataV3 | null>;
+    /**
+     * Builds a transaction for executing a trade route from Cetus aggregator
+     * @param params - Transaction parameters
+     * @param params.completeRoute - Complete router data from getTradeRoute() (aliased as routers)
+     * @param params.walletAddress - Address of the wallet executing the trade
+     * @param params.slippage - Maximum acceptable slippage (e.g., 0.01 for 1%)
+     * @returns Promise resolving to built transaction bytes ready for signing and execution
+     */
+    getTransaction({ completeRoute: routers, walletAddress, slippage, tradeFee, }: GetTransactionRequest_4): Promise<Uint8Array>;
+}
+
+export declare namespace CetusAggregator {
+    export function toCommonTradeRoutes(tradeRoute: RouterDataV3, coinInType: string, coinOutType: string): FinalTradeRoute | null;
+}
+
+/**
+ * Configuration options for the Cetus aggregator
+ */
+export declare type CetusAggregatorConfig = {
+    /** Default trade fee settings applied to each trade */
+    defaultTradeFee: TradeFeeOptions;
+    /** Optional API key for Cetus aggregator access */
+    cetusApiKey?: string;
+    /** Optional custom Cetus API endpoint */
+    cetusApiEndpoint?: string;
+    /** Optional partner ID for Cetus integration */
+    cetusPartnerId?: string;
+};
+
+export declare const CLOCK_OBJECT_ID = "0x0000000000000000000000000000000000000000000000000000000000000006";
+
+export declare interface CommonTxParams {
+    /** User address */
+    accountAddress: string;
+    /** Commission for frontend, ex: 0.01 (1%) */
+    frontendFee?: number | string;
+    /** Frontend fee recipient address */
+    frontendFeeRecipient?: string;
+    /**
+     * Give Flexibility to insert custom commands before or after swap
+     * @example
+     * ```typescript
+     * const rawTx = new Transaction();
+     * // Add custom commands to rawTx
+     * rawTx.moveCall({
+     *   target: "0x2222222::example::claim",
+     *   arguments: [],
+     * });
+     * const { tx, coinOut } = await buildTx({
+     *   quoteResponse,
+     *   accountAddress,
+     *   slippage,
+     *   commission,
+     *   extendTx: {
+     *     tx: rawTx,
+     *     coinIn: rawTx.object(coinObjectId),
+     *   },
+     * });
+     * // add more commands after the swap if needed, and remember to consume the coinOut object
+     * tx.transferObjects([coinOut], tx.pure.address(accountAddress));
+     * ```
+     */
+    extendTx?: {
+        tx: Transaction;
+        coinIn?: TransactionObjectArgument;
+    };
+    /**
+     * If true, indicates that the transaction is sponsored and its gas object should not be modified.
+     * In this case, the gas object is expected to be already set up correctly for the sponsored transaction.
+     */
+    isSponsored?: boolean;
+}
+
+/**
+ * Alternative: Create a proxy that ensures compatibility
+ */
+export declare function createCompatibleSuiClient(client: SuiClient): LegacySuiClient;
+
+export declare type FinalTradeRoute = {
+    coinIn: string;
+    coinOut: string;
+    amountIn: bigint;
+    amountOut: bigint;
+    routes: TradeRoute[];
+};
+
+/**
+ * FlowX DEX aggregator client for routing trades across multiple pools
+ * FlowX provides liquidity aggregation and optimized routing for Sui ecosystem
+ */
+export declare class FlowXAggregator {
+    /** Configuration settings for the aggregator */
+    private _config;
+    /** Sui blockchain client */
+    private _suiClient;
+    /**
+     * Creates a new FlowXAggregator instance
+     * @param config - Aggregator configuration including fee settings and optional API key
+     * @param suiClient - Sui client for blockchain interactions
+     */
+    constructor(config: FlowXAggregatorConfig, suiClient: SuiClient);
+    /**
+     * Creates a commission configuration for FlowX trades
+     * @param coinInType - Type/address of the input coin for commission calculation
+     * @param tradeFee - Optional custom trade fee settings for this commission
+     * @returns Commission instance configured with fee recipient, percentage, and coin type
+     */
+    private getCommission;
+    /**
+     * Finds the optimal trade route for swapping tokens using FlowX aggregator
+     * @param params - Trade route parameters
+     * @param params.coinInAmount - Amount of input token to swap
+     * @param params.coinInType - Type/address of input token
+     * @param params.coinOutType - Type/address of output token
+     * @returns Promise resolving to routes result with pricing and path information, or null if no route found
+     */
+    getTradeRoute({ coinInAmount, coinInType, coinOutType, tradeFee, }: GetTradeRouteRequest_5): Promise<GetRoutesResult<Coin, Coin> | null>;
+    /**
+     * Builds a transaction for executing a trade route from FlowX aggregator
+     * @param params - Transaction parameters
+     * @param params.walletAddress - Address of the wallet executing the trade
+     * @param params.completeRoute - Complete routes result from getTradeRoute()
+     * @param params.slippage - Maximum acceptable slippage (e.g., 0.01 for 1%)
+     * @returns Promise resolving to built transaction bytes ready for signing and execution
+     */
+    getTransaction({ walletAddress, completeRoute, slippage, tradeFee, }: GetTransactionRequest_5): Promise<Uint8Array>;
+}
+
+export declare namespace FlowXAggregator {
+    export function toCommonTradeRoutes(tradeRoute: GetRoutesResult<Coin, Coin>): FinalTradeRoute | null;
+}
+
+/**
+ * Configuration options for the FlowX aggregator
+ */
+export declare type FlowXAggregatorConfig = {
+    /** Default trade fee settings applied to each trade */
+    defaultTradeFee: TradeFeeOptions;
+    /** Optional API key for FlowX aggregator access */
+    flowxApiKey?: string;
+};
+
+export declare function getAmountAfterFee(amount: bigint | string, fee?: string | number): bigint;
+
+export declare const getCoinObjectIdsByAmount: (address: string, amount: string, coinType: string) => Promise<{
+    objectIds: string[];
+    objectCoins: CoinStruct[];
+    balance: string;
+}>;
+
+export declare type GetCurveAmountAfterBuyParams = {
+    suiAmount: bigint;
+    poolId: string;
+    frontendFee?: number | string;
+};
+
+export declare function getMemezPumpSDK(): MemezPumpSDK;
+
+export declare function getMoveObject(objectId: string): Promise<MoveObject>;
+
+export declare function getMoveObjectContent(objectId: string): Promise<MoveStruct>;
+
+export declare function getNeededGasFee(tx: Transaction, sender: string, bufferPercent: number): Promise<bigint>;
+
+declare type GetSplitCoinForTx = {
+    account: string;
+    amount: string;
+    splits: string[];
+    coinType: string;
+    inheritTx?: Transaction;
+    inspecTransaction?: boolean;
+    isSponsored?: boolean;
+};
+
+export declare function getSplitCoinForTx(params: GetSplitCoinForTx): Promise<{
+    tx: Transaction;
+    coinData: TransactionResult;
+}>;
+
+export declare function getSplitCoinsAfterFee(amount: string, fee: string | number): string[];
+
+export declare type GetSuiAmountAfterSellParams = {
+    curveAmount: bigint;
+    poolId: string;
+    frontendFee?: number | string;
+};
+
+export declare function getSuiClient(): SuiClient;
+
+/**
+ * Request parameters for getting a trade route
+ */
+declare type GetTradeRouteRequest = {
+    /** Amount of input coin to trade (in smallest unit) */
+    coinInAmount: bigint;
+    /** Type/address of the input coin */
+    coinInType: string;
+    /** Type/address of the output coin */
+    coinOutType: string;
+    /** Custom trade fee for this request, if not provided, the default trade fee will be applied */
+    tradeFee?: TradeFeeOptions;
+};
+
+/**
+ * Request parameters for getting a trade route
+ */
+declare type GetTradeRouteRequest_2 = {
+    /** Amount of input coin to trade (in smallest unit) */
+    coinInAmount: bigint;
+    /** Type/address of the input coin */
+    coinInType: string;
+    /** Type/address of the output coin */
+    coinOutType: string;
+    /** Custom trade fee for this request, if not provided, the default trade fee will be applied */
+    tradeFee?: TradeFeeOptions;
+};
+
+/**
+ * Request parameters for getting a trade route
+ */
+declare type GetTradeRouteRequest_3 = {
+    /** Amount of input coin to trade (in smallest unit) */
+    coinInAmount: bigint;
+    /** Type/address of the input coin */
+    coinInType: string;
+    /** Type/address of the output coin */
+    coinOutType: string;
+    /** Custom trade fee for this request, if not provided, the default trade fee will be applied */
+    tradeFee?: TradeFeeOptions;
+};
+
+/**
+ * Request parameters for getting a trade route
+ */
+declare type GetTradeRouteRequest_4 = {
+    /** Amount of input coin to trade (in smallest unit) */
+    coinInAmount: bigint;
+    /** Type/address of the input coin */
+    coinInType: string;
+    /** Type/address of the output coin */
+    coinOutType: string;
+    /** Custom trade fee for this request, if not provided, the default trade fee will be applied */
+    tradeFee?: TradeFeeOptions;
+};
+
+/**
+ * Request parameters for getting a trade route
+ */
+declare type GetTradeRouteRequest_5 = {
+    /** Amount of input coin to trade (in smallest unit) */
+    coinInAmount: bigint;
+    /** Type/address of the input coin */
+    coinInType: string;
+    /** Type/address of the output coin */
+    coinOutType: string;
+    /** Custom trade fee for this request, if not provided, the default trade fee will be applied */
+    tradeFee?: TradeFeeOptions;
+};
+
+export declare type GetTradeTransactionRequest = {
+    /** Amount of input coin to trade (in smallest unit) */
+    coinInAmount: bigint;
+    /** Type/address of the input coin */
+    coinInType: string;
+    /** Type/address of the output coin */
+    coinOutType: string;
+    /** Wallet address that will execute the transaction */
+    walletAddress: string;
+    /** Slippage tolerance as decimal (e.g., 0.01 for 1%) */
+    slippage: number;
+    /** Custom trade fee for this request, if not provided, the default trade fee will be applied */
+    tradeFee?: TradeFeeOptions;
+    /** The bonding curve Pool ID */
+    poolId: string;
+};
+
+/**
+ * Request parameters for getting a transaction
+ */
+declare type GetTransactionRequest = {
+    /** Wallet address that will execute the transaction */
+    walletAddress: string;
+    /** Complete quote response from 7K Protocol */
+    completeRoute: QuoteResponse;
+    /** Slippage tolerance (e.g., 0.01 for 1%) */
+    slippage: number;
+    /** Custom trade fee for this request, if not provided, the default trade fee will be applied */
+    tradeFee?: TradeFeeOptions;
+};
+
+/**
+ * Request parameters for getting a transaction
+ */
+declare type GetTransactionRequest_2 = {
+    /** Wallet address that will execute the transaction */
+    walletAddress: string;
+    /** Complete trade route from Aftermath router */
+    completeRoute: RouterCompleteTradeRoute;
+    /** Slippage tolerance (e.g., 0.01 for 1%) */
+    slippage: number;
+};
+
+/**
+ * Request parameters for getting a transaction
+ */
+declare type GetTransactionRequest_3 = {
+    /** Wallet address that will execute the transaction */
+    walletAddress: string;
+    /** Complete quote from Astros aggregator */
+    completeRoute: Quote;
+    /** Slippage tolerance (e.g., 0.01 for 1%) */
+    slippage: number;
+    /** Custom trade fee for this request, if not provided, the default trade fee will be applied */
+    tradeFee?: TradeFeeOptions;
+};
+
+/**
+ * Request parameters for getting a transaction
+ */
+declare type GetTransactionRequest_4 = {
+    /** Wallet address that will execute the transaction */
+    walletAddress: string;
+    /** Complete router data from Cetus aggregator */
+    completeRoute: RouterDataV3;
+    /** Slippage tolerance (e.g., 0.01 for 1%) */
+    slippage: number;
+    /** Custom trade fee for this request, if not provided, the default trade fee will be applied */
+    tradeFee?: TradeFeeOptions;
+};
+
+/**
+ * Request parameters for getting a transaction
+ */
+declare type GetTransactionRequest_5 = {
+    /** Wallet address that will execute the transaction */
+    walletAddress: string;
+    /** Complete routes result from FlowX aggregator */
+    completeRoute: GetRoutesResult<Coin, Coin>;
+    /** Slippage tolerance (e.g., 0.01 for 1%) */
+    slippage: number;
+    /** Custom trade fee for this request, if not provided, the default trade fee will be applied */
+    tradeFee?: TradeFeeOptions;
+};
+
+declare type LegacySuiClient = SuiClient;
+
+export declare namespace MathUtils {
+    export namespace U64 {
+        export function mulDivUp(a: bigint, b: bigint, c: bigint): bigint;
+    }
+}
+
+export declare namespace MoonbagsCalculation {
+    export function getCurveAmountAfterBuy(params: GetCurveAmountAfterBuyParams): Promise<bigint>;
+    export function getSuiAmountAfterSell(params: GetSuiAmountAfterSellParams): Promise<bigint>;
+    export function getUsedSuiForTx(params: {
+        suiAmount: bigint;
+        frontendFee?: number | string;
+    }): Promise<bigint>;
+}
+
+export declare namespace MoonbagsConstants {
+    const PACKAGE_ID = "0xb8df325010942634a4afb3db3901ee215546af43a4ec4af781e7213b0bba7290";
+    const CONFIG_OBJECT_ID = "0x74aecf86067c6913960ba4925333aefd2b1f929cafca7e21fd55a8f244b70499";
+    const LOCK_CONFIG_OBJECT_ID = "0xfb09822d9808980abd04c51321adb850701f5f55535c6206658ef4d910c3e9be";
+    const BURN_MANAGER_OBJECT_ID = "0x1d94aa32518d0cb00f9de6ed60d450c9a2090761f326752ffad06b2e9404f845";
+    const POOLS_OBJECT_ID = "0xf699e7f2276f5c9a75944b37a0c5b5d9ddfd2471bf6242483b03ab2887d198d0";
+    const GLOBAL_CONFIG_OBJECT_ID = "0xdaa46292632c3c4d8f31f23ea0f9b36a28ff3677e9684980e4438403a67a3d8f";
+    const FEE_DENOMINATOR: bigint;
+}
+
+export declare namespace MoonbagsPackage {
+    export namespace Curves {
+        export function calculateAddLiquidityCost(tokenIn: bigint, tokenReserve: bigint, tokenAmount: bigint): bigint;
+        export function calculateRemoveLiquidityReturn(tokenIn: bigint, tokenReserve: bigint, tokenRemoved: bigint): bigint;
+        export function calculateTokenAmountReceived(tokenIn: bigint, tokenReserve: bigint, tokenOutReserve: bigint): bigint;
+    }
+    export namespace Moonbags {
+        export type Configuration = {
+            platform_fee: string;
+        };
+        export type Pool = {
+            id: {
+                id: string;
+            };
+            virtual_sui_reserves: string;
+            virtual_token_reserves: string;
+            remain_token_reserves: MoveObjectStruct<BalanceContent>;
+            real_sui_reserves: MoveObjectStruct<BalanceContent>;
+        };
+        export type DynamicVirtualTokenReserves = {
+            id: {
+                id: string;
+            };
+            name: number[];
+            value: string;
+        };
+        export function getDynamicVirtualTokenReserves(poolId: string): Promise<bigint | undefined>;
+        export function buyExactInReturnsWithLock(params: {
+            inputAmount: bigint;
+            amountIn: bigint;
+            pool: Pool;
+            config: Configuration;
+            dynamicVirtualTokenReserves: bigint | undefined;
+        }): {
+            receivedCurve: bigint;
+            receivedSui: bigint;
+        };
+        export function sellReturns(params: {
+            amountIn: bigint;
+            pool: Pool;
+            config: Configuration;
+        }): {
+            receivedCurve: bigint;
+            receivedSui: bigint;
+        };
+    }
+}
+
+export declare namespace MoonbagsTransaction {
+    export function buildBuyTx(params: BuildSwapTxParams): Promise<BuildTxResult>;
+    export function buildSellTx(params: BuildSwapTxParams): Promise<BuildTxResult>;
+    export function getBuyTransaction({ coinInAmount, coinInType, coinOutType, poolId, slippage, walletAddress, tradeFee }: GetTradeTransactionRequest, suiClient: SuiClient): Promise<Uint8Array>;
+    export function getSellTransaction({ coinInAmount, coinInType, coinOutType, poolId, slippage, walletAddress, tradeFee }: GetTradeTransactionRequest, suiClient: SuiClient): Promise<Uint8Array>;
+}
+
+export declare type MoveEnumObjectStruct<Content, Variant extends string = string> = MoveObjectStruct<Content> & {
+    variant: Variant;
+};
+
+export declare type MoveObject = {
+    dataType: "moveObject";
+    fields: MoveStruct;
+    hasPublicTransfer: boolean;
+    type: string;
+};
+
+export declare type MoveObjectStruct<Content> = {
+    type: string;
+    fields: Content;
+};
+
+export declare const NATIVE_USDC_TOKEN_TYPE = "0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC";
+
+/**
+ * 7K Protocol DEX aggregator client for routing trades across multiple pools
+ * 7K Protocol aggregates liquidity from various DEXs to find optimal trade routes
+ */
+export declare class SevenKAggregator {
+    /** Configuration settings for the aggregator */
+    private _config;
+    /** Sui blockchain client */
+    private _suiClient;
+    /**
+     * Creates a new SevenKAggregator instance
+     * @param config - Aggregator configuration including fee settings and optional API key
+     * @param suiClient - Sui client for blockchain interactions
+     */
+    constructor(config: SevenKAggregatorConfig, suiClient: SuiClient);
+    /**
+     * Finds the optimal trade route for swapping tokens using 7K Protocol
+     * @param params - Trade route parameters
+     * @param params.coinInAmount - Amount of input token to swap
+     * @param params.coinInType - Type/address of input token
+     * @param params.coinOutType - Type/address of output token
+     * @returns Promise resolving to quote response with pricing and route information, or null if no route found
+     */
+    getTradeRoute({ coinInAmount, coinInType, coinOutType, tradeFee, }: GetTradeRouteRequest): Promise<QuoteResponse | null>;
+    /**
+     * Builds a transaction for executing a trade route from 7K Protocol
+     * @param params - Transaction parameters
+     * @param params.walletAddress - Address of the wallet executing the trade
+     * @param params.completeRoute - Complete quote response from getTradeRoute()
+     * @param params.slippage - Maximum acceptable slippage (e.g., 0.01 for 1%)
+     * @returns Promise resolving to built transaction bytes ready for signing and execution
+     */
+    getTransaction({ walletAddress, completeRoute, slippage, tradeFee, }: GetTransactionRequest): Promise<Uint8Array>;
+}
+
+export declare namespace SevenKAggregator {
+    export function toCommonTradeRoutes(tradeRouteResponse: QuoteResponse): FinalTradeRoute | null;
+}
+
+/**
+ * Configuration options for the 7K Protocol aggregator
+ */
+export declare type SevenKAggregatorConfig = {
+    /** Default trade fee settings applied to each trade */
+    defaultTradeFee: TradeFeeOptions;
+    /** Optional API key for 7K Protocol access */
+    sevenKApiKey?: string;
+};
+
+export declare function splitSuiCoinAfterFeeFromBuyTx(params: BuildSwapTxParams): Promise<BuildTxResult>;
+
+export declare function splitSuiCoinAfterFeeFromSellTx(tx: Transaction, params: BuildSwapTxParams, suiCoin: TransactionObjectArgument): Promise<BuildTxResult>;
+
+export declare const SUI_FULL_TYPE = "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI";
+
+export declare const SUI_METADATA_OBJECT_ID = "0x9258181f5ceac8dbffb7030890243caed69a9599d2886d957a9cb7656af3bdb3";
+
+export declare const SUI_TYPE = "0x2::sui::SUI";
+
+export declare enum SupportedAggregator {
+    ASTROS = "ASTROS",
+    AFTERMATH = "AFTERMATH",
+    SEVENK = "7K",
+    CETUS = "CETUS",
+    FLOWX = "FLOWX"
+}
+
+export declare enum SupportedBondingCurve {
+    BLAST_FUN = "BLAST_FUN",
+    MOONBAGS = "MOONBAGS"
+}
+
+/**
+ * Configuration options for trade fees applied to aggregator transactions
+ */
+export declare type TradeFeeOptions = {
+    /** Trade fee percentage as a decimal (e.g., 0.01 for 1%, 0.003 for 0.3%) */
+    tradeFeePercent: number;
+    /** Address that will receive the trade fees */
+    tradeFeeRecipientAddress: string;
+};
+
+export declare namespace TradeFeeOptions {
+    export function equals(a: TradeFeeOptions, b: TradeFeeOptions): boolean;
+}
+
+export declare type TradePath = {
+    poolAddress: string;
+    coinIn: string;
+    coinOut: string;
+    amountIn: bigint;
+    amountOut: bigint;
+};
+
+export declare type TradeRoute = {
+    coinIn: string;
+    coinOut: string;
+    amountIn: bigint;
+    amountOut: bigint;
+    paths: TradePath[];
+};
+
+export declare const USDC_TOKEN_TYPE = "0x5d4b302506645c37ff133b98c4b50a5ae14841659738d6d733d59d0d217a93bf::coin::COIN";
+
+export { }