@cetusprotocol/aggregator-sdk 0.4.0 → 0.4.2

package/src/const.ts

@@ -1,15 +0,0 @@
-import BN from "bn.js"
-
-export const ZERO = new BN(0)
-
-export const ONE = new BN(1)
-
-export const TWO = new BN(2)
-
-export const U128 = TWO.pow(new BN(128))
-
-export const U64_MAX_BN = new BN("18446744073709551615")
-
-export const U64_MAX = "18446744073709551615"
-
-export const TEN_POW_NINE = 1000000000

package/src/errors.ts

@@ -1,77 +0,0 @@
-export enum TypesErrorCode {
-  InvalidType = `InvalidType`,
-}
-
-export enum ConfigErrorCode {
-  MissAggregatorPackage = `MissAggregatorPackage`,
-  MissGlobalConfig = `MissGlobalConfig`,
-  InvalidWallet = `InvalidWallet`,
-  SimulateError = `SimulateError`,
-}
-
-export enum TransactionErrorCode {
-  InsufficientBalance = `InsufficientBalance`,
-  SimulateEventError = `simulateEventError`,
-  CannotGetDecimals = `CannotGetDecimals`,
-  MissCoinA = `MissCoinA`,
-  MissCoinB = `MissCoinB`,
-  MissTurbosFeeType = `MissTurbosFeeType`,
-  MissAftermathLpSupplyType = `MissAftermathLpSupplyType`,
-}
-
-export type AggregatorErrorCode =
-  | TypesErrorCode
-  | ConfigErrorCode
-  | TransactionErrorCode
-
-/**
- * AggregatorError is a custom error class that extends the built-in Error class. It is used to represent errors that occur during aggregation operations.
- * The key functionality of this code includes:
- * - Defining the AggregatorError class that represents an error during aggregation. It includes a message property and an optional errorCode property.
- * - Providing a static method isAggregatorErrorCode() that checks if a given error instance is an instance of AggregatorError and has a specific error code.
- */
-export class AggregatorError extends Error {
-  override message: string
-
-  errorCode?: AggregatorErrorCode
-
-  constructor(message: string, errorCode?: AggregatorErrorCode) {
-    super(message)
-    this.message = message
-    this.errorCode = errorCode
-  }
-
-  static isAggregatorErrorCode(e: any, code: AggregatorErrorCode): boolean {
-    return e instanceof AggregatorError && e.errorCode === code
-  }
-}
-
-export enum AggregatorServerErrorCode {
-  CalculateError = 10000,
-  NumberTooLarge = 10001,
-  NoRouter = 10002,
-  InsufficientLiquidity = 10003,
-  HoneyPot = 10004,
-  RateLimitExceeded = 10005,
-}
-
-export function getAggregatorServerErrorMessage(
-  code: AggregatorServerErrorCode
-): string {
-  switch (code) {
-    case AggregatorServerErrorCode.CalculateError:
-      return "Calculate error"
-    case AggregatorServerErrorCode.NumberTooLarge:
-      return "Input number too large can not fit in target type"
-    case AggregatorServerErrorCode.NoRouter:
-      return "No router"
-    case AggregatorServerErrorCode.InsufficientLiquidity:
-      return "Insufficient Liquidity"
-    case AggregatorServerErrorCode.HoneyPot:
-      return "Target token is detected as a HoneyPot scam"
-    case AggregatorServerErrorCode.RateLimitExceeded:
-      return "Too many requests. Please try again later"
-    default:
-      return "Unknown error"
-  }
-}

package/src/index.ts

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

package/src/math.ts

@@ -1,66 +0,0 @@
-// Calculate amount limit.
-// If byAmountIn is true, the expectAmount means amountOut, otherwise means amountIn.
-// `byAmountIn` means fixed amount in or out.
-
-import BN from "bn.js"
-import { TEN_POW_NINE, ZERO } from "./const"
-import Decimal from "decimal.js"
-
-// `slippage` is a percentage, for example, 0.01 means 1%.
-export function CalculateAmountLimit(
-  expectAmount: BN,
-  byAmountIn: boolean,
-  slippage: number
-): number {
-  let amountLimit = ZERO
-  if (byAmountIn) {
-    amountLimit = expectAmount
-      .mul(new BN(TEN_POW_NINE - slippage * TEN_POW_NINE))
-      .div(new BN(TEN_POW_NINE))
-  } else {
-    amountLimit = expectAmount
-      .mul(new BN(TEN_POW_NINE + slippage * TEN_POW_NINE))
-      .div(new BN(TEN_POW_NINE))
-  }
-
-  return Number(amountLimit.toString())
-}
-
-export function CalculateAmountLimitBN(
-  expectAmount: BN,
-  byAmountIn: boolean,
-  slippage: number
-): BN {
-  let amountLimit = ZERO
-  if (byAmountIn) {
-    amountLimit = expectAmount
-      .mul(new BN(TEN_POW_NINE - slippage * TEN_POW_NINE))
-      .div(new BN(TEN_POW_NINE))
-  } else {
-    amountLimit = expectAmount
-      .mul(new BN(TEN_POW_NINE + slippage * TEN_POW_NINE))
-      .div(new BN(TEN_POW_NINE))
-  }
-
-  return amountLimit
-}
-
-const MAX_SQER_PRICE_X64 = "79226673515401279992447579055"
-const MIN_SQER_PRICE_X64 = "4295048016"
-
-export function GetDefaultSqrtPriceLimit(a2b: boolean): BN {
-  if (a2b) {
-    return new BN(MIN_SQER_PRICE_X64)
-  } else {
-    return new BN(MAX_SQER_PRICE_X64)
-  }
-}
-
-export function sqrtPriceX64ToPrice(
-  sqrtPriceStr: string,
-  decimalsA: number,
-  decimalsB: number
-): Decimal {
-  const sqrtPriceX64 = new Decimal(sqrtPriceStr).mul(Decimal.pow(2, -64))
-  return sqrtPriceX64.pow(2).mul(Decimal.pow(10, decimalsA - decimalsB))
-}

package/src/transaction/afsui.ts

@@ -1,62 +0,0 @@
-import {
-  Transaction,
-  TransactionObjectArgument,
-} from "@mysten/sui/transactions"
-import { AggregatorClient, Dex, Env, getAggregatorV2PublishedAt, Path } from ".."
-
-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,
-    packages?: Map<string, string>
-  ): 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 publishedAt = getAggregatorV2PublishedAt(client.publishedAtV2(), packages)
-
-    const res = txb.moveCall({
-      target: `${publishedAt}::afsui::${func}`,
-      typeArguments: [],
-      arguments: args,
-    }) as TransactionObjectArgument
-
-    return res
-  }
-}

package/src/transaction/aftermath.ts

@@ -1,88 +0,0 @@
-import {
-  Transaction,
-  TransactionObjectArgument,
-} from "@mysten/sui/transactions"
-import { AggregatorClient, Dex, Env, getAggregatorV2PublishedAt, Path } from ".."
-import BN from "bn.js"
-
-export class Aftermath implements Dex {
-  private slippage: string
-  private poolRegistry: string
-  private protocolFeeVault: string
-  private treasury: string
-  private insuranceFund: string
-  private referrealVault: string
-
-  constructor(env: Env) {
-    if (env !== Env.Mainnet) {
-      throw new Error("Aftermath only supported on mainnet")
-    }
-
-    this.slippage = "900000000000000000"
-    this.poolRegistry =
-      "0xfcc774493db2c45c79f688f88d28023a3e7d98e4ee9f48bbf5c7990f651577ae"
-    this.protocolFeeVault =
-      "0xf194d9b1bcad972e45a7dd67dd49b3ee1e3357a00a50850c52cd51bb450e13b4"
-    this.treasury =
-      "0x28e499dff5e864a2eafe476269a4f5035f1c16f338da7be18b103499abf271ce"
-    this.insuranceFund =
-      "0xf0c40d67b078000e18032334c3325c47b9ec9f3d9ae4128be820d54663d14e3b"
-    this.referrealVault =
-      "0x35d35b0e5b177593d8c3a801462485572fc30861e6ce96a55af6dc4730709278"
-  }
-
-  amountLimit(exportAmountOut: string): string {
-    return new BN(exportAmountOut)
-      .mul(new BN(this.slippage))
-      .div(new BN("1000000000000000000"))
-      .toString()
-  }
-
-  async swap(
-    client: AggregatorClient,
-    txb: Transaction,
-    path: Path,
-    inputCoin: TransactionObjectArgument,
-    packages?: Map<string, string>
-  ): 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.aftermathLpSupplyType == null) {
-        throw new Error("LP supply type not supported")
-      }
-    }
-
-    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 publishedAt = getAggregatorV2PublishedAt(client.publishedAtV2(), packages)
-
-    const res = txb.moveCall({
-      target: `${publishedAt}::aftermath::${func}`,
-      typeArguments: [
-        coinAType,
-        coinBType,
-        path.extendedDetails.aftermathLpSupplyType,
-      ],
-      arguments: args,
-    }) as TransactionObjectArgument
-
-    return res
-  }
-}

package/src/transaction/alphafi.ts

@@ -1,50 +0,0 @@
-import {
-  Transaction,
-  TransactionObjectArgument,
-} from "@mysten/sui/transactions"
-import { AggregatorClient, Dex, Env, getAggregatorV2ExtendPublishedAt, Path } from ".."
-
-export class Alphafi implements Dex {
-  private sui_system_state: string
-
-  constructor(env: Env) {
-    if (env !== Env.Mainnet) {
-      throw new Error("Alphafi only supported on mainnet")
-    }
-
-    this.sui_system_state =
-      env === Env.Mainnet
-        ? "0x0000000000000000000000000000000000000000000000000000000000000005"
-        : "0x0"
-  }
-
-  async swap(
-    client: AggregatorClient,
-    txb: Transaction,
-    path: Path,
-    inputCoin: TransactionObjectArgument,
-    packages?: Map<string, string>
-  ): Promise<TransactionObjectArgument> {
-    const { direction, from, target } = path
-
-    const [func, stCoinType] = direction
-      ? ["swap_a2b", target]
-      : ["swap_b2a", from]
-
-    const args = [
-      txb.object(path.id),
-      txb.object(this.sui_system_state),
-      inputCoin,
-    ]
-
-    const publishedAt = getAggregatorV2ExtendPublishedAt(client.publishedAtV2Extend(), packages)
-
-    const res = txb.moveCall({
-      target: `${publishedAt}::alphafi::${func}`,
-      typeArguments: [stCoinType],
-      arguments: args,
-    }) as TransactionObjectArgument
-
-    return res
-  }
-}

package/src/transaction/bluefin.ts

@@ -1,46 +0,0 @@
-import {
-  Transaction,
-  TransactionArgument,
-  TransactionObjectArgument,
-} from "@mysten/sui/transactions"
-import { AggregatorClient, CLOCK_ADDRESS, Dex, Env, getAggregatorV2ExtendPublishedAt, Path } from ".."
-
-export class Bluefin implements Dex {
-  private globalConfig: string
-
-  constructor(env: Env) {
-    if (env !== Env.Mainnet) {
-      throw new Error("Bluefin only supported on mainnet")
-    }
-
-    this.globalConfig =
-      "0x03db251ba509a8d5d8777b6338836082335d93eecbdd09a11e190a1cff51c352"
-  }
-
-  async swap(
-    client: AggregatorClient,
-    txb: Transaction,
-    path: Path,
-    inputCoin: TransactionObjectArgument,
-    packages?: Map<string, string>
-  ): 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),
-      inputCoin,
-      txb.object(CLOCK_ADDRESS),
-    ]
-    const publishedAt = getAggregatorV2ExtendPublishedAt(client.publishedAtV2Extend(), packages)
-
-    const res = txb.moveCall({
-      target: `${publishedAt}::bluefin::${func}`,
-      typeArguments: [coinAType, coinBType],
-      arguments: args,
-    }) as TransactionArgument
-    return res
-  }
-}

package/src/transaction/bluemove.ts

@@ -1,42 +0,0 @@
-import {
-  Transaction,
-  TransactionObjectArgument,
-} from "@mysten/sui/transactions"
-import { AggregatorClient, Dex, Env, getAggregatorV2PublishedAt, Path } from ".."
-
-export class Bluemove implements Dex {
-  private dexInfo: string
-
-  constructor(env: Env) {
-    if (env !== Env.Mainnet) {
-      throw new Error("Bluemove only supported on mainnet")
-    }
-
-    this.dexInfo =
-      "0x3f2d9f724f4a1ce5e71676448dc452be9a6243dac9c5b975a588c8c867066e92"
-  }
-
-  async swap(
-    client: AggregatorClient,
-    txb: Transaction,
-    path: Path,
-    inputCoin: TransactionObjectArgument,
-    packages?: Map<string, string>
-  ): 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.dexInfo), inputCoin]
-    const publishedAt = getAggregatorV2PublishedAt(client.publishedAtV2(), packages)
-    const res = txb.moveCall({
-      target: `${publishedAt}::bluemove::${func}`,
-      typeArguments: [coinAType, coinBType],
-      arguments: args,
-    }) as TransactionObjectArgument
-
-    return res
-  }
-}

package/src/transaction/cetus.ts

@@ -1,118 +0,0 @@
-import {
-  Transaction,
-  TransactionArgument,
-  TransactionObjectArgument,
-} from "@mysten/sui/transactions"
-import { AggregatorClient, CLOCK_ADDRESS, Dex, Env, getAggregatorV2PublishedAt, Path } from ".."
-
-export type CetusFlashSwapResult = {
-  targetCoin: TransactionObjectArgument
-  flashReceipt: TransactionObjectArgument
-  payAmount: TransactionArgument
-}
-
-export class Cetus implements Dex {
-  private globalConfig: string
-  private partner: string
-
-  constructor(env: Env, partner?: string) {
-    this.globalConfig =
-      env === Env.Mainnet
-        ? "0xdaa46292632c3c4d8f31f23ea0f9b36a28ff3677e9684980e4438403a67a3d8f"
-        : "0x9774e359588ead122af1c7e7f64e14ade261cfeecdb5d0eb4a5b3b4c8ab8bd3e"
-
-    this.partner =
-      partner ??
-      (env === Env.Mainnet
-        ? "0x639b5e433da31739e800cd085f356e64cae222966d0f1b11bd9dc76b322ff58b"
-        : "0x1f5fa5c820f40d43fc47815ad06d95e40a1942ff72a732a92e8ef4aa8cde70a5")
-  }
-
-  flash_swap(
-    client: AggregatorClient,
-    txb: Transaction,
-    path: Path,
-    by_amount_in: boolean,
-    packages?: Map<string, string>
-  ): 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 publishedAt = getAggregatorV2PublishedAt(client.publishedAtV2(), packages)
-    const res: TransactionObjectArgument[] = txb.moveCall({
-      target: `${publishedAt}::cetus::${func}`,
-      typeArguments: [coinAType, coinBType],
-      arguments: args,
-    })
-    return {
-      targetCoin: res[0],
-      flashReceipt: res[1],
-      payAmount: res[2],
-    }
-  }
-
-  repay_flash_swap(
-    client: AggregatorClient,
-    txb: Transaction,
-    path: Path,
-    inputCoin: TransactionObjectArgument,
-    receipt: TransactionArgument,
-    packages?: Map<string, string>
-  ): 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 publishedAt = getAggregatorV2PublishedAt(client.publishedAtV2(), packages)
-    const res = txb.moveCall({
-      target: `${publishedAt}::cetus::${func}`,
-      typeArguments: [coinAType, coinBType],
-      arguments: args,
-    })
-    return res[0] as TransactionObjectArgument
-  }
-
-  async swap(
-    client: AggregatorClient,
-    txb: Transaction,
-    path: Path,
-    inputCoin: TransactionObjectArgument,
-    packages?: Map<string, string>
-  ): 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 publishedAt = getAggregatorV2PublishedAt(client.publishedAtV2(), packages)
-    const res = txb.moveCall({
-      target: `${publishedAt}::cetus::${func}`,
-      typeArguments: [coinAType, coinBType],
-      arguments: args,
-    }) as TransactionArgument
-    return res
-  }
-}

package/src/transaction/deepbook_v2.ts

@@ -1,122 +0,0 @@
-import {
-  Transaction,
-  TransactionObjectArgument,
-} from "@mysten/sui/transactions"
-import { AggregatorClient, CLOCK_ADDRESS, Dex, Env, getAggregatorV2PublishedAt, 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,
-    packages?: Map<string, string>
-  ): 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 publishedAt = getAggregatorV2PublishedAt(client.publishedAtV2(), packages)
-    const res = txb.moveCall({
-      target: `${publishedAt}::deepbook::${func}`,
-      typeArguments: [coinAType, coinBType],
-      arguments: args,
-    }) as TransactionObjectArgument
-
-    if (accountCapRes.isCreate) {
-      txb.transferObjects([accountCapRes.accountCap], client.signer)
-    }
-
-    return res
-  }
-}