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

package/dist/index.js

@@ -5,6 +5,8 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
 // src/lib/client.ts
 import { BaseClient, MissingParameterError as MissingParameterError2 } from "@bolt-liquidity-hq/core";
 import { SuiClient } from "@mysten/sui/client";
+import { normalizeStructTag as normalizeStructTag5 } from "@mysten/sui/utils";
+import axios from "axios";
 
 // src/config/mainnet.ts
 import { SUI_DECIMALS, SUI_TYPE_ARG } from "@mysten/sui/utils";
@@ -40,21 +42,24 @@ var MainnetAssets = {
     coingeckoId: "usd-coin"
   }
 };
+var MainnetPools = [];
 
 // src/config/testnet.ts
 import { SUI_DECIMALS as SUI_DECIMALS2, SUI_TYPE_ARG as SUI_TYPE_ARG2 } from "@mysten/sui/utils";
+var TestnetConfigUrl = "https://phi-labs-ltd.github.io/sui-outpost/testnet.json";
 var TestnetChainConfig = {
   name: "Sui Testnet",
   id: "103",
   rpcEndpoint: "https://fullnode.testnet.sui.io:443"
 };
 var TestnetContracts = {
-  oracle: "0xecece01cfb23b5439e04b18fe656eaf2746b9087cf68f1d48797c8f71a3dd93b",
-  router: "0x3881fdcb4a7fbcda8edc230e6f92eb57b24c0be6b44af0b5e1d0b45564f3ed00"
+  oracle: " ",
+  router: " "
 };
-var TestnetPackageId = "0x22384b1841229e2be878bb7e88833c03e23ff5dc39accd050fb932120602f85e";
-var TestnetPoolGlobalConfigId = "0xa9491e59fa63e666cbfdea2e880b2d8ba0085eeb244220cefa3fb817559cd79c";
+var TestnetPackageId = "";
+var TestnetPoolGlobalConfigId = "";
 var TestnetNativeTokenDenom = SUI_TYPE_ARG2;
+var TestnetHelperAssets = ["::test_btc::TEST_BTC", "::test_usdt::TEST_USDT"];
 var TestnetAssets = {
   [SUI_TYPE_ARG2]: {
     symbol: "SUI",
@@ -73,20 +78,32 @@ var TestnetAssets = {
     decimals: 6,
     logo: "https://raw.githubusercontent.com/cosmos/chain-registry/master/noble/images/USDCoin.png",
     coingeckoId: "usd-coin"
+  },
+  "::test_btc::TEST_BTC": {
+    symbol: "TEST_BTC",
+    name: "Test BTC",
+    chainId: "103",
+    denom: "::test_btc::TEST_BTC",
+    decimals: 8,
+    logo: "https://github.com/cosmos/chain-registry/blob/master/_non-cosmos/bitcoin/images/btc.png",
+    coingeckoId: "bitcoin"
+  },
+  "::test_usdt::TEST_USDT": {
+    symbol: "TEST_USDT",
+    name: "Test USDT",
+    chainId: "103",
+    denom: "::test_usdt::TEST_USDT",
+    decimals: 6,
+    logo: "https://github.com/cosmos/chain-registry/blob/master/_non-cosmos/ethereum/images/usdt.png",
+    coingeckoId: "tether"
   }
 };
 
-// src/lib/oracle/get-asset-pairs.ts
-import { bcs as bcs6 } from "@mysten/bcs";
-
-// src/lib/constants/defaults.ts
-var DEFAULT_PAGINATION_LIMIT = 50;
-
 // src/lib/constants/sui-objects.ts
 var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000000000000000000000000000";
 var PRICE_ORACLE_MODULE = "price_oracle";
 var ROUTER_MODULE = "router";
-var POOL_MODULE = "settlement";
+var POOL_MODULE = "pool";
 
 // src/lib/helpers/bcs-parse.ts
 import { InvalidObjectError, ParseError } from "@bolt-liquidity-hq/core";
@@ -120,9 +137,6 @@ var parseDevInspectResult = (result, bcsType, resultIndex = 0, returnValueIndex
     });
   }
 };
-var parseMultipleResults = (info, schema) => {
-  return schema.map((bcsType, index) => parseDevInspectResult(info, bcsType, 0, index));
-};
 
 // src/lib/helpers/coin-manager.ts
 import { InsufficientFundsError, MissingParameterError } from "@bolt-liquidity-hq/core";
@@ -556,15 +570,45 @@ var queryDevInspect = async (suiClient, target, args, typeArguments, senderAddre
   }
 };
 
-// src/lib/helpers/txs.ts
+// src/lib/helpers/transactions.ts
 import {
   DEFAULT_GAS_ADJUSTMENT,
+  NotFoundError,
   TransactionFailedError as TransactionFailedError2,
   UnexpectedError as UnexpectedError2
 } from "@bolt-liquidity-hq/core";
+import { bcs as bcs2 } from "@mysten/bcs";
 import { Transaction as Transaction2 } from "@mysten/sui/transactions";
-import { SUI_TYPE_ARG as SUI_TYPE_ARG4 } from "@mysten/sui/utils";
+import { normalizeStructTag, SUI_CLOCK_OBJECT_ID, SUI_TYPE_ARG as SUI_TYPE_ARG4 } from "@mysten/sui/utils";
 import { BigNumber } from "bignumber.js";
+var buildSwapTxArgs = async (client, swapParams, signer) => {
+  const { assetIn, amountIn, assetOut, minimumAmountOut, receiver } = swapParams;
+  const pool = client.routerClient.getPool(assetIn, assetOut);
+  if (!pool) {
+    throw new NotFoundError(`Pool for the pair ${assetIn}/${assetOut}`);
+  }
+  const isSell = normalizeStructTag(assetIn) === pool.baseDenom;
+  const FUNCTION_NAME = isSell ? "swap_sell" : "swap_buy";
+  const finalSigner = client.getSigner(signer);
+  const tx = new Transaction2();
+  const coinManager = new CoinManager(client.suiClient, finalSigner.toSuiAddress());
+  const coinInput = await coinManager.prepareCoinInput(tx, assetIn, amountIn);
+  return {
+    signer: finalSigner,
+    target: [client.packageId, ROUTER_MODULE, FUNCTION_NAME],
+    args: [
+      pool.poolAddress,
+      client.contracts.oracle,
+      SUI_CLOCK_OBJECT_ID,
+      coinInput,
+      bcs2.u64().serialize(amountIn),
+      bcs2.option(bcs2.string()).serialize(minimumAmountOut),
+      bcs2.option(bcs2.string()).serialize(receiver)
+    ],
+    typeArguments: [isSell ? assetIn : assetOut, isSell ? assetOut : assetIn],
+    tx
+  };
+};
 var signAndExecuteTx = async (suiClient, signer, target, args, typeArguments, transaction, options) => {
   const tx = transaction ?? new Transaction2();
   const targetString = Array.isArray(target) ? `${target[0]}::${target[1]}::${target[2]}` : target;
@@ -595,7 +639,7 @@ var signAndExecuteTx = async (suiClient, signer, target, args, typeArguments, tr
     });
   }
 };
-var estimateTxGasPrice = async (suiClient, target, args, typeArguments, transaction, gasAdjustment = DEFAULT_GAS_ADJUSTMENT) => {
+var estimateTxGasPrice = async (suiClient, senderAddress, target, args, typeArguments, transaction, gasAdjustment = DEFAULT_GAS_ADJUSTMENT) => {
   const tx = transaction ?? new Transaction2();
   const targetString = Array.isArray(target) ? `${target[0]}::${target[1]}::${target[2]}` : target;
   const txArgs = args?.map(
@@ -606,6 +650,7 @@ var estimateTxGasPrice = async (suiClient, target, args, typeArguments, transact
     arguments: txArgs,
     typeArguments
   });
+  tx.setSender(senderAddress);
   try {
     const transactionBytes = await tx.build({ client: suiClient });
     const dryRunResult = await suiClient.dryRunTransactionBlock({
@@ -640,7 +685,8 @@ import { InvalidObjectError as InvalidObjectError2 } from "@bolt-liquidity-hq/co
 import { BigNumber as BigNumber2 } from "bignumber.js";
 var parseOracleConfigStructOutput = (output) => {
   return {
-    admin: output.admin,
+    // TODO: try to query admin somewhere else? to fill empty value
+    admin: "",
     priceThresholdRatio: output.price_threshold_ratio,
     priceExpireTime: {
       secs: Number(output.default_price_expiry_seconds),
@@ -651,45 +697,44 @@ var parseOracleConfigStructOutput = (output) => {
 var parseAssetPairStructOutput = (output) => {
   return {
     base: {
-      name: output.base_symbol,
-      symbol: output.base_symbol,
+      name: output.base_name,
+      // TODO: map a different value for name/symbols
+      symbol: output.base_name,
       precision: output.base_precision
     },
     quote: {
-      name: output.quote_symbol,
-      symbol: output.quote_symbol,
+      name: output.quote_name,
+      // TODO: map a different value for name/symbols
+      symbol: output.quote_name,
       precision: output.quote_precision
     }
   };
 };
-var parsePriceDataStructOutput = (output) => {
+var parseAssetPairsResponseStructOutput = (output) => {
+  return output.map((item) => parseAssetPairStructOutput(item.info));
+};
+var parsePriceDataStructOutput = (output, baseDenom, quoteDenom) => {
   return {
-    baseDenom: output.base_symbol,
-    quoteDenom: output.quote_symbol,
-    price: output.price,
-    expiryTime: BigNumber2(output.expiry_time_ms).times(1e6).toFixed(),
+    baseDenom,
+    quoteDenom,
+    price: output.price.price,
+    expiryTime: BigNumber2(output.price.expiry).times(1e6).toFixed(),
     isInverse: false
   };
 };
-var parsePriceResponseStructOutput = (output) => {
+var parsePriceResponseStructOutput = (output, baseDenom, quoteDenom) => {
   if (!output.pair_data) {
     throw new InvalidObjectError2("Can't find pair data price");
   }
-  return parsePriceDataStructOutput(output.pair_data);
-};
-var parseAssetPairsResponsePaginatedStructOutput = (output) => {
-  return output.asset_pairs.map((item) => parseAssetPairStructOutput(item));
-};
-var parsePricesResponsePaginatedStructOutput = (output) => {
-  return output.prices.map((item) => parsePriceDataStructOutput(item));
+  return parsePriceDataStructOutput(output.pair_data, baseDenom, quoteDenom);
 };
 
 // src/types/bcs.ts
-import { bcs as bcs2, BcsType } from "@mysten/bcs";
+import { bcs as bcs3, BcsType } from "@mysten/bcs";
 var PaginationStruct = {
-  total_count: bcs2.u64(),
-  has_next_page: bcs2.bool(),
-  next_cursor: bcs2.option(bcs2.string())
+  total_count: bcs3.u64(),
+  has_next_page: bcs3.bool(),
+  next_cursor: bcs3.option(bcs3.string())
 };
 var BcsAddressType = new BcsType({
   name: "address",
@@ -711,112 +756,114 @@ var BcsAddressType = new BcsType({
 });
 
 // src/types/oracle.ts
-import { bcs as bcs3 } from "@mysten/bcs";
-var OracleConfigStruct = bcs3.struct("Config", {
-  admin: BcsAddressType,
-  price_threshold_ratio: bcs3.u64(),
-  default_price_expiry_seconds: bcs3.u64()
+import { bcs as bcs4 } from "@mysten/bcs";
+var OracleConfigStruct = bcs4.struct("Config", {
+  price_threshold_ratio: bcs4.u64(),
+  default_price_expiry_seconds: bcs4.u64()
 });
-var AssetPairStruct = bcs3.struct("AssetPair", {
-  base_symbol: bcs3.string(),
-  quote_symbol: bcs3.string(),
-  base_precision: bcs3.u8(),
-  quote_precision: bcs3.u8()
+var AssetPairStruct = bcs4.struct("AssetPair", {
+  base_name: bcs4.string(),
+  quote_name: bcs4.string(),
+  base_precision: bcs4.u8(),
+  quote_precision: bcs4.u8()
 });
-var AssetPairsResponseStruct = bcs3.struct("AssetPairsResponse", {
-  asset_pairs: bcs3.vector(AssetPairStruct)
+var TypeNameStruct = bcs4.struct("TypeName", {
+  name: bcs4.string()
 });
-var AssetPairsResponsePaginatedStruct = bcs3.struct("AssetPairsResponsePaginated", {
-  asset_pairs: bcs3.vector(AssetPairStruct),
-  ...PaginationStruct
+var RawPairStruct = bcs4.struct("RawPair", {
+  base: TypeNameStruct,
+  quote: TypeNameStruct
+});
+var AssetPairResponseStruct = bcs4.struct("AssetPairResponse", {
+  pair: RawPairStruct,
+  info: AssetPairStruct
+});
+var AssetPairsResponseStruct = bcs4.vector(AssetPairResponseStruct);
+var RawPriceStruct = bcs4.struct("RawPrice", {
+  price: bcs4.u128(),
+  expiry: bcs4.u64()
 });
-var PriceDataStruct = bcs3.struct("PriceData", {
-  base_symbol: bcs3.string(),
-  quote_symbol: bcs3.string(),
-  price: bcs3.u128(),
-  expiry_time_ms: bcs3.u64(),
-  last_updated_ms: bcs3.u64(),
+var PriceDataStruct = bcs4.struct("PriceData", {
+  price: RawPriceStruct,
+  last_updated_ms: bcs4.u64(),
   updater: BcsAddressType
 });
-var PriceResponseStruct = bcs3.struct("PriceResponse", {
-  pair_data: bcs3.option(PriceDataStruct)
+var PriceResponseStruct = bcs4.struct("PriceResponse", {
+  pair_data: bcs4.option(PriceDataStruct)
 });
-var PricesResponsePaginatedStruct = bcs3.struct("PricesResponsePaginated", {
-  prices: bcs3.vector(PriceDataStruct),
+var PricesResponsePaginatedStruct = bcs4.struct("PricesResponsePaginated", {
+  prices: bcs4.vector(PriceDataStruct),
   ...PaginationStruct
 });
 
 // src/types/router.ts
-import { bcs as bcs4 } from "@mysten/bcs";
-var RouterConfigStruct = bcs4.struct("Config", {
+import { bcs as bcs5 } from "@mysten/bcs";
+var RouterConfigStruct = bcs5.struct("Config", {
   admin: BcsAddressType,
   default_price_oracle_contract: BcsAddressType,
   default_protocol_fee_recipient: BcsAddressType,
-  default_protocol_fee: bcs4.u64(),
-  default_lp_fee: bcs4.u64()
+  default_protocol_fee: bcs5.u64(),
+  default_lp_fee: bcs5.u64()
 });
-var MarketStruct = bcs4.struct("Market", {
-  base_asset_symbol: bcs4.string(),
-  quote_assets_symbols: bcs4.vector(bcs4.string()),
-  market_address: bcs4.string(),
-  is_permissioned: bcs4.bool(),
-  created_at_ms: bcs4.u64()
+var MarketStruct = bcs5.struct("Market", {
+  base_asset_symbol: bcs5.string(),
+  quote_assets_symbols: bcs5.vector(bcs5.string()),
+  market_address: bcs5.string(),
+  is_permissioned: bcs5.bool(),
+  created_at_ms: bcs5.u64()
 });
-var MarketResponseStruct = bcs4.struct("MarketResponse", {
-  market: bcs4.option(MarketStruct)
+var MarketResponseStruct = bcs5.struct("MarketResponse", {
+  market: bcs5.option(MarketStruct)
 });
-var MarketsResponseStruct = bcs4.struct("MarketsResponse", {
-  markets: bcs4.vector(MarketStruct)
+var MarketsResponseStruct = bcs5.struct("MarketsResponse", {
+  markets: bcs5.vector(MarketStruct)
 });
-var MarketsResponsePaginatedStruct = bcs4.struct("MarketsResponsePaginated", {
-  markets: bcs4.vector(MarketStruct),
+var MarketsResponsePaginatedStruct = bcs5.struct("MarketsResponsePaginated", {
+  markets: bcs5.vector(MarketStruct),
   ...PaginationStruct
 });
-var BaseLiquidityInfoStruct = bcs4.struct("BaseLiquidityInfo", {
-  denom: bcs4.string(),
-  amount: bcs4.u64()
+var BaseLiquidityInfoStruct = bcs5.struct("BaseLiquidityInfo", {
+  denom: bcs5.string(),
+  amount: bcs5.u64()
 });
-var BaseLiquidityResponseStruct = bcs4.struct("BaseLiquidityResponse", {
-  base_assets: bcs4.vector(BaseLiquidityInfoStruct),
+var BaseLiquidityResponseStruct = bcs5.struct("BaseLiquidityResponse", {
+  base_assets: bcs5.vector(BaseLiquidityInfoStruct),
   ...PaginationStruct
 });
 
 // src/types/pool.ts
-import { bcs as bcs5 } from "@mysten/bcs";
-var GetPoolInfoResponseStruct = [
-  bcs5.u64(),
-  bcs5.u128(),
-  BcsAddressType,
-  bcs5.bool()
-];
-var GetFeesResponseStruct = [bcs5.u64(), bcs5.u64(), bcs5.u64()];
+import { bcs as bcs6 } from "@mysten/bcs";
+var PoolInfoStruct = bcs6.struct("PoolInfo", {
+  base_liquidity: bcs6.u64(),
+  total_lp_shares: bcs6.u64(),
+  admin: BcsAddressType,
+  is_paused: bcs6.bool()
+});
+var PoolFeesInfoStruct = bcs6.struct("PoolFeesInfo", {
+  swap_fee_pct: bcs6.u64(),
+  lp_withdrawal_fee_pct: bcs6.u64(),
+  lp_fee_pct: bcs6.u64()
+});
+var ProtocolFeesInfoStruct = bcs6.struct("ProtocolFeesInfo", {
+  bolt_fee_addr: BcsAddressType,
+  swap_fee_pct: bcs6.u64(),
+  lp_withdrawal_fee_pct: bcs6.u64()
+});
 
 // src/lib/oracle/get-asset-pairs.ts
 var getAssetPairs = async (client) => {
-  const ASSET_PAIRS_PAGINATED_FUNCTION = "asset_pairs_paginated";
-  const result = [];
-  let currentCursor = null;
-  let hasNextPage = true;
-  while (hasNextPage) {
-    const response = await queryDevInspect(
-      client.suiClient,
-      [client.packageId, PRICE_ORACLE_MODULE, ASSET_PAIRS_PAGINATED_FUNCTION],
-      [
-        client.contracts.oracle,
-        bcs6.option(bcs6.u64()).serialize(DEFAULT_PAGINATION_LIMIT),
-        bcs6.option(bcs6.string()).serialize(currentCursor)
-      ]
-    );
-    const output = parseDevInspectResult(response, AssetPairsResponsePaginatedStruct);
-    const assetPairs = parseAssetPairsResponsePaginatedStructOutput(output);
-    result.push(...assetPairs);
-    currentCursor = output.next_cursor;
-    hasNextPage = output.has_next_page;
-  }
-  return result;
+  const ASSET_PAIRS_FUNCTION = "asset_pairs";
+  const response = await queryDevInspect(
+    client.suiClient,
+    [client.packageId, PRICE_ORACLE_MODULE, ASSET_PAIRS_FUNCTION],
+    [client.contracts.oracle]
+  );
+  const output = parseDevInspectResult(response, AssetPairsResponseStruct);
+  return parseAssetPairsResponseStructOutput(output);
 };
 
 // src/lib/oracle/get-assets.ts
+import { normalizeStructTag as normalizeStructTag2 } from "@mysten/sui/utils";
 var getAssets = async (client) => {
   const assetPairs = await client.getAllOracleAssetPairs();
   const uniqueOracleAssets = {};
@@ -830,7 +877,7 @@ var getAssets = async (client) => {
       symbol: item.name,
       name: item.name,
       chainId: client.chainConfig.id,
-      denom: item.symbol,
+      denom: normalizeStructTag2(item.symbol),
       decimals: item.precision,
       logo: void 0,
       coingeckoId: void 0
@@ -851,248 +898,164 @@ var getOracleConfig = async (client) => {
 };
 
 // src/lib/oracle/get-price.ts
-import { bcs as bcs7 } from "@mysten/bcs";
-import { SUI_CLOCK_OBJECT_ID } from "@mysten/sui/utils";
 var getPrice = async (client, baseDenom, quoteDenom) => {
   const GET_PRICE_FUNCTION = "get_price";
   const response = await queryDevInspect(
     client.suiClient,
     [client.packageId, PRICE_ORACLE_MODULE, GET_PRICE_FUNCTION],
-    [
-      client.contracts.oracle,
-      bcs7.string().serialize(baseDenom),
-      bcs7.string().serialize(quoteDenom),
-      SUI_CLOCK_OBJECT_ID
-    ]
+    [client.contracts.oracle],
+    [baseDenom, quoteDenom]
   );
   const output = parseDevInspectResult(response, PriceResponseStruct);
-  return parsePriceResponseStructOutput(output);
+  return parsePriceResponseStructOutput(output, baseDenom, quoteDenom);
 };
 
 // src/lib/oracle/get-prices.ts
-import { bcs as bcs8 } from "@mysten/bcs";
+import { NotFoundError as NotFoundError2 } from "@bolt-liquidity-hq/core";
+import { normalizeStructTag as normalizeStructTag3 } from "@mysten/sui/utils";
 var getPrices = async (client) => {
-  const GET_PRICES_PAGINATED_FUNCTION = "get_prices_paginated";
-  const result = [];
-  let currentCursor = null;
-  let hasNextPage = true;
-  while (hasNextPage) {
-    const response = await queryDevInspect(
-      client.suiClient,
-      [client.packageId, PRICE_ORACLE_MODULE, GET_PRICES_PAGINATED_FUNCTION],
-      [
-        client.contracts.oracle,
-        bcs8.option(bcs8.u64()).serialize(DEFAULT_PAGINATION_LIMIT),
-        bcs8.option(bcs8.string()).serialize(currentCursor)
-      ]
+  const oracleObject = await client.suiClient.getObject({
+    id: client.contracts.oracle,
+    options: { showContent: true }
+  });
+  if (!oracleObject.data?.content || oracleObject.data.content.dataType !== "moveObject") {
+    throw new NotFoundError2("Oracle object");
+  }
+  const pricesTableId = oracleObject.data.content.fields?.prices?.fields?.id?.id;
+  if (!pricesTableId) {
+    throw new NotFoundError2("Prices table in the Oracle contract");
+  }
+  const prices = [];
+  let cursor = null;
+  while (true) {
+    const dynamicFields = await client.suiClient.getDynamicFields({
+      parentId: pricesTableId,
+      cursor,
+      limit: 50
+      // Max limit per request
+    });
+    const fieldPromises = dynamicFields.data.map(
+      (field) => client.suiClient.getDynamicFieldObject({
+        parentId: pricesTableId,
+        name: field.name
+      })
     );
-    const output = parseDevInspectResult(response, PricesResponsePaginatedStruct);
-    const assetPairs = parsePricesResponsePaginatedStructOutput(output);
-    result.push(...assetPairs);
-    currentCursor = output.next_cursor;
-    hasNextPage = output.has_next_page;
+    const fieldObjects = await Promise.all(fieldPromises);
+    fieldObjects.forEach((obj, index) => {
+      if (obj.data?.content?.dataType === "moveObject") {
+        const fields = obj.data.content.fields?.value?.fields?.price?.fields;
+        const pairKey = dynamicFields.data[index]?.name?.value;
+        if (fields && pairKey) {
+          prices.push({
+            baseDenom: normalizeStructTag3(pairKey.base.name),
+            quoteDenom: normalizeStructTag3(pairKey.quote.name),
+            price: fields.price,
+            expiryTime: fields.expiry
+          });
+        }
+      }
+    });
+    if (!dynamicFields.hasNextPage) break;
+    cursor = dynamicFields.nextCursor;
   }
-  return result;
+  return prices;
 };
 
 // src/lib/router/estimate-swap-exact-in-gas-fees.ts
 import { DEFAULT_GAS_ADJUSTMENT as DEFAULT_GAS_ADJUSTMENT2 } from "@bolt-liquidity-hq/core";
-import { bcs as bcs9 } from "@mysten/bcs";
-import { Transaction as Transaction3 } from "@mysten/sui/transactions";
-import { SUI_CLOCK_OBJECT_ID as SUI_CLOCK_OBJECT_ID2 } from "@mysten/sui/utils";
-var estimateSwapExactInGasFees = async (client, { assetIn, amountIn, assetOut, minimumAmountOut, receiver }, signer, gasAdjustment = DEFAULT_GAS_ADJUSTMENT2) => {
-  const SWAP_EXACT_IN_FUNCTION = "swap_exact_in";
-  const finalSigner = client.getSigner(signer);
-  const tx = new Transaction3();
-  const coinManager = new CoinManager(client.suiClient, finalSigner.toSuiAddress());
-  const coinInput = await coinManager.prepareCoinInput(tx, assetIn, amountIn);
+var estimateSwapExactInGasFees = async (client, swapParams, signer, gasAdjustment = DEFAULT_GAS_ADJUSTMENT2) => {
+  const swapArgs = await buildSwapTxArgs(client, swapParams, signer);
   return await estimateTxGasPrice(
     client.suiClient,
-    [client.packageId, ROUTER_MODULE, SWAP_EXACT_IN_FUNCTION],
-    [
-      client.contracts.router,
-      bcs9.string().serialize(assetOut),
-      "",
-      // TODO: pass correct pool when router can actually route to the pools depending on other arguments
-      bcs9.string().serialize(assetIn),
-      bcs9.option(bcs9.string()).serialize(minimumAmountOut),
-      bcs9.option(bcs9.string()).serialize(receiver),
-      coinInput,
-      SUI_CLOCK_OBJECT_ID2
-    ],
-    [assetIn, assetOut],
-    tx,
+    swapArgs.signer.toSuiAddress(),
+    swapArgs.target,
+    swapArgs.args,
+    swapArgs.typeArguments,
+    swapArgs.tx,
     gasAdjustment
   );
 };
 
 // src/lib/router/get-all-base-liquidity.ts
-import { bcs as bcs10 } from "@mysten/bcs";
-
-// src/lib/router/parsers.ts
-import { NotFoundError } from "@bolt-liquidity-hq/core";
-var parseMarketStructOutput = (output) => {
-  return {
-    poolAddress: output.market_address,
-    baseDenom: output.base_asset_symbol,
-    quoteDenoms: output.quote_assets_symbols
-  };
-};
-var parseMarketResponseStructOutput = (output) => {
-  if (!output.market) {
-    throw new NotFoundError("Market", void 0, { output });
-  }
-  return parseMarketStructOutput(output.market);
-};
-var parseMarketsResponsePaginatedStructOutput = (output) => {
-  return output.markets.map((item) => parseMarketStructOutput(item));
-};
-var parseRouterConfigStructOutput = (output) => {
-  return {
-    admin: output.admin,
-    defaultPriceOracleContract: output.default_price_oracle_contract,
-    defaultProtocolFeeRecipient: output.default_protocol_fee_recipient,
-    defaultProtocolFee: output.default_protocol_fee,
-    defaultLpFee: output.default_lp_fee
-  };
+import {
+  NotImplementedError
+} from "@bolt-liquidity-hq/core";
+var getAllBaseLiquidity = async (_client) => {
+  throw new NotImplementedError("getRouterConfig on Sui Client");
 };
-var parseBaseLiquidityResponseStructOutput = (output) => {
-  return output.base_assets.map((item) => ({
-    baseLiquidity: {
-      denom: item.denom,
-      amount: item.amount
-    },
-    totalShares: ""
-    // TODO: add real total shares if it is returned by the smart contract later
-  }));
+
+// src/lib/router/get-all-quotes-for-user.ts
+import { NotImplementedError as NotImplementedError2 } from "@bolt-liquidity-hq/core";
+var getAllQuotesForUser = async (_client, _lpAddress) => {
+  throw new NotImplementedError2("getRouterConfig on Sui Client");
 };
 
-// src/lib/router/get-all-base-liquidity.ts
-var getAllBaseLiquidity = async (client) => {
-  const BASE_LIQUIDITY_ALL_PAGINATED_FUNCTION = "base_liquidity_all_paginated";
-  const result = {};
-  let currentCursor = null;
-  let hasNextPage = true;
-  while (hasNextPage) {
-    const response = await queryDevInspect(
-      client.suiClient,
-      [client.packageId, ROUTER_MODULE, BASE_LIQUIDITY_ALL_PAGINATED_FUNCTION],
-      [
-        client.contracts.router,
-        bcs10.option(bcs10.u64()).serialize(DEFAULT_PAGINATION_LIMIT),
-        bcs10.option(bcs10.string()).serialize(currentCursor)
-      ]
-    );
-    const output = parseDevInspectResult(response, BaseLiquidityResponseStruct);
-    const baseLiquidities = parseBaseLiquidityResponseStructOutput(output);
-    for (const item of baseLiquidities) {
-      result[item.baseLiquidity.denom] = item;
-    }
-    currentCursor = output.next_cursor;
-    hasNextPage = output.has_next_page;
+// src/lib/router/get-pool-by-denom.ts
+import { NotFoundError as NotFoundError3 } from "@bolt-liquidity-hq/core";
+var getPoolByDenom = async (client, baseDenom, quoteDenom) => {
+  const result = await client.routerClient.getPool(baseDenom, quoteDenom);
+  if (!result) {
+    throw new NotFoundError3("Pool", `Didn't find a pool to swap ${baseDenom} for ${quoteDenom}`);
   }
   return result;
 };
 
-// src/lib/router/get-all-quotes-for-user.ts
-import { bcs as bcs11 } from "@mysten/bcs";
-var getAllQuotesForUser = async (client, lpAddress) => {
-  const QUOTES_FOR_USER_ALL_FUNCTION = "quotes_for_user_all";
-  const response = await queryDevInspect(
-    client.suiClient,
-    [client.packageId, ROUTER_MODULE, QUOTES_FOR_USER_ALL_FUNCTION],
-    [client.contracts.router, bcs11.string().serialize(lpAddress)]
-  );
-  console.log(response);
-  return {};
+// src/lib/router/get-pools.ts
+var getPools = async (client) => {
+  return await client.routerClient.getPools();
 };
 
-// src/lib/router/get-pool-for-base.ts
-import { bcs as bcs12 } from "@mysten/bcs";
-var getPoolForBase = async (client, baseDenom) => {
-  const MARKET_FOR_BASE_FUNCTION = "market_for_base";
-  const response = await queryDevInspect(
-    client.suiClient,
-    [client.packageId, ROUTER_MODULE, MARKET_FOR_BASE_FUNCTION],
-    [client.contracts.router, bcs12.string().serialize(baseDenom)]
-  );
-  const output = parseDevInspectResult(response, MarketResponseStruct);
-  return parseMarketResponseStructOutput(output);
+// src/lib/router/get-router-config.ts
+import { NotImplementedError as NotImplementedError3 } from "@bolt-liquidity-hq/core";
+var getRouterConfig = async (_client) => {
+  throw new NotImplementedError3("getRouterConfig on Sui Client");
 };
 
-// src/lib/router/get-pools.ts
-import { bcs as bcs13 } from "@mysten/bcs";
-var getPools = async (client) => {
-  const MARKETS_PAGINATED_FUNCTION = "markets_paginated";
-  const result = [];
-  let currentCursor = null;
-  let hasNextPage = true;
-  while (hasNextPage) {
-    const response = await queryDevInspect(
-      client.suiClient,
-      [client.packageId, ROUTER_MODULE, MARKETS_PAGINATED_FUNCTION],
-      [
-        client.contracts.router,
-        bcs13.option(bcs13.u64()).serialize(DEFAULT_PAGINATION_LIMIT),
-        bcs13.option(bcs13.string()).serialize(currentCursor)
-      ]
+// src/lib/router/router-client/RouterClient.ts
+import { normalizeStructTag as normalizeStructTag4 } from "@mysten/sui/utils";
+var RouterClient = class {
+  constructor(pools) {
+    this.pools = pools;
+  }
+  getPool(denomIn, denomOut) {
+    const normalizedDenomIn = normalizeStructTag4(denomIn);
+    const normalizedDenomOut = normalizeStructTag4(denomOut);
+    const directPairPool = this.pools.find(
+      (item) => item.baseDenom === normalizedDenomIn && item.quoteDenoms.includes(normalizedDenomOut)
+    );
+    if (directPairPool) {
+      return directPairPool;
+    }
+    const inversePairPool = this.pools.find(
+      (item) => item.baseDenom === normalizedDenomOut && item.quoteDenoms.includes(normalizedDenomIn)
     );
-    const output = parseDevInspectResult(response, MarketsResponsePaginatedStruct);
-    const pools = parseMarketsResponsePaginatedStructOutput(output);
-    result.push(...pools);
-    currentCursor = output.next_cursor;
-    hasNextPage = output.has_next_page;
+    if (inversePairPool) {
+      return inversePairPool;
+    }
+    return;
+  }
+  getPools() {
+    return this.pools;
   }
-  return result;
-};
-
-// src/lib/router/get-router-config.ts
-var getRouterConfig = async (client) => {
-  const CONFIG_FUNCTION = "config";
-  const response = await queryDevInspect(
-    client.suiClient,
-    [client.packageId, ROUTER_MODULE, CONFIG_FUNCTION],
-    [client.contracts.router]
-  );
-  const output = parseDevInspectResult(response, RouterConfigStruct);
-  return parseRouterConfigStructOutput(output);
 };
 
 // src/lib/router/swap-exact-in.ts
-import { bcs as bcs14 } from "@mysten/bcs";
-import { Transaction as Transaction4 } from "@mysten/sui/transactions";
-import { SUI_CLOCK_OBJECT_ID as SUI_CLOCK_OBJECT_ID3 } from "@mysten/sui/utils";
-var swapExactIn = async (client, { assetIn, amountIn, assetOut, minimumAmountOut, receiver }, signer) => {
-  const SWAP_EXACT_IN_FUNCTION = "swap_exact_in";
-  const finalSigner = client.getSigner(signer);
-  const tx = new Transaction4();
-  const coinManager = new CoinManager(client.suiClient, finalSigner.toSuiAddress());
-  const coinInput = await coinManager.prepareCoinInput(tx, assetIn, amountIn);
+var swapExactIn = async (client, swapParams, signer) => {
+  const swapArgs = await buildSwapTxArgs(client, swapParams, signer);
   const txOutput = await signAndExecuteTx(
     client.suiClient,
-    finalSigner,
-    [client.packageId, ROUTER_MODULE, SWAP_EXACT_IN_FUNCTION],
-    [
-      client.contracts.router,
-      bcs14.string().serialize(assetOut),
-      "",
-      // TODO: pass correct pool when router can actually route to the pools depending on other arguments
-      bcs14.string().serialize(assetIn),
-      bcs14.option(bcs14.string()).serialize(minimumAmountOut),
-      bcs14.option(bcs14.string()).serialize(receiver),
-      coinInput,
-      SUI_CLOCK_OBJECT_ID3
-    ],
-    [assetIn, assetOut],
-    tx,
+    swapArgs.signer,
+    swapArgs.target,
+    swapArgs.args,
+    swapArgs.typeArguments,
+    swapArgs.tx,
     { showEffects: true, showEvents: true, showBalanceChanges: true }
   );
   return {
     txOutput,
     txHash: txOutput.digest,
-    amountOut: "",
-    // TODO: implement when contract emits event
-    assetOut
+    amountOut: txOutput.events?.at(0)?.parsedJson?.["amount_out"] ?? "0",
+    assetOut: swapParams.assetOut
   };
 };
 
@@ -1100,57 +1063,56 @@ var swapExactIn = async (client, { assetIn, amountIn, assetOut, minimumAmountOut
 import { SUI_TYPE_ARG as SUI_TYPE_ARG5 } from "@mysten/sui/utils";
 
 // src/lib/settlement/parsers.ts
-var parseSettlementConfigStructOutput = (globalConfig, feesOutput) => {
+var parseSettlementConfigStructOutput = (routerClient, poolFeesInfo, protocolFeesInfo, priceOracleContract) => {
   return {
-    priceOracleContract: "0x",
-    // Should come from pool config
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
-    protocolFeeRecipient: globalConfig.data?.content?.fields.protocol_fee_recipient || "",
-    protocolFee: feesOutput[0],
-    // Protocol fee percentage
-    lpFee: feesOutput[2],
-    // LP fee percentage
+    priceOracleContract,
+    protocolFeeRecipient: protocolFeesInfo.bolt_fee_addr,
+    protocolFee: poolFeesInfo.swap_fee_pct,
+    lpFee: poolFeesInfo.lp_fee_pct,
     allowanceMode: "allow",
     // Should come from pool config
-    lps: ["0x"],
-    // Should come from  pool config
-    minBaseOut: "1"
-    // Should come from  pool config
+    lps: routerClient.getPools().map((item) => item.poolAddress),
+    minBaseOut: "0"
+    // Should come from pool config
   };
 };
 
 // src/lib/settlement/get-pool-info.ts
 var getPoolInfo = async (client, contractAddress) => {
-  const GET_FEES_FUNCTION = "get_fees";
-  const [globalConfig, fees] = await Promise.all([
-    // Fetch the global pool configuration object
-    client.suiClient.getObject({
-      id: client.poolGlobalConfigId,
-      options: {
-        showContent: true,
-        showType: true
-      }
-    }),
-    // Query pool-specific fee structure
+  const GET_POOL_FEES_INFO_FUNCTION = "get_pool_fees_info";
+  const GET_PROTOCOL_FEES_INFO_FUNCTION = "get_protocol_fees_info";
+  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
+      [SUI_TYPE_ARG5]
+    ),
+    // Query protocol fee information
     queryDevInspect(
       client.suiClient,
-      [client.packageId, POOL_MODULE, GET_FEES_FUNCTION],
+      [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
       [SUI_TYPE_ARG5]
     )
   ]);
-  const feesOutput = parseMultipleResults(fees, GetFeesResponseStruct);
-  return parseSettlementConfigStructOutput(globalConfig, feesOutput);
+  const poolFeesInfoOutput = parseDevInspectResult(poolFeesInfo, PoolFeesInfoStruct);
+  const protocolFeesInfoOutput = parseDevInspectResult(protocolFeesInfo, ProtocolFeesInfoStruct);
+  return parseSettlementConfigStructOutput(
+    client.routerClient,
+    poolFeesInfoOutput,
+    protocolFeesInfoOutput,
+    client.contracts.oracle
+  );
 };
 
-// src/tests/constants/sui-objects.ts
-var TEST_POOL = "0xdd05c1caea7b6725da3f67e30e99872033fc5d3a610a4f72ac1c434bc81c3c0d";
-
-// src/lib/settlement/get-pool-info-for-base.ts
-var getPoolInfoForBase = async (client, baseDenom) => {
-  const pool = await getPoolForBase(client, baseDenom && "SUI");
-  return await getPoolInfo(client, pool.poolAddress || TEST_POOL);
+// src/lib/settlement/get-pool-info-by-denom.ts
+var getPoolInfoByDenom = async (client, baseDenom, quoteDenom) => {
+  const pool = await getPoolByDenom(client, baseDenom, quoteDenom);
+  return await getPoolInfo(client, pool.poolAddress);
 };
 
 // src/lib/client.ts
@@ -1160,7 +1122,8 @@ var BoltSuiClient = class extends BaseClient {
    *
    * The client automatically configures itself based on the specified environment,
    * loading the appropriate contract addresses, chain configuration, native token denomination,
-   * and assets from configuration files.
+   * and assets from configuration files. For testnet environments, the client can dynamically
+   * fetch configuration from a remote URL.
    *
    * @param config - (Optional) Configuration for the client
    * @param config.environment - (Optional) The deployment environment ('mainnet' or 'testnet'). Defaults to 'mainnet'
@@ -1186,7 +1149,7 @@ var BoltSuiClient = class extends BaseClient {
    * // Use default configuration (Sui mainnet)
    * const client = new BoltSuiClient();
    *
-   * // Use testnet configuration
+   * // Use testnet configuration (will fetch config dynamically)
    * const testnetClient = new BoltSuiClient({
    *   environment: 'testnet'
    * });
@@ -1229,12 +1192,14 @@ var BoltSuiClient = class extends BaseClient {
    */
   constructor(config) {
     const { environment = "mainnet", customOverride, signer, suiClient } = config ?? {};
-    const defaultChainConfig = environment === "mainnet" ? MainnetChainConfig : TestnetChainConfig;
-    const defaultContracts = environment === "mainnet" ? MainnetContracts : TestnetContracts;
-    const defaultPackageId = environment === "mainnet" ? MainnetPackageId : TestnetPackageId;
-    const defaultPoolGlobalConfigId = environment === "mainnet" ? MainnetPoolGlobalConfigId : TestnetPoolGlobalConfigId;
-    const defaultNativeTokenDenom = environment === "mainnet" ? MainnetNativeTokenDenom : TestnetNativeTokenDenom;
-    const assetsConfig = environment === "mainnet" ? MainnetAssets : TestnetAssets;
+    const isEnvironmentMainnet = environment === "mainnet";
+    const defaultChainConfig = isEnvironmentMainnet ? MainnetChainConfig : TestnetChainConfig;
+    const defaultContracts = isEnvironmentMainnet ? MainnetContracts : TestnetContracts;
+    const defaultPackageId = isEnvironmentMainnet ? MainnetPackageId : TestnetPackageId;
+    const defaultPoolGlobalConfigId = isEnvironmentMainnet ? MainnetPoolGlobalConfigId : TestnetPoolGlobalConfigId;
+    const defaultNativeTokenDenom = isEnvironmentMainnet ? MainnetNativeTokenDenom : TestnetNativeTokenDenom;
+    const assetsConfig = isEnvironmentMainnet ? MainnetAssets : TestnetAssets;
+    const pools = isEnvironmentMainnet ? MainnetPools : [];
     const chainConfig = {
       id: customOverride?.chainConfig?.id ?? defaultChainConfig.id,
       name: customOverride?.chainConfig?.name ?? defaultChainConfig.name,
@@ -1272,18 +1237,30 @@ var BoltSuiClient = class extends BaseClient {
     __publicField(this, "poolGlobalConfigId");
     /**
      * Cached instance of the Signer for transaction execution
-     * @private
      */
     __publicField(this, "signer");
     /**
      * Instance of the Sui client to interact with the blockchain
      */
     __publicField(this, "suiClient");
+    /**
+     * URL for fetching testnet configuration dynamically.
+     * Used to load package IDs, oracle addresses, and asset configurations for testnet environments.
+     * @private
+     */
+    __publicField(this, "configFileUrl");
+    /**
+     * Router client instance for managing pool configurations and routing calculations.
+     * Handles pool discovery and optimal path finding for swaps.
+     */
+    __publicField(this, "routerClient");
     this.chainConfig = chainConfig;
     this.packageId = packageId;
     this.poolGlobalConfigId = poolGlobalConfigId;
     this.signer = signer;
     this.suiClient = suiClient ?? new SuiClient({ url: chainConfig.rpcEndpoint });
+    this.routerClient = new RouterClient(pools);
+    this.configFileUrl = isEnvironmentMainnet ? void 0 : TestnetConfigUrl;
   }
   /**
    * Gets or sets the signer for transaction execution.
@@ -1319,51 +1296,81 @@ var BoltSuiClient = class extends BaseClient {
   // Only add documentation here if you need to override or add implementation-specific details
   /** @inheritdoc */
   async getOracleConfig() {
+    await this.loadConfigFromUrl();
     return await getOracleConfig(this);
   }
   /** @inheritdoc */
   async getAllOracleAssetPairs() {
+    await this.loadConfigFromUrl();
     return await getAssetPairs(this);
   }
   /** @inheritdoc */
   async getPrice(baseDenom, quoteDenom) {
+    await this.loadConfigFromUrl();
     return await getPrice(this, baseDenom, quoteDenom);
   }
   /** @inheritdoc */
   async getAllPrices() {
+    await this.loadConfigFromUrl();
     return await getPrices(this);
   }
   /** @inheritdoc */
   async getRouterConfig() {
+    await this.loadConfigFromUrl();
     return await getRouterConfig(this);
   }
   /** @inheritdoc */
   async getAllBaseAssetsLiquidity() {
+    await this.loadConfigFromUrl();
     return await getAllBaseLiquidity(this);
   }
   /** @inheritdoc */
   async getAllQuotesByUser(address) {
+    await this.loadConfigFromUrl();
     return await getAllQuotesForUser(this, address);
   }
-  /** @inheritdoc */
-  async getPoolByBaseAsset(baseDenom) {
-    return await getPoolForBase(this, baseDenom);
+  /**
+   * @inheritdoc
+   *
+   * @remarks
+   * In the Sui implementation, both `baseDenom` and `quoteDenom` parameters are required.
+   * The Sui architecture uses both asset types to uniquely identify pools for specific
+   * trading pairs.
+   *
+   * @throws Will throw an error if no pool exists for the specified base/quote asset pair
+   */
+  async getPoolByDenom(baseDenom, quoteDenom) {
+    await this.loadConfigFromUrl();
+    return await getPoolByDenom(this, baseDenom, quoteDenom);
   }
   /** @inheritdoc */
   async getAllPools() {
+    await this.loadConfigFromUrl();
     return await getPools(this);
   }
-  // Satisfy the base class requirement
+  /** @inheritdoc */
   async getPoolConfig(poolContractAddress) {
+    await this.loadConfigFromUrl();
     return await getPoolInfo(this, poolContractAddress);
   }
   /** @inheritdoc */
   async getAssets() {
+    await this.loadConfigFromUrl();
     return await getAssets(this);
   }
-  /** @inheritdoc */
-  async getPoolConfigByBaseAsset(baseDenom) {
-    return await getPoolInfoForBase(this, baseDenom);
+  /**
+   * @inheritdoc
+   *
+   * @remarks
+   * In the Sui implementation, both `baseDenom` and `quoteDenom` parameters are required.
+   * The Sui architecture uses both asset types to uniquely identify pools for specific
+   * trading pairs.
+   *
+   * @throws Will throw an error if no pool exists for the specified base/quote asset pair
+   */
+  async getPoolConfigByDenom(baseDenom, quoteDenom) {
+    await this.loadConfigFromUrl();
+    return await getPoolInfoByDenom(this, baseDenom, quoteDenom);
   }
   /**
    * @inheritdoc
@@ -1394,6 +1401,7 @@ var BoltSuiClient = class extends BaseClient {
    * which includes details like gas costs, transaction effects, object changes, and events.
    */
   async swap(params, signer) {
+    await this.loadConfigFromUrl();
     return await swapExactIn(this, params, signer);
   }
   /**
@@ -1425,28 +1433,91 @@ var BoltSuiClient = class extends BaseClient {
    * - Sui's gas model includes computation, storage, and storage rebates
    */
   async estimateSwapGasFees(params, signer, gasAdjustment) {
+    await this.loadConfigFromUrl();
     return await estimateSwapExactInGasFees(this, params, signer, gasAdjustment);
   }
+  /**
+   * Loads configuration from a remote URL for testnet environments.
+   *
+   * This method fetches and applies dynamic configuration including:
+   * - Package ID for Bolt contracts
+   * - Oracle contract address
+   * - Pool global configuration ID
+   * - Asset mappings and metadata
+   * - Pool configurations
+   *
+   * The method is called automatically before API operations when a config URL is set.
+   * After successful loading, the config URL is cleared to prevent redundant fetches.
+   *
+   * @private
+   * @remarks
+   * - Only executes if `configFileUrl` is set (typically for testnet)
+   * - Updates testnet-specific asset denoms with their actual deployed addresses
+   * - Populates the router client's pool configurations
+   * - Normalizes struct tags for consistency
+   */
+  async loadConfigFromUrl() {
+    if (!this.configFileUrl) {
+      return;
+    }
+    const response = await axios.get(this.configFileUrl);
+    const { package_id, oracle_id, global_config_id, assets, pools } = response.data ?? {};
+    if (!this.packageId && package_id) {
+      this.packageId = package_id;
+    }
+    if (!this.contracts.oracle.trim() && oracle_id) {
+      this.contracts.oracle = oracle_id;
+    }
+    if (!this.poolGlobalConfigId && global_config_id) {
+      this.poolGlobalConfigId = global_config_id;
+    }
+    for (const item of Object.values(assets)) {
+      for (const suffix of TestnetHelperAssets) {
+        if (item.includes(suffix) && this.assetsConfig[suffix]) {
+          this.assetsConfig[item] = {
+            ...this.assetsConfig[suffix],
+            denom: item
+          };
+          delete this.assetsConfig[suffix];
+          break;
+        }
+      }
+    }
+    if (this.routerClient.pools.length === 0) {
+      for (const item of pools) {
+        this.routerClient.pools.push({
+          poolAddress: item.pool_object_id,
+          baseDenom: normalizeStructTag5(item.base),
+          quoteDenoms: Object.values(assets).map((auxAsset) => normalizeStructTag5(auxAsset)).filter((auxAsset) => auxAsset !== normalizeStructTag5(item.base))
+        });
+      }
+    }
+    this.configFileUrl = void 0;
+  }
 };
 export {
+  AssetPairResponseStruct,
   AssetPairStruct,
-  AssetPairsResponsePaginatedStruct,
   AssetPairsResponseStruct,
   BaseLiquidityInfoStruct,
   BaseLiquidityResponseStruct,
   BcsAddressType,
   BoltSuiClient,
-  GetFeesResponseStruct,
-  GetPoolInfoResponseStruct,
   MarketResponseStruct,
   MarketStruct,
   MarketsResponsePaginatedStruct,
   MarketsResponseStruct,
   OracleConfigStruct,
   PaginationStruct,
+  PoolFeesInfoStruct,
+  PoolInfoStruct,
   PriceDataStruct,
   PriceResponseStruct,
   PricesResponsePaginatedStruct,
-  RouterConfigStruct
+  ProtocolFeesInfoStruct,
+  RawPairStruct,
+  RawPriceStruct,
+  RouterConfigStruct,
+  TypeNameStruct
 };
 //# sourceMappingURL=index.js.map