@cetusprotocol/aggregator-sdk 0.0.1

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

@@ -0,0 +1,7 @@
+import { SuiClient } from "@mysten/sui/client";
+import { Transaction, TransactionObjectArgument } from "@mysten/sui/transactions";
+export type GetOrCreateAccountCapResult = {
+    accountCap: TransactionObjectArgument;
+    isCreate: boolean;
+};
+export declare function getOrCreateAccountCap(txb: Transaction, client: SuiClient, owner: string): Promise<GetOrCreateAccountCapResult>;

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

@@ -0,0 +1,4 @@
+export declare function completionCoin(s: string): string;
+export declare function compareCoins(coinA: string, coinB: string): boolean;
+export declare function parseTurbosPoolFeeType(typeData: string): string | null;
+export declare function parseAftermathFeeType(typeData: string): string | undefined;

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,16 @@
+import type { SuiAddress, SuiStructTag } from '../types/sui';
+export declare function isSortedSymbols(symbolX: string, symbolY: string): boolean;
+export declare function composeType(address: string, generics: SuiAddress[]): SuiAddress;
+export declare function composeType(address: string, struct: string, generics?: SuiAddress[]): SuiAddress;
+export declare function composeType(address: string, module: string, struct: string, generics?: SuiAddress[]): SuiAddress;
+export declare function extractAddressFromType(type: string): string;
+export declare function extractStructTagFromType(type: string): SuiStructTag;
+export declare function normalizeCoinType(coinType: string): string;
+export declare function fixSuiObjectId(value: string): string;
+/**
+ * Recursively traverses the given data object and patches any string values that represent Sui object IDs.
+ *
+ * @param {any} data - The data object to be patched.
+ */
+export declare function patchFixSuiObjectId(data: any): void;
+export declare function createTarget(packageName: string, moduleName: string, functionName: string): `${string}::${string}::${string}`;

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

@@ -0,0 +1 @@
+export * from './contracts';

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

@@ -0,0 +1,3 @@
+import { Transaction } from "@mysten/sui/transactions";
+export declare function printTransaction(tx: Transaction, isPrint?: boolean): Promise<void>;
+export declare function checkInvalidSuiAddress(address: string): boolean;

package/dist/tests/router.test.d.ts

@@ -0,0 +1,2 @@
+import { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519";
+export declare function buildTestAccount(): Ed25519Keypair;

package/dist/tests/wallet.test.d.ts

@@ -0,0 +1 @@
+export {};

package/jest.config.mjs

@@ -0,0 +1,13 @@
+// jest.config.mjs
+export default {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  transform: {
+    '^.+\\.tsx?$': ['ts-jest', {
+      tsconfig: './tsconfig.json'
+    }]
+  },
+  moduleNameMapper: {
+    '^~/(.*)$': '<rootDir>/src/$1'
+  }
+};

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@cetusprotocol/aggregator-sdk",
+  "version": "0.0.1",
+  "sideEffects": false,
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "module": "dist/index.js",
+  "scripts": {
+    "build": "tsup --format cjs,esm --dts",
+    "dev": "tsup --watch",
+    "test": "node -r esm node_modules/.bin/jest",
+    "clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist",
+    "publish:test": "node version.mjs && npm publish --tag experimental"
+  },
+  "devDependencies": {
+    "@types/bn.js": "^5.1.5",
+    "@types/bun": "latest",
+    "bn.js": "^5.2.1",
+    "decimal.js": "^10.4.3",
+    "tsup": "^8.0.2"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "dependencies": {
+    "@babel/core": "^7.24.5",
+    "@babel/preset-env": "^7.24.5",
+    "@babel/preset-typescript": "^7.24.1",
+    "@jest/globals": "^29.7.0",
+    "@mysten/sui": "^1.0.5",
+    "@types/jest": "^29.5.12",
+    "@types/node": "^20.12.12",
+    "babel-jest": "^29.7.0",
+    "bip39": "^3.1.0",
+    "dotenv": "^16.4.5",
+    "jest": "^29.7.0",
+    "node-fetch": "^3.3.2",
+    "ts-jest": "^29.1.3",
+    "typescript": "^5.4.5"
+  }
+}

package/src/client.ts

@@ -0,0 +1,383 @@
+import type { AggregatorConfig } from "./config"
+import Decimal from "decimal.js"
+import { SuiClient } from "@mysten/sui/client"
+import { CoinAsset } from "./types/sui"
+import { createTarget, extractStructTagFromType } from "./utils"
+import { Transaction } from "@mysten/sui/transactions"
+import {
+  buildInputCoin,
+  checkCoinThresholdAndMergeCoin,
+  transferOrDestoryCoin,
+} from "./transaction/common"
+import { expectInputRouterSwap, expectOutputRouterSwap } from "./transaction"
+import { CalculateAmountLimit } from "./math"
+import { Signer } from "@mysten/sui/dist/cjs/cryptography"
+import BN from "bn.js"
+import { swapInPools } from "./transaction/swap"
+import { completionCoin } from "./utils/coin"
+import { SUI_FRAMEWORK_ADDRESS } from "@mysten/sui/utils"
+import { AFTERMATH_AMM, JOIN_FUNC, PAY_MODULE, TURBOS_DEX } from "./const"
+
+export type ExtendedDetails = {
+  aftermathPoolFlatness?: number
+  aftermathLpSupplyType?: string
+  turbosFeeType?: string
+}
+
+export type Path = {
+  id: string
+  a2b: boolean
+  provider: string
+  from: string
+  target: string
+  feeRate: number
+  amountIn: number
+  amountOut: number
+  extendedDetails?: ExtendedDetails
+  version?: string
+}
+
+export type Router = {
+  path: Path[]
+  amountIn: BN
+  amountOut: BN
+  initialPrice: Decimal
+}
+
+export type RouterData = {
+  amountIn: BN
+  amountOut: BN
+  routes: Router[]
+}
+
+export type AggregatorResponse = {
+  code: number
+  msg: string
+  data: RouterData
+}
+
+export type BuildRouterSwapParams = {
+  routers: Router[]
+  amountIn: BN
+  amountOut: BN
+  byAmountIn: boolean
+  slippage: number
+  fromCoinType: string
+  targetCoinType: string
+  partner?: string
+  isMergeTragetCoin?: boolean
+  refreshAllCoins?: boolean
+}
+
+export interface FindRouterParams {
+  from: string
+  target: string
+  amount: BN
+  byAmountIn: boolean
+  depth: number | null
+  splitAlgorithm: string | null
+  splitFactor: number | null
+  splitCount: number | null
+  providers: string[] | null
+}
+
+export interface SwapInPoolsParams {
+  from: string
+  target: string
+  amount: BN
+  byAmountIn: boolean
+  pools: string[]
+}
+
+export interface SwapInPoolsResult {
+  isExceed: boolean
+  routeData?: RouterData
+}
+
+export class AggregatorClient {
+  private config: AggregatorConfig
+
+  private wallet: string
+
+  private client: SuiClient
+
+  private allCoins: CoinAsset[]
+
+  constructor(config: AggregatorConfig) {
+    this.config = config
+    this.client = new SuiClient({ url: config.getFullNodeUrl() })
+    this.wallet = config.getWallet()
+    this.allCoins = []
+  }
+
+  async getAllCoins(): Promise<CoinAsset[]> {
+    let cursor = null
+    let limit = 50
+
+    const allCoins: CoinAsset[] = []
+
+    while (true) {
+      const gotAllCoins = await this.client.getAllCoins({
+        owner: this.wallet,
+        cursor,
+        limit,
+      })
+      for (const coin of gotAllCoins.data) {
+        allCoins.push({
+          coinAddress: extractStructTagFromType(coin.coinType).source_address,
+          coinObjectId: coin.coinObjectId,
+          balance: BigInt(coin.balance),
+        })
+      }
+
+      if (gotAllCoins.data.length < limit) {
+        break
+      }
+      cursor = gotAllCoins.data[limit - 1].coinObjectId
+    }
+
+    return allCoins
+  }
+
+  async findRouter(
+    fromRouterParams: FindRouterParams
+  ): Promise<RouterData | null> {
+    const {
+      from,
+      target,
+      amount,
+      byAmountIn,
+      depth,
+      splitAlgorithm,
+      splitFactor,
+      splitCount,
+      providers,
+    } = fromRouterParams
+    const fromCoin = completionCoin(from)
+    const targetCoin = completionCoin(target)
+
+    let url =
+      this.config.getAggregatorUrl() +
+      `/find_routes?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)
+    const data = await response.json()
+
+    if (data.data != null) {
+      const res = parseRouterResponse(data.data)
+      return res
+    }
+
+    return null
+  }
+
+  async swapInPools(
+    params: SwapInPoolsParams
+  ): Promise<SwapInPoolsResult | null> {
+    let result
+    try {
+      result = await swapInPools(this.client, params, this.config)
+    } catch (e) {
+      return null
+    }
+
+    return result
+  }
+
+  async routerSwap(params: BuildRouterSwapParams): Promise<Transaction> {
+    const {
+      routers: _,
+      amountIn,
+      amountOut,
+      byAmountIn,
+      slippage,
+      fromCoinType,
+      targetCoinType,
+      partner,
+      isMergeTragetCoin,
+      refreshAllCoins,
+    } = params
+    const amountLimit = CalculateAmountLimit(
+      byAmountIn ? amountOut : amountIn,
+      byAmountIn,
+      slippage
+    )
+
+    const txb = new Transaction()
+
+    if (refreshAllCoins || this.allCoins.length === 0) {
+      this.allCoins = await this.getAllCoins()
+    }
+
+    const allCoins = this.allCoins
+    let targetCoins = []
+
+    if (byAmountIn) {
+      const buildFromCoinRes = buildInputCoin(
+        txb,
+        allCoins,
+        BigInt(amountIn.toString()),
+        fromCoinType
+      )
+      const fromCoin = buildFromCoinRes.targetCoin
+      const swapedCoins = await expectInputRouterSwap(
+        this.client,
+        params,
+        txb,
+        fromCoin,
+        this.config,
+        partner
+      )
+      const mergedCoin = checkCoinThresholdAndMergeCoin(
+        txb,
+        swapedCoins,
+        targetCoinType,
+        amountLimit,
+        this.config
+      )
+      targetCoins.push(mergedCoin)
+    } else {
+      const fromCoin = buildInputCoin(
+        txb,
+        allCoins,
+        BigInt(amountLimit),
+        fromCoinType
+      ).targetCoin
+      const swapedCoins = await expectOutputRouterSwap(
+        params,
+        txb,
+        fromCoin,
+        this.config,
+        partner
+      )
+      targetCoins.push(...swapedCoins)
+    }
+
+    if (isMergeTragetCoin) {
+      const targetCoinRes = buildInputCoin(
+        txb,
+        allCoins,
+        BigInt(0),
+        targetCoinType
+      )
+      txb.mergeCoins(targetCoinRes.targetCoin, targetCoins)
+      if (targetCoinRes.isMintZeroCoin) {
+        transferOrDestoryCoin(
+          txb,
+          targetCoinRes.targetCoin,
+          targetCoinType,
+          this.config
+        )
+      }
+    } else {
+      if (targetCoins.length > 1) {
+        const vec = txb.makeMoveVec({ elements: targetCoins.slice(1) })
+        txb.moveCall({
+          target: createTarget(SUI_FRAMEWORK_ADDRESS, PAY_MODULE, JOIN_FUNC),
+          typeArguments: [targetCoinType],
+          arguments: [targetCoins[0], vec],
+        })
+      }
+      transferOrDestoryCoin(txb, targetCoins[0], targetCoinType, this.config)
+    }
+
+    return txb
+  }
+
+  async signAndExecuteTransaction(txb: Transaction, signer: Signer) {
+    const res = await this.client.signAndExecuteTransaction({
+      transaction: txb,
+      signer,
+      options: {
+        showEffects: true,
+        showEvents: true,
+        showInput: true,
+        showBalanceChanges: true,
+      },
+    })
+    return res
+  }
+
+  async devInspectTransactionBlock(txb: Transaction, signer: Signer) {
+    const res = await this.client.devInspectTransactionBlock({
+      transactionBlock: txb,
+      sender: signer.getPublicKey().toSuiAddress(),
+    })
+
+    return res
+  }
+
+  async sendTransaction(txb: Transaction, signer: Signer) {
+    const res = await this.client.signAndExecuteTransaction({
+      transaction: txb,
+      signer,
+    })
+
+    return res
+  }
+}
+
+function parseRouterResponse(data: any): RouterData {
+  return {
+    amountIn: new BN(data.amount_in.toString()),
+    amountOut: new BN(data.amount_out.toString()),
+    routes: data.routes.map((route: any) => {
+      return {
+        path: route.path.map((path: any) => {
+          let version
+          if (path.provider === AFTERMATH_AMM) {
+            version =
+              path.extended_details.aftermath_pool_flatness === 0 ? "v2" : "v3"
+          }
+
+          let extendedDetails
+          if (path.provider === TURBOS_DEX || path.provider === AFTERMATH_AMM) {
+            extendedDetails = {
+              aftermathLpSupplyType:
+                path.extended_details?.aftermath_lp_supply_type,
+              turbosFeeType: path.extended_details?.turbos_fee_type,
+            }
+          }
+
+          return {
+            id: path.id,
+            a2b: path.direction,
+            provider: path.provider,
+            from: path.from,
+            target: path.target,
+            feeRate: path.fee_rate,
+            amountIn: path.amount_in,
+            amountOut: path.amount_out,
+            extendedDetails,
+            version,
+          }
+        }),
+        amountIn: new BN(route.amount_in.toString()),
+        amountOut: new BN(route.amount_out.toString()),
+        initialPrice: new Decimal(route.initial_price.toString()),
+      }
+    }),
+  }
+}

package/src/config.ts

@@ -0,0 +1,65 @@
+export type Package = {
+  packageName: string
+  packageId: string
+  publishedAt: string
+}
+
+export enum ENV {
+  MAINNET,
+  TESTNET,
+}
+
+export class AggregatorConfig {
+  private aggregatorUrl: string;
+  private fullNodeUrl: string;
+  private wallet: string;
+  private packages: Package[];
+  private env: ENV;
+
+  constructor(aggregatorUrl: string, fullNodeUrl: string, wallet: string, packages: Package[], env: ENV) {
+    this.aggregatorUrl = aggregatorUrl;
+    this.fullNodeUrl = fullNodeUrl;
+    this.wallet = wallet;
+    this.packages = packages;
+    this.env = env;
+  }
+
+  getAggregatorUrl(): string {
+    return this.aggregatorUrl;
+  }
+
+  getFullNodeUrl(): string {
+    return this.fullNodeUrl;
+  }
+
+  getWallet(): string {
+    return this.wallet;
+  }
+
+  getENV(): ENV {
+    return this.env
+  }
+
+  getPackages(): Package[] {
+    return this.packages;
+  }
+
+  getPackage(packageName: string) {
+    return this.packages.find(pkg => pkg.packageName === packageName);
+  }
+
+  addPackage(newPackage: Package): void {
+    if (!newPackage.packageName || !newPackage.packageId || !newPackage.publishedAt) {
+      throw new Error("Invalid package data");
+    }
+    this.packages.push(newPackage);
+  }
+
+  removePackageById(packageId: string): void {
+    this.packages = this.packages.filter(pkg => pkg.packageId !== packageId);
+  }
+
+  findPackageById(packageId: string): Package | undefined {
+    return this.packages.find(pkg => pkg.packageId === packageId);
+  }
+}

package/src/const.ts

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