@cetusprotocol/aggregator-sdk 0.0.8 → 0.1.1

package/src/const.ts

@@ -1,95 +1,5 @@
 import BN from "bn.js"
 
-/**
- * The address representing the clock in the system.
- */
-export const CLOCK_ADDRESS =
-  "0x0000000000000000000000000000000000000000000000000000000000000006"
-
-/**
- * The address for CoinInfo module.
- */
-export const CoinInfoAddress = "0x1::coin::CoinInfo"
-
-/**
- * The address for CoinStore module.
- */
-export const CoinStoreAddress = "0x1::coin::CoinStore"
-
-export const SuiZeroCoinFn = "0x2::coin::zero"
-
-// Dex names
-export const AGGREGATOR = "aggregator"
-export const CETUS_DEX = "CETUS"
-export const DEEPBOOK_DEX = "DEEPBOOK"
-export const KRIYA_DEX = "KRIYA"
-export const FLOWX_AMM = "FLOWX"
-export const TURBOS_DEX = "TURBOS"
-export const AFTERMATH_AMM = "AFTERMATH"
-
-export const INTEGRATE = "integrate"
-
-// Module names
-export const CETUS_MODULE = "cetus"
-export const DEEPBOOK_MODULE = "deepbook"
-export const KRIYA_MODULE = "kriya"
-export const UTILS_MODULE = "utils"
-export const POOL_MODULT = "pool"
-export const PAY_MODULE = "pay"
-export const FLOWX_AMM_MODULE = "flowx_amm"
-export const TURBOS_MODULE = "turbos"
-export const AFTERMATH_MODULE = "aftermath"
-
-export const DEEPBOOK_CUSTODIAN_V2_MODULE = "custodian_v2"
-export const DEEPBOOK_CLOB_V2_MODULE = "clob_v2"
-
-// Function names
-export const FlashSwapFunc = "flash_swap"
-export const FlashSwapWithPartnerFunc = "flash_swap_with_partner"
-export const RepayFalshSwapFunc = "repay_flash_swap"
-export const RepayFlashSwapWithPartnerFunc = "repay_flash_swap_with_partner"
-
-export const FlashSwapA2BFunc = "flash_swap_a2b"
-export const FlashSwapB2AFunc = "flash_swap_b2a"
-
-export const FlashSwapWithPartnerA2BFunc = "flash_swap_with_partner_a2b"
-export const FlashSwapWithPartnerB2AFunc = "flash_swap_with_partner_b2a"
-
-export const REPAY_FLASH_SWAP_A2B_FUNC = "repay_flash_swap_a2b"
-export const REPAY_FLASH_SWAP_B2A_FUNC = "repay_flash_swap_b2a"
-
-export const REPAY_FLASH_SWAP_WITH_PARTNER_A2B_FUNC =
-  "repay_flash_swap_with_partner_a2b"
-export const REPAY_FLASH_SWAP_WITH_PARTNER_B2A_FUNC =
-  "repay_flash_swap_with_partner_b2a"
-
-export const SWAP_A2B_FUNC = "swap_a2b"
-export const SWAP_B2A_FUNC = "swap_b2a"
-
-export const TRANSFER_OR_DESTORY_COIN_FUNC = "transfer_or_destroy_coin"
-export const CHECK_COINS_THRESHOLD_FUNC = "check_coins_threshold"
-
-export const JOIN_FUNC = "join_vec"
-
-export const TRANSFER_ACCOUNT_CAP = "transfer_account_cap"
-
-// Package IDs
-export const DEEPBOOK_PACKAGE_ID =
-  "0x000000000000000000000000000000000000000000000000000000000000dee9"
-export const DEEPBOOK_PUBLISHED_AT =
-  "0x000000000000000000000000000000000000000000000000000000000000dee9"
-
-export const CETUS_PUBLISHED_AT =
-  "0x70968826ad1b4ba895753f634b0aea68d0672908ca1075a2abdf0fc9e0b2fc6a"
-
-// Mainnet Cetus objects IDs
-export const MAINNET_CETUS_GLOBAL_CONFIG_ID =
-  "0xdaa46292632c3c4d8f31f23ea0f9b36a28ff3677e9684980e4438403a67a3d8f"
-
-// Testnet Cetus objects IDs
-export const TESTNET_CETUS_GLOBAL_CONFIG_ID =
-  "0x6f4149091a5aea0e818e7243a13adcfb403842d670b9a2089de058512620687a"
-
 export const ZERO = new BN(0)
 
 export const ONE = new BN(1)
@@ -103,26 +13,3 @@ export const U64_MAX_BN = new BN("18446744073709551615")
 export const U64_MAX = "18446744073709551615"
 
 export const TEN_POW_NINE = 1000000000
-
-export const MAINNET_FLOWX_AMM_CONTAINER_ID =
-  "0xb65dcbf63fd3ad5d0ebfbf334780dc9f785eff38a4459e37ab08fa79576ee511"
-export const TESTNET_FLOWX_AMM_CONTAINER_ID = ""
-
-export const TURBOS_VERSIONED =
-  "0xf1cf0e81048df168ebeb1b8030fad24b3e0b53ae827c25053fff0779c1445b6f"
-
-export const MAINNET_AFTERMATH_REGISTRY_ID =
-  "0xfcc774493db2c45c79f688f88d28023a3e7d98e4ee9f48bbf5c7990f651577ae"
-export const TESTNET_AFTERMATH_REGISTRY_ID = ""
-export const MAINNET_AFTERMATH_PROTOCOL_FEE_VAULT_ID =
-  "0xf194d9b1bcad972e45a7dd67dd49b3ee1e3357a00a50850c52cd51bb450e13b4"
-export const TESTNET_AFTERMATH_PROTOCOL_FEE_VAULT_ID = ""
-export const MAINNET_AFTERMATH_TREASURY_ID =
-  "0x28e499dff5e864a2eafe476269a4f5035f1c16f338da7be18b103499abf271ce"
-export const TESTNET_AFTERMATH_TREASURY_ID = ""
-export const MAINNET_AFTERMATH_INSURANCE_FUND_ID =
-  "0xf0c40d67b078000e18032334c3325c47b9ec9f3d9ae4128be820d54663d14e3b"
-export const TESTNET_AFTERMATH_INSURANCE_FUND_ID = ""
-export const MAINNET_AFTERMATH_REFERRAL_VAULT_ID =
-  "0x35d35b0e5b177593d8c3a801462485572fc30861e6ce96a55af6dc4730709278"
-export const TESTNET_AFTERMATH_REFERRAL_VAULT_ID = ""

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