@cetusprotocol/aggregator-sdk 0.0.8 → 0.1.1

package/dist/src/api.d.ts

@@ -0,0 +1,53 @@
+import BN from "bn.js";
+import Decimal from "decimal.js";
+export interface FindRouterParams {
+    from: string;
+    target: string;
+    amount: BN;
+    byAmountIn: boolean;
+    depth?: number;
+    splitAlgorithm?: string;
+    splitFactor?: number;
+    splitCount?: number;
+    providers?: string[];
+}
+export type ExtendedDetails = {
+    aftermathPoolFlatness?: number;
+    aftermathLpSupplyType?: string;
+    turbosFeeType?: string;
+};
+export type Path = {
+    id: string;
+    direction: 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 RouterError = {
+    code: number;
+    msg: string;
+};
+export type RouterData = {
+    amountIn: BN;
+    amountOut: BN;
+    routes: Router[];
+    insufficientLiquidity: boolean;
+    error?: RouterError;
+};
+export type AggregatorResponse = {
+    code: number;
+    msg: string;
+    data: RouterData;
+};
+export declare function getRouterResult(endpoint: string, params: FindRouterParams): Promise<RouterData | null>;

package/dist/src/client.d.ts

@@ -1,71 +1,36 @@
-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 { SuiClient } from "@mysten/sui/client";
+import { Transaction, TransactionObjectArgument } from "@mysten/sui/transactions";
+import { Signer } from "@mysten/sui/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 RouterError = {
-    code: number;
-    msg: string;
-};
-export type RouterData = {
-    amountIn: BN;
-    amountOut: BN;
-    routes: Router[];
-    insufficientLiquidity: boolean;
-    error?: RouterError;
-};
-export type AggregatorResponse = {
-    code: number;
-    msg: string;
-    data: RouterData;
-};
+import { Dex, Env, FindRouterParams, Router, RouterData } from ".";
+import { CoinAsset } from "./types/sui";
+export declare const CETUS = "CETUS";
+export declare const DEEPBOOKV2 = "DEEPBOOK";
+export declare const KRIYA = "KRIYA";
+export declare const FLOWXV2 = "FLOWX";
+export declare const KRIYAV3 = "KRIYAV3";
+export declare const TURBOS = "TURBOS";
+export declare const AFTERMATH = "AFTERMATH";
+export declare const HAEDAL = "HAEDAL";
+export declare const VOLO = "VOLO";
+export declare const AFSUI = "AFSUI";
 export type BuildRouterSwapParams = {
     routers: Router[];
-    amountIn: BN;
-    amountOut: BN;
     byAmountIn: boolean;
+    inputCoin: TransactionObjectArgument;
     slippage: number;
-    fromCoinType: string;
-    targetCoinType: string;
+    txb: Transaction;
+    partner?: string;
+};
+export type BuildFastRouterSwapParams = {
+    routers: Router[];
+    byAmountIn: boolean;
+    slippage: number;
+    txb: Transaction;
     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;
@@ -78,15 +43,23 @@ export interface SwapInPoolsResult {
     routeData?: RouterData;
 }
 export declare class AggregatorClient {
-    private config;
-    private wallet;
-    private client;
+    endpoint: string;
+    signer: string;
+    client: SuiClient;
+    env: Env;
     private allCoins;
-    constructor(config: AggregatorConfig);
+    constructor(endpoint: string, signer: string, client: SuiClient, env: Env);
     getAllCoins(): Promise<CoinAsset[]>;
-    findRouter(fromRouterParams: FindRouterParams): Promise<RouterData | null>;
+    findRouters(params: FindRouterParams): Promise<RouterData | null>;
+    expectInputSwap(txb: Transaction, inputCoin: TransactionObjectArgument, routers: Router[], amountOutLimit: BN, partner?: string): Promise<TransactionObjectArgument>;
+    expectOutputSwap(txb: Transaction, inputCoin: TransactionObjectArgument, routers: Router[], partner?: string): Promise<TransactionObjectArgument>;
     swapInPools(params: SwapInPoolsParams): Promise<SwapInPoolsResult | null>;
-    routerSwap(params: BuildRouterSwapParams): Promise<Transaction>;
+    routerSwap(params: BuildRouterSwapParams): Promise<TransactionObjectArgument>;
+    fastRouterSwap(params: BuildFastRouterSwapParams): Promise<void>;
+    publishedAt(): string;
+    transferOrDestoryCoin(txb: Transaction, coin: TransactionObjectArgument, coinType: string): void;
+    checkCoinThresholdAndMergeCoin(txb: Transaction, coins: TransactionObjectArgument[], coinType: string, amountLimit: BN): TransactionObjectArgument;
+    newDex(provider: string, partner?: string): Dex;
     signAndExecuteTransaction(txb: Transaction, signer: Signer): Promise<import("@mysten/sui/client").SuiTransactionBlockResponse>;
     devInspectTransactionBlock(txb: Transaction): Promise<import("@mysten/sui/client").DevInspectResults>;
     sendTransaction(txb: Transaction, signer: Signer): Promise<import("@mysten/sui/client").SuiTransactionBlockResponse>;

package/dist/src/const.d.ts

@@ -1,59 +1,4 @@
 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;
@@ -61,16 +6,3 @@ export declare const U128: BN;
 export declare const U64_MAX_BN: BN;
 export declare const U64_MAX = "18446744073709551615";
 export declare const TEN_POW_NINE = 1000000000;
-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/index.d.ts

@@ -1,5 +1,9 @@
-export * from './client';
-export * from './transaction';
-export * from './config';
-export * from './utils';
-export * from './const';
+export * from "./client";
+export * from "./transaction";
+export * from "./utils";
+export * from "./const";
+export * from "./api";
+export declare enum Env {
+    Mainnet = 0,
+    Testnet = 1
+}

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

@@ -0,0 +1,10 @@
+import { Transaction, TransactionObjectArgument } from "@mysten/sui/transactions";
+import { AggregatorClient, Dex, Env, Path } from "..";
+export declare class Afsui implements Dex {
+    private stakedSuiVault;
+    private safe;
+    private referVault;
+    private validator;
+    constructor(env: Env);
+    swap(client: AggregatorClient, txb: Transaction, path: Path, inputCoin: TransactionObjectArgument): Promise<TransactionObjectArgument>;
+}

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

@@ -1,24 +1,13 @@
-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>;
+import { Transaction, TransactionObjectArgument } from "@mysten/sui/transactions";
+import { AggregatorClient, Dex, Env, Path } from "..";
+export declare class Aftermath implements Dex {
+    private slippage;
+    private poolRegistry;
+    private protocolFeeVault;
+    private treasury;
+    private insuranceFund;
+    private referrealVault;
+    constructor(env: Env);
+    amountLimit(exportAmountOut: number): number;
+    swap(client: AggregatorClient, txb: Transaction, path: Path, inputCoin: TransactionObjectArgument): Promise<TransactionObjectArgument>;
+}

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

@@ -1,39 +1,15 @@
 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;
-};
+import { AggregatorClient, Dex, Env, Path } from "..";
 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>;
+export declare class Cetus implements Dex {
+    private globalConfig;
+    private partner;
+    constructor(env: Env, partner?: string);
+    flash_swap(client: AggregatorClient, txb: Transaction, path: Path, by_amount_in: boolean): CetusFlashSwapResult;
+    repay_flash_swap(client: AggregatorClient, txb: Transaction, path: Path, inputCoin: TransactionObjectArgument, receipt: TransactionArgument): TransactionObjectArgument;
+    swap(client: AggregatorClient, txb: Transaction, path: Path, inputCoin: TransactionObjectArgument): Promise<TransactionObjectArgument>;
+}

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

@@ -0,0 +1,14 @@
+import { Transaction, TransactionObjectArgument } from "@mysten/sui/transactions";
+import { AggregatorClient, Dex, Env, Path } from "..";
+import { SuiClient } from "@mysten/sui/client";
+type GetOrCreateAccountCapResult = {
+    accountCap: TransactionObjectArgument;
+    isCreate: boolean;
+};
+export declare class DeepbookV2 implements Dex {
+    constructor(env: Env);
+    getAccountCap(client: SuiClient, owner: string): Promise<string | null>;
+    getOrCreateAccountCap(txb: Transaction, client: SuiClient, owner: string): Promise<GetOrCreateAccountCapResult>;
+    swap(client: AggregatorClient, txb: Transaction, path: Path, inputCoin: TransactionObjectArgument): Promise<TransactionObjectArgument>;
+}
+export {};

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

@@ -0,0 +1,7 @@
+import { Transaction, TransactionObjectArgument } from "@mysten/sui/transactions";
+import { AggregatorClient, Dex, Env, Path } from "..";
+export declare class FlowxV2 implements Dex {
+    private container;
+    constructor(env: Env);
+    swap(client: AggregatorClient, txb: Transaction, path: Path, inputCoin: TransactionObjectArgument): Promise<TransactionObjectArgument>;
+}

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

@@ -0,0 +1,6 @@
+import { Transaction, TransactionObjectArgument } from "@mysten/sui/transactions";
+import { AggregatorClient, Dex, Env, Path } from "..";
+export declare class Haedal implements Dex {
+    constructor(env: Env);
+    swap(client: AggregatorClient, txb: Transaction, path: Path, inputCoin: TransactionObjectArgument): Promise<TransactionObjectArgument>;
+}

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

@@ -1 +1,6 @@
-export * from "./router";
+import { Transaction, TransactionObjectArgument } from "@mysten/sui/transactions";
+import { AggregatorClient, Path } from "..";
+export declare const CLOCK_ADDRESS = "0x0000000000000000000000000000000000000000000000000000000000000006";
+export interface Dex {
+    swap(client: AggregatorClient, ptb: Transaction, path: Path, inputCoin: TransactionObjectArgument): Promise<TransactionObjectArgument>;
+}

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

@@ -0,0 +1,6 @@
+import { Transaction, TransactionObjectArgument } from "@mysten/sui/transactions";
+import { AggregatorClient, Dex, Env, Path } from "..";
+export declare class KriyaV2 implements Dex {
+    constructor(env: Env);
+    swap(client: AggregatorClient, txb: Transaction, path: Path, inputCoin: TransactionObjectArgument): Promise<TransactionObjectArgument>;
+}

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

@@ -0,0 +1,7 @@
+import { Transaction, TransactionObjectArgument } from "@mysten/sui/transactions";
+import { AggregatorClient, Dex, Env, Path } from "..";
+export declare class KriyaV3 implements Dex {
+    private version;
+    constructor(env: Env);
+    swap(client: AggregatorClient, txb: Transaction, path: Path, inputCoin: TransactionObjectArgument): Promise<TransactionObjectArgument>;
+}

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

@@ -1,5 +1,4 @@
 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>;
+export declare function swapInPools(client: SuiClient, params: SwapInPoolsParams, sender: string): Promise<SwapInPoolsResult>;

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

@@ -1,22 +1,7 @@
-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 turbosClmmSwapMovecall(swapParams: TurbosSwapParams, txb: Transaction, config: AggregatorConfig): Promise<TurbosSwapResult>;
+import { Transaction, TransactionObjectArgument } from "@mysten/sui/transactions";
+import { AggregatorClient, Dex, Env, Path } from "..";
+export declare class Turbos implements Dex {
+    private versioned;
+    constructor(env: Env);
+    swap(client: AggregatorClient, txb: Transaction, path: Path, inputCoin: TransactionObjectArgument): Promise<TransactionObjectArgument>;
+}

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

@@ -0,0 +1,8 @@
+import { Transaction, TransactionObjectArgument } from "@mysten/sui/transactions";
+import { AggregatorClient, Dex, Env, Path } from "..";
+export declare class Volo implements Dex {
+    private nativePool;
+    private metadata;
+    constructor(env: Env);
+    swap(client: AggregatorClient, txb: Transaction, path: Path, inputCoin: TransactionObjectArgument): Promise<TransactionObjectArgument>;
+}

package/dist/src/utils/coin.d.ts

@@ -1,2 +1,11 @@
+import { CoinAsset } from "../types/sui";
+import { Transaction, TransactionObjectArgument } from "@mysten/sui/transactions";
 export declare function completionCoin(s: string): string;
 export declare function compareCoins(coinA: string, coinB: string): boolean;
+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;

package/dist/{src → tests}/test_data.test.d.ts

@@ -6,3 +6,4 @@ 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";
+export declare const M_SSWP = "0x361dd589b98e8fcda9a7ee53b85efabef3569d00416640d2faa516e3801d7ffc::TOKEN::TOKEN";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cetusprotocol/aggregator-sdk",
-  "version": "0.0.8",
+  "version": "0.1.1",
   "sideEffects": false,
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -27,7 +27,7 @@
     "@babel/preset-env": "^7.24.5",
     "@babel/preset-typescript": "^7.24.1",
     "@jest/globals": "^29.7.0",
-    "@mysten/sui": "^1.0.5",
+    "@mysten/sui": "^1.6.0",
     "@types/jest": "^29.5.12",
     "@types/node": "^20.12.12",
     "babel-jest": "^29.7.0",

package/src/api.ts

@@ -0,0 +1,144 @@
+import BN from "bn.js"
+import Decimal from "decimal.js"
+import { completionCoin } from "~/utils/coin"
+import { ZERO } from "./const"
+import {
+  AggregatorServerErrorCode,
+  getAggregatorServerErrorMessage,
+} from "./errors"
+import { parseRouterResponse } from "./client"
+
+export interface FindRouterParams {
+  from: string
+  target: string
+  amount: BN
+  byAmountIn: boolean
+  depth?: number
+  splitAlgorithm?: string
+  splitFactor?: number
+  splitCount?: number
+  providers?: string[]
+}
+
+export type ExtendedDetails = {
+  aftermathPoolFlatness?: number
+  aftermathLpSupplyType?: string
+  turbosFeeType?: string
+}
+
+export type Path = {
+  id: string
+  direction: 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 RouterError = {
+  code: number
+  msg: string
+}
+
+export type RouterData = {
+  amountIn: BN
+  amountOut: BN
+  routes: Router[]
+  insufficientLiquidity: boolean
+  error?: RouterError
+}
+
+export type AggregatorResponse = {
+  code: number
+  msg: string
+  data: RouterData
+}
+
+export async function getRouterResult(
+  endpoint: string,
+  params: FindRouterParams
+): Promise<RouterData | null> {
+  const {
+    from,
+    target,
+    amount,
+    byAmountIn,
+    depth,
+    splitAlgorithm,
+    splitFactor,
+    splitCount,
+    providers,
+  } = params
+  const fromCoin = completionCoin(from)
+  const targetCoin = completionCoin(target)
+
+  let url = `${endpoint}?from=${fromCoin}&target=${targetCoin}&amount=${amount.toString()}&by_amount_in=${byAmountIn}`
+
+  if (depth) {
+    url += `&depth=${depth}`
+  }
+
+  if (splitAlgorithm) {
+    url += `&split_algorithm=${splitAlgorithm}`
+  }
+
+  if (splitFactor) {
+    url += `&split_factor=${splitFactor}`
+  }
+
+  if (splitCount) {
+    url += `&split_count=${splitCount}`
+  }
+
+  if (providers) {
+    if (providers.length > 0) {
+      url += `&providers=${providers.join(",")}`
+    }
+  }
+
+  const response = await fetch(url)
+  if (!response.ok) {
+    return {
+      amountIn: ZERO,
+      amountOut: ZERO,
+      routes: [],
+      insufficientLiquidity: false,
+      error: {
+        code: AggregatorServerErrorCode.NumberTooLarge,
+        msg: getAggregatorServerErrorMessage(
+          AggregatorServerErrorCode.NumberTooLarge
+        ),
+      },
+    }
+  }
+  const data = await response.json()
+  if (data.data != null) {
+    const res = parseRouterResponse(data.data)
+    return res
+  }
+  const insufficientLiquidity = data.msg === "liquidity is not enough"
+
+  return {
+    amountIn: ZERO,
+    amountOut: ZERO,
+    routes: [],
+    insufficientLiquidity,
+    error: {
+      code: AggregatorServerErrorCode.InsufficientLiquidity,
+      msg: getAggregatorServerErrorMessage(
+        AggregatorServerErrorCode.InsufficientLiquidity
+      ),
+    },
+  }
+}