@minswap/noodles-sdk 0.1.2-beta.0 → 0.2.0

package/dist/portfolio.d.ts

@@ -0,0 +1,704 @@
+import { Coin } from '@flowx-finance/sdk';
+import type { GetRoutesResult } from '@flowx-finance/sdk';
+import type { Protocol } from '@flowx-finance/sdk';
+import { QuoteResponse } from '@bluefin-exchange/bluefin7k-aggregator-sdk';
+import type { RouterCompleteTradeRoute } from 'aftermath-ts-sdk';
+import type { RouterDataV3 } from '@cetusprotocol/aggregator-sdk';
+import { SourceDex } from '@bluefin-exchange/bluefin7k-aggregator-sdk';
+import { SuiGrpcClient } from '@mysten/sui/grpc';
+import { SuiJsonRpcClient } from '@mysten/sui/jsonRpc';
+
+declare class AftermathAggregator {
+    private _config;
+    private _aftermathClient;
+    private _suiClient;
+    constructor(config: AftermathAggregatorConfig, suiClient: SuiJsonRpcClient);
+    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): Promise<RouterCompleteTradeRoute | null>;
+    /**
+     * 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): Promise<Uint8Array>;
+}
+
+declare namespace AftermathAggregator {
+    function toCommonTradeRoutes(tradeRoute: RouterCompleteTradeRoute): FinalTradeRoute | null;
+}
+
+declare type AftermathAggregatorConfig = {
+    defaultTradeFee: TradeFeeOptions;
+    aftermathApiKey?: string;
+    /** Defaults to the MAINNET endpoint when omitted. */
+    aftermathApiEndpoint?: string;
+};
+
+/**
+ * Unified access to the supported DEX aggregators (Cetus, FlowX, Aftermath, 7K).
+ */
+declare class AggregatorModule implements IModule {
+    readonly sdk: NoodlesSdk;
+    private _aftermathAggregator;
+    private _sevenkAggregator;
+    private _cetusAggregator;
+    private _flowXAggregator;
+    constructor(sdk: NoodlesSdk);
+    get aftermathAggregator(): AftermathAggregator;
+    get sevenkAggregator(): SevenKAggregator;
+    get cetusAggregator(): CetusAggregator;
+    get flowXAggregator(): FlowXAggregator;
+    /**
+     * Finds the optimal trade route using the specified aggregator
+     * @param aggregator - The aggregator to use for route finding
+     * @param params - Trade route parameters including token types and amounts
+     * @returns Promise resolving to route response with both standardized and raw data, or null if no route found
+     */
+    getTradeRoute(aggregator: SupportedAggregator, params: GetTradeRouteRequest_5): Promise<GetTradeRouteResponse | null>;
+    /**
+     * Builds a transaction from an existing trade route
+     * @param aggregator - The aggregator that generated the route
+     * @param params - Transaction parameters including wallet address, route, and slippage
+     * @returns Promise resolving to built transaction bytes ready for signing and execution
+     */
+    getTransactionByRoute(aggregator: SupportedAggregator, params: GetTransactionByRouteRequest): Promise<Uint8Array>;
+    /**
+     * Combines route finding and transaction building into a single operation
+     * This is a convenience method that calls getTradeRoute followed by getTransactionByRoute
+     * @param aggregator - The aggregator to use for both route finding and transaction building
+     * @param params - Combined parameters including trade details, wallet address, and slippage
+     * @returns Promise resolving to complete response with route info and built transaction, or null if no route found
+     */
+    getTradeTransaction(aggregator: SupportedAggregator, params: GetTradeTransactionRequest): Promise<GetTradeTransactionResponse | null>;
+    /**
+     * Finds the best rate across all aggregators and returns the optimal trade transaction
+     * This method queries all available aggregators and selects the one with the best output amount
+     * @param params - Combined parameters including trade details, wallet address, and slippage
+     * @returns Promise resolving to complete response with route info and built transaction from the best aggregator, or null if no routes found
+     */
+    getTradeTransactionWithBestRate(params: GetTradeTransactionRequest): Promise<GetTradeTransactionResponse | null>;
+    /**
+     * Gets the expected output amount for a trade using the specified aggregator
+     * This is a lightweight method that only fetches the route and returns the output amount
+     * without building a transaction
+     *
+     * @param aggregator - The aggregator to use for calculating output amount
+     * @param params - Trade route parameters including token types and input amount
+     * @returns Promise resolving to the expected output amount in smallest unit, or null if no route found
+     */
+    getAmountOut(aggregator: SupportedAggregator, params: GetTradeRouteRequest_5): Promise<bigint | null>;
+    /**
+     * Finds the best output amount across all aggregators without building a transaction
+     * This method queries all available aggregators in parallel and returns the aggregator
+     * that provides the highest output amount along with that amount
+     *
+     * @param params - Trade route parameters including token types and input amount
+     * @returns Promise resolving to an object containing the best output amount and the aggregator that provided it, or null if no routes found
+     */
+    getBestAmountOut(params: GetTradeRouteRequest_5): Promise<{
+        amountOut: bigint;
+        aggregator: SupportedAggregator;
+    } | null>;
+}
+
+export declare type AlphalendPositionResponse = {
+    positionId: string;
+    netWorth: number;
+    dailyEarnings: number;
+    netApr: number;
+    safeBorrowLimit: number;
+    borrowLimitUsed: number;
+    liquidationThreshold: number;
+    totalSuppliedUsd: number;
+    aggregatedSupplyApr: number;
+    totalBorrowedUsd: number;
+    aggregatedBorrowApr: number;
+    suppliedAmounts: {
+        coinType: string;
+        amount: number;
+    }[];
+    borrowedAmounts: {
+        coinType: string;
+        amount: number;
+    }[];
+    rewardsToClaimUsd: number;
+    rewardsToClaim: {
+        coinType: string;
+        rewardAmount: number;
+    }[];
+};
+
+declare class CetusAggregator {
+    private _config;
+    private _suiClient;
+    private _cetusClient;
+    private getCetusClientConfig;
+    constructor(config: CetusAggregatorConfig, suiClient: SuiGrpcClient);
+    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
+     * @param params.metaAggregator - If true, only meta-supported protocols are used and no extra overlay fee is applied
+     * @returns Promise resolving to router data with pricing and route information, or null if no route found
+     */
+    getTradeRoute({ coinInAmount, coinInType, coinOutType, tradeFee, metaAggregator, supportedProtocols, }: GetTradeRouteRequest_3 & {
+        supportedProtocols?: string[];
+    }): 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, metaAggregator, }: GetTransactionRequest_3): Promise<Uint8Array>;
+}
+
+declare namespace CetusAggregator {
+    function toCommonTradeRoutes(tradeRoute: RouterDataV3, coinInType: string, coinOutType: string): FinalTradeRoute | null;
+}
+
+declare type CetusAggregatorConfig = {
+    defaultTradeFee: TradeFeeOptions;
+    cetusApiKey?: string;
+    cetusApiEndpoint?: string;
+    cetusPartnerId?: string;
+};
+
+/** A single quote request in a {@link CoinAmountOutRequest} batch. */
+export declare type CoinAmountOutItem = {
+    coin_in_amount: string;
+    coin_in_type: string;
+    coin_out_type: string;
+};
+
+export declare type CoinAmountOutRequest = CoinAmountOutItem[];
+
+declare class CurveModule implements IModule {
+    readonly sdk: NoodlesSdk;
+    constructor(sdk: NoodlesSdk);
+    getEstimatedAmountOut(platform: SupportedBondingCurve, params: GetCurveEstimatedAmountOutRequest): Promise<bigint>;
+    getTradeTransaction(platform: SupportedBondingCurve, params: GetCurveTradeTransactionRequest): Promise<Uint8Array>;
+}
+
+declare enum Environment {
+    Prod = "prod",
+    Staging = "staging"
+}
+
+declare type FinalTradeRoute = {
+    coinIn: string;
+    coinOut: string;
+    amountIn: bigint;
+    amountOut: bigint;
+    routes: TradeRoute[];
+};
+
+declare class FlowXAggregator {
+    private _config;
+    private _suiClient;
+    constructor(config: FlowXAggregatorConfig, suiClient: SuiGrpcClient);
+    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
+     * @param params.metaAggregator - If true, only meta-supported DEXs are used and no extra commission is applied
+     * @returns Promise resolving to routes result with pricing and path information, or null if no route found
+     */
+    getTradeRoute({ coinInAmount, coinInType, coinOutType, tradeFee, metaAggregator, supportedProtocols, }: GetTradeRouteRequest_4 & {
+        supportedProtocols?: Protocol[];
+    }): 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, metaAggregator, }: GetTransactionRequest_4): Promise<Uint8Array>;
+}
+
+declare namespace FlowXAggregator {
+    function toCommonTradeRoutes(tradeRoute: GetRoutesResult<Coin, Coin>): FinalTradeRoute | null;
+}
+
+declare type FlowXAggregatorConfig = {
+    defaultTradeFee: TradeFeeOptions;
+    flowxApiKey?: string;
+};
+
+declare type GetCurveEstimatedAmountOutRequest = {
+    /** 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;
+    /** The bonding curve Pool ID */
+    poolId: string;
+};
+
+declare type GetCurveTradeTransactionRequest = {
+    /** 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;
+};
+
+declare type GetTradeRouteRequest = {
+    /** coinInAmount is in the input coin's smallest unit (base units, not decimals). */
+    coinInAmount: bigint;
+    coinInType: string;
+    coinOutType: string;
+    /** Overrides defaultTradeFee for this request only. */
+    tradeFee?: TradeFeeOptions;
+};
+
+declare type GetTradeRouteRequest_2 = {
+    /** coinInAmount is in the input coin's smallest unit (base units, not decimals). */
+    coinInAmount: bigint;
+    coinInType: string;
+    coinOutType: string;
+    /** Overrides defaultTradeFee for this request only. */
+    tradeFee?: TradeFeeOptions;
+    /** When true, restrict to meta-supported DEXs and charge no commission (the meta-aggregator adds its own overlay fee). */
+    metaAggregator?: boolean;
+};
+
+declare type GetTradeRouteRequest_3 = {
+    /** coinInAmount is in the input coin's smallest unit (base units, not decimals). */
+    coinInAmount: bigint;
+    coinInType: string;
+    coinOutType: string;
+    /** Overrides defaultTradeFee for this request only. */
+    tradeFee?: TradeFeeOptions;
+    /** When true, restrict to meta-supported protocols and add no overlay fee (the meta-aggregator owns the fee). */
+    metaAggregator?: boolean;
+};
+
+declare type GetTradeRouteRequest_4 = {
+    /** coinInAmount is in the input coin's smallest unit (base units, not decimals). */
+    coinInAmount: bigint;
+    coinInType: string;
+    coinOutType: string;
+    /** Overrides defaultTradeFee for this request only. */
+    tradeFee?: TradeFeeOptions;
+    /** When true, restrict to meta-supported DEXs and charge no commission (the meta-aggregator owns the fee). */
+    metaAggregator?: boolean;
+};
+
+declare type GetTradeRouteRequest_5 = {
+    /** Input amount in the coin's smallest unit (base-units, not decimals) */
+    coinInAmount: bigint;
+    coinInType: string;
+    coinOutType: string;
+    /** Overrides the SDK's default trade fee for this request */
+    tradeFee?: TradeFeeOptions;
+    /** Restrict to meta-supported aggregators, charging no extra aggregator fee */
+    metaAggregator?: boolean;
+};
+
+declare type GetTradeRouteResponse = {
+    route: FinalTradeRoute;
+    /** Raw aggregator response; shape varies per aggregator, passed back to build the tx */
+    aggregatorRoute: any;
+};
+
+declare type GetTradeTransactionRequest = {
+    /** Input amount in the coin's smallest unit (base-units, not decimals) */
+    coinInAmount: bigint;
+    coinInType: string;
+    coinOutType: string;
+    walletAddress: string;
+    /** Slippage tolerance as decimal (e.g. 0.01 for 1%) */
+    slippage: number;
+    /** Overrides the SDK's default trade fee for this request */
+    tradeFee?: TradeFeeOptions;
+    /** Restrict to meta-supported aggregators, charging no extra aggregator fee */
+    metaAggregator?: boolean;
+    poolId: string;
+};
+
+declare type GetTradeTransactionResponse = {
+    route: FinalTradeRoute;
+    aggregatorRoute: any;
+    /** Built transaction bytes ready for signing and execution */
+    transaction: Uint8Array;
+};
+
+declare type GetTransactionByRouteRequest = {
+    walletAddress: string;
+    /** Raw aggregator response from a prior getTradeRoute call */
+    completeRoute: any;
+    /** Slippage tolerance as decimal (e.g. 0.01 for 1%) */
+    slippage: number;
+    /** Overrides the SDK's default trade fee for this request */
+    tradeFee?: TradeFeeOptions;
+    /** Skip the extra aggregator fee on Cetus, FlowX, and 7K routes */
+    metaAggregator?: boolean;
+};
+
+declare type GetTransactionRequest = {
+    walletAddress: string;
+    completeRoute: RouterCompleteTradeRoute;
+    /** Slippage tolerance as a fraction, e.g. 0.01 for 1%. */
+    slippage: number;
+};
+
+declare type GetTransactionRequest_2 = {
+    walletAddress: string;
+    completeRoute: QuoteResponse;
+    /** Slippage tolerance as a fraction, e.g. 0.01 for 1%. */
+    slippage: number;
+    tradeFee?: TradeFeeOptions;
+    /** When true, charge no commission (the meta-aggregator owns the fee). */
+    metaAggregator?: boolean;
+};
+
+declare type GetTransactionRequest_3 = {
+    walletAddress: string;
+    completeRoute: RouterDataV3;
+    /** Slippage tolerance as a fraction, e.g. 0.01 for 1%. */
+    slippage: number;
+    tradeFee?: TradeFeeOptions;
+    /** When true, add no overlay fee (the meta-aggregator owns the fee). */
+    metaAggregator?: boolean;
+};
+
+declare type GetTransactionRequest_4 = {
+    walletAddress: string;
+    completeRoute: GetRoutesResult<Coin, Coin>;
+    /** Slippage tolerance as a fraction, e.g. 0.01 for 1%. */
+    slippage: number;
+    tradeFee?: TradeFeeOptions;
+    /** When true, charge no commission (the meta-aggregator owns the fee). */
+    metaAggregator?: boolean;
+};
+
+declare interface IModule {
+    readonly sdk: NoodlesSdk;
+}
+
+/**
+ * Thrown by the portfolio methods when the supplied wallet address is not a
+ * valid Sui address. Consumers can catch this to map it to a 400 response.
+ */
+export declare class InvalidSuiAddressError extends Error {
+    constructor(address: string);
+}
+
+export declare type LendingResponse = {
+    scallop: ScallopPositionResponse | undefined;
+    navi: NaviPositionResponse | undefined;
+    alphalend: AlphalendPositionResponse[];
+};
+
+export declare type NaviPositionResponse = {
+    borrows: {
+        coinType: string;
+        amount: number;
+    }[];
+    supplies: {
+        coinType: string;
+        amount: number;
+    }[];
+};
+
+declare enum Network {
+    Mainnet = "mainnet",
+    Testnet = "testnet"
+}
+
+/**
+ * Read-only portfolio SDK: aggregates a wallet's lending positions across
+ * Scallop, Navi and Alphalend, and resolves best-rate output amounts for a
+ * batch of coin pairs.
+ *
+ * It is the library form of the Noodles backend's `PortfolioHandler` — it only
+ * fetches and shapes data, leaving HTTP/transport concerns to the caller.
+ */
+export declare class NoodlesPortfolioSdk {
+    private readonly noodlesSdk;
+    private readonly scallopAddressId;
+    private scallopQuery;
+    private alphalendClient;
+    constructor(options: NoodlesPortfolioSdkOptions);
+    private assertValidAddress;
+    private getScallopQuery;
+    private getAlphalendClient;
+    /**
+     * Fetches the wallet's full Scallop portfolio (lendings, borrowings, veSCA, etc.).
+     * @param address - The wallet's Sui address.
+     * @returns The wallet's Scallop position.
+     * @throws {InvalidSuiAddressError} If `address` is not a valid Sui address.
+     */
+    getScallopPosition(address: string): Promise<ScallopPositionResponse>;
+    /**
+     * Fetches the wallet's Navi supply/borrow balances via `@naviprotocol/lending`
+     * (the successor to the legacy `navi-sdk`). Regular and e-mode positions are
+     * folded into the same `supplies`/`borrows` lists; zero-amount entries are dropped.
+     *
+     * Runs on a nested @mysten/sui v1 (see file header); no client is passed so navi
+     * builds its own v1 client.
+     * @param address - The wallet's Sui address.
+     * @returns The wallet's Navi supplies and borrows.
+     * @throws {InvalidSuiAddressError} If `address` is not a valid Sui address.
+     */
+    getNaviPosition(address: string): Promise<NaviPositionResponse>;
+    /**
+     * Fetches the wallet's Alphalend positions, resolving each market id to its coin type.
+     * @param address - The wallet's Sui address.
+     * @returns One entry per Alphalend position; empty when the wallet has none.
+     * @throws {InvalidSuiAddressError} If `address` is not a valid Sui address.
+     */
+    getAlphalendPosition(address: string): Promise<AlphalendPositionResponse[]>;
+    /**
+     * Fetches the wallet's positions across all supported lending protocols in
+     * parallel (Scallop, Navi, Alphalend).
+     * @param address - The wallet's Sui address.
+     * @returns The per-protocol positions keyed by `scallop`, `navi`, and `alphalend`.
+     * @throws {InvalidSuiAddressError} If `address` is not a valid Sui address.
+     */
+    getAllLendingPositions(address: string): Promise<LendingResponse>;
+    /**
+     * Resolves the best-rate output amount (as a base-unit string) for each
+     * requested coin pair, querying the aggregator in parallel batches.
+     * @param request - Coin pairs to quote, each `{ coin_in_amount, coin_in_type, coin_out_type }`.
+     * @returns One base-unit amount string per request item, index-aligned with `request`;
+     * a pair with no available route resolves to `"0"`.
+     */
+    getCoinAmountOut(request: CoinAmountOutRequest): Promise<string[]>;
+}
+
+export declare type NoodlesPortfolioSdkOptions = {
+    /**
+     * The main Noodles SDK instance — used for aggregator quoting
+     * ({@link NoodlesPortfolioSdk.getCoinAmountOut}).
+     */
+    noodlesSdk: NoodlesSdk;
+    /** Override the Scallop address registry id (defaults to mainnet). */
+    scallopAddressId?: string;
+};
+
+declare class NoodlesSdk {
+    readonly network: Network;
+    readonly env: Environment;
+    readonly options: SdkOptions;
+    private _suiGrpcClient;
+    private _suiJsonRpcClient;
+    readonly aggregatorModule: AggregatorModule;
+    readonly curveModule: CurveModule;
+    constructor(options: SdkOptions, network?: Network, env?: Environment);
+    get suiClient(): SuiGrpcClient;
+    get suiJsonRpcClient(): SuiJsonRpcClient;
+}
+
+/**
+ * Response/request types for {@link NoodlesPortfolioSdk}.
+ */
+export declare type ScallopPositionResponse = {
+    totalLockedScaValue: number;
+    lendings: {
+        suppliedCoin: number;
+        suppliedValue: number;
+        stakedCoin: number;
+        coinName: string;
+        symbol: string;
+        coinType: string;
+        coinPrice: number;
+        coinDecimals: number;
+        supplyApr: number;
+        supplyApy: number;
+        incentiveApr: number;
+    }[];
+    borrowings: {
+        obligationId: string;
+        totalDebtsInUsd: number;
+        totalCollateralInUsd: number;
+        riskLevel: number;
+        availableCollateralInUsd: number;
+        totalUnhealthyCollateralInUsd: number;
+        collaterals: {
+            coinName: string;
+            symbol: string;
+            coinDecimals: number;
+            coinType: string;
+            coinPrice: number;
+            depositedCoin: number;
+            depositedValueInUsd: number;
+        }[];
+        borrowedPools: {
+            coinName: string;
+            symbol: string;
+            coinDecimals: number;
+            coinType: string;
+            coinPrice: number;
+            borrowedCoin: number;
+            borrowedValueInUsd: number;
+            borrowApr: number | undefined;
+            borrowApy: number | undefined;
+            incentiveInfos: {
+                coinName: string;
+                symbol: string;
+                coinType: string;
+                incentiveApr: number;
+            }[];
+        }[];
+    }[];
+    pendingRewards: {
+        lendings: any;
+        borrowIncentives: any;
+    };
+    veScas: {
+        veScaKey: string;
+        coinPrice: number;
+        lockedScaInCoin: number;
+        lockedScaInUsd: number;
+        currentVeScaBalance: number;
+        remainingLockPeriodInDays: number;
+        unlockAt: number;
+    }[];
+    totalDebtValue: number;
+    totalCollateralValue: number;
+    totalSupplyValue: number;
+};
+
+/**
+ * Sui clients used by the SDK.
+ *
+ * `grpc` is required. `jsonRpc` is optional — when omitted, the SDK creates a
+ * default JSON-RPC client against the public Sui fullnode for the SDK network.
+ * (JSON-RPC is still required by third-party SDKs such as Aftermath and Pyth.)
+ */
+declare type SdkClients = {
+    grpc: SuiGrpcClient;
+    jsonRpc?: SuiJsonRpcClient;
+};
+
+declare type SdkOptions = {
+    clients: SdkClients;
+    tradeFee: TradeFeeOptions;
+    /** Optional API key for Astros aggregator access */
+    astrosApiKey?: string;
+    /** Optional API key for authenticated Aftermath API access */
+    aftermathApiKey?: string;
+    /** Optional custom Aftermath API endpoint (defaults to MAINNET if not provided) */
+    aftermathApiEndpoint?: string;
+    /** Optional API key for 7K Protocol access */
+    sevenKApiKey?: string;
+    /** Optional API key for Cetus aggregator access */
+    cetusApiKey?: string;
+    /** Optional custom Cetus API endpoint */
+    cetusApiEndpoint?: string;
+    /** Optional partner ID for Cetus integration */
+    cetusPartnerId?: string;
+    /** Optional API key for FlowX aggregator access */
+    flowxApiKey?: string;
+};
+
+declare class SevenKAggregator {
+    private _config;
+    private _suiClient;
+    constructor(config: SevenKAggregatorConfig, suiClient: SuiGrpcClient);
+    /**
+     * 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
+     * @param params.metaAggregator - If true, only meta-supported DEXs are used and no extra commission is applied
+     * @returns Promise resolving to quote response with pricing and route information, or null if no route found
+     */
+    getTradeRoute({ coinInAmount, coinInType, coinOutType, tradeFee, metaAggregator, supportedProtocols, }: GetTradeRouteRequest_2 & {
+        supportedProtocols?: SourceDex[];
+    }): 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, metaAggregator, }: GetTransactionRequest_2): Promise<Uint8Array>;
+}
+
+declare namespace SevenKAggregator {
+    function toCommonTradeRoutes(tradeRouteResponse: QuoteResponse): FinalTradeRoute | null;
+}
+
+declare type SevenKAggregatorConfig = {
+    defaultTradeFee: TradeFeeOptions;
+    sevenKApiKey?: string;
+};
+
+declare enum SupportedAggregator {
+    AFTERMATH = "AFTERMATH",
+    SEVENK = "7K",
+    CETUS = "CETUS",
+    FLOWX = "FLOWX"
+}
+
+declare enum SupportedBondingCurve {
+    BLAST_FUN = "BLAST_FUN",
+    MOONBAGS = "MOONBAGS"
+}
+
+declare type TradeFeeOptions = {
+    /** Decimal fraction, not bps: 0.01 = 1%, 0.003 = 0.3% */
+    tradeFeePercent: number;
+    tradeFeeRecipientAddress: string;
+};
+
+declare namespace TradeFeeOptions {
+    function equals(a: TradeFeeOptions, b: TradeFeeOptions): boolean;
+}
+
+declare type TradePath = {
+    poolAddress: string;
+    coinIn: string;
+    coinOut: string;
+    amountIn: bigint;
+    amountOut: bigint;
+};
+
+declare type TradeRoute = {
+    coinIn: string;
+    coinOut: string;
+    amountIn: bigint;
+    amountOut: bigint;
+    paths: TradePath[];
+};
+
+export { }