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

package/dist/index.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __export = (target, all) => {
@@ -16,40 +18,57 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  AssetPairResponseStruct: () => AssetPairResponseStruct,
   AssetPairStruct: () => AssetPairStruct,
-  AssetPairsResponsePaginatedStruct: () => AssetPairsResponsePaginatedStruct,
   AssetPairsResponseStruct: () => AssetPairsResponseStruct,
   BaseLiquidityInfoStruct: () => BaseLiquidityInfoStruct,
   BaseLiquidityResponseStruct: () => BaseLiquidityResponseStruct,
   BcsAddressType: () => BcsAddressType,
   BoltSuiClient: () => BoltSuiClient,
-  GetFeesResponseStruct: () => GetFeesResponseStruct,
-  GetPoolInfoResponseStruct: () => GetPoolInfoResponseStruct,
   MarketResponseStruct: () => MarketResponseStruct,
   MarketStruct: () => MarketStruct,
   MarketsResponsePaginatedStruct: () => MarketsResponsePaginatedStruct,
   MarketsResponseStruct: () => MarketsResponseStruct,
   OracleConfigStruct: () => OracleConfigStruct,
   PaginationStruct: () => PaginationStruct,
+  PoolFeesInfoStruct: () => PoolFeesInfoStruct,
+  PoolInfoStruct: () => PoolInfoStruct,
   PriceDataStruct: () => PriceDataStruct,
   PriceResponseStruct: () => PriceResponseStruct,
-  PricesResponsePaginatedStruct: () => PricesResponsePaginatedStruct,
-  RouterConfigStruct: () => RouterConfigStruct
+  ProtocolFeesInfoStruct: () => ProtocolFeesInfoStruct,
+  RawPairStruct: () => RawPairStruct,
+  RawPriceStruct: () => RawPriceStruct,
+  RouterConfigStruct: () => RouterConfigStruct,
+  TypeNameStruct: () => TypeNameStruct
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/lib/client.ts
-var import_core8 = require("@bolt-liquidity-hq/core");
+var import_core13 = require("@bolt-liquidity-hq/core");
 var import_client = require("@mysten/sui/client");
+var import_utils9 = 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",
@@ -61,14 +80,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"
   },
@@ -82,28 +101,31 @@ var MainnetAssets = {
     coingeckoId: "usd-coin"
   }
 };
+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",
   id: "103",
   rpcEndpoint: "https://fullnode.testnet.sui.io:443"
 };
 var TestnetContracts = {
-  oracle: "0xecece01cfb23b5439e04b18fe656eaf2746b9087cf68f1d48797c8f71a3dd93b",
-  router: "0x3881fdcb4a7fbcda8edc230e6f92eb57b24c0be6b44af0b5e1d0b45564f3ed00"
+  oracle: " ",
+  router: " "
 };
-var TestnetPackageId = "0x22384b1841229e2be878bb7e88833c03e23ff5dc39accd050fb932120602f85e";
-var TestnetPoolGlobalConfigId = "0xa9491e59fa63e666cbfdea2e880b2d8ba0085eeb244220cefa3fb817559cd79c";
-var TestnetNativeTokenDenom = import_utils2.SUI_TYPE_ARG;
+var TestnetPackageId = "";
+var TestnetPoolGlobalConfigId = "";
+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"
   },
@@ -115,20 +137,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://raw.githubusercontent.com/cosmos/chain-registry/refs/heads/master/_non-cosmos/bitcoin/images/btc.svg",
+    coingeckoId: "bitcoin"
+  },
+  "::test_usdt::TEST_USDT": {
+    symbol: "TEST_USDT",
+    name: "Test USDT",
+    chainId: "103",
+    denom: "::test_usdt::TEST_USDT",
+    decimals: 6,
+    logo: "https://raw.githubusercontent.com/cosmos/chain-registry/refs/heads/master/_non-cosmos/ethereum/images/usdt.svg",
+    coingeckoId: "tether"
   }
 };
 
-// src/lib/oracle/get-asset-pairs.ts
-var import_bcs9 = require("@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
 var import_core = require("@bolt-liquidity-hq/core");
@@ -162,13 +196,10 @@ 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
 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.
@@ -535,7 +566,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;
     }
@@ -598,11 +629,42 @@ var queryDevInspect = async (suiClient, target, args, typeArguments, senderAddre
   }
 };
 
-// src/lib/helpers/txs.ts
+// src/lib/helpers/transactions.ts
 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;
+  const pool = client.routerClient.getPool(assetIn, assetOut);
+  if (!pool) {
+    throw new import_core4.NotFoundError(`Pool for the pair ${assetIn}/${assetOut}`);
+  }
+  const isSell = (0, import_utils5.normalizeStructTag)(assetIn) === pool.baseDenom;
+  const FUNCTION_NAME = isSell ? "swap_sell" : "swap_buy";
+  const finalSigner = client.getSigner(signer);
+  const tx = new import_transactions2.Transaction();
+  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_utils5.SUI_CLOCK_OBJECT_ID,
+      coinInput,
+      import_bcs2.bcs.u64().serialize(amountIn),
+      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],
+    tx
+  };
+};
 var signAndExecuteTx = async (suiClient, signer, target, args, typeArguments, transaction, options) => {
   const tx = transaction ?? new import_transactions2.Transaction();
   const targetString = Array.isArray(target) ? `${target[0]}::${target[1]}::${target[2]}` : target;
@@ -615,15 +677,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", {
@@ -633,7 +709,7 @@ var signAndExecuteTx = async (suiClient, signer, target, args, typeArguments, tr
     });
   }
 };
-var estimateTxGasPrice = async (suiClient, target, args, typeArguments, transaction, gasAdjustment = import_core4.DEFAULT_GAS_ADJUSTMENT) => {
+var estimateTxGasPrice = async (suiClient, senderAddress, target, args, typeArguments, transaction, gasAdjustment = import_core4.DEFAULT_GAS_ADJUSTMENT) => {
   const tx = transaction ?? new import_transactions2.Transaction();
   const targetString = Array.isArray(target) ? `${target[0]}::${target[1]}::${target[2]}` : target;
   const txArgs = args?.map(
@@ -644,6 +720,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({
@@ -665,20 +742,28 @@ var estimateTxGasPrice = async (suiClient, target, args, typeArguments, transact
     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");
 var import_bignumber2 = require("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),
@@ -689,47 +774,46 @@ 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, isInverted) => {
   return {
-    baseDenom: output.base_symbol,
-    quoteDenom: output.quote_symbol,
-    price: output.price,
-    expiryTime: (0, import_bignumber2.BigNumber)(output.expiry_time_ms).times(1e6).toFixed(),
-    isInverse: false
+    baseDenom,
+    quoteDenom,
+    price: output.price.price,
+    expiryTime: (0, import_bignumber2.BigNumber)(output.price.expiry).times(1e6).toFixed(),
+    isInverse: isInverted ?? false
   };
 };
-var parsePriceResponseStructOutput = (output) => {
+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);
-};
-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, output.is_inverted);
 };
 
 // src/types/bcs.ts
-var import_bcs2 = require("@mysten/bcs");
+var import_bcs3 = require("@mysten/bcs");
 var PaginationStruct = {
-  total_count: import_bcs2.bcs.u64(),
-  has_next_page: import_bcs2.bcs.bool(),
-  next_cursor: import_bcs2.bcs.option(import_bcs2.bcs.string())
+  total_count: import_bcs3.bcs.u64(),
+  has_next_page: import_bcs3.bcs.bool(),
+  next_cursor: import_bcs3.bcs.option(import_bcs3.bcs.string())
 };
-var BcsAddressType = new import_bcs2.BcsType({
+var BcsAddressType = new import_bcs3.BcsType({
   name: "address",
   read(reader) {
     const bytes = new Uint8Array(32);
@@ -749,118 +833,123 @@ var BcsAddressType = new import_bcs2.BcsType({
 });
 
 // src/types/oracle.ts
-var import_bcs3 = require("@mysten/bcs");
-var OracleConfigStruct = import_bcs3.bcs.struct("Config", {
-  admin: BcsAddressType,
-  price_threshold_ratio: import_bcs3.bcs.u64(),
-  default_price_expiry_seconds: import_bcs3.bcs.u64()
+var import_bcs4 = require("@mysten/bcs");
+var OracleConfigStruct = import_bcs4.bcs.struct("Config", {
+  price_threshold_ratio: import_bcs4.bcs.u64(),
+  default_price_expiry_seconds: import_bcs4.bcs.u64()
 });
-var AssetPairStruct = import_bcs3.bcs.struct("AssetPair", {
-  base_symbol: import_bcs3.bcs.string(),
-  quote_symbol: import_bcs3.bcs.string(),
-  base_precision: import_bcs3.bcs.u8(),
-  quote_precision: import_bcs3.bcs.u8()
+var AssetPairStruct = import_bcs4.bcs.struct("AssetPair", {
+  base_name: import_bcs4.bcs.string(),
+  quote_name: import_bcs4.bcs.string(),
+  base_precision: import_bcs4.bcs.u8(),
+  quote_precision: import_bcs4.bcs.u8()
 });
-var AssetPairsResponseStruct = import_bcs3.bcs.struct("AssetPairsResponse", {
-  asset_pairs: import_bcs3.bcs.vector(AssetPairStruct)
+var TypeNameStruct = import_bcs4.bcs.struct("TypeName", {
+  name: import_bcs4.bcs.string()
 });
-var AssetPairsResponsePaginatedStruct = import_bcs3.bcs.struct("AssetPairsResponsePaginated", {
-  asset_pairs: import_bcs3.bcs.vector(AssetPairStruct),
-  ...PaginationStruct
+var RawPairStruct = import_bcs4.bcs.struct("RawPair", {
+  base: TypeNameStruct,
+  quote: TypeNameStruct
 });
-var PriceDataStruct = import_bcs3.bcs.struct("PriceData", {
-  base_symbol: import_bcs3.bcs.string(),
-  quote_symbol: import_bcs3.bcs.string(),
-  price: import_bcs3.bcs.u128(),
-  expiry_time_ms: import_bcs3.bcs.u64(),
-  last_updated_ms: import_bcs3.bcs.u64(),
-  updater: BcsAddressType
+var AssetPairResponseStruct = import_bcs4.bcs.struct("AssetPairResponse", {
+  pair: RawPairStruct,
+  info: AssetPairStruct
 });
-var PriceResponseStruct = import_bcs3.bcs.struct("PriceResponse", {
-  pair_data: import_bcs3.bcs.option(PriceDataStruct)
+var AssetPairsResponseStruct = import_bcs4.bcs.vector(AssetPairResponseStruct);
+var RawPriceStruct = import_bcs4.bcs.struct("RawPrice", {
+  price: import_bcs4.bcs.u128(),
+  expiry: import_bcs4.bcs.u64()
 });
-var PricesResponsePaginatedStruct = import_bcs3.bcs.struct("PricesResponsePaginated", {
-  prices: import_bcs3.bcs.vector(PriceDataStruct),
-  ...PaginationStruct
+var PriceDataStruct = import_bcs4.bcs.struct("PriceData", {
+  price: RawPriceStruct,
+  last_updated_ms: import_bcs4.bcs.u64(),
+  updater: BcsAddressType
+});
+var PriceResponseStruct = import_bcs4.bcs.struct("PriceResponse", {
+  pair_data: import_bcs4.bcs.option(PriceDataStruct),
+  is_inverted: import_bcs4.bcs.bool()
 });
 
 // src/types/router.ts
-var import_bcs5 = require("@mysten/bcs");
-var RouterConfigStruct = import_bcs5.bcs.struct("Config", {
+var import_bcs6 = require("@mysten/bcs");
+var RouterConfigStruct = import_bcs6.bcs.struct("Config", {
   admin: BcsAddressType,
   default_price_oracle_contract: BcsAddressType,
   default_protocol_fee_recipient: BcsAddressType,
-  default_protocol_fee: import_bcs5.bcs.u64(),
-  default_lp_fee: import_bcs5.bcs.u64()
+  default_protocol_fee: import_bcs6.bcs.u64(),
+  default_lp_fee: import_bcs6.bcs.u64()
 });
-var MarketStruct = import_bcs5.bcs.struct("Market", {
-  base_asset_symbol: import_bcs5.bcs.string(),
-  quote_assets_symbols: import_bcs5.bcs.vector(import_bcs5.bcs.string()),
-  market_address: import_bcs5.bcs.string(),
-  is_permissioned: import_bcs5.bcs.bool(),
-  created_at_ms: import_bcs5.bcs.u64()
+var MarketStruct = import_bcs6.bcs.struct("Market", {
+  base_asset_symbol: import_bcs6.bcs.string(),
+  quote_assets_symbols: import_bcs6.bcs.vector(import_bcs6.bcs.string()),
+  market_address: import_bcs6.bcs.string(),
+  is_permissioned: import_bcs6.bcs.bool(),
+  created_at_ms: import_bcs6.bcs.u64()
 });
-var MarketResponseStruct = import_bcs5.bcs.struct("MarketResponse", {
-  market: import_bcs5.bcs.option(MarketStruct)
+var MarketResponseStruct = import_bcs6.bcs.struct("MarketResponse", {
+  market: import_bcs6.bcs.option(MarketStruct)
 });
-var MarketsResponseStruct = import_bcs5.bcs.struct("MarketsResponse", {
-  markets: import_bcs5.bcs.vector(MarketStruct)
+var MarketsResponseStruct = import_bcs6.bcs.struct("MarketsResponse", {
+  markets: import_bcs6.bcs.vector(MarketStruct)
 });
-var MarketsResponsePaginatedStruct = import_bcs5.bcs.struct("MarketsResponsePaginated", {
-  markets: import_bcs5.bcs.vector(MarketStruct),
+var MarketsResponsePaginatedStruct = import_bcs6.bcs.struct("MarketsResponsePaginated", {
+  markets: import_bcs6.bcs.vector(MarketStruct),
   ...PaginationStruct
 });
-var BaseLiquidityInfoStruct = import_bcs5.bcs.struct("BaseLiquidityInfo", {
-  denom: import_bcs5.bcs.string(),
-  amount: import_bcs5.bcs.u64()
+var BaseLiquidityInfoStruct = import_bcs6.bcs.struct("BaseLiquidityInfo", {
+  denom: import_bcs6.bcs.string(),
+  amount: import_bcs6.bcs.u64()
 });
-var BaseLiquidityResponseStruct = import_bcs5.bcs.struct("BaseLiquidityResponse", {
-  base_assets: import_bcs5.bcs.vector(BaseLiquidityInfoStruct),
+var BaseLiquidityResponseStruct = import_bcs6.bcs.struct("BaseLiquidityResponse", {
+  base_assets: import_bcs6.bcs.vector(BaseLiquidityInfoStruct),
   ...PaginationStruct
 });
 
 // src/types/pool.ts
-var import_bcs7 = require("@mysten/bcs");
-var GetPoolInfoResponseStruct = [
-  import_bcs7.bcs.u64(),
-  import_bcs7.bcs.u128(),
-  BcsAddressType,
-  import_bcs7.bcs.bool()
-];
-var GetFeesResponseStruct = [import_bcs7.bcs.u64(), import_bcs7.bcs.u64(), import_bcs7.bcs.u64()];
+var import_bcs8 = require("@mysten/bcs");
+var PoolInfoStruct = import_bcs8.bcs.struct("PoolInfo", {
+  base_liquidity: import_bcs8.bcs.u64(),
+  total_lp_shares: import_bcs8.bcs.u64(),
+  admin: BcsAddressType,
+  is_paused: import_bcs8.bcs.bool()
+});
+var PoolFeesInfoStruct = import_bcs8.bcs.struct("PoolFeesInfo", {
+  swap_fee_pct: import_bcs8.bcs.u64(),
+  lp_withdrawal_fee_pct: import_bcs8.bcs.u64(),
+  lp_fee_pct: import_bcs8.bcs.u64()
+});
+var ProtocolFeesInfoStruct = import_bcs8.bcs.struct("ProtocolFeesInfo", {
+  bolt_fee_addr: BcsAddressType,
+  swap_fee_pct: import_bcs8.bcs.u64(),
+  lp_withdrawal_fee_pct: import_bcs8.bcs.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,
-        import_bcs9.bcs.option(import_bcs9.bcs.u64()).serialize(DEFAULT_PAGINATION_LIMIT),
-        import_bcs9.bcs.option(import_bcs9.bcs.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
+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
@@ -868,7 +957,7 @@ var getAssets = async (client) => {
       symbol: item.name,
       name: item.name,
       chainId: client.chainConfig.id,
-      denom: item.symbol,
+      denom: (0, import_utils6.normalizeStructTag)(item.symbol),
       decimals: item.precision,
       logo: void 0,
       coingeckoId: void 0
@@ -889,316 +978,233 @@ var getOracleConfig = async (client) => {
 };
 
 // src/lib/oracle/get-price.ts
-var import_bcs10 = require("@mysten/bcs");
-var import_utils5 = require("@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,
-      import_bcs10.bcs.string().serialize(baseDenom),
-      import_bcs10.bcs.string().serialize(quoteDenom),
-      import_utils5.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
-var import_bcs11 = require("@mysten/bcs");
+var import_core6 = require("@bolt-liquidity-hq/core");
+var import_utils7 = require("@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,
-        import_bcs11.bcs.option(import_bcs11.bcs.u64()).serialize(DEFAULT_PAGINATION_LIMIT),
-        import_bcs11.bcs.option(import_bcs11.bcs.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 import_core6.NotFoundError("Oracle object");
+  }
+  const pricesTableId = oracleObject.data.content.fields?.prices?.fields?.id?.id;
+  if (!pricesTableId) {
+    throw new import_core6.NotFoundError("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: (0, import_utils7.normalizeStructTag)(pairKey.base.name),
+            quoteDenom: (0, import_utils7.normalizeStructTag)(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
-var import_core6 = require("@bolt-liquidity-hq/core");
-var import_bcs12 = require("@mysten/bcs");
-var import_transactions3 = require("@mysten/sui/transactions");
-var import_utils6 = require("@mysten/sui/utils");
-var estimateSwapExactInGasFees = async (client, { assetIn, amountIn, assetOut, minimumAmountOut, receiver }, signer, gasAdjustment = import_core6.DEFAULT_GAS_ADJUSTMENT) => {
-  const SWAP_EXACT_IN_FUNCTION = "swap_exact_in";
-  const finalSigner = client.getSigner(signer);
-  const tx = new import_transactions3.Transaction();
-  const coinManager = new CoinManager(client.suiClient, finalSigner.toSuiAddress());
-  const coinInput = await coinManager.prepareCoinInput(tx, assetIn, amountIn);
+var import_core7 = require("@bolt-liquidity-hq/core");
+var estimateSwapExactInGasFees = async (client, swapParams, signer, gasAdjustment = import_core7.DEFAULT_GAS_ADJUSTMENT) => {
+  const swapArgs = await buildSwapTxArgs(client, swapParams, signer);
   return await estimateTxGasPrice(
     client.suiClient,
-    [client.packageId, ROUTER_MODULE, SWAP_EXACT_IN_FUNCTION],
-    [
-      client.contracts.router,
-      import_bcs12.bcs.string().serialize(assetOut),
-      "",
-      // TODO: pass correct pool when router can actually route to the pools depending on other arguments
-      import_bcs12.bcs.string().serialize(assetIn),
-      import_bcs12.bcs.option(import_bcs12.bcs.string()).serialize(minimumAmountOut),
-      import_bcs12.bcs.option(import_bcs12.bcs.string()).serialize(receiver),
-      coinInput,
-      import_utils6.SUI_CLOCK_OBJECT_ID
-    ],
-    [assetIn, assetOut],
-    tx,
+    swapArgs.signerAddress,
+    swapArgs.target,
+    swapArgs.args,
+    swapArgs.typeArguments,
+    swapArgs.tx,
     gasAdjustment
   );
 };
 
 // src/lib/router/get-all-base-liquidity.ts
-var import_bcs13 = require("@mysten/bcs");
-
-// src/lib/router/parsers.ts
-var import_core7 = require("@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 import_core7.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
-  };
+var import_core8 = require("@bolt-liquidity-hq/core");
+var getAllBaseLiquidity = async (_client) => {
+  throw new import_core8.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
+var import_core9 = require("@bolt-liquidity-hq/core");
+var getAllQuotesForUser = async (_client, _lpAddress) => {
+  throw new import_core9.NotImplementedError("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,
-        import_bcs13.bcs.option(import_bcs13.bcs.u64()).serialize(DEFAULT_PAGINATION_LIMIT),
-        import_bcs13.bcs.option(import_bcs13.bcs.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
+var import_core10 = require("@bolt-liquidity-hq/core");
+var getPoolByDenom = async (client, 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 ${quoteDenom} for ${baseDenom}`);
   }
   return result;
 };
 
-// src/lib/router/get-all-quotes-for-user.ts
-var import_bcs14 = require("@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, import_bcs14.bcs.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
-var import_bcs15 = require("@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, import_bcs15.bcs.string().serialize(baseDenom)]
-  );
-  const output = parseDevInspectResult(response, MarketResponseStruct);
-  return parseMarketResponseStructOutput(output);
+// src/lib/router/get-router-config.ts
+var import_core11 = require("@bolt-liquidity-hq/core");
+var getRouterConfig = async (_client) => {
+  throw new import_core11.NotImplementedError("getRouterConfig on Sui Client");
 };
 
-// src/lib/router/get-pools.ts
-var import_bcs16 = require("@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,
-        import_bcs16.bcs.option(import_bcs16.bcs.u64()).serialize(DEFAULT_PAGINATION_LIMIT),
-        import_bcs16.bcs.option(import_bcs16.bcs.string()).serialize(currentCursor)
-      ]
+// src/lib/router/router-client/RouterClient.ts
+var import_utils8 = require("@mysten/sui/utils");
+var RouterClient = class {
+  constructor(pools) {
+    this.pools = pools;
+  }
+  getPool(denomIn, denomOut) {
+    const normalizedDenomIn = (0, import_utils8.normalizeStructTag)(denomIn);
+    const normalizedDenomOut = (0, import_utils8.normalizeStructTag)(denomOut);
+    const directPairPool = this.pools.find(
+      (item) => item.baseDenom === normalizedDenomOut && item.quoteDenoms.includes(normalizedDenomIn)
+    );
+    if (directPairPool) {
+      return directPairPool;
+    }
+    const inversePairPool = this.pools.find(
+      (item) => item.baseDenom === normalizedDenomIn && item.quoteDenoms.includes(normalizedDenomOut)
     );
-    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
-var import_bcs17 = require("@mysten/bcs");
-var import_transactions4 = require("@mysten/sui/transactions");
-var import_utils7 = require("@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 import_transactions4.Transaction();
-  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,
-      import_bcs17.bcs.string().serialize(assetOut),
-      "",
-      // TODO: pass correct pool when router can actually route to the pools depending on other arguments
-      import_bcs17.bcs.string().serialize(assetIn),
-      import_bcs17.bcs.option(import_bcs17.bcs.string()).serialize(minimumAmountOut),
-      import_bcs17.bcs.option(import_bcs17.bcs.string()).serialize(receiver),
-      coinInput,
-      import_utils7.SUI_CLOCK_OBJECT_ID
-    ],
-    [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
   };
 };
 
 // src/lib/settlement/get-pool-info.ts
-var import_utils8 = require("@mysten/sui/utils");
+var import_core12 = require("@bolt-liquidity-hq/core");
 
 // src/lib/settlement/parsers.ts
-var parseSettlementConfigStructOutput = (globalConfig, feesOutput) => {
+var import_bignumber3 = require("bignumber.js");
+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: (0, import_bignumber3.BigNumber)(poolFeesInfo.swap_fee_pct).div(100).toFixed(),
+    lpFee: (0, import_bignumber3.BigNumber)(poolFeesInfo.lp_fee_pct).div(100).toFixed(),
     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 pool = client.routerClient.pools.find((item) => item.poolAddress === contractAddress);
+  if (!pool) {
+    throw new import_core12.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],
+      [pool.baseDenom]
+    ),
+    // 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
-      [import_utils8.SUI_TYPE_ARG]
+      [pool.baseDenom]
     )
   ]);
-  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
-var BoltSuiClient = class extends import_core8.BaseClient {
+var BoltSuiClient = class extends import_core13.BaseClient {
   /**
    * Creates a new instance of the BoltSuiClient.
    *
    * 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'
@@ -1224,7 +1230,7 @@ var BoltSuiClient = class extends import_core8.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'
    * });
@@ -1267,12 +1273,14 @@ var BoltSuiClient = class extends import_core8.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,
@@ -1310,18 +1318,30 @@ var BoltSuiClient = class extends import_core8.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 import_client.SuiClient({ url: chainConfig.rpcEndpoint });
+    this.routerClient = new RouterClient(pools);
+    this.configFileUrl = isEnvironmentMainnet ? void 0 : TestnetConfigUrl;
   }
   /**
    * Gets or sets the signer for transaction execution.
@@ -1349,7 +1369,7 @@ var BoltSuiClient = class extends import_core8.BaseClient {
   getSigner(newSigner) {
     this.signer = newSigner ?? this.signer;
     if (!this.signer) {
-      throw new import_core8.MissingParameterError("signer");
+      throw new import_core13.MissingParameterError("signer");
     }
     return this.signer;
   }
@@ -1357,51 +1377,81 @@ var BoltSuiClient = class extends import_core8.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
@@ -1432,6 +1482,7 @@ var BoltSuiClient = class extends import_core8.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);
   }
   /**
@@ -1463,7 +1514,66 @@ var BoltSuiClient = class extends import_core8.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 import_axios.default.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: (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))
+        });
+      }
+    }
+    this.configFileUrl = void 0;
+  }
 };
 //# sourceMappingURL=index.cjs.map