@cetusprotocol/aggregator-sdk 0.3.32 → 0.4.1

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 = {
@@ -124,7 +126,6 @@ export interface SwapInPoolsParams {
 }
 
 interface PythConfig {
-  connections: SuiPriceServiceConnection[]
   wormholeStateId: string
   pythStateId: string
 }
@@ -146,11 +147,21 @@ function isBuilderFastRouterSwapParams(
   return Array.isArray((params as BuildFastRouterSwapParams).routers)
 }
 
+export type AggregatorClientParams = {
+  endpoint?: string
+  signer?: string
+  client?: SuiClient
+  env?: Env
+  pythUrls?: string[]
+  apiKey?: string
+}
+
 export class AggregatorClient {
   public endpoint: string
   public signer: string
   public client: SuiClient
   public env: Env
+  public apiKey: string
   private allCoins: Map<string, CoinAsset[]>
 
   private pythConnections: SuiPriceServiceConnection[]
@@ -158,26 +169,12 @@ export class AggregatorClient {
 
   private static readonly CONFIG: Record<Env, PythConfig> = {
     [Env.Testnet]: {
-      connections: [
-        new SuiPriceServiceConnection("https://hermes-beta.pyth.network"),
-      ],
       wormholeStateId:
         "0x31358d198147da50db32eda2562951d53973a0c0ad5ed738e9b17d88b213d790",
       pythStateId:
         "0x243759059f4c3111179da5878c12f68d612c21a8d54d85edc86164bb18be1c7c",
     },
     [Env.Mainnet]: {
-      connections: [
-        new SuiPriceServiceConnection(
-          "https://cetus-pythnet-a648.mainnet.pythnet.rpcpool.com/219cf7a8-6d75-432d-a648-d487a6dd5dc3/hermes",
-          {
-            timeout: 3000,
-          }
-        ),
-        new SuiPriceServiceConnection("https://hermes.pyth.network", {
-          timeout: 3000,
-        }),
-      ],
       wormholeStateId:
         "0xaeab97f96cf9877fee2883315d459552b2b921edc16d7ceac6eab944dd88919c",
       pythStateId:
@@ -185,25 +182,30 @@ export class AggregatorClient {
     },
   }
 
-  constructor(
-    endpoint?: string,
-    signer?: string,
-    client?: SuiClient,
-    env?: Env
-  ) {
-    this.endpoint = endpoint ? processEndpoint(endpoint) : DEFAULT_ENDPOINT
-    this.client = client || new SuiClient({ url: getFullnodeUrl("mainnet") })
-    this.signer = signer || ""
-    this.env = env || Env.Mainnet
+  constructor(params: AggregatorClientParams) {
+    this.endpoint = params.endpoint ? processEndpoint(params.endpoint) : DEFAULT_ENDPOINT
+    this.client = params.client || new SuiClient({ url: getFullnodeUrl("mainnet") })
+    this.signer = params.signer || ""
+    this.env = params.env || Env.Mainnet
     this.allCoins = new Map<string, CoinAsset[]>()
 
     const config = AggregatorClient.CONFIG[this.env]
-    this.pythConnections = config.connections
+    this.pythConnections = this.newPythClients(params.pythUrls ?? [])
     this.pythClient = new SuiPythClient(
       this.client,
       config.pythStateId,
       config.wormholeStateId
     )
+    this.apiKey = params.apiKey || ""
+  }
+
+  newPythClients(pythUrls: string[]) {
+    if (!pythUrls.includes("https://hermes.pyth.network")) {
+      pythUrls.push("https://hermes.pyth.network")
+    }
+
+    const connections = pythUrls.map(url => new SuiPriceServiceConnection(url, { timeout: 3000 }))
+    return connections
   }
 
   async getCoins(
@@ -255,7 +257,79 @@ export class AggregatorClient {
   }
 
   async findRouters(params: FindRouterParams): Promise<RouterData | null> {
-    return getRouterResult(this.endpoint, params)
+    return getRouterResult(this.endpoint, this.apiKey, 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(
@@ -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(
@@ -611,7 +748,8 @@ export class AggregatorClient {
       // return "0xf2fcea41dc217385019828375764fa06d9bd25e8e4726ba1962680849fb8d613" // version 8
       // return "0xa2d8a4279d69d8fec04b2fea8852d0d467d3cc0d39c5890180d439ae7a9953ed" // version 9
       // return "0x34ef25b60b51f9d07cd9b7dc5b08dfdf26c7b0ff00c57bb17454c161fa6b6b83" // version 10
-      return "0xf57be4b9f9036034b1c5484d299d8fb68d5f43862d6afe8886d67db293dfc4bc" // version 11
+      // return "0xf57be4b9f9036034b1c5484d299d8fb68d5f43862d6afe8886d67db293dfc4bc" // version 11
+      return "0x200e762fa2c49f3dc150813038fbf22fd4f894ac6f23ebe1085c62f2ef97f1ca" // version 12
     } else {
       return "0xabb6a81c8a216828e317719e06125de5bb2cb0fe8f9916ff8c023ca5be224c78"
     }
@@ -712,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}`)
     }
@@ -776,7 +916,7 @@ export class AggregatorClient {
 
     if (priceUpdateData == null) {
       throw new Error(
-        `No pyth price seeds update data found: ${lastError?.message}`
+        `All Pyth price nodes are unavailable. Cannot fetch price data. Please switch to or add new available Pyth nodes. Detailed error: ${lastError?.message}`
       )
     }
 
@@ -788,7 +928,7 @@ export class AggregatorClient {
         priceIDs
       )
     } catch (e) {
-      throw new Error(`Failed to update price feeds: ${e}`)
+      throw new Error(`All Pyth price nodes are unavailable. Cannot fetch price data. Please switch to or add new available Pyth nodes in the pythUrls parameter when initializing AggregatorClient, for example: new AggregatorClient({ pythUrls: ["https://your-pyth-node-url"] }). Detailed error: ${e}`)
     }
 
     let priceInfoObjectIdsMap = new Map<string, string>()
@@ -822,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)
@@ -871,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:
@@ -899,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/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/tests/router/alphafi.test.ts

@@ -0,0 +1,132 @@
+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 scallop provider", () => {
+  let client: AggregatorClient
+  let keypair: Ed25519Keypair
+
+  const T_SUI = "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI"
+  const LSDT_SUI  = "0xd1b72982e40348d069bb1ff701e634c117bb5f741f44dff91e472d3b01461e55::stsui::STSUI"
+  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 =
+      "0x4dde66fc52ec16d5e6c0fbd0968580cdf0d962cbb970591ec1e47617b9265617"
+
+    console.log("wallet: ", wallet)
+
+    const endpoint = aggregatorURL
+
+    const suiClient = new SuiClient({
+      url: fullNodeURL,
+    })
+
+    client = new AggregatorClient({
+      endpoint,
+      signer: wallet,
+      client: suiClient,
+      env: Env.Mainnet,
+      pythUrls: ["https://cetus-pythnet-a648.mainnet.pythnet.rpcpool.com/219cf7a8-6d75-432d-a648-d487a6dd5dc3/hermes"],
+      apiKey: "8MJDUzLDPJxCgbc7I0bHXSg994mVfh8NRMqV6hcQ",
+    })
+  })
+
+  test("Find Routers", async () => {
+    const amounts = ["1000", "1000000", "100000000", "5000000000", "1000000000000000000000000000"]
+    
+    while (true) {
+      const res = await client.findRouters({
+        from: LSDT_SUI,
+        target: T_USDC,
+        amount: new BN("1000000000000"),
+        byAmountIn: true,
+        depth: 3,
+        splitCount: 1,
+        providers: ["ALPHAFI"],
+      })
+
+      if (res != null) {
+        console.log(JSON.stringify(res, null, 2))
+      }
+      console.log("amount in", res?.amountIn.toString())
+      console.log("amount out", res?.amountOut.toString())
+    }
+  }, 6000000)
+
+  test("Build Router TX", async () => {
+    const amount = "100000"
+
+    const res = await client.findRouters({
+      from: LSDT_SUI,
+      target: T_SUI,
+      amount: new BN(amount),
+      byAmountIn: true,
+      depth: 3,
+      splitCount: 2,
+      providers: ["ALPHAFI", "CETUS"],
+    })
+
+    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)
+})

package/tests/router/metastable.test.ts

@@ -57,7 +57,13 @@ describe("Test metastable provider", () => {
     const suiClient = new SuiClient({
       url: fullNodeURL,
     })
-    client = new AggregatorClient(endpoint, wallet, suiClient, Env.Mainnet)
+    client = new AggregatorClient({
+      endpoint,
+      signer: wallet,
+      client: suiClient,
+      env: Env.Mainnet,
+      pythUrls: ["https://cetus-pythnet-a648.mainnet.pythnet.rpcpool.com/219cf7a8-6d75-432d-a648-d487a6dd5dc3/hermes"],
+    })
   })
 
   test("Find Routers --> SUI -> SUPER_SUI", async () => {