@cetusprotocol/aggregator-sdk 0.3.28 → 0.3.30

package/src/api.ts

@@ -8,7 +8,7 @@ import {
 } from "./errors"
 import { parseRouterResponse } from "./client"
 
-const SDK_VERSION = 1000328
+const SDK_VERSION = 1000330
 
 export interface FindRouterParams {
   from: string
@@ -53,6 +53,13 @@ export type ExtendedDetails = {
   steammBCoinAType?: string
   steammBCoinBType?: string
   steammLPToken?: string
+  metastablePriceSeed?: string
+  metastableETHPriceSeed?: string
+  metastableWhitelistedAppId?: string
+  metastableCreateCapPkgId?: string
+  metastableCreateCapModule?: string
+  metastableCreateCapAllTypeParams?: boolean
+  metastableRegistryId?: string
 }
 
 export type Path = {
@@ -146,7 +153,6 @@ export async function getRouterResult(
     }
   }
   if (data.data != null) {
-    console.log("data.data", JSON.stringify(data.data, null, 2))
     const res = parseRouterResponse(data.data, params.byAmountIn)
     return res
   }

package/src/client.ts

@@ -48,6 +48,7 @@ import {
   SuiPythClient,
 } from "@pythnetwork/pyth-sui-js"
 import { Steamm } from "./transaction/steamm"
+import { Metastable } from "./transaction/metastable"
 
 export const CETUS = "CETUS"
 export const DEEPBOOKV2 = "DEEPBOOK"
@@ -69,6 +70,7 @@ export const HAEDALPMM = "HAEDALPMM"
 export const ALPHAFI = "ALPHAFI"
 export const SPRINGSUI = "SPRINGSUI"
 export const STEAMM = "STEAMM"
+export const METASTABLE = "METASTABLE"
 export const DEFAULT_ENDPOINT = "https://api-sui.cetus.zone/router_v2"
 
 export type BuildRouterSwapParams = {
@@ -167,7 +169,7 @@ export class AggregatorClient {
     [Env.Mainnet]: {
       connections: [
         new SuiPriceServiceConnection(
-          "https://cetus.liquify.com/api=X9LTVPQD7Y3R5N2A/hermes",
+          "https://cetus-pythnet-a648.mainnet.pythnet.rpcpool.com/219cf7a8-6d75-432d-a648-d487a6dd5dc3/hermes",
           {
             timeout: 3000,
           }
@@ -224,23 +226,28 @@ export class AggregatorClient {
 
     const allCoins: CoinAsset[] = []
     while (true) {
-      const gotCoins = await this.client.getCoins({
-        owner: this.signer,
-        coinType,
-        cursor,
-        limit,
-      })
-      for (const coin of gotCoins.data) {
-        allCoins.push({
-          coinAddress: extractStructTagFromType(coin.coinType).source_address,
-          coinObjectId: coin.coinObjectId,
-          balance: BigInt(coin.balance),
+      try {
+        const gotCoins = await this.client.getCoins({
+          owner: this.signer,
+          coinType,
+          cursor,
+          limit,
         })
-      }
-      if (gotCoins.data.length < limit) {
+        for (const coin of gotCoins.data) {
+          allCoins.push({
+            coinAddress: extractStructTagFromType(coin.coinType).source_address,
+            coinObjectId: coin.coinObjectId,
+            balance: BigInt(coin.balance),
+          })
+        }
+        if (gotCoins.data.length < limit) {
+          break
+        }
+        cursor = gotCoins.data[limit - 1].coinObjectId
+      } catch (e) {
+        console.error("getCoins error:", e)
         break
       }
-      cursor = gotCoins.data[limit - 1].coinObjectId
     }
 
     this.allCoins.set(coinType, allCoins)
@@ -583,7 +590,8 @@ export class AggregatorClient {
     if (this.env === Env.Mainnet) {
       // return "0x3fb42ddf908af45f9fc3c59eab227888ff24ba2e137b3b55bf80920fd47e11af" // version 6
       // return "0xf9c6f78322ed667909e05f6b42b2f5a67af6297503c905335e02a15148e9440d" // version 7
-      return "0x2485feb9d42c7c3bcb8ecde555ad40f1b073d9fb4faf354fa2d30a0b183a23ce" // version 8
+      // return "0x2485feb9d42c7c3bcb8ecde555ad40f1b073d9fb4faf354fa2d30a0b183a23ce" // version 8
+      return "0x3864c7c59a4889fec05d1aae4bc9dba5a0e0940594b424fbed44cb3f6ac4c032" // version 9
       // return "0x803db8dfcc86fc1afbc7d2212bd14ec9690978ddebea0d590e01147d6b17aa06" // pre
     } else {
       // return "0x0ed287d6c3fe4962d0994ffddc1d19a15fba6a81533f3f0dcc2bbcedebce0637" // version 2
@@ -701,6 +709,8 @@ export class AggregatorClient {
         return new Alphafi(this.env)
       case STEAMM:
         return new Steamm(this.env)
+      case METASTABLE:
+        return new Metastable(this.env, pythPriceIDs)
       default:
         throw new Error(`Unsupported dex ${provider}`)
     }
@@ -803,6 +813,14 @@ export function findPythPriceIDs(routes: Router[]): string[] {
           priceIDs.add(path.extendedDetails.haedalPmmQuotePriceSeed)
         }
       }
+      if (path.provider === METASTABLE) {
+        if (path.extendedDetails && path.extendedDetails.metastablePriceSeed) {
+          priceIDs.add(path.extendedDetails.metastablePriceSeed)
+        }
+        if (path.extendedDetails && path.extendedDetails.metastableETHPriceSeed) {
+          priceIDs.add(path.extendedDetails.metastableETHPriceSeed)
+        }
+      }
     }
   }
   return Array.from(priceIDs)
@@ -851,7 +869,8 @@ export function parseRouterResponse(
             path.provider === DEEPBOOKV3 ||
             path.provider === SCALLOP ||
             path.provider === HAEDALPMM ||
-            path.provider === STEAMM
+            path.provider === STEAMM ||
+            path.provider === METASTABLE
           ) {
             extendedDetails = {
               aftermathLpSupplyType:
@@ -871,7 +890,14 @@ export function parseRouterResponse(
               steammLendingMarketType: path.extended_details?.steamm_lending_market_type,
               steammBCoinAType: path.extended_details?.steamm_btoken_a_type,
               steammBCoinBType: path.extended_details?.steamm_btoken_b_type,
-              steammLPToken: path.extended_details?.steamm_lp_token_type, 
+              steammLPToken: path.extended_details?.steamm_lp_token_type,
+              metastablePriceSeed: path.extended_details?.metastable_price_seed,
+              metastableETHPriceSeed: path.extended_details?.metastable_eth_price_seed,
+              metastableWhitelistedAppId: path.extended_details?.metastable_whitelisted_app_id,
+              metastableCreateCapPkgId: path.extended_details?.metastable_create_cap_pkg_id,
+              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,
             }
           }
 

package/src/transaction/metastable.ts

@@ -0,0 +1,141 @@
+import {
+  Transaction,
+  TransactionObjectArgument,
+} from "@mysten/sui/transactions"
+import { AggregatorClient, CLOCK_ADDRESS, Dex, Env, getAggregatorV2ExtendPublishedAt, Path } from ".."
+
+const SUPER_SUI_TYPE = "0x790f258062909e3a0ffc78b3c53ac2f62d7084c3bab95644bdeb05add7250001::super_sui::SUPER_SUI"
+const MUSD_TYPE = "0xe44df51c0b21a27ab915fa1fe2ca610cd3eaa6d9666fe5e62b988bf7f0bd8722::musd::MUSD"
+const METH_TYPE = "0xccd628c2334c5ed33e6c47d6c21bb664f8b6307b2ac32c2462a61f69a31ebcee::meth::METH"
+
+export class Metastable implements Dex {
+  private pythPriceIDs: Map<string, string>
+  private versionID: string
+
+  constructor(env: Env, pythPriceIDs: Map<string, string>) {
+    if (env !== Env.Mainnet) {
+      throw new Error("Metastable only supported on mainnet")
+    }
+    this.versionID = "0x4696559327b35ff2ab26904e7426a1646312e9c836d5c6cff6709a5ccc30915c"
+    this.pythPriceIDs = pythPriceIDs
+  }
+
+  async swap(
+    client: AggregatorClient,
+    txb: Transaction,
+    path: Path,
+    inputCoin: TransactionObjectArgument,
+    packages?: Map<string, string>
+  ): Promise<TransactionObjectArgument> {
+    const { direction, from, target } = path
+
+    const [func, createCapFunc, coinType, metaCoinType] = direction
+      ? ["swap_a2b", "create_deposit_cap", from, target]
+      : ["swap_b2a", "create_withdraw_cap", target, from]
+
+    let createExchangePkgId = "";
+    let createDepositModule = "pyth";
+    let metaSingletonId = "";
+    if (path.extendedDetails == null) {
+      throw new Error("Extended details not supported metastable")
+    } else {
+      if (
+        !path.extendedDetails.metastableCreateCapPkgId ||
+        !path.extendedDetails.metastableCreateCapModule ||
+        !path.extendedDetails.metastableRegistryId ||
+        !path.extendedDetails.metastableWhitelistedAppId
+      ) {
+        throw new Error("CreateCapPkgId or CreateCapModule or RegistryId or WhitelistedAppId or CreateCapAllTypeParams not supported")
+      }
+      createExchangePkgId = path.extendedDetails.metastableCreateCapPkgId
+      createDepositModule = path.extendedDetails.metastableCreateCapModule
+      metaSingletonId = path.extendedDetails.metastableWhitelistedAppId
+    }
+
+    const createDepositCapTypeArgs = [
+      metaCoinType
+    ]
+    if (path.extendedDetails.metastableCreateCapAllTypeParams) {
+      createDepositCapTypeArgs.push(coinType);
+    }
+
+    const depositArgs = [
+      txb.object(metaSingletonId),
+      txb.object(path.id),
+    ]
+    
+    switch (metaCoinType) {
+      case SUPER_SUI_TYPE: {
+        if (!path.extendedDetails.metastableRegistryId) {
+          throw new Error("Not found registry id for super sui")
+        }
+        depositArgs.push(txb.object(path.extendedDetails.metastableRegistryId));
+        break;
+      }
+      case MUSD_TYPE: {
+        if (path.extendedDetails.metastablePriceSeed != null) {
+          const priceId = this.pythPriceIDs.get(path.extendedDetails.metastablePriceSeed)
+          if (priceId == null) {
+            throw new Error("Invalid Pyth price feed: " + path.extendedDetails.metastablePriceSeed)
+          }
+          depositArgs.push(txb.object(priceId));
+        }
+        if (path.extendedDetails.metastableETHPriceSeed != null) {
+          const priceId = this.pythPriceIDs.get(path.extendedDetails.metastableETHPriceSeed)
+          if (priceId == null) {
+            throw new Error("Invalid Pyth price feed: " + path.extendedDetails.metastableETHPriceSeed)
+          }
+          depositArgs.push(txb.object(priceId));
+        }
+        depositArgs.push(txb.object(CLOCK_ADDRESS));
+        break;
+      }
+      case METH_TYPE: {
+        if (path.extendedDetails.metastablePriceSeed != null) {
+          const priceId = this.pythPriceIDs.get(path.extendedDetails.metastablePriceSeed)
+          if (priceId == null) {
+            throw new Error("Invalid Pyth price feed: " + path.extendedDetails.metastablePriceSeed)
+          }
+          depositArgs.push(txb.object(priceId));
+        }
+        if (path.extendedDetails.metastableETHPriceSeed != null) {
+          const priceId = this.pythPriceIDs.get(path.extendedDetails.metastableETHPriceSeed)
+          if (priceId == null) {
+            throw new Error("Invalid Pyth price feed: " + path.extendedDetails.metastableETHPriceSeed)
+          }
+          depositArgs.push(txb.object(priceId));
+        }
+        depositArgs.push(txb.object(CLOCK_ADDRESS));
+        break;
+      }
+
+      default:
+        throw new Error("Invalid Metacoin: " + metaCoinType);
+    }
+
+    const depositResult = txb.moveCall({
+      target: `${createExchangePkgId}::${createDepositModule}::${createCapFunc}`,
+      typeArguments: createDepositCapTypeArgs,
+      arguments: depositArgs,
+    }) as TransactionObjectArgument
+
+    const swapArgs = [
+      txb.object(path.id),
+      txb.object(this.versionID),
+      depositResult,
+      inputCoin,
+    ]
+
+    const publishedAt = getAggregatorV2ExtendPublishedAt(client.publishedAtV2Extend(), packages)
+    const res = txb.moveCall({
+      target: `${publishedAt}::metastable::${func}`,
+      typeArguments: [
+        coinType, 
+        metaCoinType,
+      ],
+      arguments: swapArgs,
+    }) as TransactionObjectArgument
+
+    return res
+  }
+}

package/tests/router/metastable.test.ts

@@ -0,0 +1,377 @@
+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 metastable provider", () => {
+  let client: AggregatorClient
+  let keypair: Ed25519Keypair
+
+  const T_SUPER_SUI = "0x790f258062909e3a0ffc78b3c53ac2f62d7084c3bab95644bdeb05add7250001::super_sui::SUPER_SUI"
+  const T_SUI = "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI"
+  const AF_SUI = "0xf325ce1300e8dac124071d3152c5c5ee6174914f8bc2161e88329cf579246efc::afsui::AFSUI"
+
+  const WH_USDC = "0x5d4b302506645c37ff133b98c4b50a5ae14841659738d6d733d59d0d217a93bf::coin::COIN"
+  const T_USDC = "0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC"
+  const M_USDC = "0xe44df51c0b21a27ab915fa1fe2ca610cd3eaa6d9666fe5e62b988bf7f0bd8722::musd::MUSD"
+
+  const METH = "0xccd628c2334c5ed33e6c47d6c21bb664f8b6307b2ac32c2462a61f69a31ebcee::meth::METH"
+  const ETH = "0xd0e89b2af5e4910726fbcd8b8dd37bb79b29e5f83f7491bca830e94f7f226d29::eth::ETH"
+  const WEHT = "0xaf8cd5edc19c4512f4259f0bee101a40d41ebed738ade5874359610ef8eeced5::coin::COIN"
+
+  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 =
+    //   "0x5cade8f29891e04c5f6e5ad3a020583fda51c8267f1b0c0fa5a85158d486ac3b"  // has 1 meth
+
+    const wallet = "0x80cda5d0baa1e33ad073f590f8e6dc00a8d3657663ce06ce08c18ecbb0e47031" // 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 -> SUPER_SUI", async () => {
+    // const amounts = ["1000", "1000000", "100000000", "5000000000", "10000000000000"]
+    const amounts = ["999000000", "5000000000"]
+    
+    for (const amount of amounts) {
+      const res = await client.findRouters({
+        from: T_SUI,
+        target: T_SUPER_SUI,
+        amount: new BN(amount),
+        byAmountIn: true,
+        depth: 3,
+        splitCount: 1,
+        providers: ["METASTABLE"],
+      })
+
+      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))
+        }
+      }
+    }
+  })
+
+  test("Find Routers --> SUPER_SUI --> SUI", async () => {
+    // const amounts = ["1000", "1000000", "100000000", "5000000000", "10000000000000"]
+    const amounts = ["1000", "1000000", "900000000"]
+    
+    for (const amount of amounts) {
+      const res = await client.findRouters({
+        from: T_SUPER_SUI,
+        target: T_SUI,
+        amount: new BN(amount),
+        byAmountIn: true,
+        depth: 3,
+        splitCount: 1,
+        providers: ["METASTABLE"],
+      })
+
+      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()
+
+        // 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("Find Routers --> USDC -> MUSDC", async () => {
+    const amounts = ["1000000", "30000000"]
+    
+    for (const amount of amounts) {
+      const res = await client.findRouters({
+        from: T_USDC,
+        target: M_USDC,
+        amount: new BN(amount),
+        byAmountIn: true,
+        depth: 3,
+        splitCount: 1,
+        providers: ["METASTABLE"],
+      })
+
+      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)
+
+        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("Find Routers --> MUSDC -> USDC", async () => {
+    // const amounts = ["1000", "1000000", "100000000", "5000000000", "10000000000000"]
+    const amounts = ["1000000", "1000000000"]
+    
+    for (const amount of amounts) {
+      const res = await client.findRouters({
+        from: M_USDC,
+        target: T_USDC,
+        amount: new BN(amount),
+        byAmountIn: true,
+        depth: 3,
+        splitCount: 1,
+        providers: ["METASTABLE"],
+      })
+
+      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)
+
+        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("Find Routers --> METH -> ETH", async () => {
+    const amounts = ["5000000", "100000000"]
+    
+    for (const amount of amounts) {
+      const res = await client.findRouters({
+        from: METH,
+        target: ETH,
+        amount: new BN(amount),
+        byAmountIn: true,
+        depth: 3,
+        splitCount: 1,
+        providers: ["METASTABLE"],
+      })
+
+      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)
+
+        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("Find Routers --> ETH -> METH", async () => {
+    const amounts = ["10000000", "5000000000"]
+    
+    for (const amount of amounts) {
+      const res = await client.findRouters({
+        from: ETH,
+        target: METH,
+        amount: new BN(amount),
+        byAmountIn: true,
+        depth: 3,
+        splitCount: 1,
+        providers: ["METASTABLE"],
+      })
+
+      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)
+
+        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 = "10000000"
+
+    const res = await client.findRouters({
+      from: T_USDC,
+      target: M_USDC,
+      amount: new BN(amount),
+      byAmountIn: true,
+      depth: 3,
+      providers: ["METASTABLE"],
+    })
+
+    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.test.ts

@@ -33,9 +33,7 @@ describe("router module", () => {
       keypair = buildTestAccount()
     }
 
-    // const wallet = keypair.getPublicKey().toSuiAddress()
-    const wallet =
-      "0x073dfdcbb5d6552efd954273f7ab9e0b918d7bf30103e3f4e632502289cd92ee"
+    const wallet = keypair.getPublicKey().toSuiAddress()
 
     console.log("wallet: ", wallet)
 
@@ -49,7 +47,7 @@ describe("router module", () => {
   })
 
   test("Get coins", () => {
-    return client.getCoins(testData.M_wUSDC).then((coins) => {
+    return client.getCoins(testData.M_USDC).then((coins) => {
       console.log(coins)
     })
   })