@cetusprotocol/aggregator-sdk 0.4.1 → 0.4.3

package/src/transaction/steamm.ts

@@ -1,77 +0,0 @@
-import {
-  Transaction,
-  TransactionObjectArgument,
-} from "@mysten/sui/transactions"
-import { AggregatorClient, CLOCK_ADDRESS, Dex, Env, getAggregatorV2ExtendPublishedAt, Path } from ".."
-
-export class Steamm implements Dex {
-  constructor(env: Env) {
-    if (env !== Env.Mainnet) {
-      throw new Error("Steamm only supported on mainnet")
-    }
-  }
-
-  async swap(
-    client: AggregatorClient,
-    txb: Transaction,
-    path: Path,
-    inputCoin: TransactionObjectArgument,
-    packages?: Map<string, string>
-  ): Promise<TransactionObjectArgument> {
-    const { direction, from, target } = path
-
-    const [func, coinAType, coinBType] = direction
-      ? ["swap_a2b", from, target]
-      : ["swap_b2a", target, from]
-
-    if (path.extendedDetails == null) {
-      throw new Error("Extended details not supported")
-    } else {
-      if (path.extendedDetails.steammBankA == null) {
-        throw new Error("Steamm bank a type not supported")
-      }
-      if (path.extendedDetails.steammBankB == null) {
-        throw new Error("Steamm bank b type not supported")
-      }
-      if (path.extendedDetails.steammLendingMarket == null) {
-        throw new Error("Steamm lending market not supported")
-      }
-      if (path.extendedDetails.steammLendingMarketType == null) {
-        throw new Error("Steamm lending market type not supported")
-      }
-      if (path.extendedDetails.steammBCoinAType == null) {
-        throw new Error("Steamm b coin a type not supported")
-      }
-      if (path.extendedDetails.steammBCoinBType == null) {
-        throw new Error("Steamm b coin b type not supported")
-      }
-      if (path.extendedDetails.steammLPToken == null) {
-        throw new Error("Steamm lp token not supported")
-      }
-    }
-
-    const args = [
-      txb.object(path.id),
-      txb.object(path.extendedDetails.steammBankA),
-      txb.object(path.extendedDetails.steammBankB),
-      txb.object(path.extendedDetails.steammLendingMarket),
-      inputCoin,
-      txb.object(CLOCK_ADDRESS),
-    ]
-    const publishedAt = getAggregatorV2ExtendPublishedAt(client.publishedAtV2Extend(), packages)
-    const res = txb.moveCall({
-      target: `${publishedAt}::steammfe::${func}`,
-      typeArguments: [
-        path.extendedDetails.steammLendingMarketType,
-        coinAType, 
-        coinBType,
-        path.extendedDetails.steammBCoinAType,
-        path.extendedDetails.steammBCoinBType,
-        path.extendedDetails.steammLPToken,
-      ],
-      arguments: args,
-    }) as TransactionObjectArgument
-
-    return res
-  }
-}

package/src/transaction/suilend.ts

@@ -1,48 +0,0 @@
-import {
-  Transaction,
-  TransactionObjectArgument,
-} from "@mysten/sui/transactions"
-import { AggregatorClient, Dex, Env, getAggregatorV2ExtendPublishedAt, Path } from ".."
-
-export class Suilend implements Dex {
-  private sui_system_state: string
-
-  constructor(env: Env) {
-    if (env !== Env.Mainnet) {
-      throw new Error("Suilend only supported on mainnet")
-    }
-
-    this.sui_system_state =
-      env === Env.Mainnet
-        ? "0x0000000000000000000000000000000000000000000000000000000000000005"
-        : "0x0"
-  }
-
-  async swap(
-    client: AggregatorClient,
-    txb: Transaction,
-    path: Path,
-    inputCoin: TransactionObjectArgument,
-    packages?: Map<string, string>
-  ): Promise<TransactionObjectArgument> {
-    const { direction, from, target } = path
-
-    const [func, springCoinType] = direction
-      ? ["swap_a2b", target]
-      : ["swap_b2a", from]
-
-    const args = [
-      txb.object(path.id),
-      txb.object(this.sui_system_state),
-      inputCoin,
-    ]
-    const publishedAt = getAggregatorV2ExtendPublishedAt(client.publishedAtV2Extend(), packages)
-    const res = txb.moveCall({
-      target: `${publishedAt}::suilend::${func}`,
-      typeArguments: [springCoinType],
-      arguments: args,
-    }) as TransactionObjectArgument
-
-    return res
-  }
-}

package/src/transaction/swap.ts

@@ -1,162 +0,0 @@
-import { Transaction } from "@mysten/sui/transactions"
-import { SwapInPoolsParams } from "~/client"
-import { compareCoins, completionCoin } from "~/utils/coin"
-import { Env, SwapInPoolsResult, U64_MAX_BN, ZERO } from ".."
-import { ConfigErrorCode, TransactionErrorCode } from "~/errors"
-import { checkInvalidSuiAddress, printTransaction } 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,
-  sender: string,
-  env: Env
-): Promise<SwapInPoolsResult> {
-  const { from, target, amount, byAmountIn, pools } = params
-  const fromCoin = completionCoin(from)
-  const targetCoin = completionCoin(target)
-
-  const tx = new Transaction()
-  const direction = compareCoins(fromCoin, targetCoin)
-  const integratePublishedAt = env === Env.Mainnet ?
-    "0x2d8c2e0fc6dd25b0214b3fa747e0fd27fd54608142cd2e4f64c1cd350cc4add4" :
-    "0x4f920e1ef6318cfba77e20a0538a419a5a504c14230169438b99aba485db40a6"
-  const coinA = direction ? fromCoin : targetCoin
-  const coinB = direction ? targetCoin : fromCoin
-
-  const typeArguments = [coinA, coinB]
-
-  for (let i = 0; i < pools.length; i++) {
-    const args = [
-      tx.object(pools[i]),
-      tx.pure.bool(direction),
-      tx.pure.bool(byAmountIn),
-      tx.pure.u64(amount.toString()),
-    ]
-    tx.moveCall({
-      target: `${integratePublishedAt}::fetcher_script::calculate_swap_result`,
-      arguments: args,
-      typeArguments,
-    })
-  }
-
-  if (!checkInvalidSuiAddress(sender)) {
-    throw new AggregateError(
-      "Aggregator package not set",
-      ConfigErrorCode.InvalidWallet
-    )
-  }
-
-  const simulateRes = await client.devInspectTransactionBlock({
-    transactionBlock: tx,
-    sender,
-  })
-  if (simulateRes.error != null) {
-    console.log("simulateRes.error", simulateRes.error)
-    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 feeRate = Number(event.fee_rate) / 1000000
-  const pureAmountIn = new BN(event.amount_in ?? 0)
-  const feeAmount = new BN(event.fee_amount ?? 0)
-  const amountIn = pureAmountIn.add(feeAmount)
-
-  const routeData = {
-    amountIn: amountIn,
-    amountOut: new BN(event.amount_out ?? 0),
-    routes: [
-      {
-        path: [
-          {
-            id: pools[tempIndex],
-            direction,
-            provider: "CETUS",
-            from: fromCoin,
-            target: targetCoin,
-            feeRate,
-            amountIn: event.amount_in,
-            amountOut: event.amount_out,
-            extendedDetails: {
-              afterSqrtPrice: event.after_sqrt_price,
-            },
-          },
-        ],
-        amountIn: amountIn,
-        amountOut: new BN(event.amount_out ?? 0),
-        initialPrice,
-      },
-    ],
-    insufficientLiquidity: false,
-    byAmountIn: params.byAmountIn,
-  }
-
-  const result = {
-    isExceed: event.is_exceed,
-    routeData,
-  }
-
-  return result
-}

package/src/transaction/turbos.ts

@@ -1,56 +0,0 @@
-import {
-  Transaction,
-  TransactionArgument,
-  TransactionObjectArgument,
-} from "@mysten/sui/transactions"
-import { AggregatorClient, CLOCK_ADDRESS, Dex, Env, getAggregatorV2PublishedAt, Path } from ".."
-
-export class Turbos implements Dex {
-  private versioned: string
-
-  constructor(env: Env) {
-    if (env !== Env.Mainnet) {
-      throw new Error("Turbos only supported on mainnet")
-    }
-
-    this.versioned =
-      "0xf1cf0e81048df168ebeb1b8030fad24b3e0b53ae827c25053fff0779c1445b6f"
-  }
-
-  async swap(
-    client: AggregatorClient,
-    txb: Transaction,
-    path: Path,
-    inputCoin: TransactionObjectArgument,
-    packages?: Map<string, string>
-  ): Promise<TransactionObjectArgument> {
-    const { direction, from, target } = path
-
-    const [func, coinAType, coinBType] = direction
-      ? ["swap_a2b", from, target]
-      : ["swap_b2a", target, from]
-
-    if (path.extendedDetails == null) {
-      throw new Error("Extended details not supported")
-    } else {
-      if (path.extendedDetails.turbosFeeType == null) {
-        throw new Error("Turbos fee type not supported")
-      }
-    }
-
-    const args = [
-      txb.object(path.id),
-      inputCoin,
-      txb.object(CLOCK_ADDRESS),
-      txb.object(this.versioned),
-    ]
-    const publishedAt = getAggregatorV2PublishedAt(client.publishedAtV2(), packages)
-    const res = txb.moveCall({
-      target: `${publishedAt}::turbos::${func}`,
-      typeArguments: [coinAType, coinBType, path.extendedDetails.turbosFeeType],
-      arguments: args,
-    }) as TransactionObjectArgument
-
-    return res
-  }
-}

package/src/transaction/volo.ts

@@ -1,53 +0,0 @@
-import {
-  Transaction,
-  TransactionObjectArgument,
-} from "@mysten/sui/transactions"
-import { AggregatorClient, Dex, Env, getAggregatorV2PublishedAt, Path } from ".."
-
-export class Volo implements Dex {
-  private nativePool: string
-  private metadata: string
-
-  constructor(env: Env) {
-    if (env !== Env.Mainnet) {
-      throw new Error("Volo only supported on mainnet")
-    }
-
-    this.nativePool =
-      "0x7fa2faa111b8c65bea48a23049bfd81ca8f971a262d981dcd9a17c3825cb5baf"
-    this.metadata =
-      "0x680cd26af32b2bde8d3361e804c53ec1d1cfe24c7f039eb7f549e8dfde389a60"
-  }
-
-  async swap(
-    client: AggregatorClient,
-    txb: Transaction,
-    path: Path,
-    inputCoin: TransactionObjectArgument,
-    packages?: Map<string, string>
-  ): Promise<TransactionObjectArgument> {
-    const { direction } = path
-
-    if (!direction) {
-      throw new Error("Volo not support b2a swap")
-    }
-
-    const func = "swap_a2b"
-
-    const args = [
-      txb.object(this.nativePool),
-      txb.object(this.metadata),
-      txb.object("0x5"),
-      inputCoin,
-    ]
-
-    const publishedAt = getAggregatorV2PublishedAt(client.publishedAtV2(), packages)
-    const res = txb.moveCall({
-      target: `${publishedAt}::volo::${func}`,
-      typeArguments: [],
-      arguments: args,
-    }) as TransactionObjectArgument
-
-    return res
-  }
-}

package/src/types/CoinAssist.ts

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