@cetusprotocol/aggregator-sdk 0.0.8 → 0.1.0

package/src/transaction/deepbook_v2.ts

@@ -0,0 +1,122 @@
+import {
+  Transaction,
+  TransactionArgument,
+  TransactionObjectArgument,
+} from "@mysten/sui/transactions"
+import { AggregatorClient, CLOCK_ADDRESS, Dex, Env, Path } from ".."
+import { SuiClient } from "@mysten/sui/client"
+
+const DEEPBOOK_PACKAGE_ID =
+  "0x000000000000000000000000000000000000000000000000000000000000dee9"
+
+type GetOrCreateAccountCapResult = {
+  accountCap: TransactionObjectArgument
+  isCreate: boolean
+}
+
+export class DeepbookV2 implements Dex {
+  constructor(env: Env) {
+    if (env !== Env.Mainnet) {
+      throw new Error("Aftermath only supported on mainnet")
+    }
+  }
+
+  async 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: "custodian_v2",
+          },
+        },
+      })
+
+      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
+  }
+
+  async getOrCreateAccountCap(
+    txb: Transaction,
+    client: SuiClient,
+    owner: string
+  ): Promise<GetOrCreateAccountCapResult> {
+    let accountCapStr = await this.getAccountCap(client, owner)
+    if (accountCapStr !== null) {
+      return {
+        accountCap: txb.object(accountCapStr),
+        isCreate: false,
+      }
+    }
+
+    const accountCap = txb.moveCall({
+      target: `${DEEPBOOK_PACKAGE_ID}::clob_v2::create_account`,
+      typeArguments: [],
+      arguments: [],
+    })
+
+    return {
+      accountCap,
+      isCreate: true,
+    }
+  }
+
+  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]
+
+    const accountCapRes = await this.getOrCreateAccountCap(
+      txb,
+      client.client,
+      client.signer
+    )
+
+    const args = [
+      txb.object(path.id),
+      inputCoin,
+      accountCapRes.accountCap,
+      txb.object(CLOCK_ADDRESS),
+    ]
+
+    const res = txb.moveCall({
+      target: `${client.publishedAt()}::deepbook::${func}`,
+      typeArguments: [coinAType, coinBType],
+      arguments: args,
+    }) as TransactionObjectArgument
+
+    if (accountCapRes.isCreate) {
+      txb.transferObjects([accountCapRes.accountCap], client.signer)
+    }
+
+    return res
+  }
+}

package/src/transaction/flowx_v2.ts

@@ -0,0 +1,42 @@
+import {
+  Transaction,
+  TransactionArgument,
+  TransactionObjectArgument,
+} from "@mysten/sui/transactions"
+import { AggregatorClient, Dex, Env, Path } from ".."
+
+export class FlowxV2 implements Dex {
+  private container: string
+
+  constructor(env: Env) {
+    if (env !== Env.Mainnet) {
+      throw new Error("Flowx only supported on mainnet")
+    }
+
+    this.container =
+      "0xb65dcbf63fd3ad5d0ebfbf334780dc9f785eff38a4459e37ab08fa79576ee511"
+  }
+
+  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]
+
+    const args = [txb.object(this.container), inputCoin]
+
+    const res = txb.moveCall({
+      target: `${client.publishedAt()}::flowx_amm::${func}`,
+      typeArguments: [coinAType, coinBType],
+      arguments: args,
+    }) as TransactionObjectArgument
+
+    return res
+  }
+}

package/src/transaction/haedal.ts

@@ -0,0 +1,41 @@
+import {
+  Transaction,
+  TransactionObjectArgument,
+} from "@mysten/sui/transactions"
+import { AggregatorClient, Dex, Env, Path } from ".."
+import { SUI_SYSTEM_ADDRESS } from "@mysten/sui/utils"
+
+export class Haedal implements Dex {
+  constructor(env: Env) {
+    if (env !== Env.Mainnet) {
+      throw new Error("Haedal only supported on mainnet")
+    }
+  }
+
+  async swap(
+    client: AggregatorClient,
+    txb: Transaction,
+    path: Path,
+    inputCoin: TransactionObjectArgument
+  ): Promise<TransactionObjectArgument> {
+    const { direction } = path
+
+    if (!direction) {
+      throw new Error("Haedal not support b2a swap")
+    }
+
+    const func = "swap_a2b"
+
+    console.log("haedal path id", path.id)
+
+    const args = [txb.object(path.id), txb.object("0x5"), inputCoin]
+
+    const res = txb.moveCall({
+      target: `${client.publishedAt()}::haedal::${func}`,
+      typeArguments: [],
+      arguments: args,
+    }) as TransactionObjectArgument
+
+    return res
+  }
+}

package/src/transaction/index.ts

@@ -1 +1,17 @@
-export * from "./router"
+import {
+  Transaction,
+  TransactionObjectArgument,
+} from "@mysten/sui/transactions"
+import { AggregatorClient, Path } from ".."
+
+export const CLOCK_ADDRESS =
+  "0x0000000000000000000000000000000000000000000000000000000000000006"
+
+export interface Dex {
+  swap(
+    client: AggregatorClient,
+    ptb: Transaction,
+    path: Path,
+    inputCoin: TransactionObjectArgument
+  ): Promise<TransactionObjectArgument>
+}

package/src/transaction/kriya_v2.ts

@@ -0,0 +1,38 @@
+import {
+  Transaction,
+  TransactionArgument,
+  TransactionObjectArgument,
+  TransactionResult,
+} from "@mysten/sui/transactions"
+import { AggregatorClient, Dex, Env, Path } from ".."
+
+export class KriyaV2 implements Dex {
+  constructor(env: Env) {
+    if (env !== Env.Mainnet) {
+      throw new Error("Kriya amm only supported on mainnet")
+    }
+  }
+
+  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]
+
+    const args = [txb.object(path.id), inputCoin]
+
+    const res = txb.moveCall({
+      target: `${client.publishedAt()}::kriya_amm::${func}`,
+      typeArguments: [coinAType, coinBType],
+      arguments: args,
+    }) as TransactionObjectArgument
+
+    return res
+  }
+}

package/src/transaction/kriya_v3.ts

@@ -0,0 +1,46 @@
+import {
+  Transaction,
+  TransactionObjectArgument,
+} from "@mysten/sui/transactions"
+import { AggregatorClient, CLOCK_ADDRESS, Dex, Env, Path } from ".."
+
+export class KriyaV3 implements Dex {
+  private version: string
+
+  constructor(env: Env) {
+    if (env !== Env.Mainnet) {
+      throw new Error("Kriya clmm only supported on mainnet")
+    }
+
+    this.version =
+      "0xf5145a7ac345ca8736cf8c76047d00d6d378f30e81be6f6eb557184d9de93c78"
+  }
+
+  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]
+
+    const args = [
+      txb.object(path.id),
+      inputCoin,
+      txb.object(this.version),
+      txb.object(CLOCK_ADDRESS),
+    ]
+
+    const res = txb.moveCall({
+      target: `${client.publishedAt()}::kriya_clmm::${func}`,
+      typeArguments: [coinAType, coinBType],
+      arguments: args,
+    }) as TransactionObjectArgument
+
+    return res
+  }
+}

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