@cetusprotocol/aggregator-sdk 0.0.7 → 0.1.0

package/src/transaction/common.ts

@@ -1,174 +0,0 @@
-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,
-    }
-  }
-
-  console.log("used coin asests", usedCoinAsests)
-
-  let totalCoinBalance = CoinUtils.calculateTotalBalance(usedCoinAsests)
-
-  console.log("totalCoinBalance", totalCoinBalance)
-  console.log("amount", amount)
-  if (totalCoinBalance < amount) {
-    throw new AggregateError(
-      "Insufficient balance when build merge coin",
-      TransactionErrorCode.InsufficientBalance
-    )
-  }
-
-  if (CoinUtils.isSuiCoin(coinType) && amount <= BigInt(950000000000)) {
-    const resultCoin = txb.splitCoins(txb.gas, [
-      txb.pure.u64(amount.toString()),
-    ])
-    return {
-      targetCoin: resultCoin,
-      isMintZeroCoin: true,
-      targetCoinAmount: Number(amount.toString()),
-    }
-  }
-
-  // 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
-}

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
-  }
-}