@cetusprotocol/aggregator-sdk 0.0.8 → 0.1.0

package/src/index.ts

@@ -1,5 +1,10 @@
-export * from './client'
-export * from './transaction'
-export * from './config'
-export * from './utils'
-export * from './const'
+export * from "./client"
+export * from "./transaction"
+export * from "./utils"
+export * from "./const"
+export * from "./api"
+
+export enum Env {
+  Mainnet,
+  Testnet,
+}

package/src/transaction/afsui.ts

@@ -0,0 +1,60 @@
+import {
+  Transaction,
+  TransactionObjectArgument,
+} from "@mysten/sui/transactions"
+import { AggregatorClient, Dex, Env, Path } from ".."
+import { SUI_SYSTEM_ADDRESS } from "@mysten/sui/utils"
+
+export class Afsui implements Dex {
+  private stakedSuiVault: string
+  private safe: string
+  private referVault: string
+  private validator: string
+
+  constructor(env: Env) {
+    if (env !== Env.Mainnet) {
+      throw new Error("Afsui only supported on mainnet")
+    }
+
+    this.stakedSuiVault =
+      "0x2f8f6d5da7f13ea37daa397724280483ed062769813b6f31e9788e59cc88994d"
+    this.safe =
+      "0xeb685899830dd5837b47007809c76d91a098d52aabbf61e8ac467c59e5cc4610"
+    this.referVault =
+      "0x4ce9a19b594599536c53edb25d22532f82f18038dc8ef618afd00fbbfb9845ef"
+    this.validator =
+      "0xd30018ec3f5ff1a3c75656abf927a87d7f0529e6dc89c7ddd1bd27ecb05e3db2"
+  }
+
+  async swap(
+    client: AggregatorClient,
+    txb: Transaction,
+    path: Path,
+    inputCoin: TransactionObjectArgument
+  ): Promise<TransactionObjectArgument> {
+    const { direction } = path
+
+    if (!direction) {
+      throw new Error("Afsui not support b2a swap")
+    }
+
+    const func = "swap_a2b"
+
+    const args = [
+      txb.object(this.stakedSuiVault),
+      txb.object(this.safe),
+      txb.object("0x5"),
+      txb.object(this.referVault),
+      txb.object(this.validator),
+      inputCoin,
+    ]
+
+    const res = txb.moveCall({
+      target: `${client.publishedAt()}::afsui::${func}`,
+      typeArguments: [],
+      arguments: args,
+    }) as TransactionObjectArgument
+
+    return res
+  }
+}

package/src/transaction/aftermath.ts

@@ -1,142 +1,89 @@
 import {
-  TransactionArgument,
   Transaction,
+  TransactionArgument,
   TransactionObjectArgument,
+  TransactionResult,
 } from "@mysten/sui/transactions"
-import { AggregatorConfig, ENV } from "../config"
-import {
-  AFTERMATH_MODULE,
-  AGGREGATOR,
-  MAINNET_AFTERMATH_INSURANCE_FUND_ID,
-  MAINNET_AFTERMATH_PROTOCOL_FEE_VAULT_ID,
-  MAINNET_AFTERMATH_REFERRAL_VAULT_ID,
-  MAINNET_AFTERMATH_REGISTRY_ID,
-  MAINNET_AFTERMATH_TREASURY_ID,
-  SWAP_A2B_FUNC,
-  SWAP_B2A_FUNC,
-  TESTNET_AFTERMATH_INSURANCE_FUND_ID,
-  TESTNET_AFTERMATH_PROTOCOL_FEE_VAULT_ID,
-  TESTNET_AFTERMATH_REFERRAL_VAULT_ID,
-  TESTNET_AFTERMATH_REGISTRY_ID,
-  TESTNET_AFTERMATH_TREASURY_ID,
-} from "../const"
-import { ConfigErrorCode, TransactionErrorCode } from "../errors"
-import { createTarget } from "../utils"
+import { AggregatorClient, Dex, Env, Path } from ".."
+import BN from "bn.js"
 
-export type AftermathSwapParams = {
-  poolId: string
-  amount: TransactionArgument
-  amountOut: number
-  amountLimit: number
-  a2b: boolean
-  byAmountIn: boolean
-  coinA?: TransactionObjectArgument
-  coinB?: TransactionObjectArgument
-  useFullInputCoinAmount: boolean
-  coinAType: string
-  coinBType: string
-  slippage: number
-  lpSupplyType: string
-}
+export class Aftermath implements Dex {
+  private slippage: string
+  private poolRegistry: string
+  private protocolFeeVault: string
+  private treasury: string
+  private insuranceFund: string
+  private referrealVault: string
 
-export type AftermathSwapResult = {
-  targetCoin: TransactionObjectArgument
-  amountIn: TransactionArgument
-  amountOut: TransactionArgument
-  txb: Transaction
-}
+  constructor(env: Env) {
+    if (env !== Env.Mainnet) {
+      throw new Error("Aftermath only supported on mainnet")
+    }
 
-export async function AftermathAmmSwapMovecall(
-  swapParams: AftermathSwapParams,
-  txb: Transaction,
-  config: AggregatorConfig
-): Promise<AftermathSwapResult> {
-  const aggregatorPackage = config.getPackage(AGGREGATOR)
-  if (aggregatorPackage == null) {
-    throw new AggregateError(
-      "Aggregator package not set",
-      ConfigErrorCode.MissAggregatorPackage
-    )
+    this.slippage = "900000000000000000"
+    this.poolRegistry =
+      "0xfcc774493db2c45c79f688f88d28023a3e7d98e4ee9f48bbf5c7990f651577ae"
+    this.protocolFeeVault =
+      "0xf194d9b1bcad972e45a7dd67dd49b3ee1e3357a00a50850c52cd51bb450e13b4"
+    this.treasury =
+      "0x28e499dff5e864a2eafe476269a4f5035f1c16f338da7be18b103499abf271ce"
+    this.insuranceFund =
+      "0xf0c40d67b078000e18032334c3325c47b9ec9f3d9ae4128be820d54663d14e3b"
+    this.referrealVault =
+      "0x35d35b0e5b177593d8c3a801462485572fc30861e6ce96a55af6dc4730709278"
   }
-  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
-      )
-    }
+  amountLimit(exportAmountOut: number): number {
+    return Number(
+      new BN(exportAmountOut)
+        .mul(new BN(this.slippage))
+        .div(new BN("1000000000000000000"))
+        .toString()
+    )
   }
 
-  const poolRegistryID =
-    config.getENV() === ENV.MAINNET
-      ? MAINNET_AFTERMATH_REGISTRY_ID
-      : TESTNET_AFTERMATH_REGISTRY_ID
-
-  const vaultID =
-    config.getENV() === ENV.MAINNET
-      ? MAINNET_AFTERMATH_PROTOCOL_FEE_VAULT_ID
-      : TESTNET_AFTERMATH_PROTOCOL_FEE_VAULT_ID
-
-  const treasuryID =
-    config.getENV() === ENV.MAINNET
-      ? MAINNET_AFTERMATH_TREASURY_ID
-      : TESTNET_AFTERMATH_TREASURY_ID
+  async swap(
+    client: AggregatorClient,
+    txb: Transaction,
+    path: Path,
+    inputCoin: TransactionObjectArgument
+  ): Promise<TransactionObjectArgument> {
+    const { direction, from, target } = path
 
-  const insuranceFundID =
-    config.getENV() === ENV.MAINNET
-      ? MAINNET_AFTERMATH_INSURANCE_FUND_ID
-      : TESTNET_AFTERMATH_INSURANCE_FUND_ID
+    const [func, coinAType, coinBType] = direction
+      ? ["swap_a2b", from, target]
+      : ["swap_b2a", target, from]
 
-  const referrealVaultID =
-    config.getENV() === ENV.MAINNET
-      ? MAINNET_AFTERMATH_REFERRAL_VAULT_ID
-      : TESTNET_AFTERMATH_REFERRAL_VAULT_ID
-
-  const swapCoin = swapParams.a2b ? swapParams.coinA! : swapParams.coinB!
-
-  const slippageArg = (1 - swapParams.slippage) * 1000000000000000000
-
-  const args = [
-    txb.object(swapParams.poolId),
-    txb.object(poolRegistryID),
-    txb.object(vaultID),
-    txb.object(treasuryID),
-    txb.object(insuranceFundID),
-    txb.object(referrealVaultID),
-    swapParams.amount,
-    txb.pure.u64(swapParams.amountLimit),
-    txb.pure.u64(swapParams.amountOut),
-    txb.pure.u64(slippageArg),
-    swapCoin,
-    txb.pure.bool(swapParams.useFullInputCoinAmount),
-  ]
+    if (path.extendedDetails == null) {
+      throw new Error("Extended details not supported")
+    } else {
+      if (path.extendedDetails.aftermathLpSupplyType == null) {
+        throw new Error("LP supply type not supported")
+      }
+    }
 
-  const func = swapParams.a2b ? SWAP_A2B_FUNC : SWAP_B2A_FUNC
+    const args = [
+      txb.object(path.id),
+      txb.object(this.poolRegistry),
+      txb.object(this.protocolFeeVault),
+      txb.object(this.treasury),
+      txb.object(this.insuranceFund),
+      txb.object(this.referrealVault),
+      txb.pure.u64(this.amountLimit(path.amountOut)),
+      txb.pure.u64(this.slippage),
+      inputCoin,
+    ]
 
-  const target = createTarget(aggregatorPublishedAt, AFTERMATH_MODULE, func)
+    const res = txb.moveCall({
+      target: `${client.publishedAt()}::aftermath::${func}`,
+      typeArguments: [
+        coinAType,
+        coinBType,
+        path.extendedDetails.aftermathLpSupplyType,
+      ],
+      arguments: args,
+    }) as TransactionObjectArgument
 
-  const res = txb.moveCall({
-    target,
-    typeArguments: [
-      swapParams.coinAType,
-      swapParams.coinBType,
-      swapParams.lpSupplyType,
-    ],
-    arguments: args,
-  })
-  return {
-    targetCoin: res[0],
-    amountIn: res[1],
-    amountOut: res[2],
-    txb,
+    return res
   }
 }

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