@cetusprotocol/aggregator-sdk 0.3.16 → 0.3.18

package/dist/src/api.d.ts

@@ -53,8 +53,10 @@ export type RouterError = {
 export type RouterData = {
     amountIn: BN;
     amountOut: BN;
+    byAmountIn: boolean;
     routes: Router[];
     insufficientLiquidity: boolean;
+    packages?: Map<string, string>;
     totalDeepFee?: number;
     error?: RouterError;
 };

package/dist/src/client.d.ts

@@ -21,6 +21,7 @@ export declare const SCALLOP = "SCALLOP";
 export declare const SUILEND = "SUILEND";
 export declare const BLUEFIN = "BLUEFIN";
 export declare const HAEDALPMM = "HAEDALPMM";
+export declare const ALPHAFI = "ALPHAFI";
 export declare const DEFAULT_ENDPOINT = "https://api-sui.cetus.zone/router_v2";
 export type BuildRouterSwapParams = {
     routers: Router[];
@@ -37,7 +38,22 @@ export type BuildFastRouterSwapParams = {
     slippage: number;
     txb: Transaction;
     partner?: string;
-    isMergeTragetCoin?: boolean;
+    refreshAllCoins?: boolean;
+    payDeepFeeAmount?: number;
+};
+export type BuildRouterSwapParamsV2 = {
+    routers: RouterData;
+    inputCoin: TransactionObjectArgument;
+    slippage: number;
+    txb: Transaction;
+    partner?: string;
+    deepbookv3DeepFee?: TransactionObjectArgument;
+};
+export type BuildFastRouterSwapParamsV2 = {
+    routers: RouterData;
+    slippage: number;
+    txb: Transaction;
+    partner?: string;
     refreshAllCoins?: boolean;
     payDeepFeeAmount?: number;
 };
@@ -61,20 +77,20 @@ export declare class AggregatorClient {
     constructor(endpoint?: string, signer?: string, client?: SuiClient, env?: Env);
     getCoins(coinType: string, refresh?: boolean): Promise<CoinAsset[]>;
     findRouters(params: FindRouterParams): Promise<RouterData | null>;
-    expectInputSwap(txb: Transaction, inputCoin: TransactionObjectArgument, routers: Router[], amountOutLimit: BN, partner?: string, deepbookv3DeepFee?: TransactionObjectArgument): Promise<TransactionObjectArgument>;
-    expectOutputSwap(txb: Transaction, inputCoin: TransactionObjectArgument, routers: Router[], partner?: string): Promise<TransactionObjectArgument>;
+    expectInputSwap(txb: Transaction, inputCoin: TransactionObjectArgument, routers: Router[], amountOutLimit: BN, partner?: string, deepbookv3DeepFee?: TransactionObjectArgument, packages?: Map<string, string>): Promise<TransactionObjectArgument>;
+    expectOutputSwap(txb: Transaction, inputCoin: TransactionObjectArgument, routers: Router[], partner?: string, packages?: Map<string, string>): Promise<TransactionObjectArgument>;
     swapInPools(params: SwapInPoolsParams): Promise<SwapInPoolsResult | null>;
-    routerSwap(params: BuildRouterSwapParams): Promise<TransactionObjectArgument>;
-    fastRouterSwap(params: BuildFastRouterSwapParams): Promise<void>;
-    publishedAt(): string;
+    routerSwap(params: BuildRouterSwapParams | BuildRouterSwapParamsV2): Promise<TransactionObjectArgument>;
+    fastRouterSwap(params: BuildFastRouterSwapParams | BuildFastRouterSwapParamsV2): Promise<void>;
     publishedAtV2(): string;
+    publishedAtV2Extend(): string;
     deepbookv3DeepFeeType(): string;
-    transferOrDestoryCoin(txb: Transaction, coin: TransactionObjectArgument, coinType: string): void;
-    checkCoinThresholdAndMergeCoin(txb: Transaction, coins: TransactionObjectArgument[], coinType: string, amountLimit: BN): TransactionObjectArgument;
+    transferOrDestoryCoin(txb: Transaction, coin: TransactionObjectArgument, coinType: string, aggregatorV2PublishedAt: string): void;
+    checkCoinThresholdAndMergeCoin(txb: Transaction, coins: TransactionObjectArgument[], coinType: string, amountLimit: BN, aggregatorV2PublishedAt: string): 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>;
     getDeepbookV3Config(): Promise<DeepbookV3Config | null>;
 }
-export declare function parseRouterResponse(data: any): RouterData;
+export declare function parseRouterResponse(data: any, byAmountIn: boolean): RouterData;

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

@@ -6,5 +6,5 @@ export declare class Afsui implements Dex {
     private referVault;
     private validator;
     constructor(env: Env);
-    swap(client: AggregatorClient, txb: Transaction, path: Path, inputCoin: TransactionObjectArgument): Promise<TransactionObjectArgument>;
+    swap(client: AggregatorClient, txb: Transaction, path: Path, inputCoin: TransactionObjectArgument, packages?: Map<string, string>): Promise<TransactionObjectArgument>;
 }

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

@@ -9,5 +9,5 @@ export declare class Aftermath implements Dex {
     private referrealVault;
     constructor(env: Env);
     amountLimit(exportAmountOut: string): string;
-    swap(client: AggregatorClient, txb: Transaction, path: Path, inputCoin: TransactionObjectArgument): Promise<TransactionObjectArgument>;
+    swap(client: AggregatorClient, txb: Transaction, path: Path, inputCoin: TransactionObjectArgument, packages?: Map<string, string>): Promise<TransactionObjectArgument>;
 }

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

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

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

@@ -3,5 +3,5 @@ import { AggregatorClient, Dex, Env, Path } from "..";
 export declare class Bluefin implements Dex {
     private globalConfig;
     constructor(env: Env);
-    swap(client: AggregatorClient, txb: Transaction, path: Path, inputCoin: TransactionObjectArgument): Promise<TransactionObjectArgument>;
+    swap(client: AggregatorClient, txb: Transaction, path: Path, inputCoin: TransactionObjectArgument, packages?: Map<string, string>): Promise<TransactionObjectArgument>;
 }

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

@@ -3,5 +3,5 @@ import { AggregatorClient, Dex, Env, Path } from "..";
 export declare class Bluemove implements Dex {
     private dexInfo;
     constructor(env: Env);
-    swap(client: AggregatorClient, txb: Transaction, path: Path, inputCoin: TransactionObjectArgument): Promise<TransactionObjectArgument>;
+    swap(client: AggregatorClient, txb: Transaction, path: Path, inputCoin: TransactionObjectArgument, packages?: Map<string, string>): Promise<TransactionObjectArgument>;
 }

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

@@ -9,7 +9,7 @@ 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>;
+    flash_swap(client: AggregatorClient, txb: Transaction, path: Path, by_amount_in: boolean, packages?: Map<string, string>): CetusFlashSwapResult;
+    repay_flash_swap(client: AggregatorClient, txb: Transaction, path: Path, inputCoin: TransactionObjectArgument, receipt: TransactionArgument, packages?: Map<string, string>): TransactionObjectArgument;
+    swap(client: AggregatorClient, txb: Transaction, path: Path, inputCoin: TransactionObjectArgument, packages?: Map<string, string>): Promise<TransactionObjectArgument>;
 }

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

@@ -9,6 +9,6 @@ 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>;
+    swap(client: AggregatorClient, txb: Transaction, path: Path, inputCoin: TransactionObjectArgument, packages?: Map<string, string>): Promise<TransactionObjectArgument>;
 }
 export {};

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

@@ -8,5 +8,5 @@ export type CetusFlashSwapResult = {
 export declare class DeepbookV3 implements Dex {
     private deepbookV3Config;
     constructor(env: Env);
-    swap(client: AggregatorClient, txb: Transaction, path: Path, inputCoin: TransactionObjectArgument, deepbookv3DeepFee?: TransactionObjectArgument): Promise<TransactionObjectArgument>;
+    swap(client: AggregatorClient, txb: Transaction, path: Path, inputCoin: TransactionObjectArgument, packages?: Map<string, string>, deepbookv3DeepFee?: TransactionObjectArgument): Promise<TransactionObjectArgument>;
 }

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

@@ -3,5 +3,5 @@ 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>;
+    swap(client: AggregatorClient, txb: Transaction, path: Path, inputCoin: TransactionObjectArgument, packages?: Map<string, string>): Promise<TransactionObjectArgument>;
 }

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

@@ -4,5 +4,5 @@ export declare class FlowxV3 implements Dex {
     private versioned;
     private poolRegistry;
     constructor(env: Env);
-    swap(client: AggregatorClient, txb: Transaction, path: Path, inputCoin: TransactionObjectArgument): Promise<TransactionObjectArgument>;
+    swap(client: AggregatorClient, txb: Transaction, path: Path, inputCoin: TransactionObjectArgument, packages?: Map<string, string>): Promise<TransactionObjectArgument>;
 }

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

@@ -2,5 +2,5 @@ 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>;
+    swap(client: AggregatorClient, txb: Transaction, path: Path, inputCoin: TransactionObjectArgument, packages?: Map<string, string>): Promise<TransactionObjectArgument>;
 }

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

@@ -5,5 +5,5 @@ export declare class HaedalPmm implements Dex {
     private connection;
     private pythClient;
     constructor(env: Env, suiClient: SuiClient);
-    swap(client: AggregatorClient, txb: Transaction, path: Path, inputCoin: TransactionObjectArgument): Promise<TransactionObjectArgument>;
+    swap(client: AggregatorClient, txb: Transaction, path: Path, inputCoin: TransactionObjectArgument, packages?: Map<string, string>): Promise<TransactionObjectArgument>;
 }

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

@@ -1,6 +1,10 @@
 import { Transaction, TransactionObjectArgument } from "@mysten/sui/transactions";
 import { AggregatorClient, Path } from "..";
 export declare const CLOCK_ADDRESS = "0x0000000000000000000000000000000000000000000000000000000000000006";
+export declare const AGGREGATOR_V2 = "aggregator_v2";
+export declare const AGGREGATOR_V2_EXTEND = "aggregator_v2_extend";
+export declare function getAggregatorV2PublishedAt(aggregatorV2PublishedAt: string, packages?: Map<string, string> | Record<string, string>): string;
+export declare function getAggregatorV2ExtendPublishedAt(aggregatorV2ExtendPublishedAt: string, packages?: Map<string, string> | Record<string, string>): string;
 export interface Dex {
-    swap(client: AggregatorClient, ptb: Transaction, path: Path, inputCoin: TransactionObjectArgument, deepbookv3DeepFee?: TransactionObjectArgument): Promise<TransactionObjectArgument>;
+    swap(client: AggregatorClient, ptb: Transaction, path: Path, inputCoin: TransactionObjectArgument, packages?: Map<string, string>, deepbookv3DeepFee?: TransactionObjectArgument): Promise<TransactionObjectArgument>;
 }

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

@@ -2,5 +2,5 @@ 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>;
+    swap(client: AggregatorClient, txb: Transaction, path: Path, inputCoin: TransactionObjectArgument, packages?: Map<string, string>): Promise<TransactionObjectArgument>;
 }

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

@@ -3,5 +3,5 @@ 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>;
+    swap(client: AggregatorClient, txb: Transaction, path: Path, inputCoin: TransactionObjectArgument, packages?: Map<string, string>): Promise<TransactionObjectArgument>;
 }

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

@@ -4,5 +4,5 @@ export declare class Scallop implements Dex {
     private version;
     private market;
     constructor(env: Env);
-    swap(client: AggregatorClient, txb: Transaction, path: Path, inputCoin: TransactionObjectArgument): Promise<TransactionObjectArgument>;
+    swap(client: AggregatorClient, txb: Transaction, path: Path, inputCoin: TransactionObjectArgument, packages?: Map<string, string>): Promise<TransactionObjectArgument>;
 }

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

@@ -1,8 +1,7 @@
 import { Transaction, TransactionObjectArgument } from "@mysten/sui/transactions";
 import { AggregatorClient, Dex, Env, Path } from "..";
 export declare class Suilend implements Dex {
-    private liquid_staking_pool;
     private sui_system_state;
     constructor(env: Env);
-    swap(client: AggregatorClient, txb: Transaction, path: Path, inputCoin: TransactionObjectArgument): Promise<TransactionObjectArgument>;
+    swap(client: AggregatorClient, txb: Transaction, path: Path, inputCoin: TransactionObjectArgument, packages?: Map<string, string>): Promise<TransactionObjectArgument>;
 }

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

@@ -3,5 +3,5 @@ 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>;
+    swap(client: AggregatorClient, txb: Transaction, path: Path, inputCoin: TransactionObjectArgument, packages?: Map<string, string>): Promise<TransactionObjectArgument>;
 }

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

@@ -4,5 +4,5 @@ export declare class Volo implements Dex {
     private nativePool;
     private metadata;
     constructor(env: Env);
-    swap(client: AggregatorClient, txb: Transaction, path: Path, inputCoin: TransactionObjectArgument): Promise<TransactionObjectArgument>;
+    swap(client: AggregatorClient, txb: Transaction, path: Path, inputCoin: TransactionObjectArgument, packages?: Map<string, string>): Promise<TransactionObjectArgument>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cetusprotocol/aggregator-sdk",
-  "version": "0.3.16",
+  "version": "0.3.18",
   "sideEffects": false,
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/api.ts

@@ -67,8 +67,10 @@ export type RouterError = {
 export type RouterData = {
   amountIn: BN
   amountOut: BN
+  byAmountIn: boolean
   routes: Router[]
   insufficientLiquidity: boolean
+  packages?: Map<string, string>
   totalDeepFee?: number
   error?: RouterError
 }
@@ -99,6 +101,7 @@ export async function getRouterResult(
       amountIn: ZERO,
       amountOut: ZERO,
       routes: [],
+      byAmountIn: params.byAmountIn,
       insufficientLiquidity: false,
       error: {
         code: AggregatorServerErrorCode.NumberTooLarge,
@@ -116,6 +119,7 @@ export async function getRouterResult(
       amountIn: ZERO,
       amountOut: ZERO,
       routes: [],
+      byAmountIn: params.byAmountIn,
       insufficientLiquidity,
       error: {
         code: AggregatorServerErrorCode.HoneyPot,
@@ -126,16 +130,16 @@ export async function getRouterResult(
     }
   }
   if (data.data != null) {
-    const res = parseRouterResponse(data.data)
+    const res = parseRouterResponse(data.data, params.byAmountIn)
     return res
   }
-  
 
   return {
     amountIn: ZERO,
     amountOut: ZERO,
     routes: [],
     insufficientLiquidity,
+    byAmountIn: params.byAmountIn,
     error: {
       code: AggregatorServerErrorCode.InsufficientLiquidity,
       msg: getAggregatorServerErrorMessage(
@@ -186,7 +190,7 @@ async function getRouter(endpoint: string, params: FindRouterParams) {
     }
 
     // set newest sdk version
-    url += "&v=1000316"
+    url += "&v=1000318"
 
     const response = await fetch(url)
     return response