@cetusprotocol/aggregator-sdk 0.0.8 → 0.1.1

package/src/transaction/deepbook.ts

@@ -1,126 +0,0 @@
-import {
-  TransactionArgument,
-  Transaction,
-  TransactionObjectArgument,
-} from "@mysten/sui/transactions"
-import { AggregatorConfig } from "../config"
-import {
-  AGGREGATOR,
-  CLOCK_ADDRESS,
-  DEEPBOOK_MODULE,
-  SWAP_A2B_FUNC,
-  SWAP_B2A_FUNC,
-  TRANSFER_ACCOUNT_CAP,
-} from "../const"
-import { ConfigErrorCode, TransactionErrorCode } from "../errors"
-import { createTarget } from "../utils"
-import { getOrCreateAccountCap } from "../utils/account_cap"
-import { SuiClient } from "@mysten/sui/client"
-
-export type DeepbookSwapParams = {
-  poolId: string
-  a2b: boolean
-  amount: TransactionArgument
-  amountLimit: number
-  coinA?: TransactionObjectArgument
-  coinB?: TransactionObjectArgument
-  useFullInputCoinAmount: boolean
-  coinAType: string
-  coinBType: string
-}
-
-export type DeepbookSwapResult = {
-  targetCoin: TransactionObjectArgument
-  amountIn: TransactionArgument
-  amountOut: TransactionArgument
-  txb: Transaction
-}
-
-export async function deepbookSwapMovecall(
-  swapParams: DeepbookSwapParams,
-  client: SuiClient,
-  txb: Transaction,
-  config: AggregatorConfig
-): Promise<DeepbookSwapResult> {
-  const accountCapRes = await getOrCreateAccountCap(
-    txb,
-    client,
-    config.getWallet()
-  )
-  const accountCap = accountCapRes.accountCap
-
-  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 args = swapParams.a2b
-    ? [
-        txb.object(swapParams.poolId),
-        swapParams.amount,
-        txb.pure.u64(swapParams.amountLimit),
-        swapParams.coinA!,
-        accountCap,
-        txb.pure.bool(swapParams.useFullInputCoinAmount),
-        txb.object(CLOCK_ADDRESS),
-      ]
-    : [
-        txb.object(swapParams.poolId),
-        swapParams.amount,
-        txb.pure.u64(swapParams.amountLimit),
-        swapParams.coinB!,
-        accountCap,
-        txb.pure.bool(swapParams.useFullInputCoinAmount),
-        txb.object(CLOCK_ADDRESS),
-      ]
-
-  let func = swapParams.a2b ? SWAP_A2B_FUNC : SWAP_B2A_FUNC
-  const target = createTarget(aggregatorPublishedAt, DEEPBOOK_MODULE, func)
-
-  const res = txb.moveCall({
-    target,
-    typeArguments: [swapParams.coinAType, swapParams.coinBType],
-    arguments: args,
-  })
-
-  if (accountCapRes.isCreate) {
-    const target = createTarget(
-      aggregatorPublishedAt,
-      DEEPBOOK_MODULE,
-      TRANSFER_ACCOUNT_CAP
-    )
-
-    const res = txb.moveCall({
-      target,
-      typeArguments: [],
-      arguments: [accountCap],
-    })
-  }
-
-  return {
-    targetCoin: res[0],
-    amountIn: res[1],
-    amountOut: res[2],
-    txb,
-  }
-}

package/src/transaction/flowx.ts

@@ -1,97 +0,0 @@
-import {
-  TransactionArgument,
-  Transaction,
-  TransactionObjectArgument,
-} from "@mysten/sui/transactions"
-import { AggregatorConfig, ENV } from "../config"
-import {
-  AGGREGATOR,
-  FLOWX_AMM_MODULE,
-  MAINNET_FLOWX_AMM_CONTAINER_ID,
-  SWAP_A2B_FUNC,
-  SWAP_B2A_FUNC,
-  TESTNET_FLOWX_AMM_CONTAINER_ID,
-} from "../const"
-import { ConfigErrorCode, TransactionErrorCode } from "../errors"
-import { createTarget } from "../utils"
-
-export type FlowxSwapParams = {
-  amount: TransactionArgument
-  amountLimit: number
-  a2b: boolean
-  byAmountIn: boolean
-  coinA?: TransactionObjectArgument
-  coinB?: TransactionObjectArgument
-  useFullInputCoinAmount: boolean
-  coinAType: string
-  coinBType: string
-}
-
-export type FlowxSwapResult = {
-  targetCoin: TransactionObjectArgument
-  amountIn: TransactionArgument
-  amountOut: TransactionArgument
-  txb: Transaction
-}
-
-export async function flowxAmmSwapMovecall(
-  swapParams: FlowxSwapParams,
-  txb: Transaction,
-  config: AggregatorConfig
-): Promise<FlowxSwapResult> {
-  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 containerID =
-    config.getENV() === ENV.MAINNET
-      ? MAINNET_FLOWX_AMM_CONTAINER_ID
-      : TESTNET_FLOWX_AMM_CONTAINER_ID
-
-  const swapCoin = swapParams.a2b ? swapParams.coinA! : swapParams.coinB!
-
-  const args = [
-    txb.object(containerID),
-    swapParams.amount,
-    txb.pure.u64(swapParams.amountLimit),
-    swapCoin,
-    txb.pure.bool(swapParams.useFullInputCoinAmount),
-  ]
-
-  const func = swapParams.a2b ? SWAP_A2B_FUNC : SWAP_B2A_FUNC
-
-  const target = createTarget(aggregatorPublishedAt, FLOWX_AMM_MODULE, func)
-
-  const res = txb.moveCall({
-    target,
-    typeArguments: [swapParams.coinAType, swapParams.coinBType],
-    arguments: args,
-  })
-  return {
-    targetCoin: res[0],
-    amountIn: res[1],
-    amountOut: res[2],
-    txb,
-  }
-}

package/src/transaction/kriya.ts

@@ -1,77 +0,0 @@
-import { TransactionArgument, Transaction, TransactionObjectArgument } from "@mysten/sui/transactions"
-import { AggregatorConfig } from "../config"
-import { AGGREGATOR, KRIYA_MODULE, SWAP_A2B_FUNC, SWAP_B2A_FUNC } from "../const"
-import { ConfigErrorCode, TransactionErrorCode } from "../errors"
-import { createTarget } from "../utils"
-
-export type KriyaSwapParams = {
-  poolId: string
-  amount: TransactionArgument
-  amountLimit: number
-  a2b: boolean
-  byAmountIn: boolean
-  coinA?: TransactionObjectArgument
-  coinB?: TransactionObjectArgument
-  useFullInputCoinAmount: boolean
-  coinAType: string
-  coinBType: string
-}
-
-export type KriyaSwapResult = {
-  targetCoin: TransactionObjectArgument
-  amountIn: TransactionArgument
-  amountOut: TransactionArgument
-  txb: Transaction
-}
-
-export async function kriyaSwapMovecall(
-  swapParams: KriyaSwapParams,
-  txb: Transaction,
-  config: AggregatorConfig,
-): Promise<KriyaSwapResult> {
-  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 args = swapParams.a2b ? [
-    txb.object(swapParams.poolId),
-    swapParams.amount,
-    txb.pure.u64(swapParams.amountLimit),
-    swapParams.coinA!,
-    txb.pure.bool(swapParams.useFullInputCoinAmount)
-  ] : [
-    txb.object(swapParams.poolId),
-    swapParams.amount,
-    txb.pure.u64(swapParams.amountLimit),
-    swapParams.coinB!,
-    txb.pure.bool(swapParams.useFullInputCoinAmount)
-  ]
-
-  const func = swapParams.a2b ? SWAP_A2B_FUNC : SWAP_B2A_FUNC
-
-  const target = createTarget(aggregatorPublishedAt, KRIYA_MODULE, func)
-
-  const res = txb.moveCall({
-    target,
-    typeArguments: [swapParams.coinAType, swapParams.coinBType],
-    arguments: args,
-  })
-  return {
-    targetCoin: res[0],
-    amountIn: res[1],
-    amountOut: res[2],
-    txb
-  }
-}

package/src/transaction/router.ts

@@ -1,339 +0,0 @@
-import {
-  TransactionArgument,
-  Transaction,
-  TransactionObjectArgument,
-} from "@mysten/sui/transactions"
-import type { BuildRouterSwapParams } from "../client"
-import { AggregatorConfig } from "../config"
-import {
-  AFTERMATH_AMM,
-  CETUS_DEX,
-  DEEPBOOK_DEX,
-  FLOWX_AMM,
-  KRIYA_DEX,
-  TURBOS_DEX,
-  U64_MAX,
-} from "../const"
-import { deepbookSwapMovecall } from "./deepbook"
-import { SuiClient } from "@mysten/sui/client"
-import { kriyaSwapMovecall } from "./kriya"
-import {
-  cetusFlashSwapMovecall,
-  cetusRepayFlashSwapMovecall,
-  cetusSwapWithOutLimit,
-} from "./cetus"
-import { transferOrDestoryCoin } from "./common"
-import { GetDefaultSqrtPriceLimit } from "../math"
-import { flowxAmmSwapMovecall } from "./flowx"
-import { turbosClmmSwapMovecall } from "./turbos"
-import { AftermathAmmSwapMovecall } from "./aftermath"
-import { TransactionErrorCode } from "~/errors"
-
-export async function expectInputRouterSwap(
-  client: SuiClient,
-  params: BuildRouterSwapParams,
-  txb: Transaction,
-  fromCoin: TransactionObjectArgument,
-  config: AggregatorConfig,
-  partner?: string
-): Promise<TransactionObjectArgument[]> {
-  const splitAmounts = params.routers.map((router) =>
-    router.amountIn.toString()
-  )
-  const targetCoins = []
-  const fromCoins = txb.splitCoins(fromCoin, splitAmounts)
-
-  for (let i = 0; i < params.routers.length; i++) {
-    const router = params.routers[i]
-    let intermediateTargetCoin: TransactionObjectArgument
-    let nextFromCoin = fromCoins[i] as TransactionObjectArgument
-    let nextFlashAmount: TransactionArgument = txb.pure.u64(splitAmounts[i])
-
-    for (let j = 0; j < router.path.length; j++) {
-      const firstPathPool = j === 0
-      const path = router.path[j]
-
-      if (path.provider === CETUS_DEX) {
-        const swapParams = {
-          poolId: path.id,
-          amount: nextFlashAmount,
-          amountLimit: "0",
-          a2b: path.a2b,
-          byAmountIn: true,
-          sqrtPriceLimit: GetDefaultSqrtPriceLimit(path.a2b),
-          partner: partner!,
-          coinAType: path.a2b ? path.from : path.target,
-          coinBType: path.a2b ? path.target : path.from,
-        }
-
-        const swapResult = await cetusSwapWithOutLimit(
-          swapParams,
-          nextFromCoin,
-          txb,
-          config
-        )
-
-        transferOrDestoryCoin(
-          txb,
-          swapResult.repayTargetCoin,
-          path.from,
-          config
-        )
-
-        intermediateTargetCoin = swapResult.flashTargetCoin!
-        nextFromCoin = intermediateTargetCoin
-        nextFlashAmount = swapResult.nextInputAmount!
-      }
-
-      if (path.provider === DEEPBOOK_DEX) {
-        const coinA = path.a2b ? nextFromCoin : undefined
-        const coinB = path.a2b ? undefined : nextFromCoin
-
-        const swapParams = {
-          poolId: path.id,
-          a2b: path.a2b,
-          amount: nextFlashAmount,
-          amountLimit: 0,
-          coinA,
-          coinB,
-          useFullInputCoinAmount: !firstPathPool,
-          coinAType: path.a2b ? path.from : path.target,
-          coinBType: path.a2b ? params.targetCoinType : path.from,
-        }
-        const deepbookSwapResult = await deepbookSwapMovecall(
-          swapParams,
-          client,
-          txb,
-          config
-        )
-
-        intermediateTargetCoin = deepbookSwapResult.targetCoin
-        nextFromCoin = intermediateTargetCoin
-        nextFlashAmount = deepbookSwapResult.amountOut
-      }
-
-      if (path.provider === KRIYA_DEX) {
-        const coinA = path.a2b ? nextFromCoin : undefined
-        const coinB = path.a2b ? undefined : nextFromCoin
-
-        const swapParams = {
-          poolId: path.id,
-          amount: nextFlashAmount,
-          amountLimit: 0,
-          a2b: path.a2b,
-          byAmountIn: true,
-          coinA,
-          coinB,
-          useFullInputCoinAmount: !firstPathPool,
-          coinAType: path.a2b ? path.from : path.target,
-          coinBType: path.a2b ? path.target : path.from,
-        }
-
-        const swapResult = await kriyaSwapMovecall(swapParams, txb, config)
-
-        intermediateTargetCoin = swapResult.targetCoin
-        nextFromCoin = intermediateTargetCoin
-        nextFlashAmount = swapResult.amountOut
-      }
-
-      if (path.provider === FLOWX_AMM) {
-        const coinA = path.a2b ? nextFromCoin : undefined
-        const coinB = path.a2b ? undefined : nextFromCoin
-
-        const swapParams = {
-          amount: nextFlashAmount,
-          amountLimit: 0,
-          a2b: path.a2b,
-          byAmountIn: true,
-          coinA,
-          coinB,
-          useFullInputCoinAmount: !firstPathPool,
-          coinAType: path.a2b ? path.from : path.target,
-          coinBType: path.a2b ? path.target : path.from,
-        }
-
-        const swapResult = await flowxAmmSwapMovecall(swapParams, txb, config)
-
-        intermediateTargetCoin = swapResult.targetCoin
-        nextFromCoin = intermediateTargetCoin
-        nextFlashAmount = swapResult.amountOut
-      }
-
-      if (path.provider === TURBOS_DEX) {
-        const coinA = path.a2b ? nextFromCoin : undefined
-        const coinB = path.a2b ? undefined : nextFromCoin
-
-        let feeType = ""
-        if (
-          path.extendedDetails != null &&
-          path.extendedDetails.turbosFeeType != null
-        ) {
-          feeType = path.extendedDetails.turbosFeeType
-        } else {
-          throw new AggregateError(
-            "Build turbos swap movecall error: ",
-            TransactionErrorCode.MissTurbosFeeType
-          )
-        }
-
-        const swapParams = {
-          poolId: path.id,
-          amount: nextFlashAmount,
-          amountLimit: 0,
-          a2b: path.a2b,
-          byAmountIn: true,
-          coinA,
-          coinB,
-          useFullInputCoinAmount: !firstPathPool,
-          coinAType: path.a2b ? path.from : path.target,
-          coinBType: path.a2b ? path.target : path.from,
-          feeType,
-        }
-
-        const swapResult = await turbosClmmSwapMovecall(swapParams, txb, config)
-
-        intermediateTargetCoin = swapResult.targetCoin
-        nextFromCoin = intermediateTargetCoin
-        nextFlashAmount = swapResult.amountOut
-      }
-
-      if (path.provider === AFTERMATH_AMM) {
-        const coinA = path.a2b ? nextFromCoin : undefined
-        const coinB = path.a2b ? undefined : nextFromCoin
-
-        let lpSupplyType = ""
-
-        if (
-          path.extendedDetails != null &&
-          path.extendedDetails.aftermathLpSupplyType != null
-        ) {
-          lpSupplyType = path.extendedDetails.aftermathLpSupplyType
-        } else {
-          throw new AggregateError(
-            "Build aftermath swap movecall error: ",
-            TransactionErrorCode.MissAftermathLpSupplyType
-          )
-        }
-
-        const swapParams = {
-          poolId: path.id,
-          amount: nextFlashAmount,
-          amountOut: path.amountOut,
-          amountLimit: 0,
-          a2b: path.a2b,
-          byAmountIn: true,
-          coinA,
-          coinB,
-          useFullInputCoinAmount: !firstPathPool,
-          coinAType: path.a2b ? path.from : path.target,
-          coinBType: path.a2b ? path.target : path.from,
-          slippage: params.slippage,
-          lpSupplyType,
-        }
-
-        const swapResult = await AftermathAmmSwapMovecall(
-          swapParams,
-          txb,
-          config
-        )
-
-        intermediateTargetCoin = swapResult.targetCoin
-        nextFromCoin = intermediateTargetCoin
-        nextFlashAmount = swapResult.amountOut
-      }
-    }
-    targetCoins.push(nextFromCoin)
-  }
-
-  transferOrDestoryCoin(txb, fromCoin, params.fromCoinType, config)
-
-  return targetCoins
-}
-
-export async function expectOutputRouterSwap(
-  params: BuildRouterSwapParams,
-  txb: Transaction,
-  fromCoin: TransactionObjectArgument,
-  config: AggregatorConfig,
-  partner?: string
-): Promise<TransactionObjectArgument[]> {
-  const splitAmounts = params.routers.map((router) =>
-    router.amountOut.toString()
-  )
-
-  const returnCoins: TransactionObjectArgument[] = []
-  const receipts: TransactionObjectArgument[] = []
-
-  const targetCoins = []
-
-  for (let i = 0; i < params.routers.length; i++) {
-    const router = params.routers[i]
-
-    let nextFlashAmount: TransactionArgument = txb.pure.u64(splitAmounts[i])
-    for (let j = router.path.length - 1; j >= 0; j--) {
-      const path = router.path[j]
-
-      const coinAType = path.a2b ? path.from : path.target
-      const coinBType = path.a2b ? path.target : path.from
-
-      const swapParams = {
-        poolId: path.id,
-        amount: nextFlashAmount,
-        amountLimit: U64_MAX,
-        a2b: path.a2b,
-        byAmountIn: false,
-        sqrtPriceLimit: GetDefaultSqrtPriceLimit(path.a2b), //
-        partner,
-        coinAType,
-        coinBType,
-      }
-
-      const flashSwapResult = cetusFlashSwapMovecall(swapParams, txb, config)
-      nextFlashAmount = flashSwapResult.payAmount
-      returnCoins.unshift(flashSwapResult.targetCoin)
-      receipts.unshift(flashSwapResult.flashReceipt)
-    }
-
-    let nextRepayCoin = fromCoin
-    for (let j = 0; j < router.path.length; j++) {
-      const path = router.path[j]
-
-      const coinAType = path.a2b ? path.from : path.target
-      const coinBType = path.a2b ? path.target : path.from
-
-      const repayParams = {
-        poolId: path.id,
-        a2b: path.a2b,
-        partner: partner,
-        coinA: path.a2b ? nextRepayCoin : undefined,
-        coinB: path.a2b ? undefined : nextRepayCoin,
-        receipt: receipts[j],
-        coinAType,
-        coinBType,
-      }
-      const repayResult = await cetusRepayFlashSwapMovecall(
-        repayParams,
-        txb,
-        config
-      )
-      nextRepayCoin = returnCoins[j]
-      if (j === 0) {
-        fromCoin = repayResult.repayTargetCoin
-      } else {
-        transferOrDestoryCoin(
-          txb,
-          repayResult.repayTargetCoin,
-          path.from,
-          config
-        )
-      }
-      if (j === router.path.length - 1) {
-        targetCoins.push(nextRepayCoin)
-      }
-    }
-  }
-
-  transferOrDestoryCoin(txb, fromCoin, params.fromCoinType, config)
-
-  return targetCoins
-}

package/src/utils/account_cap.ts

@@ -1,62 +0,0 @@
-import { SuiClient } from "@mysten/sui/client"
-import { DEEPBOOK_CLOB_V2_MODULE, DEEPBOOK_CUSTODIAN_V2_MODULE, DEEPBOOK_PACKAGE_ID, DEEPBOOK_PUBLISHED_AT } from "../const"
-import { Transaction, TransactionObjectArgument } from "@mysten/sui/transactions"
-
-export type GetOrCreateAccountCapResult = {
-  accountCap: TransactionObjectArgument,
-  isCreate: boolean
-}
-
-export async function getOrCreateAccountCap(txb: Transaction, client: SuiClient, owner: string): Promise<GetOrCreateAccountCapResult> {
-  let accountCapStr = await getAccountCap(client, owner)
-  if (accountCapStr !== null) {
-    return {
-      accountCap: txb.object(accountCapStr),
-      isCreate: false,
-    }
-  }
-
-  const accountCap = txb.moveCall({
-    target: `${DEEPBOOK_PUBLISHED_AT}::${DEEPBOOK_CLOB_V2_MODULE}::create_account`,
-    typeArguments: [],
-    arguments: [],
-  })
-
-  return {
-    accountCap,
-    isCreate: true,
-  }
-}
-
-async function getAccountCap(client: SuiClient, owner: string): Promise<string | null> {
-  let limit = 50;
-  let cursor = null;
-
-  while (true) {
-    const ownedObjects: any = client.getOwnedObjects({
-      owner,
-      cursor,
-      limit,
-      filter: {
-        MoveModule: {
-          package: DEEPBOOK_PACKAGE_ID,
-          module: DEEPBOOK_CUSTODIAN_V2_MODULE,
-        }
-      }
-    })
-
-    if (ownedObjects != null && ownedObjects.data != null) {
-      if (ownedObjects.data.length !== 0) {
-        return ownedObjects.data[0].data.objectId
-      }
-
-      if (ownedObjects.data.length < 50) {
-        break
-      }
-    } else {
-      break
-    }
-  }
-  
-  return null
-}