@cetusprotocol/aggregator-sdk 0.0.8 → 0.1.1

package/src/transaction/swap.ts

@@ -1,8 +1,7 @@
 import { Transaction } from "@mysten/sui/transactions"
 import { SwapInPoolsParams } from "~/client"
-import { AggregatorConfig } from "~/config"
 import { compareCoins, completionCoin } from "~/utils/coin"
-import { CETUS_DEX, INTEGRATE, SwapInPoolsResult, U64_MAX_BN, ZERO } from ".."
+import { SwapInPoolsResult, U64_MAX_BN, ZERO } from ".."
 import { ConfigErrorCode, TransactionErrorCode } from "~/errors"
 import { checkInvalidSuiAddress } from "~/utils/transaction"
 import { SuiClient } from "@mysten/sui/client"
@@ -12,32 +11,24 @@ import { sqrtPriceX64ToPrice } from "~/math"
 export async function swapInPools(
   client: SuiClient,
   params: SwapInPoolsParams,
-  config: AggregatorConfig
+  sender: string
 ): 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 direction = compareCoins(fromCoin, targetCoin)
+  const integratePublishedAt =
+    "0x8faab90228e4c4df91c41626bbaefa19fc25c514405ac64de54578dec9e6f5ee"
+  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(a2b),
+      tx.pure.bool(direction),
       tx.pure.bool(byAmountIn),
       tx.pure.u64(amount.toString()),
     ]
@@ -48,7 +39,7 @@ export async function swapInPools(
     })
   }
 
-  if (!checkInvalidSuiAddress(config.getWallet())) {
+  if (!checkInvalidSuiAddress(sender)) {
     throw new AggregateError(
       "Aggregator package not set",
       ConfigErrorCode.InvalidWallet
@@ -57,7 +48,7 @@ export async function swapInPools(
 
   const simulateRes = await client.devInspectTransactionBlock({
     transactionBlock: tx,
-    sender: config.getWallet(),
+    sender,
   })
   if (simulateRes.error != null) {
     throw new AggregateError(
@@ -100,6 +91,8 @@ export async function swapInPools(
   }
 
   const event = valueData[tempIndex].parsedJson.data
+  console.log("event", JSON.stringify(event, null, 2))
+
   const currentSqrtPrice = event.step_results[0].current_sqrt_price
 
   const [decimalA, decimalB] = await Promise.all([
@@ -131,13 +124,13 @@ export async function swapInPools(
         path: [
           {
             id: pools[tempIndex],
-            a2b,
-            provider: CETUS_DEX,
+            direction,
+            provider: "CETUS",
             from: fromCoin,
             target: targetCoin,
-            feeRate: 0,
-            amountIn: 0,
-            amountOut: 0,
+            feeRate: event.fee_rate,
+            amountIn: event.amount_in,
+            amountOut: event.amount_out,
           },
         ],
         amountIn: new BN(event.amount_in ?? 0),

package/src/transaction/turbos.ts

@@ -1,114 +1,55 @@
 import {
-  TransactionArgument,
   Transaction,
+  TransactionArgument,
   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"
+import { AggregatorClient, CLOCK_ADDRESS, Dex, Env, Path } from ".."
 
-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 class Turbos implements Dex {
+  private versioned: string
 
-export type TurbosSwapResult = {
-  targetCoin: TransactionObjectArgument
-  amountIn: TransactionArgument
-  amountOut: TransactionArgument
-  txb: Transaction
-}
+  constructor(env: Env) {
+    if (env !== Env.Mainnet) {
+      throw new Error("Turbos only supported on mainnet")
+    }
 
-export async function turbosClmmSwapMovecall(
-  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
-    )
+    this.versioned =
+      "0xf1cf0e81048df168ebeb1b8030fad24b3e0b53ae827c25053fff0779c1445b6f"
   }
-  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
-      )
+  async swap(
+    client: AggregatorClient,
+    txb: Transaction,
+    path: Path,
+    inputCoin: TransactionObjectArgument
+  ): 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 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 args = [
+      txb.object(path.id),
+      inputCoin,
+      txb.object(CLOCK_ADDRESS),
+      txb.object(this.versioned),
+    ]
 
-  const target = createTarget(aggregatorPublishedAt, TURBOS_MODULE, func)
+    const res = txb.moveCall({
+      target: `${client.publishedAt()}::turbos::${func}`,
+      typeArguments: [coinAType, coinBType, path.extendedDetails.turbosFeeType],
+      arguments: args,
+    }) as TransactionObjectArgument
 
-  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,
+    return res
   }
 }

package/src/transaction/volo.ts

@@ -0,0 +1,52 @@
+import {
+  Transaction,
+  TransactionObjectArgument,
+} from "@mysten/sui/transactions"
+import { AggregatorClient, Dex, Env, Path } from ".."
+import { SUI_SYSTEM_ADDRESS } from "@mysten/sui/utils"
+
+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
+  ): 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 res = txb.moveCall({
+      target: `${client.publishedAt()}::volo::${func}`,
+      typeArguments: [],
+      arguments: args,
+    }) as TransactionObjectArgument
+
+    return res
+  }
+}

package/src/utils/coin.ts

@@ -1,24 +1,27 @@
+import { SuiZeroCoinFn } from "../const"
+import { CoinAsset } from "../types/sui"
+import { CoinUtils } from "../types/CoinAssist"
+import { TransactionErrorCode } from "../errors"
+import {
+  Transaction,
+  TransactionObjectArgument,
+} from "@mysten/sui/transactions"
+
 export function completionCoin(s: string): string {
   const index = s.indexOf("::")
   if (index === -1) {
     return s
   }
-
   const prefix = s.substring(0, index)
   const rest = s.substring(index)
-
   if (!prefix.startsWith("0x")) {
     return s
   }
-
   const hexStr = prefix.substring(2)
-
   if (hexStr.length > 64) {
     return s
   }
-
   const paddedHexStr = hexStr.padStart(64, "0")
-
   return `0x${paddedHexStr}${rest}`
 }
 
@@ -38,3 +41,85 @@ export function compareCoins(coinA: string, coinB: string): boolean {
   // If both strings are the same length and all characters are equal
   return true // or coinB, they are equal
 }
+
+export function mintZeroCoin(
+  txb: Transaction,
+  coinType: string
+): TransactionObjectArgument {
+  return txb.moveCall({
+    target: "0x2::coin::zero",
+    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,
+    }
+  }
+
+  let totalCoinBalance = CoinUtils.calculateTotalBalance(usedCoinAsests)
+  if (totalCoinBalance < amount) {
+    throw new AggregateError(
+      "Insufficient balance when build merge coin",
+      TransactionErrorCode.InsufficientBalance
+    )
+  }
+
+  if (CoinUtils.isSuiCoin(coinType)) {
+    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()),
+  }
+}

package/src/utils/transaction.ts

@@ -5,7 +5,7 @@ export async function printTransaction(tx: Transaction, isPrint = true) {
   let i = 0
 
   tx.getData().commands.forEach((item, index) => {
-    if (isPrint && i < 15) {
+    if (isPrint) {
       console.log(`transaction ${index}: `, JSON.stringify(item, null, 2))
       i++
     }