@cetusprotocol/aggregator-sdk 0.3.31 → 0.4.0

package/src/client.ts

@@ -49,6 +49,7 @@ import {
 } from "@pythnetwork/pyth-sui-js"
 import { Steamm } from "./transaction/steamm"
 import { Metastable } from "./transaction/metastable"
+import { Obric } from "./transaction/obric"
 
 export const CETUS = "CETUS"
 export const DEEPBOOKV2 = "DEEPBOOK"
@@ -71,6 +72,7 @@ export const ALPHAFI = "ALPHAFI"
 export const SPRINGSUI = "SPRINGSUI"
 export const STEAMM = "STEAMM"
 export const METASTABLE = "METASTABLE"
+export const OBRIC = "OBRIC"
 export const DEFAULT_ENDPOINT = "https://api-sui.cetus.zone/router_v2"
 
 export type BuildRouterSwapParams = {
@@ -258,6 +260,78 @@ export class AggregatorClient {
     return getRouterResult(this.endpoint, params)
   }
 
+  async executeFlexibleInputSwap(
+    txb: Transaction,
+    inputCoin: TransactionObjectArgument,
+    routers: Router[],
+    amountOutLimit: BN,
+    pythPriceIDs: Map<string, string>,
+    partner?: string,
+    deepbookv3DeepFee?: TransactionObjectArgument,
+    packages?: Map<string, string>
+  ) {
+    if (routers.length === 0) {
+      throw new Error("No router found")
+    }
+    
+    const outputCoinType = routers[0].path[routers[0].path.length - 1].target
+    const outputCoins = []
+    
+    for (let i = 0; i < routers.length - 1; i++) {
+      if (routers[i].path.length === 0) {
+        throw new Error("Empty path")
+      }
+      // 为每条路径分割所需的代币
+      const splitCoin = txb.splitCoins(inputCoin, [routers[i].amountIn.toString()])
+      let nextCoin = splitCoin[0] as TransactionObjectArgument
+      
+      for (const path of routers[i].path) {
+        const dex = this.newDex(path.provider, pythPriceIDs, partner)
+        nextCoin = await dex.swap(
+          this,
+          txb,
+          path,
+          nextCoin,
+          packages,
+          deepbookv3DeepFee
+        )
+      }
+      outputCoins.push(nextCoin)
+    }
+
+    // 处理最后一条路径，使用剩余的所有代币
+    if (routers[routers.length - 1].path.length === 0) {
+      throw new Error("Empty path")
+    }
+    let lastCoin = inputCoin
+    for (const path of routers[routers.length - 1].path) {
+      const dex = this.newDex(path.provider, pythPriceIDs, partner)
+      lastCoin = await dex.swap(
+        this,
+        txb,
+        path,
+        lastCoin,
+        packages,
+        deepbookv3DeepFee
+      )
+    }
+    outputCoins.push(lastCoin)
+
+    const aggregatorV2PublishedAt = getAggregatorV2PublishedAt(
+      this.publishedAtV2(),
+      packages
+    )
+
+    const mergedTargetCoin = this.checkCoinThresholdAndMergeCoin(
+      txb,
+      outputCoins,
+      outputCoinType,
+      amountOutLimit,
+      aggregatorV2PublishedAt
+    )
+    return mergedTargetCoin
+  }
+
   async expectInputSwap(
     txb: Transaction,
     inputCoin: TransactionObjectArgument,
@@ -476,6 +550,69 @@ export class AggregatorClient {
     return targetCoin
   }
 
+  async fixableRouterSwap(
+    params: BuildRouterSwapParamsV2
+  ): Promise<TransactionObjectArgument> {
+    const { routers, inputCoin, slippage, txb, partner, deepbookv3DeepFee } =
+      params
+
+    const routerData = Array.isArray(routers) ? routers : routers.routes
+    const byAmountIn = params.routers.byAmountIn
+
+    const amountIn = routerData.reduce(
+      (acc, router) => acc.add(router.amountIn),
+      new BN(0)
+    )
+    const amountOut = routerData.reduce(
+      (acc, router) => acc.add(router.amountOut),
+      new BN(0)
+    )
+
+    const amountLimit = CalculateAmountLimitBN(
+      byAmountIn ? amountOut : amountIn,
+      byAmountIn,
+      slippage
+    )
+
+    const packages = isBuilderRouterSwapParams(params)
+      ? undefined
+      : params.routers.packages
+
+    const aggregatorV2PublishedAt = getAggregatorV2PublishedAt(
+      this.publishedAtV2(),
+      packages
+    )
+
+    const priceIDs = findPythPriceIDs(routerData)
+
+    const priceInfoObjectIds =
+      priceIDs.length > 0
+        ? await this.updatePythPriceIDs(priceIDs, txb)
+        : new Map<string, string>()
+
+    if (byAmountIn) {
+      const targetCoin = await this.executeFlexibleInputSwap(
+        txb,
+        inputCoin,
+        routerData,
+        amountLimit,
+        priceInfoObjectIds,
+        partner,
+        deepbookv3DeepFee,
+        packages
+      )
+      return targetCoin
+    }
+
+    const targetCoin = await this.expectOutputSwap(
+      txb,
+      inputCoin,
+      routerData,
+      partner
+    )
+    return targetCoin
+  }
+
   // auto build input coin
   // auto merge, transfer or destory target coin.
   async fastRouterSwap(
@@ -610,7 +747,9 @@ export class AggregatorClient {
       // return "0x347dd58bbd11cd82c8b386b344729717c04a998da73386e82a239cc196d5706b" // version 7
       // return "0xf2fcea41dc217385019828375764fa06d9bd25e8e4726ba1962680849fb8d613" // version 8
       // return "0xa2d8a4279d69d8fec04b2fea8852d0d467d3cc0d39c5890180d439ae7a9953ed" // version 9
-      return "0x34ef25b60b51f9d07cd9b7dc5b08dfdf26c7b0ff00c57bb17454c161fa6b6b83" // version 10
+      // return "0x34ef25b60b51f9d07cd9b7dc5b08dfdf26c7b0ff00c57bb17454c161fa6b6b83" // version 10
+      // return "0xf57be4b9f9036034b1c5484d299d8fb68d5f43862d6afe8886d67db293dfc4bc" // version 11
+      return "0x200e762fa2c49f3dc150813038fbf22fd4f894ac6f23ebe1085c62f2ef97f1ca" // version 12
     } else {
       return "0xabb6a81c8a216828e317719e06125de5bb2cb0fe8f9916ff8c023ca5be224c78"
     }
@@ -711,6 +850,8 @@ export class AggregatorClient {
         return new Steamm(this.env)
       case METASTABLE:
         return new Metastable(this.env, pythPriceIDs)
+      case OBRIC:
+        return new Obric(this.env, pythPriceIDs)
       default:
         throw new Error(`Unsupported dex ${provider}`)
     }
@@ -821,6 +962,14 @@ export function findPythPriceIDs(routes: Router[]): string[] {
           priceIDs.add(path.extendedDetails.metastableETHPriceSeed)
         }
       }
+      if (path.provider === OBRIC) {
+        if (path.extendedDetails && path.extendedDetails.obricCoinAPriceSeed) {
+          priceIDs.add(path.extendedDetails.obricCoinAPriceSeed)
+        }
+        if (path.extendedDetails && path.extendedDetails.obricCoinBPriceSeed) {
+          priceIDs.add(path.extendedDetails.obricCoinBPriceSeed)
+        }
+      }
     }
   }
   return Array.from(priceIDs)
@@ -870,7 +1019,8 @@ export function parseRouterResponse(
             path.provider === SCALLOP ||
             path.provider === HAEDALPMM ||
             path.provider === STEAMM ||
-            path.provider === METASTABLE
+            path.provider === METASTABLE ||
+            path.provider === OBRIC
           ) {
             extendedDetails = {
               aftermathLpSupplyType:
@@ -898,6 +1048,10 @@ export function parseRouterResponse(
               metastableCreateCapModule: path.extended_details?.metastable_create_cap_module,
               metastableCreateCapAllTypeParams: path.extended_details?.metastable_create_cap_all_type_params,
               metastableRegistryId: path.extended_details?.metastable_registry_id,
+              obricCoinAPriceSeed: path.extended_details?.obric_coin_a_price_seed,
+              obricCoinBPriceSeed: path.extended_details?.obric_coin_b_price_seed,
+              obricCoinAPriceId: path.extended_details?.obric_coin_a_price_id,
+              obricCoinBPriceId: path.extended_details?.obric_coin_b_price_id,
             }
           }
 

package/src/errors.ts

@@ -51,7 +51,8 @@ export enum AggregatorServerErrorCode {
   NumberTooLarge = 10001,
   NoRouter = 10002,
   InsufficientLiquidity = 10003,
-  HoneyPot = 10004
+  HoneyPot = 10004,
+  RateLimitExceeded = 10005,
 }
 
 export function getAggregatorServerErrorMessage(
@@ -68,6 +69,8 @@ export function getAggregatorServerErrorMessage(
       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/transaction/obric.ts

@@ -0,0 +1,90 @@
+import {
+  Transaction,
+  TransactionArgument,
+  TransactionObjectArgument,
+} from "@mysten/sui/transactions"
+import {
+  AggregatorClient,
+  CLOCK_ADDRESS,
+  Dex,
+  Env,
+  getAggregatorV2ExtendPublishedAt,
+  Path,
+} from ".."
+
+export class Obric implements Dex {
+  private pythPriceIDs: Map<string, string>
+  private pythStateObjectId: string
+
+  constructor(env: Env, pythPriceIDs: Map<string, string>) {
+    if (env === Env.Testnet) {
+      throw new Error("Obric is not supported on testnet")
+    }
+    this.pythPriceIDs = pythPriceIDs
+    this.pythStateObjectId = "0x1f9310238ee9298fb703c3419030b35b22bb1cc37113e3bb5007c99aec79e5b8"
+  }
+
+  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]
+
+    let coinAPriceSeed
+    let coinBPriceSeed
+
+    let coinAPriceInfoObjectId
+    let coinBPriceInfoObjectId
+
+    if (path.extendedDetails == null) {
+      throw new Error("Extended details not supported in obric")
+    } else {
+      if (
+        path.extendedDetails.obricCoinAPriceSeed && path.extendedDetails.obricCoinBPriceSeed
+      ) {
+        coinAPriceSeed = path.extendedDetails.obricCoinAPriceSeed
+        coinAPriceInfoObjectId = this.pythPriceIDs.get(coinAPriceSeed!)
+        coinBPriceSeed = path.extendedDetails.obricCoinBPriceSeed
+        coinBPriceInfoObjectId = this.pythPriceIDs.get(coinBPriceSeed!)
+      } else {
+        if (!path.extendedDetails.obricCoinAPriceId || !path.extendedDetails.obricCoinBPriceId) {
+          throw new Error("Base price id or quote price id not supported")
+        } else {
+          coinAPriceInfoObjectId = path.extendedDetails.obricCoinAPriceId
+          coinBPriceInfoObjectId = path.extendedDetails.obricCoinBPriceId
+        }
+      }
+    }
+
+    if (!coinAPriceInfoObjectId || !coinBPriceInfoObjectId) {
+      throw new Error(
+        "Base price info object id or quote price info object id not found"
+      )
+    }
+
+    const args = [
+      txb.object(path.id),
+      inputCoin,
+      txb.object(this.pythStateObjectId),
+      txb.object(coinAPriceInfoObjectId),
+      txb.object(coinBPriceInfoObjectId),
+      txb.object(CLOCK_ADDRESS),
+    ]
+    const publishedAt = getAggregatorV2ExtendPublishedAt(
+      client.publishedAtV2Extend(),
+      packages
+    )
+    const res = txb.moveCall({
+      target: `${publishedAt}::obric::${func}`,
+      typeArguments: [coinAType, coinBType],
+      arguments: args,
+    }) as TransactionArgument
+    return res
+  }
+}

package/src/utils/msafe.ts

@@ -3,28 +3,38 @@ import BN from 'bn.js'
 import Decimal from "decimal.js"
 
 export const dealWithFastRouterSwapParamsForMsafe = (data: any) => {
-  const result = data?.map((item: any) => {
-    return {
-      ...item,
-      amountIn: item?.amountIn?.toString(),
-      amountOut: item?.amountOut?.toString(),
-      initialPrice: item?.initialPrice?.toString()
-    }
-  } )
+  const result = {
+    ...data,
+    amountIn: data?.amountIn?.toString(),
+    amountOut: data?.amountIn?.toString(),
+    routes: data?.routes?.map((item:any) => {
+      return {
+        ...item,
+        amountIn: item?.amountIn?.toString(),
+        amountOut: item?.amountOut?.toString(),
+        initialPrice: item?.initialPrice?.toString()
+      }
+    })
+  }
 
   return result
 }
 
 
 export const restituteMsafeFastRouterSwapParams = (data: any) => {
-  const result = data?.map((item: any) => {
-    return {
-      ...item,
-      amountIn: new BN(item?.amountIn),
-      amountOut: new BN(item?.amountOut),
-      initialPrice: new Decimal(item?.initialPrice)
-    }
-  } )
+  const result = {
+    ...data,
+    amountIn: new BN(data?.amountIn),
+    amountOut: new BN(data?.amountIn),
+    routes: data?.routes?.map((item:any) => {
+      return {
+        ...item,
+        amountIn: new BN(item?.amountIn),
+        amountOut: new BN(item?.amountOut),
+        initialPrice: new Decimal(item?.initialPrice?.toString())
+      }
+    })
+  }
 
   return result
-}
+}

package/tests/router/obric.test.ts

@@ -0,0 +1,197 @@
+import { describe, test } from "@jest/globals"
+import dotenv from "dotenv"
+import { AggregatorClient } from "~/client"
+import { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519"
+import { printTransaction } from "~/utils/transaction"
+import BN from "bn.js"
+import { fromB64 } from "@mysten/sui/utils"
+import { SuiClient } from "@mysten/sui/client"
+import { Env } from "~/index"
+import { Transaction } from "@mysten/sui/transactions"
+
+dotenv.config()
+
+export function buildTestAccount(): Ed25519Keypair {
+  const mnemonics = process.env.SUI_WALLET_MNEMONICS || ""
+  const testAccountObject = Ed25519Keypair.deriveKeypair(mnemonics)
+  return testAccountObject
+}
+
+describe("Test obric provider", () => {
+  let client: AggregatorClient
+  let keypair: Ed25519Keypair
+
+  const T_SUI = "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI"
+  const WH_USDC = "0x5d4b302506645c37ff133b98c4b50a5ae14841659738d6d733d59d0d217a93bf::coin::COIN"
+  const T_USDC = "0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC"
+
+  beforeAll(() => {
+    const fullNodeURL = process.env.SUI_RPC!
+    const aggregatorURL = process.env.CETUS_AGGREGATOR!
+    const secret = process.env.SUI_WALLET_SECRET!
+
+    if (secret) {
+      keypair = Ed25519Keypair.fromSecretKey(fromB64(secret).slice(1, 33))
+    } else {
+      keypair = buildTestAccount()
+    }
+
+    // const wallet = keypair.getPublicKey().toSuiAddress()
+
+    const wallet = "0x935029ca5219502a47ac9b69f556ccf6e2198b5e7815cf50f68846f723739cbd" // has 80 eth
+    console.log("wallet: ", wallet)
+
+    const endpoint = aggregatorURL
+
+    const suiClient = new SuiClient({
+      url: fullNodeURL,
+    })
+    client = new AggregatorClient(endpoint, wallet, suiClient, Env.Mainnet)
+  })
+
+  test("Find Routers --> SUI -> USDC, locked", async () => {
+    // const amounts = ["1000", "1000000", "100000000", "5000000000", "10000000000000"]
+    const amounts = ["9990", "5000000000"]
+    
+    for (const amount of amounts) {
+      const res = await client.findRouters({
+        from: T_SUI,
+        target: WH_USDC,
+        amount: new BN(amount),
+        byAmountIn: true,
+        depth: 3,
+        splitCount: 1,
+        providers: ["OBRIC"],
+      })
+
+      if (res != null) {
+        console.log(JSON.stringify(res, null, 2))
+      }
+      console.log("amount in", res?.amountIn.toString())
+      console.log("amount out", res?.amountOut.toString())
+
+      const txb = new Transaction()
+
+      if (res != null) {
+        console.log(JSON.stringify(res, null, 2))
+        await client.fastRouterSwap({
+          routers: res,
+          txb,
+          slippage: 0.01,
+          refreshAllCoins: true,
+          payDeepFeeAmount: 0,
+        })
+  
+        txb.setSender(client.signer)
+        const buildTxb = await txb.build({ client: client.client })
+        // const buildTxb = await txb.getData()
+        
+        console.log("buildTxb", buildTxb)
+        printTransaction(txb)
+  
+        let result = await client.devInspectTransactionBlock(txb)
+        console.log("🚀 ~ file: router.test.ts:180 ~ test ~ result:", result)
+        for (const event of result.events) {
+          console.log("event", JSON.stringify(event, null, 2))
+        }
+      }
+    }
+  }, 50000)
+
+  test("Find Routers --> WUSDC --> SUI, no pyth mode", async () => {
+    // const amounts = ["1000", "1000000", "100000000", "5000000000", "10000000000000"]
+    // const amounts = ["1000", "1000000", "900000000"]
+    const amounts = ["90000000"]
+    
+    for (const amount of amounts) {
+      const res = await client.findRouters({
+        from: T_USDC,
+        target: T_SUI,
+        amount: new BN(amount),
+        byAmountIn: true,
+        depth: 3,
+        splitCount: 1,
+        providers: ["OBRIC"],
+      })
+
+      if (res != null) {
+        console.log(JSON.stringify(res, null, 2))
+      }
+      console.log("amount in", res?.amountIn.toString())
+      console.log("amount out", res?.amountOut.toString())
+
+      const txb = new Transaction()
+
+      if (res != null) {
+        await client.fastRouterSwap({
+          routers: res,
+          txb,
+          slippage: 0.001,
+          refreshAllCoins: true,
+          payDeepFeeAmount: 0,
+        })
+  
+        txb.setSender(client.signer)
+        const buildTxb = await txb.build({ client: client.client })
+        // const buildTxb = await txb.getData()
+
+        // printTransaction(txb)
+  
+        let result = await client.devInspectTransactionBlock(txb)
+        console.log("🚀 ~ file: router.test.ts:180 ~ test ~ result:", result)
+        for (const event of result.events) {
+          console.log("event", JSON.stringify(event, null, 2))
+        }
+      }
+    }
+  })
+
+  test("Build Router TX", async () => {
+    const amount = "1000000"
+
+    const res = await client.findRouters({
+      from: T_USDC,
+      target: T_SUI,
+      amount: new BN(amount),
+      byAmountIn: true,
+      depth: 3,
+      providers: ["OBRIC"],
+    })
+
+    console.log("amount in", res?.amountIn.toString())
+    console.log("amount out", res?.amountOut.toString())
+
+    const txb = new Transaction()
+
+    if (res != null) {
+      console.log(JSON.stringify(res, null, 2))
+      await client.fastRouterSwap({
+        routers: res,
+        txb,
+        slippage: 0.01,
+        refreshAllCoins: true,
+        payDeepFeeAmount: 0,
+      })
+
+      txb.setSender(client.signer)
+      const buildTxb = await txb.build({ client: client.client })
+      // const buildTxb = await txb.getData()
+      
+      console.log("buildTxb", buildTxb)
+      // printTransaction(txb)
+
+      let result = await client.devInspectTransactionBlock(txb)
+      console.log("🚀 ~ file: router.test.ts:180 ~ test ~ result:", result)
+      for (const event of result.events) {
+        console.log("event", JSON.stringify(event, null, 2))
+      }
+
+      // if (result.effects.status.status === "success") {
+      //   const result = await client.signAndExecuteTransaction(txb, keypair)
+      //   console.log("result", result)
+      // } else {
+      //   console.log("result", result)
+      // }
+    }
+  }, 600000)
+})