@bolt-liquidity-hq/sui-client 0.1.0-beta.13 → 0.1.0-beta.15

package/dist/index.cjs

@@ -49,23 +49,27 @@ __export(index_exports, {
   PoolInfoStruct: () => PoolInfoStruct,
   PriceDataStruct: () => PriceDataStruct,
   PriceResponseStruct: () => PriceResponseStruct,
-  PricesResponsePaginatedStruct: () => PricesResponsePaginatedStruct,
   ProtocolFeesInfoStruct: () => ProtocolFeesInfoStruct,
   RawPairStruct: () => RawPairStruct,
   RawPriceStruct: () => RawPriceStruct,
   RouterConfigStruct: () => RouterConfigStruct,
+  SwapSimulationResultStruct: () => SwapSimulationResultStruct,
   TypeNameStruct: () => TypeNameStruct
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/lib/client.ts
-var import_core12 = require("@bolt-liquidity-hq/core");
+var import_core15 = require("@bolt-liquidity-hq/core");
 var import_client = require("@mysten/sui/client");
-var import_utils9 = require("@mysten/sui/utils");
+var import_utils10 = require("@mysten/sui/utils");
 var import_axios = __toESM(require("axios"), 1);
 
-// src/config/mainnet.ts
+// src/config/common.ts
 var import_utils = require("@mysten/sui/utils");
+var SUI_TOKEN_DENOM = (0, import_utils.normalizeStructTag)(import_utils.SUI_TYPE_ARG);
+
+// src/config/mainnet.ts
+var import_utils2 = require("@mysten/sui/utils");
 var MainnetChainConfig = {
   name: "Sui",
   id: "101",
@@ -77,14 +81,14 @@ var MainnetContracts = {
 };
 var MainnetPackageId = "0x...";
 var MainnetPoolGlobalConfigId = "0x...";
-var MainnetNativeTokenDenom = import_utils.SUI_TYPE_ARG;
+var MainnetNativeTokenDenom = SUI_TOKEN_DENOM;
 var MainnetAssets = {
-  [import_utils.SUI_TYPE_ARG]: {
+  [SUI_TOKEN_DENOM]: {
     symbol: "SUI",
     name: "Sui",
     chainId: "101",
-    denom: import_utils.SUI_TYPE_ARG,
-    decimals: import_utils.SUI_DECIMALS,
+    denom: SUI_TOKEN_DENOM,
+    decimals: import_utils2.SUI_DECIMALS,
     logo: "https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/sui/info/logo.png",
     coingeckoId: "sui"
   },
@@ -101,7 +105,7 @@ var MainnetAssets = {
 var MainnetPools = [];
 
 // src/config/testnet.ts
-var import_utils2 = require("@mysten/sui/utils");
+var import_utils3 = require("@mysten/sui/utils");
 var TestnetConfigUrl = "https://phi-labs-ltd.github.io/sui-outpost/testnet.json";
 var TestnetChainConfig = {
   name: "Sui Testnet",
@@ -114,15 +118,15 @@ var TestnetContracts = {
 };
 var TestnetPackageId = "";
 var TestnetPoolGlobalConfigId = "";
-var TestnetNativeTokenDenom = import_utils2.SUI_TYPE_ARG;
+var TestnetNativeTokenDenom = SUI_TOKEN_DENOM;
 var TestnetHelperAssets = ["::test_btc::TEST_BTC", "::test_usdt::TEST_USDT"];
 var TestnetAssets = {
-  [import_utils2.SUI_TYPE_ARG]: {
+  [SUI_TOKEN_DENOM]: {
     symbol: "SUI",
     name: "Sui",
     chainId: "103",
-    denom: import_utils2.SUI_TYPE_ARG,
-    decimals: import_utils2.SUI_DECIMALS,
+    denom: SUI_TOKEN_DENOM,
+    decimals: import_utils3.SUI_DECIMALS,
     logo: "https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/sui/info/logo.png",
     coingeckoId: "sui"
   },
@@ -141,7 +145,7 @@ var TestnetAssets = {
     chainId: "103",
     denom: "::test_btc::TEST_BTC",
     decimals: 8,
-    logo: "https://github.com/cosmos/chain-registry/blob/master/_non-cosmos/bitcoin/images/btc.png",
+    logo: "https://raw.githubusercontent.com/cosmos/chain-registry/refs/heads/master/_non-cosmos/bitcoin/images/btc.svg",
     coingeckoId: "bitcoin"
   },
   "::test_usdt::TEST_USDT": {
@@ -150,11 +154,14 @@ var TestnetAssets = {
     chainId: "103",
     denom: "::test_usdt::TEST_USDT",
     decimals: 6,
-    logo: "https://github.com/cosmos/chain-registry/blob/master/_non-cosmos/ethereum/images/usdt.png",
+    logo: "https://raw.githubusercontent.com/cosmos/chain-registry/refs/heads/master/_non-cosmos/ethereum/images/usdt.svg",
     coingeckoId: "tether"
   }
 };
 
+// src/lib/constants/defaults.ts
+var BASIS_POINTS = 1e4;
+
 // src/lib/constants/sui-objects.ts
 var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000000000000000000000000000";
 var PRICE_ORACLE_MODULE = "price_oracle";
@@ -196,7 +203,7 @@ var parseDevInspectResult = (result, bcsType, resultIndex = 0, returnValueIndex
 
 // src/lib/helpers/coin-manager.ts
 var import_core2 = require("@bolt-liquidity-hq/core");
-var import_utils3 = require("@mysten/sui/utils");
+var import_utils4 = require("@mysten/sui/utils");
 var CoinManager = class {
   /**
    * Creates a new CoinManager instance.
@@ -563,7 +570,7 @@ var CoinManager = class {
    */
   async prepareCoinInput(tx, coinType, amount, options = {}, owner) {
     const ownerAddress = this.getOwnerAddress(owner);
-    if (coinType === import_utils3.SUI_TYPE_ARG) {
+    if ((0, import_utils4.normalizeStructTag)(coinType) === SUI_TOKEN_DENOM) {
       const [coin] = tx.splitCoins(tx.gas, [amount]);
       return coin;
     }
@@ -630,7 +637,7 @@ var queryDevInspect = async (suiClient, target, args, typeArguments, senderAddre
 var import_core4 = require("@bolt-liquidity-hq/core");
 var import_bcs2 = require("@mysten/bcs");
 var import_transactions2 = require("@mysten/sui/transactions");
-var import_utils4 = require("@mysten/sui/utils");
+var import_utils5 = require("@mysten/sui/utils");
 var import_bignumber = require("bignumber.js");
 var buildSwapTxArgs = async (client, swapParams, signer) => {
   const { assetIn, amountIn, assetOut, minimumAmountOut, receiver } = swapParams;
@@ -638,25 +645,26 @@ var buildSwapTxArgs = async (client, swapParams, signer) => {
   if (!pool) {
     throw new import_core4.NotFoundError(`Pool for the pair ${assetIn}/${assetOut}`);
   }
-  const isSell = (0, import_utils4.normalizeStructTag)(assetIn) === pool.baseDenom;
-  const FUNCTION_NAME = isSell ? "swap_sell" : "swap_buy";
+  const FUNCTION_NAME = pool.isInverse ? "swap_sell" : "swap_buy";
   const finalSigner = client.getSigner(signer);
   const tx = new import_transactions2.Transaction();
-  const coinManager = new CoinManager(client.suiClient, finalSigner.toSuiAddress());
+  const signerAddress = getSignerAddress(finalSigner);
+  const coinManager = new CoinManager(client.suiClient, signerAddress);
   const coinInput = await coinManager.prepareCoinInput(tx, assetIn, amountIn);
   return {
     signer: finalSigner,
+    signerAddress,
     target: [client.packageId, ROUTER_MODULE, FUNCTION_NAME],
     args: [
       pool.poolAddress,
       client.contracts.oracle,
-      import_utils4.SUI_CLOCK_OBJECT_ID,
+      import_utils5.SUI_CLOCK_OBJECT_ID,
       coinInput,
       import_bcs2.bcs.u64().serialize(amountIn),
-      import_bcs2.bcs.option(import_bcs2.bcs.string()).serialize(minimumAmountOut),
+      import_bcs2.bcs.option(import_bcs2.bcs.u64()).serialize(minimumAmountOut),
       import_bcs2.bcs.option(import_bcs2.bcs.string()).serialize(receiver)
     ],
-    typeArguments: [isSell ? assetIn : assetOut, isSell ? assetOut : assetIn],
+    typeArguments: [pool.isInverse ? assetIn : assetOut, pool.isInverse ? assetOut : assetIn],
     tx
   };
 };
@@ -672,15 +680,29 @@ var signAndExecuteTx = async (suiClient, signer, target, args, typeArguments, tr
     typeArguments
   });
   try {
-    const result = await suiClient.signAndExecuteTransaction({
-      signer,
-      transaction: tx,
-      options
-    });
-    if (result.effects?.status.status === "success") {
-      return result;
+    if ("toSuiAddress" in signer) {
+      const result = await suiClient.signAndExecuteTransaction({
+        signer,
+        transaction: tx,
+        options
+      });
+      if (result.effects?.status.status === "success") {
+        return result;
+      } else {
+        throw new import_core4.TransactionFailedError(result.digest, result.effects?.status.error, { result });
+      }
     } else {
-      throw new import_core4.TransactionFailedError(result.digest, result.effects?.status.error, { result });
+      const result = await signer.signAndExecuteTransaction({
+        transaction: tx
+      });
+      if (!result.digest) {
+        throw new import_core4.TransactionFailedError("not found");
+      }
+      const fullTx = await suiClient.waitForTransaction({
+        digest: result.digest,
+        options
+      });
+      return fullTx;
     }
   } catch (error) {
     throw import_core4.UnexpectedError.from(error, "Failed to execute transaction", {
@@ -723,13 +745,20 @@ var estimateTxGasPrice = async (suiClient, senderAddress, target, args, typeArgu
     const totalGasCost = (0, import_bignumber.BigNumber)(gasUsed.computationCost).plus(gasUsed.storageCost).minus(gasUsed.storageRebate);
     const adjustedGasCost = totalGasCost.times(gasAdjustment);
     return {
-      denom: import_utils4.SUI_TYPE_ARG,
+      denom: SUI_TOKEN_DENOM,
       amount: adjustedGasCost.toFixed(0, import_bignumber.BigNumber.ROUND_CEIL)
     };
   } catch {
     return;
   }
 };
+var getSignerAddress = (signer) => {
+  const address = "address" in signer ? signer.address : signer.toSuiAddress?.();
+  if (!address) {
+    throw new import_core4.NotFoundError("Signer account's address");
+  }
+  return address;
+};
 
 // src/lib/oracle/parsers.ts
 var import_core5 = require("@bolt-liquidity-hq/core");
@@ -764,20 +793,20 @@ var parseAssetPairStructOutput = (output) => {
 var parseAssetPairsResponseStructOutput = (output) => {
   return output.map((item) => parseAssetPairStructOutput(item.info));
 };
-var parsePriceDataStructOutput = (output, baseDenom, quoteDenom) => {
+var parsePriceDataStructOutput = (output, baseDenom, quoteDenom, isInverted) => {
   return {
     baseDenom,
     quoteDenom,
     price: output.price.price,
     expiryTime: (0, import_bignumber2.BigNumber)(output.price.expiry).times(1e6).toFixed(),
-    isInverse: false
+    isInverse: isInverted ?? false
   };
 };
 var parsePriceResponseStructOutput = (output, baseDenom, quoteDenom) => {
   if (!output.pair_data) {
     throw new import_core5.InvalidObjectError("Can't find pair data price");
   }
-  return parsePriceDataStructOutput(output.pair_data, baseDenom, quoteDenom);
+  return parsePriceDataStructOutput(output.pair_data, baseDenom, quoteDenom, output.is_inverted);
 };
 
 // src/types/bcs.ts
@@ -840,11 +869,8 @@ var PriceDataStruct = import_bcs4.bcs.struct("PriceData", {
   updater: BcsAddressType
 });
 var PriceResponseStruct = import_bcs4.bcs.struct("PriceResponse", {
-  pair_data: import_bcs4.bcs.option(PriceDataStruct)
-});
-var PricesResponsePaginatedStruct = import_bcs4.bcs.struct("PricesResponsePaginated", {
-  prices: import_bcs4.bcs.vector(PriceDataStruct),
-  ...PaginationStruct
+  pair_data: import_bcs4.bcs.option(PriceDataStruct),
+  is_inverted: import_bcs4.bcs.bool()
 });
 
 // src/types/router.ts
@@ -881,6 +907,14 @@ var BaseLiquidityResponseStruct = import_bcs6.bcs.struct("BaseLiquidityResponse"
   base_assets: import_bcs6.bcs.vector(BaseLiquidityInfoStruct),
   ...PaginationStruct
 });
+var SwapSimulationResultStruct = import_bcs6.bcs.struct("SwapSimulationResult", {
+  amount_out: import_bcs6.bcs.u128(),
+  dynamic_fee_pct: import_bcs6.bcs.u64(),
+  ideal_quote_amt: import_bcs6.bcs.u128(),
+  swap_fee: import_bcs6.bcs.u64(),
+  lp_fee: import_bcs6.bcs.u64(),
+  protocol_fee: import_bcs6.bcs.u64()
+});
 
 // src/types/pool.ts
 var import_bcs8 = require("@mysten/bcs");
@@ -914,13 +948,19 @@ var getAssetPairs = async (client) => {
 };
 
 // src/lib/oracle/get-assets.ts
-var import_utils5 = require("@mysten/sui/utils");
+var import_utils6 = require("@mysten/sui/utils");
 var getAssets = async (client) => {
   const assetPairs = await client.getAllOracleAssetPairs();
   const uniqueOracleAssets = {};
   for (const item of assetPairs) {
-    uniqueOracleAssets[item.base.symbol] = item.base;
-    uniqueOracleAssets[item.quote.symbol] = item.quote;
+    uniqueOracleAssets[(0, import_utils6.normalizeStructTag)(item.base.symbol)] = {
+      ...item.base,
+      symbol: (0, import_utils6.normalizeStructTag)(item.base.symbol)
+    };
+    uniqueOracleAssets[(0, import_utils6.normalizeStructTag)(item.quote.symbol)] = {
+      ...item.quote,
+      symbol: (0, import_utils6.normalizeStructTag)(item.quote.symbol)
+    };
   }
   return Object.values(uniqueOracleAssets).map(
     (item) => client.assetsConfig[item.symbol] ?? // Fallback to minimal asset data from oracle
@@ -928,7 +968,7 @@ var getAssets = async (client) => {
       symbol: item.name,
       name: item.name,
       chainId: client.chainConfig.id,
-      denom: (0, import_utils5.normalizeStructTag)(item.symbol),
+      denom: (0, import_utils6.normalizeStructTag)(item.symbol),
       decimals: item.precision,
       logo: void 0,
       coingeckoId: void 0
@@ -963,7 +1003,7 @@ var getPrice = async (client, baseDenom, quoteDenom) => {
 
 // src/lib/oracle/get-prices.ts
 var import_core6 = require("@bolt-liquidity-hq/core");
-var import_utils6 = require("@mysten/sui/utils");
+var import_utils7 = require("@mysten/sui/utils");
 var getPrices = async (client) => {
   const oracleObject = await client.suiClient.getObject({
     id: client.contracts.oracle,
@@ -998,8 +1038,8 @@ var getPrices = async (client) => {
         const pairKey = dynamicFields.data[index]?.name?.value;
         if (fields && pairKey) {
           prices.push({
-            baseDenom: (0, import_utils6.normalizeStructTag)(pairKey.base.name),
-            quoteDenom: (0, import_utils6.normalizeStructTag)(pairKey.quote.name),
+            baseDenom: (0, import_utils7.normalizeStructTag)(pairKey.base.name),
+            quoteDenom: (0, import_utils7.normalizeStructTag)(pairKey.quote.name),
             price: fields.price,
             expiryTime: fields.expiry
           });
@@ -1018,7 +1058,7 @@ var estimateSwapExactInGasFees = async (client, swapParams, signer, gasAdjustmen
   const swapArgs = await buildSwapTxArgs(client, swapParams, signer);
   return await estimateTxGasPrice(
     client.suiClient,
-    swapArgs.signer.toSuiAddress(),
+    swapArgs.signerAddress,
     swapArgs.target,
     swapArgs.args,
     swapArgs.typeArguments,
@@ -1042,9 +1082,9 @@ var getAllQuotesForUser = async (_client, _lpAddress) => {
 // src/lib/router/get-pool-by-denom.ts
 var import_core10 = require("@bolt-liquidity-hq/core");
 var getPoolByDenom = async (client, baseDenom, quoteDenom) => {
-  const result = await client.routerClient.getPool(baseDenom, quoteDenom);
+  const result = await client.routerClient.getPool(quoteDenom, baseDenom);
   if (!result) {
-    throw new import_core10.NotFoundError("Pool", `Didn't find a pool to swap ${baseDenom} for ${quoteDenom}`);
+    throw new import_core10.NotFoundError("Pool", `Didn't find a pool to swap ${quoteDenom} for ${baseDenom}`);
   }
   return result;
 };
@@ -1060,26 +1100,47 @@ var getRouterConfig = async (_client) => {
   throw new import_core11.NotImplementedError("getRouterConfig on Sui Client");
 };
 
+// src/lib/router/parsers.ts
+var import_core12 = require("@bolt-liquidity-hq/core");
+var import_bignumber3 = require("bignumber.js");
+var parseSwapSimulationResultStructOutput = (output, poolAddress, assetOut) => {
+  return {
+    poolAddress,
+    amountOut: output.amount_out,
+    assetOut,
+    protocolFee: output.protocol_fee,
+    lpFee: output.lp_fee,
+    dynamicFeePercentage: (0, import_bignumber3.BigNumber)(output.dynamic_fee_pct).div(BASIS_POINTS).toFixed(),
+    totalFees: output.swap_fee
+  };
+};
+
 // src/lib/router/router-client/RouterClient.ts
-var import_utils7 = require("@mysten/sui/utils");
+var import_utils8 = require("@mysten/sui/utils");
 var RouterClient = class {
   constructor(pools) {
     this.pools = pools;
   }
   getPool(denomIn, denomOut) {
-    const normalizedDenomIn = (0, import_utils7.normalizeStructTag)(denomIn);
-    const normalizedDenomOut = (0, import_utils7.normalizeStructTag)(denomOut);
+    const normalizedDenomIn = (0, import_utils8.normalizeStructTag)(denomIn);
+    const normalizedDenomOut = (0, import_utils8.normalizeStructTag)(denomOut);
     const directPairPool = this.pools.find(
-      (item) => item.baseDenom === normalizedDenomIn && item.quoteDenoms.includes(normalizedDenomOut)
+      (item) => item.baseDenom === normalizedDenomOut && item.quoteDenoms.includes(normalizedDenomIn)
     );
     if (directPairPool) {
-      return directPairPool;
+      return {
+        ...directPairPool,
+        isInverse: false
+      };
     }
     const inversePairPool = this.pools.find(
-      (item) => item.baseDenom === normalizedDenomOut && item.quoteDenoms.includes(normalizedDenomIn)
+      (item) => item.baseDenom === normalizedDenomIn && item.quoteDenoms.includes(normalizedDenomOut)
     );
     if (inversePairPool) {
-      return inversePairPool;
+      return {
+        ...inversePairPool,
+        isInverse: true
+      };
     }
     return;
   }
@@ -1088,6 +1149,26 @@ var RouterClient = class {
   }
 };
 
+// src/lib/router/simulate-swap.ts
+var import_core13 = require("@bolt-liquidity-hq/core");
+var import_bcs10 = require("@mysten/bcs");
+var import_utils9 = require("@mysten/sui/utils");
+var simulateSwap = async (client, { assetIn, amountIn, assetOut }) => {
+  const pool = await client.routerClient.getPool(assetIn, assetOut);
+  if (!pool) {
+    throw new import_core13.NotFoundError("Pool", `Didn't find a pool to swap ${assetIn} for ${assetOut}`);
+  }
+  const FUNCTION_NAME = pool.isInverse ? "simulate_sell_swap" : "simulate_buy_swap";
+  const response = await queryDevInspect(
+    client.suiClient,
+    [client.packageId, POOL_MODULE, FUNCTION_NAME],
+    [pool.poolAddress, client.contracts.oracle, import_utils9.SUI_CLOCK_OBJECT_ID, import_bcs10.bcs.u64().serialize(amountIn)],
+    [pool.isInverse ? assetIn : assetOut, pool.isInverse ? assetOut : assetIn]
+  );
+  const output = parseDevInspectResult(response, SwapSimulationResultStruct);
+  return parseSwapSimulationResultStructOutput(output, pool.poolAddress, assetOut);
+};
+
 // src/lib/router/swap-exact-in.ts
 var swapExactIn = async (client, swapParams, signer) => {
   const swapArgs = await buildSwapTxArgs(client, swapParams, signer);
@@ -1109,15 +1190,16 @@ var swapExactIn = async (client, swapParams, signer) => {
 };
 
 // src/lib/settlement/get-pool-info.ts
-var import_utils8 = require("@mysten/sui/utils");
+var import_core14 = require("@bolt-liquidity-hq/core");
 
 // src/lib/settlement/parsers.ts
+var import_bignumber4 = require("bignumber.js");
 var parseSettlementConfigStructOutput = (routerClient, poolFeesInfo, protocolFeesInfo, priceOracleContract) => {
   return {
     priceOracleContract,
     protocolFeeRecipient: protocolFeesInfo.bolt_fee_addr,
-    protocolFee: poolFeesInfo.swap_fee_pct,
-    lpFee: poolFeesInfo.lp_fee_pct,
+    protocolFee: (0, import_bignumber4.BigNumber)(poolFeesInfo.swap_fee_pct).div(BASIS_POINTS).toFixed(),
+    lpFee: (0, import_bignumber4.BigNumber)(poolFeesInfo.lp_fee_pct).div(BASIS_POINTS).toFixed(),
     allowanceMode: "allow",
     // Should come from pool config
     lps: routerClient.getPools().map((item) => item.poolAddress),
@@ -1130,22 +1212,24 @@ var parseSettlementConfigStructOutput = (routerClient, poolFeesInfo, protocolFee
 var getPoolInfo = async (client, contractAddress) => {
   const GET_POOL_FEES_INFO_FUNCTION = "get_pool_fees_info";
   const GET_PROTOCOL_FEES_INFO_FUNCTION = "get_protocol_fees_info";
+  const pool = client.routerClient.pools.find((item) => item.poolAddress === contractAddress);
+  if (!pool) {
+    throw new import_core14.NotFoundError(`Pool with the address ${contractAddress}`);
+  }
   const [poolFeesInfo, protocolFeesInfo] = await Promise.all([
     // Query pool fee information
     queryDevInspect(
       client.suiClient,
       [client.packageId, POOL_MODULE, GET_POOL_FEES_INFO_FUNCTION],
       [contractAddress],
-      // TODO: get the base token of the pool to pass it here instead of hardcoded SUI token
-      [import_utils8.SUI_TYPE_ARG]
+      [pool.baseDenom]
     ),
     // Query protocol fee information
     queryDevInspect(
       client.suiClient,
       [client.packageId, POOL_MODULE, GET_PROTOCOL_FEES_INFO_FUNCTION],
       [contractAddress],
-      // TODO: get the base token of the pool to pass it here instead of hardcoded SUI token
-      [import_utils8.SUI_TYPE_ARG]
+      [pool.baseDenom]
     )
   ]);
   const poolFeesInfoOutput = parseDevInspectResult(poolFeesInfo, PoolFeesInfoStruct);
@@ -1165,7 +1249,7 @@ var getPoolInfoByDenom = async (client, baseDenom, quoteDenom) => {
 };
 
 // src/lib/client.ts
-var BoltSuiClient = class extends import_core12.BaseClient {
+var BoltSuiClient = class extends import_core15.BaseClient {
   /**
    * Creates a new instance of the BoltSuiClient.
    *
@@ -1337,7 +1421,7 @@ var BoltSuiClient = class extends import_core12.BaseClient {
   getSigner(newSigner) {
     this.signer = newSigner ?? this.signer;
     if (!this.signer) {
-      throw new import_core12.MissingParameterError("signer");
+      throw new import_core15.MissingParameterError("signer");
     }
     return this.signer;
   }
@@ -1485,6 +1569,10 @@ var BoltSuiClient = class extends import_core12.BaseClient {
     await this.loadConfigFromUrl();
     return await estimateSwapExactInGasFees(this, params, signer, gasAdjustment);
   }
+  /** @inheritdoc */
+  async simulateSwap(params) {
+    return await simulateSwap(this, params);
+  }
   /**
    * Loads configuration from a remote URL for testnet environments.
    *
@@ -1536,8 +1624,8 @@ var BoltSuiClient = class extends import_core12.BaseClient {
       for (const item of pools) {
         this.routerClient.pools.push({
           poolAddress: item.pool_object_id,
-          baseDenom: (0, import_utils9.normalizeStructTag)(item.base),
-          quoteDenoms: Object.values(assets).map((auxAsset) => (0, import_utils9.normalizeStructTag)(auxAsset)).filter((auxAsset) => auxAsset !== (0, import_utils9.normalizeStructTag)(item.base))
+          baseDenom: (0, import_utils10.normalizeStructTag)(item.base),
+          quoteDenoms: Object.values(assets).map((auxAsset) => (0, import_utils10.normalizeStructTag)(auxAsset)).filter((auxAsset) => auxAsset !== (0, import_utils10.normalizeStructTag)(item.base))
         });
       }
     }