@cetusprotocol/aggregator-sdk 0.0.8 → 0.1.1

package/src/transaction/cetus.ts

@@ -3,279 +3,108 @@ import {
   TransactionArgument,
   TransactionObjectArgument,
 } from "@mysten/sui/transactions"
-import { AggregatorConfig, ENV } from "../config"
-import {
-  AGGREGATOR,
-  CLOCK_ADDRESS,
-  CETUS_MODULE,
-  FlashSwapA2BFunc,
-  MAINNET_CETUS_GLOBAL_CONFIG_ID,
-  TESTNET_CETUS_GLOBAL_CONFIG_ID,
-  FlashSwapWithPartnerA2BFunc,
-  FlashSwapWithPartnerB2AFunc,
-  FlashSwapB2AFunc,
-  REPAY_FLASH_SWAP_WITH_PARTNER_A2B_FUNC,
-  REPAY_FLASH_SWAP_WITH_PARTNER_B2A_FUNC,
-  REPAY_FLASH_SWAP_A2B_FUNC,
-  REPAY_FLASH_SWAP_B2A_FUNC,
-} from "../const"
-import { ConfigErrorCode, TransactionErrorCode } from "../errors"
-import BN from "bn.js"
-import { createTarget } from "../utils"
-
-export type CetusSwapParams = {
-  poolId: string
-  amount: TransactionArgument
-  amountLimit: string
-  a2b: boolean
-  byAmountIn: boolean
-  sqrtPriceLimit: BN
-  partner?: string
-  coinAType: string
-  coinBType: string
-}
+import { AggregatorClient, CLOCK_ADDRESS, Dex, Env, Path } from ".."
 
 export type CetusFlashSwapResult = {
   targetCoin: TransactionObjectArgument
   flashReceipt: TransactionObjectArgument
   payAmount: TransactionArgument
-  swapedAmount: TransactionArgument
-  txb: Transaction
 }
 
-export function cetusFlashSwapMovecall(
-  swapParams: CetusSwapParams,
-  txb: Transaction,
-  config: AggregatorConfig
-): CetusFlashSwapResult {
-  const aggregatorPackage = config.getPackage(AGGREGATOR)
-  if (aggregatorPackage == null) {
-    throw new AggregateError(
-      "Aggregator package not set",
-      ConfigErrorCode.MissAggregatorPackage
-    )
-  }
-  const aggregatorPublishedAt = aggregatorPackage.publishedAt
-
-  const globalConfigId =
-    config.getENV() === ENV.MAINNET
-      ? MAINNET_CETUS_GLOBAL_CONFIG_ID
-      : TESTNET_CETUS_GLOBAL_CONFIG_ID
-
-  const hasPartner = swapParams.partner != null && swapParams.partner.length > 0
+export class Cetus implements Dex {
+  private globalConfig: string
+  private partner: string
 
-  const args = hasPartner
-    ? [
-        txb.object(globalConfigId),
-        txb.object(swapParams.poolId),
-        swapParams.amount,
-        txb.pure.u64(swapParams.amountLimit),
-        txb.pure.bool(swapParams.byAmountIn),
-        txb.pure.u128(swapParams.sqrtPriceLimit.toString()),
-        txb.object(swapParams.partner!.toString()),
-        txb.object(CLOCK_ADDRESS),
-      ]
-    : [
-        txb.object(globalConfigId),
-        txb.object(swapParams.poolId),
-        swapParams.amount,
-        txb.pure.u64(swapParams.amountLimit),
-        txb.pure.bool(swapParams.byAmountIn),
-        txb.pure.u128(swapParams.sqrtPriceLimit.toString()),
-        txb.object(CLOCK_ADDRESS),
-      ]
+  constructor(env: Env, partner?: string) {
+    this.globalConfig =
+      env === Env.Mainnet
+        ? "0xdaa46292632c3c4d8f31f23ea0f9b36a28ff3677e9684980e4438403a67a3d8f"
+        : "0x6f4149091a5aea0e818e7243a13adcfb403842d670b9a2089de058512620687a"
 
-  let func
-  if (hasPartner) {
-    if (swapParams.a2b) {
-      func = FlashSwapWithPartnerA2BFunc
-    } else {
-      func = FlashSwapWithPartnerB2AFunc
-    }
-  } else {
-    if (swapParams.a2b) {
-      func = FlashSwapA2BFunc
-    } else {
-      func = FlashSwapB2AFunc
-    }
+    this.partner =
+      partner ??
+      "0x639b5e433da31739e800cd085f356e64cae222966d0f1b11bd9dc76b322ff58b"
   }
 
-  const target = createTarget(aggregatorPublishedAt, CETUS_MODULE, func)
-
-  const moveCallRes = txb.moveCall({
-    target,
-    typeArguments: [swapParams.coinAType, swapParams.coinBType],
-    arguments: args,
-  })
-
-  return {
-    targetCoin: moveCallRes[0],
-    flashReceipt: moveCallRes[1],
-    payAmount: moveCallRes[2],
-    swapedAmount: moveCallRes[3],
-    txb,
-  }
-}
-
-export type repayParams = {
-  poolId: string
-  a2b: boolean
-  coinA?: TransactionObjectArgument
-  coinB?: TransactionObjectArgument
-  receipt: TransactionObjectArgument
-  coinAType: string
-  coinBType: string
-  partner?: string
-}
-
-export type SwapResult = {
-  repayTargetCoin: TransactionObjectArgument
-  nextInputAmount?: TransactionArgument
-  flashTargetCoin?: TransactionObjectArgument
-}
-
-export async function cetusRepayFlashSwapMovecall(
-  repayParams: repayParams,
-  txb: Transaction,
-  config: AggregatorConfig
-): Promise<SwapResult> {
-  const aggregatorPackage = config.getPackage(AGGREGATOR)
-  if (aggregatorPackage == null) {
-    throw new AggregateError(
-      "Aggregator package not set",
-      ConfigErrorCode.MissAggregatorPackage
-    )
-  }
-  const aggregatorPublishedAt = aggregatorPackage.publishedAt
-
-  const globalConfigId =
-    config.getENV() === ENV.MAINNET
-      ? MAINNET_CETUS_GLOBAL_CONFIG_ID
-      : TESTNET_CETUS_GLOBAL_CONFIG_ID
-
-  const hasPartner =
-    repayParams.partner != null && repayParams.partner.length > 0
-
-  if (repayParams.a2b) {
-    if (repayParams.coinA == null) {
-      throw new AggregateError(
-        "coinA is required",
-        TransactionErrorCode.MissCoinA
-      )
+  flash_swap(
+    client: AggregatorClient,
+    txb: Transaction,
+    path: Path,
+    by_amount_in: boolean
+  ): CetusFlashSwapResult {
+    const { direction, from, target } = path
+    const [func, coinAType, coinBType] = direction
+      ? ["flash_swap_a2b", from, target]
+      : ["flash_swap_b2a", target, from]
+    let amount = by_amount_in ? path.amountIn : path.amountOut
+    const args = [
+      txb.object(this.globalConfig),
+      txb.object(path.id),
+      txb.object(this.partner),
+      txb.pure.u64(amount),
+      txb.pure.bool(by_amount_in),
+      txb.object(CLOCK_ADDRESS),
+    ]
+    const res: TransactionObjectArgument[] = txb.moveCall({
+      target: `${client.publishedAt()}::cetus::${func}`,
+      typeArguments: [coinAType, coinBType],
+      arguments: args,
+    })
+    return {
+      targetCoin: res[0],
+      flashReceipt: res[1],
+      payAmount: res[2],
     }
-  } else {
-    if (repayParams.coinB == null) {
-      throw new AggregateError(
-        "coinB is required",
-        TransactionErrorCode.MissCoinB
-      )
-    }
-  }
-
-  let args
-  if (hasPartner) {
-    if (repayParams.a2b) {
-      args = [
-        txb.object(globalConfigId),
-        txb.object(repayParams.poolId),
-        repayParams.coinA!,
-        repayParams.receipt,
-        txb.object(repayParams.partner!),
-      ]
-    } else {
-      args = [
-        txb.object(globalConfigId),
-        txb.object(repayParams.poolId),
-        repayParams.coinB!,
-        repayParams.receipt,
-        txb.object(repayParams.partner!),
-      ]
-    }
-  } else {
-    if (repayParams.a2b) {
-      args = [
-        txb.object(globalConfigId),
-        txb.object(repayParams.poolId),
-        repayParams.coinA!,
-        repayParams.receipt,
-      ]
-    } else {
-      args = [
-        txb.object(globalConfigId),
-        txb.object(repayParams.poolId),
-        repayParams.coinB!,
-        repayParams.receipt,
-      ]
-    }
-  }
-
-  let func
-  if (hasPartner) {
-    if (repayParams.a2b) {
-      func = REPAY_FLASH_SWAP_WITH_PARTNER_A2B_FUNC
-    } else {
-      func = REPAY_FLASH_SWAP_WITH_PARTNER_B2A_FUNC
-    }
-  } else {
-    if (repayParams.a2b) {
-      func = REPAY_FLASH_SWAP_A2B_FUNC
-    } else {
-      func = REPAY_FLASH_SWAP_B2A_FUNC
-    }
-  }
-
-  const target = createTarget(aggregatorPublishedAt, CETUS_MODULE, func)
-
-  const res: TransactionObjectArgument[] = txb.moveCall({
-    target,
-    typeArguments: [repayParams.coinAType, repayParams.coinBType],
-    arguments: args,
-  })
-
-  return {
-    repayTargetCoin: res[0],
-  }
-}
-
-export async function cetusSwapWithOutLimit(
-  swapParams: CetusSwapParams,
-  fromCoin: TransactionObjectArgument,
-  txb: Transaction,
-  config: AggregatorConfig
-): Promise<SwapResult> {
-  const flashResult = cetusFlashSwapMovecall(swapParams, txb, config)
-
-  const repayCoinA = swapParams.a2b ? fromCoin : undefined
-  const repayCoinB = swapParams.a2b ? undefined : fromCoin
-
-  const repayParams = {
-    poolId: swapParams.poolId,
-    a2b: swapParams.a2b,
-    coinA: repayCoinA,
-    coinB: repayCoinB,
-    receipt: flashResult.flashReceipt,
-    coinAType: swapParams.coinAType,
-    coinBType: swapParams.coinBType,
-    partner: swapParams.partner,
   }
 
-  let nextInputAmount: TransactionArgument
-
-  if (swapParams.byAmountIn) {
-    nextInputAmount = flashResult.swapedAmount
-  } else {
-    nextInputAmount = flashResult.payAmount
+  repay_flash_swap(
+    client: AggregatorClient,
+    txb: Transaction,
+    path: Path,
+    inputCoin: TransactionObjectArgument,
+    receipt: TransactionArgument
+  ): TransactionObjectArgument {
+    const { direction, from, target } = path
+    const [func, coinAType, coinBType] = direction
+      ? ["repay_flash_swap_a2b", from, target]
+      : ["repay_flash_swap_b2a", target, from]
+    const args = [
+      txb.object(this.globalConfig),
+      txb.object(path.id),
+      txb.object(this.partner),
+      inputCoin,
+      receipt,
+    ]
+    const res = txb.moveCall({
+      target: `${client.publishedAt()}::cetus::${func}`,
+      typeArguments: [coinAType, coinBType],
+      arguments: args,
+    })
+    return res[0] as TransactionObjectArgument
   }
 
-  const repayResult = await cetusRepayFlashSwapMovecall(
-    repayParams,
-    txb,
-    config
-  )
-
-  return {
-    flashTargetCoin: flashResult.targetCoin,
-    repayTargetCoin: repayResult.repayTargetCoin,
-    nextInputAmount,
+  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.globalConfig),
+      txb.object(path.id),
+      txb.object(this.partner),
+      inputCoin,
+      txb.object(CLOCK_ADDRESS),
+    ]
+    const res = txb.moveCall({
+      target: `${client.publishedAt()}::cetus::${func}`,
+      typeArguments: [coinAType, coinBType],
+      arguments: args,
+    }) as TransactionArgument
+    return res
   }
 }

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