@cetusprotocol/aggregator-sdk 0.0.0-experimental-20240719182939

package/src/errors.ts

@@ -0,0 +1,44 @@
+export enum TypesErrorCode {
+  InvalidType = `InvalidType`,
+}
+
+export enum ConfigErrorCode {
+  MissAggregatorPackage = `MissAggregatorPackage`,
+  MissGlobalConfig = `MissGlobalConfig`,
+  InvalidWallet = `InvalidWallet`,
+  SimulateError = `SimulateError`,
+}
+
+export enum TransactionErrorCode {
+  InsufficientBalance = `InsufficientBalance`,
+  SimulateEventError = `simulateEventError`,
+  CannotGetDecimals = `CannotGetDecimals`,
+  MissCoinA = `MissCoinA`,
+  MissCoinB = `MissCoinB`,
+  MissTurbosFeeType = `MissTurbosFeeType`,
+  MissAftermathLpSupplyType = `MissAftermathLpSupplyType`,
+}
+
+export type AggregatorErrorCode = TypesErrorCode
+
+/**
+ * AggregatorError is a custom error class that extends the built-in Error class. It is used to represent errors that occur during aggregation operations.
+ * The key functionality of this code includes:
+ * - Defining the AggregatorError class that represents an error during aggregation. It includes a message property and an optional errorCode property.
+ * - Providing a static method isAggregatorErrorCode() that checks if a given error instance is an instance of AggregatorError and has a specific error code.
+ */
+export class AggregatorError extends Error {
+  override message: string
+
+  errorCode?: AggregatorErrorCode
+
+  constructor(message: string, errorCode?: AggregatorErrorCode) {
+    super(message)
+    this.message = message
+    this.errorCode = errorCode
+  }
+
+  static isAggregatorErrorCode(e: any, code: AggregatorErrorCode): boolean {
+    return e instanceof AggregatorError && e.errorCode === code
+  }
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from './client'
+export * from './transaction'
+export * from './config'
+export * from './utils'
+export * from './const'

package/src/math.ts

@@ -0,0 +1,37 @@
+// Calculate amount limit.
+// If byAmountIn is true, the expectAmount means amountOut, otherwise means amountIn.
+// `byAmountIn` means fixed amount in or out.
+
+import BN from "bn.js"
+import { ZERO } from "./const"
+import Decimal from "decimal.js"
+
+// `slippage` is a percentage, for example, 0.01 means 1%.
+export function CalculateAmountLimit(expectAmount: BN, byAmountIn: boolean, slippage: number): number {
+  let amountLimit = ZERO
+  if (byAmountIn) {
+    amountLimit = expectAmount.muln(1 - slippage)
+  } else {
+    amountLimit = expectAmount.muln(1 + slippage)
+  }
+
+  return Number(amountLimit.toString())
+}
+
+const MAX_SQER_PRICE_X64 = '79226673515401279992447579055'
+const MIN_SQER_PRICE_X64 = '4295048016'
+
+export function GetDefaultSqrtPriceLimit(a2b: boolean): BN {
+  if (a2b) {
+    return new BN(MIN_SQER_PRICE_X64)
+  } else {
+      return new BN(MAX_SQER_PRICE_X64)
+  }
+}
+
+export function sqrtPriceX64ToPrice(sqrtPriceStr: string, decimalsA: number, decimalsB: number): Decimal {
+  const sqrtPriceX64 = new Decimal(sqrtPriceStr).mul(Decimal.pow(2, -64))
+  return sqrtPriceX64
+    .pow(2)
+    .mul(Decimal.pow(10, decimalsA - decimalsB))
+}

package/src/test_data.test.ts

@@ -0,0 +1,17 @@
+// Testnet
+export const T_USDC = ""
+
+// Mainnet
+export const M_USDC =
+  "0x5d4b302506645c37ff133b98c4b50a5ae14841659738d6d733d59d0d217a93bf::coin::COIN"
+export const M_CETUS =
+  "0x06864a6f921804860930db6ddbe2e16acdf8504495ea7481637a1c8b9a8fe54b::cetus::CETUS"
+export const M_NAVI =
+  "0xa99b8952d4f7d947ea77fe0ecdcc9e5fc0bcab2841d6e2a5aa00c3044e5544b5::navx::NAVX"
+export const M_SUI = "0x2::sui::SUI"
+export const M_VSUI =
+  "0x549e8b69270defbfafd4f94e17ec44cdbdd99820b33bda2278dea3b9a32d3f55::cert::CERT"
+export const M_VAPOR =
+  "0xa1f2c11169f32165ad4efb4468ec5bdfc880cd66b22094024b32ab7b76d14d30::vapor::VAPOR"
+export const M_HASUI =
+  "0xbde4ba4c2e274a60ce15c1cfff9e5c42e41654ac8b6d906a57efa4bd3c29f47d::hasui::HASUI"

package/src/transaction/aftermath.ts

@@ -0,0 +1,142 @@
+import {
+  TransactionArgument,
+  Transaction,
+  TransactionObjectArgument,
+} from "@mysten/sui/transactions"
+import { AggregatorConfig, ENV } from "../config"
+import {
+  AFTERMATH_MODULE,
+  AGGREGATOR,
+  MAINNET_AFTERMATH_INSURANCE_FUND_ID,
+  MAINNET_AFTERMATH_PROTOCOL_FEE_VAULT_ID,
+  MAINNET_AFTERMATH_REFERRAL_VAULT_ID,
+  MAINNET_AFTERMATH_REGISTRY_ID,
+  MAINNET_AFTERMATH_TREASURY_ID,
+  SWAP_A2B_FUNC,
+  SWAP_B2A_FUNC,
+  TESTNET_AFTERMATH_INSURANCE_FUND_ID,
+  TESTNET_AFTERMATH_PROTOCOL_FEE_VAULT_ID,
+  TESTNET_AFTERMATH_REFERRAL_VAULT_ID,
+  TESTNET_AFTERMATH_REGISTRY_ID,
+  TESTNET_AFTERMATH_TREASURY_ID,
+} from "../const"
+import { ConfigErrorCode, TransactionErrorCode } from "../errors"
+import { createTarget } from "../utils"
+
+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 async function AftermathAmmSwapMovecall(
+  swapParams: AftermathSwapParams,
+  txb: Transaction,
+  config: AggregatorConfig
+): Promise<AftermathSwapResult> {
+  const aggregatorPackage = config.getPackage(AGGREGATOR)
+  if (aggregatorPackage == null) {
+    throw new AggregateError(
+      "Aggregator package not set",
+      ConfigErrorCode.MissAggregatorPackage
+    )
+  }
+  const aggregatorPublishedAt = aggregatorPackage.publishedAt
+
+  if (swapParams.a2b) {
+    if (swapParams.coinA == null) {
+      throw new AggregateError(
+        "coinA is required",
+        TransactionErrorCode.MissCoinA
+      )
+    }
+  } else {
+    if (swapParams.coinB == null) {
+      throw new AggregateError(
+        "coinB is required",
+        TransactionErrorCode.MissCoinB
+      )
+    }
+  }
+
+  const poolRegistryID =
+    config.getENV() === ENV.MAINNET
+      ? MAINNET_AFTERMATH_REGISTRY_ID
+      : TESTNET_AFTERMATH_REGISTRY_ID
+
+  const vaultID =
+    config.getENV() === ENV.MAINNET
+      ? MAINNET_AFTERMATH_PROTOCOL_FEE_VAULT_ID
+      : TESTNET_AFTERMATH_PROTOCOL_FEE_VAULT_ID
+
+  const treasuryID =
+    config.getENV() === ENV.MAINNET
+      ? MAINNET_AFTERMATH_TREASURY_ID
+      : TESTNET_AFTERMATH_TREASURY_ID
+
+  const insuranceFundID =
+    config.getENV() === ENV.MAINNET
+      ? MAINNET_AFTERMATH_INSURANCE_FUND_ID
+      : TESTNET_AFTERMATH_INSURANCE_FUND_ID
+
+  const referrealVaultID =
+    config.getENV() === ENV.MAINNET
+      ? MAINNET_AFTERMATH_REFERRAL_VAULT_ID
+      : TESTNET_AFTERMATH_REFERRAL_VAULT_ID
+
+  const swapCoin = swapParams.a2b ? swapParams.coinA! : swapParams.coinB!
+
+  const slippageArg = (1 - swapParams.slippage) * 1000000000000000000
+
+  const args = [
+    txb.object(swapParams.poolId),
+    txb.object(poolRegistryID),
+    txb.object(vaultID),
+    txb.object(treasuryID),
+    txb.object(insuranceFundID),
+    txb.object(referrealVaultID),
+    swapParams.amount,
+    txb.pure.u64(swapParams.amountLimit),
+    txb.pure.u64(swapParams.amountOut),
+    txb.pure.u64(slippageArg),
+    swapCoin,
+    txb.pure.bool(swapParams.useFullInputCoinAmount),
+  ]
+
+  const func = swapParams.a2b ? SWAP_A2B_FUNC : SWAP_B2A_FUNC
+
+  const target = createTarget(aggregatorPublishedAt, AFTERMATH_MODULE, func)
+
+  const res = txb.moveCall({
+    target,
+    typeArguments: [
+      swapParams.coinAType,
+      swapParams.coinBType,
+      swapParams.lpSupplyType,
+    ],
+    arguments: args,
+  })
+  return {
+    targetCoin: res[0],
+    amountIn: res[1],
+    amountOut: res[2],
+    txb,
+  }
+}

package/src/transaction/cetus.ts

@@ -0,0 +1,281 @@
+import {
+  Transaction,
+  TransactionArgument,
+  TransactionObjectArgument,
+} from "@mysten/sui/transactions"
+import { AggregatorConfig, ENV } from "../config"
+import {
+  AGGREGATOR,
+  CLOCK_ADDRESS,
+  CETUS_MODULE,
+  FlashSwapA2BFunc,
+  MAINNET_CETUS_GLOBAL_CONFIG_ID,
+  TESTNET_CETUS_GLOBAL_CONFIG_ID,
+  FlashSwapWithPartnerA2BFunc,
+  FlashSwapWithPartnerB2AFunc,
+  FlashSwapB2AFunc,
+  REPAY_FLASH_SWAP_WITH_PARTNER_A2B_FUNC,
+  REPAY_FLASH_SWAP_WITH_PARTNER_B2A_FUNC,
+  REPAY_FLASH_SWAP_A2B_FUNC,
+  REPAY_FLASH_SWAP_B2A_FUNC,
+} from "../const"
+import { ConfigErrorCode, TransactionErrorCode } from "../errors"
+import BN from "bn.js"
+import { createTarget } from "../utils"
+
+export type CetusSwapParams = {
+  poolId: string
+  amount: TransactionArgument
+  amountLimit: string
+  a2b: boolean
+  byAmountIn: boolean
+  sqrtPriceLimit: BN
+  partner?: string
+  coinAType: string
+  coinBType: string
+}
+
+export type CetusFlashSwapResult = {
+  targetCoin: TransactionObjectArgument
+  flashReceipt: TransactionObjectArgument
+  payAmount: TransactionArgument
+  swapedAmount: TransactionArgument
+  txb: Transaction
+}
+
+export function cetusFlashSwapMovecall(
+  swapParams: CetusSwapParams,
+  txb: Transaction,
+  config: AggregatorConfig
+): CetusFlashSwapResult {
+  const aggregatorPackage = config.getPackage(AGGREGATOR)
+  if (aggregatorPackage == null) {
+    throw new AggregateError(
+      "Aggregator package not set",
+      ConfigErrorCode.MissAggregatorPackage
+    )
+  }
+  const aggregatorPublishedAt = aggregatorPackage.publishedAt
+
+  const globalConfigId =
+    config.getENV() === ENV.MAINNET
+      ? MAINNET_CETUS_GLOBAL_CONFIG_ID
+      : TESTNET_CETUS_GLOBAL_CONFIG_ID
+
+  const hasPartner = swapParams.partner != null && swapParams.partner.length > 0
+
+  const args = hasPartner
+    ? [
+        txb.object(globalConfigId),
+        txb.object(swapParams.poolId),
+        swapParams.amount,
+        txb.pure.u64(swapParams.amountLimit),
+        txb.pure.bool(swapParams.byAmountIn),
+        txb.pure.u128(swapParams.sqrtPriceLimit.toString()),
+        txb.object(swapParams.partner!.toString()),
+        txb.object(CLOCK_ADDRESS),
+      ]
+    : [
+        txb.object(globalConfigId),
+        txb.object(swapParams.poolId),
+        swapParams.amount,
+        txb.pure.u64(swapParams.amountLimit),
+        txb.pure.bool(swapParams.byAmountIn),
+        txb.pure.u128(swapParams.sqrtPriceLimit.toString()),
+        txb.object(CLOCK_ADDRESS),
+      ]
+
+  let func
+  if (hasPartner) {
+    if (swapParams.a2b) {
+      func = FlashSwapWithPartnerA2BFunc
+    } else {
+      func = FlashSwapWithPartnerB2AFunc
+    }
+  } else {
+    if (swapParams.a2b) {
+      func = FlashSwapA2BFunc
+    } else {
+      func = FlashSwapB2AFunc
+    }
+  }
+
+  const target = createTarget(aggregatorPublishedAt, CETUS_MODULE, func)
+
+  const moveCallRes = txb.moveCall({
+    target,
+    typeArguments: [swapParams.coinAType, swapParams.coinBType],
+    arguments: args,
+  })
+
+  return {
+    targetCoin: moveCallRes[0],
+    flashReceipt: moveCallRes[1],
+    payAmount: moveCallRes[2],
+    swapedAmount: moveCallRes[3],
+    txb,
+  }
+}
+
+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 async function cetusRepayFlashSwapMovecall(
+  repayParams: repayParams,
+  txb: Transaction,
+  config: AggregatorConfig
+): Promise<SwapResult> {
+  const aggregatorPackage = config.getPackage(AGGREGATOR)
+  if (aggregatorPackage == null) {
+    throw new AggregateError(
+      "Aggregator package not set",
+      ConfigErrorCode.MissAggregatorPackage
+    )
+  }
+  const aggregatorPublishedAt = aggregatorPackage.publishedAt
+
+  const globalConfigId =
+    config.getENV() === ENV.MAINNET
+      ? MAINNET_CETUS_GLOBAL_CONFIG_ID
+      : TESTNET_CETUS_GLOBAL_CONFIG_ID
+
+  const hasPartner =
+    repayParams.partner != null && repayParams.partner.length > 0
+
+  if (repayParams.a2b) {
+    if (repayParams.coinA == null) {
+      throw new AggregateError(
+        "coinA is required",
+        TransactionErrorCode.MissCoinA
+      )
+    }
+  } else {
+    if (repayParams.coinB == null) {
+      throw new AggregateError(
+        "coinB is required",
+        TransactionErrorCode.MissCoinB
+      )
+    }
+  }
+
+  let args
+  if (hasPartner) {
+    if (repayParams.a2b) {
+      args = [
+        txb.object(globalConfigId),
+        txb.object(repayParams.poolId),
+        repayParams.coinA!,
+        repayParams.receipt,
+        txb.object(repayParams.partner!),
+      ]
+    } else {
+      args = [
+        txb.object(globalConfigId),
+        txb.object(repayParams.poolId),
+        repayParams.coinB!,
+        repayParams.receipt,
+        txb.object(repayParams.partner!),
+      ]
+    }
+  } else {
+    if (repayParams.a2b) {
+      args = [
+        txb.object(globalConfigId),
+        txb.object(repayParams.poolId),
+        repayParams.coinA!,
+        repayParams.receipt,
+      ]
+    } else {
+      args = [
+        txb.object(globalConfigId),
+        txb.object(repayParams.poolId),
+        repayParams.coinB!,
+        repayParams.receipt,
+      ]
+    }
+  }
+
+  let func
+  if (hasPartner) {
+    if (repayParams.a2b) {
+      func = REPAY_FLASH_SWAP_WITH_PARTNER_A2B_FUNC
+    } else {
+      func = REPAY_FLASH_SWAP_WITH_PARTNER_B2A_FUNC
+    }
+  } else {
+    if (repayParams.a2b) {
+      func = REPAY_FLASH_SWAP_A2B_FUNC
+    } else {
+      func = REPAY_FLASH_SWAP_B2A_FUNC
+    }
+  }
+
+  const target = createTarget(aggregatorPublishedAt, CETUS_MODULE, func)
+
+  const res: TransactionObjectArgument[] = txb.moveCall({
+    target,
+    typeArguments: [repayParams.coinAType, repayParams.coinBType],
+    arguments: args,
+  })
+
+  return {
+    repayTargetCoin: res[0],
+  }
+}
+
+export async function cetusSwapWithOutLimit(
+  swapParams: CetusSwapParams,
+  fromCoin: TransactionObjectArgument,
+  txb: Transaction,
+  config: AggregatorConfig
+): Promise<SwapResult> {
+  const flashResult = cetusFlashSwapMovecall(swapParams, txb, config)
+
+  const repayCoinA = swapParams.a2b ? fromCoin : undefined
+  const repayCoinB = swapParams.a2b ? undefined : fromCoin
+
+  const repayParams = {
+    poolId: swapParams.poolId,
+    a2b: swapParams.a2b,
+    coinA: repayCoinA,
+    coinB: repayCoinB,
+    receipt: flashResult.flashReceipt,
+    coinAType: swapParams.coinAType,
+    coinBType: swapParams.coinBType,
+    partner: swapParams.partner,
+  }
+
+  let nextInputAmount: TransactionArgument
+
+  if (swapParams.byAmountIn) {
+    nextInputAmount = flashResult.swapedAmount
+  } else {
+    nextInputAmount = flashResult.payAmount
+  }
+
+  const repayResult = await cetusRepayFlashSwapMovecall(
+    repayParams,
+    txb,
+    config
+  )
+
+  return {
+    flashTargetCoin: flashResult.targetCoin,
+    repayTargetCoin: repayResult.repayTargetCoin,
+    nextInputAmount,
+  }
+}

package/src/transaction/common.ts

@@ -0,0 +1,169 @@
+import {
+  AGGREGATOR,
+  CHECK_COINS_THRESHOLD_FUNC,
+  JOIN_FUNC,
+  PAY_MODULE,
+  SuiZeroCoinFn,
+  TRANSFER_OR_DESTORY_COIN_FUNC,
+  UTILS_MODULE,
+} from "../const"
+import { CoinAsset } from "../types/sui"
+import { CoinUtils } from "../types/CoinAssist"
+import { ConfigErrorCode, TransactionErrorCode } from "../errors"
+import { createTarget } from "../utils"
+import { AggregatorConfig } from "../config"
+import {
+  Transaction,
+  TransactionArgument,
+  TransactionObjectArgument,
+} from "@mysten/sui/transactions"
+import { SUI_FRAMEWORK_ADDRESS } from "@mysten/sui/utils"
+
+export function mintZeroCoin(
+  txb: Transaction,
+  coinType: string
+): TransactionObjectArgument {
+  return txb.moveCall({
+    target: SuiZeroCoinFn,
+    typeArguments: [coinType],
+  })
+}
+
+export type BuildCoinResult = {
+  targetCoin: TransactionObjectArgument
+  isMintZeroCoin: boolean
+  targetCoinAmount: number
+}
+
+export function buildInputCoin(
+  txb: Transaction,
+  allCoins: CoinAsset[],
+  amount: bigint,
+  coinType: string
+): BuildCoinResult {
+  const usedCoinAsests = CoinUtils.getCoinAssets(coinType, allCoins)
+  if (amount === BigInt(0) && usedCoinAsests.length === 0) {
+    const zeroCoin = mintZeroCoin(txb, coinType)
+    return {
+      targetCoin: zeroCoin,
+      isMintZeroCoin: true,
+      targetCoinAmount: 0,
+    }
+  }
+
+  if (CoinUtils.isSuiCoin(coinType)) {
+    const resultCoin = txb.splitCoins(txb.gas, [
+      txb.pure.u64(amount.toString()),
+    ])
+    return {
+      targetCoin: resultCoin,
+      isMintZeroCoin: true,
+      targetCoinAmount: Number(amount.toString()),
+    }
+  }
+
+  let totalCoinBalance = CoinUtils.calculateTotalBalance(usedCoinAsests)
+  if (totalCoinBalance < amount) {
+    throw new AggregateError(
+      "Insufficient balance when build merge coin",
+      TransactionErrorCode.InsufficientBalance
+    )
+  }
+
+  // sort used coin by amount, asc
+  let sortCoinAssets = CoinUtils.sortByBalance(usedCoinAsests)
+
+  // find first three coin if greater than amount
+  let totalThreeCoinBalance = sortCoinAssets
+    .slice(0, 3)
+    .reduce((acc, coin) => acc + coin.balance, BigInt(0))
+  if (totalThreeCoinBalance < BigInt(amount)) {
+    sortCoinAssets = CoinUtils.sortByBalanceDes(usedCoinAsests)
+  }
+
+  let selectedCoinResult = CoinUtils.selectCoinObjectIdGreaterThanOrEqual(
+    sortCoinAssets,
+    amount
+  )
+  const [masterCoin, ...mergedCoin] = selectedCoinResult.objectArray
+
+  if (mergedCoin.length > 0) {
+    txb.mergeCoins(
+      masterCoin,
+      mergedCoin.map((coin) => txb.object(coin))
+    )
+  }
+
+  return {
+    targetCoin: txb.object(masterCoin),
+    isMintZeroCoin: false,
+    targetCoinAmount: Number(amount.toString()),
+  }
+}
+
+export function transferOrDestoryCoin(
+  txb: Transaction,
+  coinObject: TransactionObjectArgument,
+  coinType: string,
+  config: AggregatorConfig
+) {
+  const aggregatorPackage = config.getPackage(AGGREGATOR)
+  if (aggregatorPackage == null) {
+    throw new AggregateError(
+      "Aggregator package not set",
+      ConfigErrorCode.MissAggregatorPackage
+    )
+  }
+  const aggregatorPublishedAt = aggregatorPackage.publishedAt
+
+  txb.moveCall({
+    target: createTarget(
+      aggregatorPublishedAt,
+      UTILS_MODULE,
+      TRANSFER_OR_DESTORY_COIN_FUNC
+    ),
+    typeArguments: [coinType],
+    arguments: [coinObject],
+  })
+}
+
+export function checkCoinThresholdAndMergeCoin(
+  txb: Transaction,
+  coins: TransactionObjectArgument[],
+  coinType: string,
+  amountLimit: number,
+  config: AggregatorConfig
+): TransactionArgument {
+  const aggregatorPackage = config.getPackage(AGGREGATOR)
+  if (aggregatorPackage == null) {
+    throw new AggregateError(
+      "Aggregator package not set",
+      ConfigErrorCode.MissAggregatorPackage
+    )
+  }
+  const aggregatorPublishedAt = aggregatorPackage.publishedAt
+
+  const vec = txb.makeMoveVec({
+    elements: coins,
+  })
+
+  txb.moveCall({
+    target: createTarget(
+      aggregatorPublishedAt,
+      UTILS_MODULE,
+      CHECK_COINS_THRESHOLD_FUNC
+    ),
+    typeArguments: [coinType],
+    arguments: [vec, txb.pure.u64(amountLimit)],
+  })
+
+  const zeroCoin = mintZeroCoin(txb, coinType)
+
+  txb.moveCall({
+    target: createTarget(SUI_FRAMEWORK_ADDRESS, PAY_MODULE, JOIN_FUNC),
+    typeArguments: [coinType],
+    arguments: [zeroCoin, vec],
+  })
+
+  return zeroCoin
+}