@cetusprotocol/aggregator-sdk 0.0.1

package/src/transaction/swap.ts

@@ -0,0 +1,163 @@
+import { Transaction } from "@mysten/sui/transactions"
+import { SwapInPoolsParams } from "~/client"
+import { AggregatorConfig } from "~/config"
+import { compareCoins, completionCoin } from "~/utils/coin"
+import {
+  CETUS_DEX,
+  INTEGRATE,
+  RouterData,
+  SwapInPoolsResult,
+  U64_MAX_BN,
+  ZERO,
+} from ".."
+import { ConfigErrorCode, TransactionErrorCode } from "~/errors"
+import { checkInvalidSuiAddress } from "~/utils/transaction"
+import { SuiClient } from "@mysten/sui/client"
+import { BN } from "bn.js"
+import { sqrtPriceX64ToPrice } from "~/math"
+
+export async function swapInPools(
+  client: SuiClient,
+  params: SwapInPoolsParams,
+  config: AggregatorConfig
+): Promise<SwapInPoolsResult> {
+  const { from, target, amount, byAmountIn, pools } = params
+  const fromCoin = completionCoin(from)
+  const targetCoin = completionCoin(target)
+
+  const tx = new Transaction()
+  const a2b = compareCoins(fromCoin, targetCoin)
+
+  const integratePackage = config.getPackage(INTEGRATE)
+  if (integratePackage == null) {
+    throw new AggregateError(
+      "Aggregator package not set",
+      ConfigErrorCode.MissAggregatorPackage
+    )
+  }
+  const integratePublishedAt = integratePackage.publishedAt
+
+  const coinA = a2b ? fromCoin : targetCoin
+  const coinB = a2b ? targetCoin : fromCoin
+
+  const typeArguments = [coinA, coinB]
+  for (let i = 0; i < pools.length; i++) {
+    const args = [
+      tx.object(pools[i]),
+      tx.pure.bool(a2b),
+      tx.pure.bool(byAmountIn),
+      tx.pure.u64(amount.toString()),
+    ]
+    tx.moveCall({
+      target: `${integratePublishedAt}::fetcher_script::calculate_swap_result`,
+      arguments: args,
+      typeArguments,
+    })
+  }
+
+  if (!checkInvalidSuiAddress(config.getWallet())) {
+    throw new AggregateError(
+      "Aggregator package not set",
+      ConfigErrorCode.InvalidWallet
+    )
+  }
+
+  const simulateRes = await client.devInspectTransactionBlock({
+    transactionBlock: tx,
+    sender: config.getWallet(),
+  })
+  if (simulateRes.error != null) {
+    throw new AggregateError(
+      "Aggregator package not set",
+      ConfigErrorCode.SimulateError
+    )
+  }
+
+  const valueData: any = simulateRes.events?.filter((item: any) => {
+    return item.type.includes("CalculatedSwapResultEvent")
+  })
+
+  if (valueData.length === 0 || valueData.length !== pools.length) {
+    throw new AggregateError(
+      "Simulate event result error",
+      TransactionErrorCode.SimulateEventError
+    )
+  }
+
+  let tempMaxAmount = byAmountIn ? ZERO : U64_MAX_BN
+  let tempIndex = 0
+  for (let i = 0; i < valueData.length; i += 1) {
+    if (valueData[i].parsedJson.data.is_exceed) {
+      continue
+    }
+
+    if (params.byAmountIn) {
+      const amount = new BN(valueData[i].parsedJson.data.amount_out)
+      if (amount.gt(tempMaxAmount)) {
+        tempIndex = i
+        tempMaxAmount = amount
+      }
+    } else {
+      const amount = new BN(valueData[i].parsedJson.data.amount_out)
+      if (amount.lt(tempMaxAmount)) {
+        tempIndex = i
+        tempMaxAmount = amount
+      }
+    }
+  }
+
+  const event = valueData[tempIndex].parsedJson.data
+  const currentSqrtPrice = event.step_results[0].current_sqrt_price
+
+  const [decimalA, decimalB] = await Promise.all([
+    client
+      .getCoinMetadata({ coinType: coinA })
+      .then((metadata) => metadata?.decimals),
+    client
+      .getCoinMetadata({ coinType: coinB })
+      .then((metadata) => metadata?.decimals),
+  ])
+
+  if (decimalA == null || decimalB == null) {
+    throw new AggregateError(
+      "Simulate event result error",
+      TransactionErrorCode.CannotGetDecimals
+    )
+  }
+  const initialPrice = sqrtPriceX64ToPrice(
+    currentSqrtPrice,
+    decimalA!,
+    decimalB!
+  )
+
+  const routeData = {
+    amountIn: new BN(event.amount_in ?? 0),
+    amountOut: new BN(event.amount_out ?? 0),
+    routes: [
+      {
+        path: [
+          {
+            id: pools[tempIndex],
+            a2b,
+            provider: CETUS_DEX,
+            from: fromCoin,
+            target: targetCoin,
+            feeRate: 0,
+            amountIn: 0,
+            amountOut: 0,
+          },
+        ],
+        amountIn: new BN(event.amount_in ?? 0),
+        amountOut: new BN(event.amount_out ?? 0),
+        initialPrice,
+      },
+    ],
+  }
+
+  const result = {
+    isExceed: event.is_exceed,
+    routeData,
+  }
+
+  return result
+}

package/src/transaction/turbos.ts

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

package/src/types/CoinAssist.ts

@@ -0,0 +1,217 @@
+import type { SuiMoveObject } from '@mysten/sui/client'
+import type { CoinAsset, SuiAddress } from './sui'
+import { extractStructTagFromType, normalizeCoinType } from '../utils/contracts' 
+
+const COIN_TYPE = '0x2::coin::Coin'
+const COIN_TYPE_ARG_REGEX = /^0x2::coin::Coin<(.+)>$/
+
+export const DEFAULT_GAS_BUDGET_FOR_SPLIT = 1000
+export const DEFAULT_GAS_BUDGET_FOR_MERGE = 500
+export const DEFAULT_GAS_BUDGET_FOR_TRANSFER = 100
+export const DEFAULT_GAS_BUDGET_FOR_TRANSFER_SUI = 100
+export const DEFAULT_GAS_BUDGET_FOR_STAKE = 1000
+export const GAS_TYPE_ARG = '0x2::sui::SUI'
+export const GAS_TYPE_ARG_LONG = '0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI'
+export const GAS_SYMBOL = 'SUI'
+export const DEFAULT_NFT_TRANSFER_GAS_FEE = 450
+export const SUI_SYSTEM_STATE_OBJECT_ID = '0x0000000000000000000000000000000000000005'
+
+/**
+ * This class provides helper methods for working with coins.
+ */
+export class CoinUtils {
+  /**
+   * Get the coin type argument from a SuiMoveObject.
+   *
+   * @param obj The SuiMoveObject to get the coin type argument from.
+   * @returns The coin type argument, or null if it is not found.
+   */
+  public static getCoinTypeArg(obj: SuiMoveObject) {
+    const res = obj.type.match(COIN_TYPE_ARG_REGEX)
+    return res ? res[1] : null
+  }
+
+  /**
+   * Get whether a SuiMoveObject is a SUI coin.
+   *
+   * @param obj The SuiMoveObject to check.
+   * @returns Whether the SuiMoveObject is a SUI coin.
+   */
+  public static isSUI(obj: SuiMoveObject) {
+    const arg = CoinUtils.getCoinTypeArg(obj)
+    return arg ? CoinUtils.getCoinSymbol(arg) === 'SUI' : false
+  }
+
+  /**
+   * Get the coin symbol from a coin type argument.
+   *
+   * @param coinTypeArg The coin type argument to get the symbol from.
+   * @returns The coin symbol.
+   */
+  public static getCoinSymbol(coinTypeArg: string) {
+    return coinTypeArg.substring(coinTypeArg.lastIndexOf(':') + 1)
+  }
+
+  /**
+   * Get the balance of a SuiMoveObject.
+   *
+   * @param obj The SuiMoveObject to get the balance from.
+   * @returns The balance of the SuiMoveObject.
+   */
+  public static getBalance(obj: SuiMoveObject): bigint {
+    return BigInt((obj.fields as any).balance)
+  }
+
+  /**
+   * Get the total balance of a list of CoinAsset objects for a given coin address.
+   *
+   * @param objs The list of CoinAsset objects to get the total balance for.
+   * @param coinAddress The coin address to get the total balance for.
+   * @returns The total balance of the CoinAsset objects for the given coin address.
+   */
+  public static totalBalance(objs: CoinAsset[], coinAddress: SuiAddress): bigint {
+    let balanceTotal = BigInt(0)
+    objs.forEach((obj) => {
+      if (coinAddress === obj.coinAddress) {
+        balanceTotal += BigInt(obj.balance)
+      }
+    })
+    return balanceTotal
+  }
+
+  /**
+   * Get the ID of a SuiMoveObject.
+   *
+   * @param obj The SuiMoveObject to get the ID from.
+   * @returns The ID of the SuiMoveObject.
+   */
+  public static getID(obj: SuiMoveObject): string {
+    return (obj.fields as any).id.id
+  }
+
+  /**
+   * Get the coin type from a coin type argument.
+   *
+   * @param coinTypeArg The coin type argument to get the coin type from.
+   * @returns The coin type.
+   */
+  public static getCoinTypeFromArg(coinTypeArg: string) {
+    return `${COIN_TYPE}<${coinTypeArg}>`
+  }
+
+  /**
+   * Get the CoinAsset objects for a given coin type.
+   *
+   * @param coinType The coin type to get the CoinAsset objects for.
+   * @param allSuiObjects The list of all SuiMoveObjects.
+   * @returns The CoinAsset objects for the given coin type.
+   */
+  public static getCoinAssets(coinType: string, allSuiObjects: CoinAsset[]): CoinAsset[] {
+    const coins: CoinAsset[] = []
+    allSuiObjects.forEach((anObj) => {
+      if (normalizeCoinType(anObj.coinAddress) === normalizeCoinType(coinType)) {
+        coins.push(anObj)
+      }
+    })
+    return coins
+  }
+
+  /**
+   * Get whether a coin address is a SUI coin.
+   *
+   * @param coinAddress The coin address to check.
+   * @returns Whether the coin address is a SUI coin.
+   */
+  public static isSuiCoin(coinAddress: SuiAddress) {
+    return extractStructTagFromType(coinAddress).full_address === GAS_TYPE_ARG
+  }
+
+  /**
+   * Select the CoinAsset objects from a list of CoinAsset objects that have a balance greater than or equal to a given amount.
+   *
+   * @param coins The list of CoinAsset objects to select from.
+   * @param amount The amount to select CoinAsset objects with a balance greater than or equal to.
+   * @param exclude A list of CoinAsset objects to exclude from the selection.
+   * @returns The CoinAsset objects that have a balance greater than or equal to the given amount.
+   */
+  static selectCoinObjectIdGreaterThanOrEqual(
+    coins: CoinAsset[],
+    amount: bigint,
+    exclude: string[] = []
+  ): { objectArray: string[]; remainCoins: CoinAsset[]; amountArray: string[] } {
+    const selectedResult = CoinUtils.selectCoinAssetGreaterThanOrEqual(coins, amount, exclude)
+    const objectArray = selectedResult.selectedCoins.map((item) => item.coinObjectId)
+    const remainCoins = selectedResult.remainingCoins
+    const amountArray = selectedResult.selectedCoins.map((item) => item.balance.toString())
+    return { objectArray, remainCoins, amountArray }
+  }
+
+  /**
+   * Select the CoinAsset objects from a list of CoinAsset objects that have a balance greater than or equal to a given amount.
+   *
+   * @param coins The list of CoinAsset objects to select from.
+   * @param amount The amount to select CoinAsset objects with a balance greater than or equal to.
+   * @param exclude A list of CoinAsset objects to exclude from the selection.
+   * @returns The CoinAsset objects that have a balance greater than or equal to the given amount.
+   */
+  static selectCoinAssetGreaterThanOrEqual(
+    coins: CoinAsset[],
+    amount: bigint,
+    exclude: string[] = []
+  ): { selectedCoins: CoinAsset[]; remainingCoins: CoinAsset[] } {
+    const sortedCoins = CoinUtils.sortByBalance(coins.filter((c) => !exclude.includes(c.coinObjectId)))
+
+    const total = CoinUtils.calculateTotalBalance(sortedCoins)
+
+    if (total < amount) {
+      return { selectedCoins: [], remainingCoins: sortedCoins }
+    }
+    if (total === amount) {
+      return { selectedCoins: sortedCoins, remainingCoins: [] }
+    }
+
+    let sum = BigInt(0)
+    const selectedCoins = []
+    const remainingCoins = [...sortedCoins]
+    while (sum < total) {
+      const target = amount - sum
+      const coinWithSmallestSufficientBalanceIndex = remainingCoins.findIndex((c) => c.balance >= target)
+      if (coinWithSmallestSufficientBalanceIndex !== -1) {
+        selectedCoins.push(remainingCoins[coinWithSmallestSufficientBalanceIndex])
+        remainingCoins.splice(coinWithSmallestSufficientBalanceIndex, 1)
+        break
+      }
+
+      const coinWithLargestBalance = remainingCoins.pop()!
+      if (coinWithLargestBalance.balance > 0) {
+        selectedCoins.push(coinWithLargestBalance)
+        sum += coinWithLargestBalance.balance
+      }
+    }
+    return { selectedCoins: CoinUtils.sortByBalance(selectedCoins), remainingCoins: CoinUtils.sortByBalance(remainingCoins) }
+  }
+
+  /**
+   * Sort the CoinAsset objects by their balance.
+   *
+   * @param coins The CoinAsset objects to sort.
+   * @returns The sorted CoinAsset objects.
+   */
+  static sortByBalance(coins: CoinAsset[]): CoinAsset[] {
+    return coins.sort((a, b) => (a.balance < b.balance ? -1 : a.balance > b.balance ? 1 : 0))
+  }
+
+  static sortByBalanceDes(coins: CoinAsset[]): CoinAsset[] {
+    return coins.sort((a, b) => (a.balance > b.balance ? -1 : a.balance < b.balance ? 0 : 1))
+  }
+
+  /**
+   * Calculate the total balance of a list of CoinAsset objects.
+   *
+   * @param coins The list of CoinAsset objects to calculate the total balance for.
+   * @returns The total balance of the CoinAsset objects.
+   */
+  static calculateTotalBalance(coins: CoinAsset[]): bigint {
+    return coins.reduce((partialSum, c) => partialSum + c.balance, BigInt(0))
+  }
+}

package/src/types/sui.ts

@@ -0,0 +1,148 @@
+import type { TransactionArgument } from '@mysten/sui/transactions'
+import Decimal from 'decimal.js'
+import { TypesErrorCode } from '../errors'
+
+/**
+ * Represents a SUI address, which is a string.
+ */
+export type SuiAddress = string
+
+/**
+ * Represents a SUI object identifier, which is a string.
+ */
+export type SuiObjectIdType = string
+
+/**
+ * Represents a BigNumber, which can be a Decimal.Value, number, or string.
+ */
+export type BigNumber = Decimal.Value | number | string
+
+
+/**
+ * Represents a SUI resource, which can be of any type.
+ */
+export type SuiResource = any
+
+/**
+ * Represents a Non-Fungible Token (NFT) with associated metadata.
+ */
+export type NFT = {
+  /**
+   * The address or identifier of the creator of the NFT.
+   */
+  creator: string
+
+  /**
+   * A description providing additional information about the NFT.
+   */
+  description: string
+
+  /**
+   * The URL to the image representing the NFT visually.
+   */
+  image_url: string
+
+  /**
+   * A link associated with the NFT, providing more details or interactions.
+   */
+  link: string
+
+  /**
+   * The name or title of the NFT.
+   */
+  name: string
+
+  /**
+   * The URL to the project or collection associated with the NFT.
+   */
+  project_url: string
+}
+
+/**
+ * Represents a SUI struct tag.
+ */
+export type SuiStructTag = {
+  /**
+   * The full address of the struct.
+   */
+  full_address: string
+
+  /**
+   * The source address of the struct.
+   */
+  source_address: string
+
+  /**
+   * The address of the struct.
+   */
+  address: SuiAddress
+
+  /**
+   * The module to which the struct belongs.
+   */
+  module: string
+
+  /**
+   * The name of the struct.
+   */
+  name: string
+
+  /**
+   * An array of type arguments (SUI addresses) for the struct.
+   */
+  type_arguments: SuiAddress[]
+}
+
+/**
+ * Represents basic SUI data types.
+ */
+export type SuiBasicTypes = 'address' | 'bool' | 'u8' | 'u16' | 'u32' | 'u64' | 'u128' | 'u256'
+
+/**
+ * Represents a SUI transaction argument, which can be of various types.
+ */
+export type SuiTxArg = TransactionArgument | string | number | bigint | boolean
+
+/**
+ * Represents input types for SUI data.
+ */
+export type SuiInputTypes = 'object' | SuiBasicTypes
+
+/**
+ * Gets the default SUI input type based on the provided value.
+ * @param value - The value to determine the default input type for.
+ * @returns The default SUI input type.
+ * @throws Error if the type of the value is unknown.
+ */
+export const getDefaultSuiInputType = (value: any): SuiInputTypes => {
+  if (typeof value === 'string' && value.startsWith('0x')) {
+    return 'object'
+  }
+  if (typeof value === 'number' || typeof value === 'bigint') {
+    return 'u64'
+  }
+  if (typeof value === 'boolean') {
+    return 'bool'
+  }
+  throw new AggregateError(`Unknown type for value: ${value}`, TypesErrorCode.InvalidType)
+}
+
+/**
+ * Represents a coin asset with address, object ID, and balance information.
+ */
+export type CoinAsset = {
+  /**
+   * The address type of the coin asset.
+   */
+  coinAddress: SuiAddress
+
+  /**
+   * The object identifier of the coin asset.
+   */
+  coinObjectId: SuiObjectIdType
+
+  /**
+   * The balance amount of the coin asset.
+   */
+  balance: bigint
+}

package/src/utils/account_cap.ts

@@ -0,0 +1,62 @@
+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
+}

package/src/utils/coin.spec.ts

@@ -0,0 +1,10 @@
+import { parseTurbosPoolFeeType } from "./coin"
+
+describe("Coin Utils", () => {
+  it("should fetch token infos by URL and return data", async () => {
+    const typeDate =
+      "0x91bfbc386a41afcfd9b2533058d7e915a1d3829089cc268ff4333d54d6339ca1::pool::Pool<0xc91acfb75009c5ff2fd57c54f3caaee12ad1fbe997681334adc0b574fc277a07::icorgi::ICORGI, 0x2::sui::SUI, 0x91bfbc386a41afcfd9b2533058d7e915a1d3829089cc268ff4333d54d6339ca1::fee10000bps::FEE10000BPS>"
+    const result = parseTurbosPoolFeeType(typeDate)
+    console.log("parse turbos pool type", result)
+  })
+})