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

package/dist/index.cjs

@@ -25,6 +25,7 @@ __export(index_exports, {
   AssetPairStruct: () => AssetPairStruct,
   AssetPairsResponsePaginatedStruct: () => AssetPairsResponsePaginatedStruct,
   AssetPairsResponseStruct: () => AssetPairsResponseStruct,
+  BaseLiquidityInfoStruct: () => BaseLiquidityInfoStruct,
   BaseLiquidityResponseStruct: () => BaseLiquidityResponseStruct,
   BcsAddressType: () => BcsAddressType,
   BoltSuiClient: () => BoltSuiClient,
@@ -44,10 +45,11 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/lib/client.ts
-var import_core5 = require("@bolt-liquidity-hq/core");
+var import_core8 = require("@bolt-liquidity-hq/core");
 var import_client = require("@mysten/sui/client");
 
 // src/config/mainnet.ts
+var import_utils = require("@mysten/sui/utils");
 var MainnetChainConfig = {
   name: "Sui",
   id: "101",
@@ -58,13 +60,15 @@ var MainnetContracts = {
   router: "0x..."
 };
 var MainnetPackageId = "0x...";
+var MainnetPoolGlobalConfigId = "0x...";
+var MainnetNativeTokenDenom = import_utils.SUI_TYPE_ARG;
 var MainnetAssets = {
-  "0x2::sui::SUI": {
+  [import_utils.SUI_TYPE_ARG]: {
     symbol: "SUI",
     name: "Sui",
     chainId: "101",
-    denom: "0x2::sui::SUI",
-    decimals: 9,
+    denom: import_utils.SUI_TYPE_ARG,
+    decimals: import_utils.SUI_DECIMALS,
     logo: "https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/sui/info/logo.png",
     coingeckoId: "sui"
   },
@@ -80,6 +84,7 @@ var MainnetAssets = {
 };
 
 // src/config/testnet.ts
+var import_utils2 = require("@mysten/sui/utils");
 var TestnetChainConfig = {
   name: "Sui Testnet",
   id: "103",
@@ -90,13 +95,15 @@ var TestnetContracts = {
   router: "0x3881fdcb4a7fbcda8edc230e6f92eb57b24c0be6b44af0b5e1d0b45564f3ed00"
 };
 var TestnetPackageId = "0x22384b1841229e2be878bb7e88833c03e23ff5dc39accd050fb932120602f85e";
+var TestnetPoolGlobalConfigId = "0xa9491e59fa63e666cbfdea2e880b2d8ba0085eeb244220cefa3fb817559cd79c";
+var TestnetNativeTokenDenom = import_utils2.SUI_TYPE_ARG;
 var TestnetAssets = {
-  "0x2::sui::SUI": {
+  [import_utils2.SUI_TYPE_ARG]: {
     symbol: "SUI",
     name: "Sui",
     chainId: "103",
-    denom: "0x2::sui::SUI",
-    decimals: 9,
+    denom: import_utils2.SUI_TYPE_ARG,
+    decimals: import_utils2.SUI_DECIMALS,
     logo: "https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/sui/info/logo.png",
     coingeckoId: "sui"
   },
@@ -159,8 +166,407 @@ var parseMultipleResults = (info, schema) => {
   return schema.map((bcsType, index) => parseDevInspectResult(info, bcsType, 0, index));
 };
 
-// src/lib/helpers/queries.ts
+// src/lib/helpers/coin-manager.ts
 var import_core2 = require("@bolt-liquidity-hq/core");
+var import_utils3 = require("@mysten/sui/utils");
+var CoinManager = class {
+  /**
+   * Creates a new CoinManager instance.
+   *
+   * @param client - The SuiClient instance for blockchain interactions
+   * @param defaultOwner - Optional default owner address for coin operations.
+   *                       If not provided, owner must be specified in each method call.
+   *
+   * @example
+   * ```typescript
+   * // With default owner
+   * const coinManager = new CoinManager(suiClient, "0x123...");
+   *
+   * // Without default owner (must specify in each call)
+   * const coinManager = new CoinManager(suiClient);
+   * ```
+   */
+  constructor(client, defaultOwner) {
+    this.client = client;
+    this.defaultOwner = defaultOwner;
+  }
+  /**
+   * Fetches all coins of a specific type owned by an address.
+   *
+   * This method handles pagination automatically to retrieve all coins,
+   * regardless of how many exist. Coins are returned in the order
+   * provided by the blockchain.
+   *
+   * @param coinType - The fully qualified type of the coin (e.g., "0x2::sui::SUI")
+   * @param owner - Optional owner address. Uses defaultOwner if not provided.
+   *
+   * @returns A promise that resolves to an array of all coins of the specified type
+   *
+   * @throws {MissingParameterError} When owner is not provided and no defaultOwner is set
+   *
+   * @example
+   * ```typescript
+   * // Get all SUI coins
+   * const suiCoins = await coinManager.getAllCoins("0x2::sui::SUI");
+   * console.log(`Found ${suiCoins.length} SUI coins`);
+   *
+   * // Get all USDC coins for a specific owner
+   * const usdcCoins = await coinManager.getAllCoins(
+   *   "0x5d4b...::coin::COIN",
+   *   "0xowner..."
+   * );
+   *
+   * // Display coin details
+   * suiCoins.forEach(coin => {
+   *   console.log(`Coin ID: ${coin.coinObjectId}`);
+   *   console.log(`Balance: ${coin.balance}`);
+   * });
+   * ```
+   */
+  async getAllCoins(coinType, owner) {
+    const ownerAddress = this.getOwnerAddress(owner);
+    const allCoins = [];
+    let cursor;
+    do {
+      const response = await this.client.getCoins({
+        owner: ownerAddress,
+        coinType,
+        cursor
+      });
+      allCoins.push(...response.data);
+      cursor = response.hasNextPage ? response.nextCursor : void 0;
+    } while (cursor);
+    return allCoins;
+  }
+  /**
+   * Resolves the owner address from the provided parameter or default.
+   *
+   * This is a helper method used internally to ensure an owner address
+   * is always available for coin operations.
+   *
+   * @param owner - Optional owner address to use
+   *
+   * @returns The resolved owner address
+   *
+   * @throws {MissingParameterError} When owner is not provided and no defaultOwner is set
+   *
+   * @example
+   * ```typescript
+   * // With default owner set
+   * const address = coinManager.getOwnerAddress(); // Returns defaultOwner
+   *
+   * // With explicit owner
+   * const address = coinManager.getOwnerAddress("0x123..."); // Returns "0x123..."
+   *
+   * // Without default owner or parameter
+   * const address = coinManager.getOwnerAddress(); // Throws MissingParameterError
+   * ```
+   */
+  getOwnerAddress(owner) {
+    const address = owner || this.defaultOwner;
+    if (!address) throw new import_core2.MissingParameterError("owner");
+    return address;
+  }
+  /**
+   * Gets the total balance of a specific coin type for an owner.
+   *
+   * This method returns the sum of all coins of the specified type,
+   * providing a quick way to check if sufficient funds are available
+   * without fetching all coin objects.
+   *
+   * @param coinType - The fully qualified type of the coin (e.g., "0x2::sui::SUI")
+   * @param owner - Optional owner address. Uses defaultOwner if not provided.
+   *
+   * @returns A promise that resolves to the total balance as a string
+   *
+   * @throws {MissingParameterError} When owner is not provided and no defaultOwner is set
+   *
+   * @example
+   * ```typescript
+   * // Get SUI balance
+   * const suiBalance = await coinManager.getTotalBalance("0x2::sui::SUI");
+   * console.log(`Total SUI: ${suiBalance}`);
+   *
+   * // Get USDC balance for specific owner
+   * const usdcBalance = await coinManager.getTotalBalance(
+   *   "0x5d4b...::coin::COIN",
+   *   "0xowner..."
+   * );
+   *
+   * // Convert to decimal for display (assuming 9 decimals for SUI)
+   * const suiDecimal = Number(suiBalance) / 1e9;
+   * console.log(`${suiDecimal} SUI`);
+   * ```
+   */
+  async getTotalBalance(coinType, owner) {
+    const ownerAddress = this.getOwnerAddress(owner);
+    const balance = await this.client.getBalance({
+      owner: ownerAddress,
+      coinType
+    });
+    return balance.totalBalance;
+  }
+  /**
+   * Asserts that the owner has sufficient balance for a transaction.
+   *
+   * This is a convenience method that checks the balance and throws
+   * a descriptive error if insufficient. Useful for fail-fast validation
+   * before attempting complex transaction preparation.
+   *
+   * @param coinType - The fully qualified type of the coin (e.g., "0x2::sui::SUI")
+   * @param amount - The required amount as a string
+   * @param owner - Optional owner address. Uses defaultOwner if not provided.
+   *
+   * @throws {MissingParameterError} When owner is not provided and no defaultOwner is set
+   * @throws {InsufficientFundsError} When the balance is less than the required amount
+   *
+   * @example
+   * ```typescript
+   * try {
+   *   // Check if user has 1 SUI
+   *   await coinManager.assertEnoughBalance(
+   *     "0x2::sui::SUI",
+   *     "1000000000" // 1 SUI
+   *   );
+   *
+   *   // Proceed with transaction
+   *   console.log("Sufficient balance confirmed");
+   * } catch (error) {
+   *   if (error instanceof InsufficientFundsError) {
+   *     console.error(`Need ${error.data.amount}, but only have ${error.data.available}`);
+   *   }
+   * }
+   * ```
+   */
+  async assertEnoughBalance(coinType, amount, owner) {
+    const ownerAddress = this.getOwnerAddress(owner);
+    const totalBalance = await this.getTotalBalance(coinType, owner);
+    if (BigInt(totalBalance) < BigInt(amount)) {
+      throw new import_core2.InsufficientFundsError(amount, totalBalance, { coinType, amount, ownerAddress });
+    }
+  }
+  /**
+   * Selects optimal coins to cover a specific amount.
+   *
+   * This method implements intelligent coin selection algorithms that consider
+   * various factors like minimizing inputs, preserving large coins, and
+   * avoiding fragmentation. It determines whether merging or splitting is needed.
+   *
+   * @param coinType - The fully qualified type of the coin (e.g., "0x2::sui::SUI")
+   * @param amount - The target amount to select for, as a string
+   * @param options - Configuration options for the selection algorithm
+   * @param owner - Optional owner address. Uses defaultOwner if not provided.
+   *
+   * @returns A promise that resolves to a CoinSelectionResult with selected coins and metadata
+   *
+   * @throws {MissingParameterError} When owner is not provided and no defaultOwner is set
+   * @throws {InsufficientFundsError} When available coins cannot cover the amount (unless allowPartial is true)
+   *
+   * @example
+   * ```typescript
+   * // Basic selection
+   * const selection = await coinManager.selectCoins(
+   *   "0x2::sui::SUI",
+   *   "1000000000" // 1 SUI
+   * );
+   *
+   * if (selection.requiresMerge) {
+   *   console.log(`Need to merge ${selection.coins.length} coins`);
+   * }
+   * if (selection.requiresSplit) {
+   *   console.log(`Need to split coin for exact amount`);
+   * }
+   *
+   * // Minimize number of inputs
+   * const minimalSelection = await coinManager.selectCoins(
+   *   "0x2::sui::SUI",
+   *   "5000000000",
+   *   { minimizeInputs: true }
+   * );
+   *
+   * // Exclude specific coins and allow partial
+   * const partialSelection = await coinManager.selectCoins(
+   *   "0x2::sui::SUI",
+   *   "10000000000",
+   *   {
+   *     excludeIds: ["0x123..."],
+   *     allowPartial: true
+   *   }
+   * );
+   * ```
+   *
+   * @remarks
+   * The selection algorithm follows these priorities:
+   * 1. Exact match - single coin with exact amount
+   * 2. Single coin that covers amount (requires split)
+   * 3. Multiple coins (requires merge, possibly split)
+   *
+   * When minimizeInputs is false, smaller coins are used first to preserve larger ones.
+   */
+  async selectCoins(coinType, amount, options = {}, owner) {
+    const ownerAddress = this.getOwnerAddress(owner);
+    const coins = await this.getAllCoins(coinType, owner);
+    const availableCoins = options.excludeIds ? coins.filter((c) => !options.excludeIds?.includes(c.coinObjectId)) : coins;
+    if (availableCoins.length === 0) {
+      throw new import_core2.InsufficientFundsError(amount, "0", {
+        availableCoins,
+        coinType,
+        ownerAddress
+      });
+    }
+    const targetAmount = BigInt(amount);
+    availableCoins.sort((a, b) => {
+      const diff = BigInt(b.balance) - BigInt(a.balance);
+      return diff > 0n ? 1 : diff < 0n ? -1 : 0;
+    });
+    const exactMatch = availableCoins.find((c) => BigInt(c.balance) === targetAmount);
+    if (exactMatch) {
+      return {
+        coins: [exactMatch],
+        totalBalance: amount,
+        requiresMerge: false,
+        requiresSplit: false
+      };
+    }
+    const singleCoin = availableCoins.find((c) => BigInt(c.balance) > targetAmount);
+    if (singleCoin && !options.preferMerge) {
+      return {
+        coins: [singleCoin],
+        totalBalance: singleCoin.balance,
+        requiresMerge: false,
+        requiresSplit: true
+      };
+    }
+    const selectedCoins = [];
+    let totalBalance = 0n;
+    if (options.minimizeInputs) {
+      for (const coin of availableCoins) {
+        selectedCoins.push(coin);
+        totalBalance += BigInt(coin.balance);
+        if (totalBalance >= targetAmount) break;
+      }
+    } else {
+      const sortedAsc = [...availableCoins].sort((a, b) => {
+        const diff = BigInt(a.balance) - BigInt(b.balance);
+        return diff > 0n ? 1 : diff < 0n ? -1 : 0;
+      });
+      for (const coin of sortedAsc) {
+        if (totalBalance >= targetAmount) break;
+        selectedCoins.push(coin);
+        totalBalance += BigInt(coin.balance);
+      }
+    }
+    if (totalBalance < targetAmount) {
+      if (options.allowPartial) {
+        return {
+          coins: selectedCoins,
+          totalBalance: totalBalance.toString(),
+          requiresMerge: selectedCoins.length > 1,
+          requiresSplit: false
+        };
+      }
+      throw new import_core2.InsufficientFundsError(amount, totalBalance.toString(), {
+        amount,
+        coinType,
+        totalBalance: totalBalance.toString(),
+        ownerAddress
+      });
+    }
+    return {
+      coins: selectedCoins,
+      totalBalance: totalBalance.toString(),
+      requiresMerge: selectedCoins.length > 1,
+      requiresSplit: totalBalance > targetAmount
+    };
+  }
+  /**
+   * Prepares a coin input for a transaction with automatic merging and splitting.
+   *
+   * This is the main method for transaction preparation. It handles all the complexity
+   * of coin selection, merging multiple coins if needed, and splitting for exact amounts.
+   * Special handling is provided for SUI gas coins.
+   *
+   * @param tx - The Transaction object to add coin operations to
+   * @param coinType - The fully qualified type of the coin (e.g., "0x2::sui::SUI")
+   * @param amount - The exact amount needed for the transaction, as a string
+   * @param options - Configuration options for coin selection
+   * @param owner - Optional owner address. Uses defaultOwner if not provided.
+   *
+   * @returns A promise that resolves to an Argument that can be used in Move calls
+   *
+   * @throws {MissingParameterError} When owner is not provided and no defaultOwner is set
+   * @throws {InsufficientFundsError} When available coins cannot cover the amount
+   *
+   * @example
+   * ```typescript
+   * const tx = new Transaction();
+   *
+   * // Prepare exact SUI amount (uses gas coin)
+   * const suiCoin = await coinManager.prepareCoinInput(
+   *   tx,
+   *   "0x2::sui::SUI",
+   *   "1000000000" // 1 SUI
+   * );
+   *
+   * // Prepare custom coin with options
+   * const customCoin = await coinManager.prepareCoinInput(
+   *   tx,
+   *   "0x5d4b...::coin::COIN",
+   *   "1000000", // 1 USDC
+   *   {
+   *     minimizeInputs: true,
+   *     excludeIds: ["0x123..."]
+   *   }
+   * );
+   *
+   * // Use in a Move call
+   * tx.moveCall({
+   *   target: `${packageId}::module::swap`,
+   *   arguments: [suiCoin, customCoin],
+   * });
+   * ```
+   *
+   * @remarks
+   * - SUI coins are handled specially by splitting from the gas coin
+   * - Single coins matching the exact amount are used directly
+   * - Multiple coins are automatically merged
+   * - Coins with excess balance are automatically split
+   * - The resulting Argument can be used directly in Move calls
+   */
+  async prepareCoinInput(tx, coinType, amount, options = {}, owner) {
+    const ownerAddress = this.getOwnerAddress(owner);
+    if (coinType === import_utils3.SUI_TYPE_ARG) {
+      const [coin] = tx.splitCoins(tx.gas, [amount]);
+      return coin;
+    }
+    const selection = await this.selectCoins(coinType, amount, options, owner);
+    if (!selection.coins[0]) {
+      throw new import_core2.InsufficientFundsError(amount, "0", {
+        coinType,
+        amount,
+        ownerAddress
+      });
+    }
+    if (selection.coins.length === 1 && !selection.requiresSplit) {
+      return tx.object(selection.coins[0].coinObjectId);
+    }
+    if (selection.coins.length === 1 && selection.requiresSplit) {
+      const [split] = tx.splitCoins(tx.object(selection.coins[0].coinObjectId), [amount]);
+      return split;
+    }
+    const primaryCoin = tx.object(selection.coins[0].coinObjectId);
+    const mergeCoins = selection.coins.slice(1).map((c) => tx.object(c.coinObjectId));
+    tx.mergeCoins(primaryCoin, mergeCoins);
+    if (selection.requiresSplit) {
+      const [split] = tx.splitCoins(primaryCoin, [amount]);
+      return split;
+    }
+    return primaryCoin;
+  }
+};
+
+// src/lib/helpers/queries.ts
+var import_core3 = require("@bolt-liquidity-hq/core");
 var import_transactions = require("@mysten/sui/transactions");
 var queryDevInspect = async (suiClient, target, args, typeArguments, senderAddress) => {
   const tx = new import_transactions.Transaction();
@@ -181,10 +587,10 @@ var queryDevInspect = async (suiClient, target, args, typeArguments, senderAddre
     if (result.effects.status.status === "success") {
       return result;
     } else {
-      throw new import_core2.TransactionFailedError("N/A", "Failed to query smart contract", { result });
+      throw new import_core3.TransactionFailedError("N/A", "Failed to query smart contract", { result });
     }
   } catch (error) {
-    throw import_core2.UnexpectedError.from(error, "Failed to query smart contract", {
+    throw import_core3.UnexpectedError.from(error, "Failed to query smart contract", {
       target: targetString,
       args,
       typeArguments
@@ -192,9 +598,84 @@ var queryDevInspect = async (suiClient, target, args, typeArguments, senderAddre
   }
 };
 
-// src/lib/oracle/parsers.ts
-var import_core3 = require("@bolt-liquidity-hq/core");
+// src/lib/helpers/txs.ts
+var import_core4 = require("@bolt-liquidity-hq/core");
+var import_transactions2 = require("@mysten/sui/transactions");
+var import_utils4 = require("@mysten/sui/utils");
 var import_bignumber = require("bignumber.js");
+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;
+  const txArgs = args?.map(
+    (item) => typeof item === "string" ? tx.object(item) : "toBytes" in item ? tx.pure(item.toBytes()) : item
+  );
+  tx.moveCall({
+    target: targetString,
+    arguments: txArgs,
+    typeArguments
+  });
+  try {
+    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 });
+    }
+  } catch (error) {
+    throw import_core4.UnexpectedError.from(error, "Failed to execute transaction", {
+      target: targetString,
+      args,
+      typeArguments
+    });
+  }
+};
+var estimateTxGasPrice = async (suiClient, 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(
+    (item) => typeof item === "string" ? tx.object(item) : "toBytes" in item ? tx.pure(item.toBytes()) : item
+  );
+  tx.moveCall({
+    target: targetString,
+    arguments: txArgs,
+    typeArguments
+  });
+  try {
+    const transactionBytes = await tx.build({ client: suiClient });
+    const dryRunResult = await suiClient.dryRunTransactionBlock({
+      transactionBlock: transactionBytes
+    });
+    if (dryRunResult.effects.status.status !== "success") {
+      throw new import_core4.UnexpectedError(
+        `Dry run failed: ${dryRunResult.effects.status.error}`,
+        "Failed to estimate gas",
+        {
+          target: targetString,
+          args,
+          typeArguments,
+          error: dryRunResult.effects.status.error
+        }
+      );
+    }
+    const gasUsed = dryRunResult.effects.gasUsed;
+    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,
+      amount: adjustedGasCost.toFixed(0, import_bignumber.BigNumber.ROUND_CEIL)
+    };
+  } catch {
+    return;
+  }
+};
+
+// 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,
@@ -219,25 +700,26 @@ var parseAssetPairStructOutput = (output) => {
     }
   };
 };
-var parsePriceDataStructOutput = (response, baseDenom, quoteDenom) => {
+var parsePriceDataStructOutput = (output) => {
   return {
-    assetPair: `${baseDenom}:${quoteDenom}`,
-    price: response.price,
-    expiryTime: (0, import_bignumber.BigNumber)(response.expiry_time_ms).times(1e6).toFixed(),
+    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
   };
 };
-var parsePriceResponseStructOutput = (response, baseDenom, quoteDenom) => {
-  if (!response.pair_data) {
-    throw new import_core3.InvalidObjectError("Can't find pair data price");
+var parsePriceResponseStructOutput = (output) => {
+  if (!output.pair_data) {
+    throw new import_core5.InvalidObjectError("Can't find pair data price");
   }
-  return parsePriceDataStructOutput(response.pair_data, baseDenom, quoteDenom);
+  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 output.prices.map((item) => parsePriceDataStructOutput(item));
 };
 
 // src/types/bcs.ts
@@ -287,6 +769,8 @@ var AssetPairsResponsePaginatedStruct = import_bcs3.bcs.struct("AssetPairsRespon
   ...PaginationStruct
 });
 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(),
@@ -326,8 +810,12 @@ var MarketsResponsePaginatedStruct = import_bcs5.bcs.struct("MarketsResponsePagi
   markets: import_bcs5.bcs.vector(MarketStruct),
   ...PaginationStruct
 });
+var BaseLiquidityInfoStruct = import_bcs5.bcs.struct("BaseLiquidityInfo", {
+  denom: import_bcs5.bcs.string(),
+  amount: import_bcs5.bcs.u64()
+});
 var BaseLiquidityResponseStruct = import_bcs5.bcs.struct("BaseLiquidityResponse", {
-  base_assets: import_bcs5.bcs.vector(import_bcs5.bcs.string()),
+  base_assets: import_bcs5.bcs.vector(BaseLiquidityInfoStruct),
   ...PaginationStruct
 });
 
@@ -402,7 +890,7 @@ var getOracleConfig = async (client) => {
 
 // src/lib/oracle/get-price.ts
 var import_bcs10 = require("@mysten/bcs");
-var import_utils = require("@mysten/sui/utils");
+var import_utils5 = require("@mysten/sui/utils");
 var getPrice = async (client, baseDenom, quoteDenom) => {
   const GET_PRICE_FUNCTION = "get_price";
   const response = await queryDevInspect(
@@ -412,11 +900,11 @@ var getPrice = async (client, baseDenom, quoteDenom) => {
       client.contracts.oracle,
       import_bcs10.bcs.string().serialize(baseDenom),
       import_bcs10.bcs.string().serialize(quoteDenom),
-      import_utils.SUI_CLOCK_OBJECT_ID
+      import_utils5.SUI_CLOCK_OBJECT_ID
     ]
   );
   const output = parseDevInspectResult(response, PriceResponseStruct);
-  return parsePriceResponseStructOutput(output, baseDenom, quoteDenom);
+  return parsePriceResponseStructOutput(output);
 };
 
 // src/lib/oracle/get-prices.ts
@@ -445,11 +933,42 @@ var getPrices = async (client) => {
   return result;
 };
 
-// src/lib/router/get-all-base-liquidity.ts
+// 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);
+  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,
+    gasAdjustment
+  );
+};
+
+// src/lib/router/get-all-base-liquidity.ts
+var import_bcs13 = require("@mysten/bcs");
 
 // src/lib/router/parsers.ts
-var import_core4 = require("@bolt-liquidity-hq/core");
+var import_core7 = require("@bolt-liquidity-hq/core");
 var parseMarketStructOutput = (output) => {
   return {
     poolAddress: output.market_address,
@@ -457,14 +976,14 @@ var parseMarketStructOutput = (output) => {
     quoteDenoms: output.quote_assets_symbols
   };
 };
-var parseMarketResponseStructOutput = (response) => {
-  if (!response.market) {
-    throw new import_core4.NotFoundError("Market", void 0, { response });
+var parseMarketResponseStructOutput = (output) => {
+  if (!output.market) {
+    throw new import_core7.NotFoundError("Market", void 0, { output });
   }
-  return parseMarketStructOutput(response.market);
+  return parseMarketStructOutput(output.market);
 };
-var parseMarketsResponsePaginatedStructOutput = (response) => {
-  return response.markets.map((item) => parseMarketStructOutput(item));
+var parseMarketsResponsePaginatedStructOutput = (output) => {
+  return output.markets.map((item) => parseMarketStructOutput(item));
 };
 var parseRouterConfigStructOutput = (output) => {
   return {
@@ -478,10 +997,11 @@ var parseRouterConfigStructOutput = (output) => {
 var parseBaseLiquidityResponseStructOutput = (output) => {
   return output.base_assets.map((item) => ({
     baseLiquidity: {
-      denom: item,
-      amount: "10"
+      denom: item.denom,
+      amount: item.amount
     },
-    totalShares: "10"
+    totalShares: ""
+    // TODO: add real total shares if it is returned by the smart contract later
   }));
 };
 
@@ -497,8 +1017,8 @@ var getAllBaseLiquidity = async (client) => {
       [client.packageId, ROUTER_MODULE, BASE_LIQUIDITY_ALL_PAGINATED_FUNCTION],
       [
         client.contracts.router,
-        import_bcs12.bcs.option(import_bcs12.bcs.u64()).serialize(DEFAULT_PAGINATION_LIMIT),
-        import_bcs12.bcs.option(import_bcs12.bcs.string()).serialize(currentCursor)
+        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);
@@ -513,33 +1033,33 @@ var getAllBaseLiquidity = async (client) => {
 };
 
 // src/lib/router/get-all-quotes-for-user.ts
-var import_bcs13 = require("@mysten/bcs");
+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_bcs13.bcs.string().serialize(lpAddress)]
+    [client.contracts.router, import_bcs14.bcs.string().serialize(lpAddress)]
   );
   console.log(response);
   return {};
 };
 
 // src/lib/router/get-pool-for-base.ts
-var import_bcs14 = require("@mysten/bcs");
+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_bcs14.bcs.string().serialize(baseDenom)]
+    [client.contracts.router, import_bcs15.bcs.string().serialize(baseDenom)]
   );
   const output = parseDevInspectResult(response, MarketResponseStruct);
   return parseMarketResponseStructOutput(output);
 };
 
 // src/lib/router/get-pools.ts
-var import_bcs15 = require("@mysten/bcs");
+var import_bcs16 = require("@mysten/bcs");
 var getPools = async (client) => {
   const MARKETS_PAGINATED_FUNCTION = "markets_paginated";
   const result = [];
@@ -551,8 +1071,8 @@ var getPools = async (client) => {
       [client.packageId, ROUTER_MODULE, MARKETS_PAGINATED_FUNCTION],
       [
         client.contracts.router,
-        import_bcs15.bcs.option(import_bcs15.bcs.u64()).serialize(DEFAULT_PAGINATION_LIMIT),
-        import_bcs15.bcs.option(import_bcs15.bcs.string()).serialize(currentCursor)
+        import_bcs16.bcs.option(import_bcs16.bcs.u64()).serialize(DEFAULT_PAGINATION_LIMIT),
+        import_bcs16.bcs.option(import_bcs16.bcs.string()).serialize(currentCursor)
       ]
     );
     const output = parseDevInspectResult(response, MarketsResponsePaginatedStruct);
@@ -577,60 +1097,89 @@ var getRouterConfig = async (client) => {
 };
 
 // src/lib/router/swap-exact-in.ts
-var swapExactIn = async (client, signer, { assetIn, amountIn, assetOut, minimumAmountOut, receiver }) => {
-  console.log(client, signer, assetIn, amountIn, assetOut, minimumAmountOut, receiver);
-  await new Promise((resolve) => setTimeout(resolve, 1e3));
-  return {};
+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);
+  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,
+    { showEffects: true, showEvents: true, showBalanceChanges: true }
+  );
+  return {
+    txOutput,
+    txHash: txOutput.digest,
+    amountOut: "",
+    // TODO: implement when contract emits event
+    assetOut
+  };
 };
 
 // src/lib/settlement/get-pool-info.ts
-var import_utils2 = require("@mysten/sui/utils");
+var import_utils8 = require("@mysten/sui/utils");
 
 // src/lib/settlement/parsers.ts
-var parseSettlementConfigStructOutput = (_poolInfoOutput, feesOutput) => {
+var parseSettlementConfigStructOutput = (globalConfig, feesOutput) => {
   return {
     priceOracleContract: "0x",
-    // Should come from poolInfoOutput
-    protocolFeeRecipient: "0x",
-    // Should be feesOutput[1]
+    // 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
     allowanceMode: "allow",
-    // Should come from poolInfoOutput
+    // Should come from pool config
     lps: ["0x"],
-    // Should come from poolInfoOutput
+    // Should come from  pool config
     minBaseOut: "1"
-    // Should come from poolInfoOutput
+    // Should come from  pool config
   };
 };
 
 // src/lib/settlement/get-pool-info.ts
 var getPoolInfo = async (client, contractAddress) => {
-  const GET_POOL_INFO = "get_pool_info";
   const GET_FEES_FUNCTION = "get_fees";
-  const [info, fees] = await Promise.all([
-    // Query pool information (LP configuration, allowance mode)
-    queryDevInspect(
-      client.suiClient,
-      [client.packageId, POOL_MODULE, GET_POOL_INFO],
-      [contractAddress],
-      // TODO: get the base token of the pool to pass it here instead of hardcoded SUI token
-      [import_utils2.SUI_TYPE_ARG]
-    ),
-    // Query fee structure (protocol fee, LP fee, recipients)
+  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
     queryDevInspect(
       client.suiClient,
       [client.packageId, POOL_MODULE, GET_FEES_FUNCTION],
       [contractAddress],
       // TODO: get the base token of the pool to pass it here instead of hardcoded SUI token
-      [import_utils2.SUI_TYPE_ARG]
+      [import_utils8.SUI_TYPE_ARG]
     )
   ]);
-  const infoOutput = parseMultipleResults(info, GetPoolInfoResponseStruct);
   const feesOutput = parseMultipleResults(fees, GetFeesResponseStruct);
-  return parseSettlementConfigStructOutput(infoOutput, feesOutput);
+  return parseSettlementConfigStructOutput(globalConfig, feesOutput);
 };
 
 // src/tests/constants/sui-objects.ts
@@ -643,25 +1192,29 @@ var getPoolInfoForBase = async (client, baseDenom) => {
 };
 
 // src/lib/client.ts
-var BoltSuiClient = class extends import_core5.BaseClient {
+var BoltSuiClient = class extends import_core8.BaseClient {
   /**
    * Creates a new instance of the BoltSuiClient.
    *
-   * The client automatically configures itself based on the specified chain and environment,
-   * loading the appropriate contract addresses, chain configuration, and assets from configuration files.
+   * 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.
    *
    * @param config - (Optional) Configuration for the client
    * @param config.environment - (Optional) The deployment environment ('mainnet' or 'testnet'). Defaults to 'mainnet'
-   * @param config.customOverride - (Optional) Custom overrides for chain configuration, contracts, and assets
+   * @param config.customOverride - (Optional) Custom overrides for chain configuration, contracts, native token, and assets
    * @param config.customOverride.chainConfig - (Optional) Override chain configuration
    * @param config.customOverride.chainConfig.id - (Optional) Custom chain ID
    * @param config.customOverride.chainConfig.name - (Optional) Custom chain name
    * @param config.customOverride.chainConfig.rpcEndpoint - (Optional) Custom RPC endpoint URL
    * @param config.customOverride.packageId - (Optional) Custom package ID for Bolt contracts
+   * @param config.customOverride.poolGlobalConfigId - (Optional) Custom Object ID for the Pool contracts' Global Config
    * @param config.customOverride.contracts - (Optional) Override contract addresses
    * @param config.customOverride.contracts.oracle - (Optional) Custom oracle contract address
    * @param config.customOverride.contracts.router - (Optional) Custom router contract address
+   * @param config.customOverride.nativeTokenDenom - (Optional) Custom native token denomination (e.g., "SUI")
    * @param config.customOverride.assetsConfig - (Optional) Custom asset configurations indexed by denom
+   * @param config.signer - (Optional) Pre-existing Signer for transaction signing
    * @param config.suiClient - (Optional) Pre-existing SuiClient to use for blockchain queries
    *
    * @throws {InvalidObjectError} Thrown when required configuration fields are missing
@@ -685,10 +1238,12 @@ var BoltSuiClient = class extends import_core5.BaseClient {
    *       rpcEndpoint: 'https://custom-rpc.example.com'
    *     },
    *     packageId: '0xcustom_package_id...',
+   *     poolGlobalConfigId: '0xcustom_global_config_id...',
    *     contracts: {
    *       oracle: '0xcustom_oracle...',
    *       router: '0xcustom_router...'
    *     },
+   *     nativeTokenDenom: 'SUI',
    *     assetsConfig: {
    *       '0x2::sui::SUI': {
    *         symbol: 'SUI',
@@ -703,17 +1258,20 @@ var BoltSuiClient = class extends import_core5.BaseClient {
    *   }
    * });
    *
-   * // Use pre-existing Sui client
+   * // Use pre-existing Sui client and signer
    * const clientWithCustomClient = new BoltSuiClient({
-   *   suiClient: mySuiClient
+   *   suiClient: mySuiClient,
+   *   signer: mySigner
    * });
    * ```
    */
   constructor(config) {
-    const { environment = "mainnet", customOverride, suiClient } = 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 chainConfig = {
       id: customOverride?.chainConfig?.id ?? defaultChainConfig.id,
@@ -721,10 +1279,12 @@ var BoltSuiClient = class extends import_core5.BaseClient {
       rpcEndpoint: customOverride?.chainConfig?.rpcEndpoint ?? defaultChainConfig.rpcEndpoint
     };
     const packageId = customOverride?.packageId ?? defaultPackageId;
+    const poolGlobalConfigId = customOverride?.poolGlobalConfigId ?? defaultPoolGlobalConfigId;
     const contracts = {
       oracle: customOverride?.contracts?.oracle ?? defaultContracts.oracle,
       router: customOverride?.contracts?.router ?? defaultContracts.router
     };
+    const nativeTokenDenom = customOverride?.nativeTokenDenom ?? defaultNativeTokenDenom;
     for (const item of Object.values(customOverride?.assetsConfig ?? {})) {
       assetsConfig[item.denom] = item;
     }
@@ -732,6 +1292,7 @@ var BoltSuiClient = class extends import_core5.BaseClient {
       customOverride: {
         chainConfig,
         contracts,
+        nativeTokenDenom,
         assetsConfig
       }
     });
@@ -743,14 +1304,55 @@ var BoltSuiClient = class extends import_core5.BaseClient {
      * Package Id for the deployed Bolt contracts on Sui
      */
     __publicField(this, "packageId");
+    /**
+     * Object Id for the GlobalConfig of the deployed Pool contracts
+     */
+    __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");
     this.chainConfig = chainConfig;
     this.packageId = packageId;
+    this.poolGlobalConfigId = poolGlobalConfigId;
+    this.signer = signer;
     this.suiClient = suiClient ?? new import_client.SuiClient({ url: chainConfig.rpcEndpoint });
   }
+  /**
+   * Gets or sets the signer for transaction execution.
+   *
+   * This method manages the signer instance used for signing transactions.
+   * A signer must be provided either when creating the client, on first call,
+   * or to replace the existing signer.
+   *
+   * @param newSigner - Optional new signer to replace the existing one
+   *
+   * @returns The current signer instance
+   *
+   * @throws {MissingParameterError} Thrown when no signer is available and none is provided
+   *
+   * @example
+   * ```typescript
+   * // Get the current signer (throws if none exists)
+   * const currentSigner = client.getSigner();
+   *
+   * // Set a new signer
+   * const newSigner = // ... obtain signer from wallet
+   * const signer = client.getSigner(newSigner);
+   * ```
+   */
+  getSigner(newSigner) {
+    this.signer = newSigner ?? this.signer;
+    if (!this.signer) {
+      throw new import_core8.MissingParameterError("signer");
+    }
+    return this.signer;
+  }
   // The following methods inherit their documentation from BaseClient
   // Only add documentation here if you need to override or add implementation-specific details
   /** @inheritdoc */
@@ -810,13 +1412,13 @@ var BoltSuiClient = class extends import_core5.BaseClient {
    * const signer = // ... obtain signer from wallet
    *
    * // Execute swap: 1 SUI for USDC
-   * const result = await client.swap(signer, {
+   * const result = await client.swap({
    *   assetIn: "0x2::sui::SUI",
    *   amountIn: "1000000000", // 1 SUI (9 decimals)
    *   assetOut: "0x5d4b302506645c37ff133b98c4b50a5ae14841659738d6d733d59d0d217a93bf::coin::COIN", // USDC address
    *   minimumAmountOut: "1950000", // Minimum 1.95 USDC expected (6 decimals)
    *   receiver: "0x..." // Optional custom receiver address
-   * });
+   * }, signer);
    *
    * console.log(`Swap successful!`);
    * console.log(`Transaction digest: ${result.txHash}`);
@@ -829,8 +1431,39 @@ var BoltSuiClient = class extends import_core5.BaseClient {
    * This implementation returns a SuiTransactionBlockResponse as the transaction output,
    * which includes details like gas costs, transaction effects, object changes, and events.
    */
-  async swap(signer, params) {
-    return await swapExactIn(this, signer, params);
+  async swap(params, signer) {
+    return await swapExactIn(this, params, signer);
+  }
+  /**
+   * @inheritdoc
+   *
+   * @example
+   * ```typescript
+   * // Get signer from wallet (e.g., Sui Wallet, Suiet, etc.)
+   * const signer = // ... obtain signer from wallet
+   *
+   * // Estimate gas for swapping 1 SUI to USDC
+   * const gasEstimate = await client.estimateSwapGasFees({
+   *   assetIn: "0x2::sui::SUI",
+   *   amountIn: "1000000000", // 1 SUI (9 decimals)
+   *   assetOut: "0x5d4b302506645c37ff133b98c4b50a5ae14841659738d6d733d59d0d217a93bf::coin::COIN", // USDC
+   *   minimumAmountOut: "1950000" // Min 1.95 USDC (6 decimals)
+   * }, signer, 1.3); // 30% safety margin
+   *
+   * if (gasEstimate) {
+   *   console.log(`Estimated gas: ${gasEstimate.amount} ${gasEstimate.denom}`);
+   * }
+   * ```
+   *
+   * @remarks
+   * - For Sui, gas is always paid in SUI tokens
+   * - The returned amount is in MIST (smallest unit, 9 decimals)
+   * - Gas estimation uses Sui's dry run transaction capability
+   * - The gasAdjustment parameter helps account for variations in actual execution
+   * - Sui's gas model includes computation, storage, and storage rebates
+   */
+  async estimateSwapGasFees(params, signer, gasAdjustment) {
+    return await estimateSwapExactInGasFees(this, params, signer, gasAdjustment);
   }
 };
 //# sourceMappingURL=index.cjs.map