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

package/dist/index.cjs

@@ -0,0 +1,836 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+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, {
+  AssetPairStruct: () => AssetPairStruct,
+  AssetPairsResponsePaginatedStruct: () => AssetPairsResponsePaginatedStruct,
+  AssetPairsResponseStruct: () => AssetPairsResponseStruct,
+  BaseLiquidityResponseStruct: () => BaseLiquidityResponseStruct,
+  BcsAddressType: () => BcsAddressType,
+  BoltSuiClient: () => BoltSuiClient,
+  GetFeesResponseStruct: () => GetFeesResponseStruct,
+  GetPoolInfoResponseStruct: () => GetPoolInfoResponseStruct,
+  MarketResponseStruct: () => MarketResponseStruct,
+  MarketStruct: () => MarketStruct,
+  MarketsResponsePaginatedStruct: () => MarketsResponsePaginatedStruct,
+  MarketsResponseStruct: () => MarketsResponseStruct,
+  OracleConfigStruct: () => OracleConfigStruct,
+  PaginationStruct: () => PaginationStruct,
+  PriceDataStruct: () => PriceDataStruct,
+  PriceResponseStruct: () => PriceResponseStruct,
+  PricesResponsePaginatedStruct: () => PricesResponsePaginatedStruct,
+  RouterConfigStruct: () => RouterConfigStruct
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/lib/client.ts
+var import_core5 = require("@bolt-liquidity-hq/core");
+var import_client = require("@mysten/sui/client");
+
+// src/config/mainnet.ts
+var MainnetChainConfig = {
+  name: "Sui",
+  id: "101",
+  rpcEndpoint: "https://fullnode.mainnet.sui.io:443"
+};
+var MainnetContracts = {
+  oracle: "0x...",
+  router: "0x..."
+};
+var MainnetPackageId = "0x...";
+var MainnetAssets = {
+  "0x2::sui::SUI": {
+    symbol: "SUI",
+    name: "Sui",
+    chainId: "101",
+    denom: "0x2::sui::SUI",
+    decimals: 9,
+    logo: "https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/sui/info/logo.png",
+    coingeckoId: "sui"
+  },
+  "0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC": {
+    symbol: "USDC",
+    name: "Circle USDC",
+    chainId: "101",
+    denom: "0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC",
+    decimals: 6,
+    logo: "https://raw.githubusercontent.com/cosmos/chain-registry/master/noble/images/USDCoin.png",
+    coingeckoId: "usd-coin"
+  }
+};
+
+// src/config/testnet.ts
+var TestnetChainConfig = {
+  name: "Sui Testnet",
+  id: "103",
+  rpcEndpoint: "https://fullnode.testnet.sui.io:443"
+};
+var TestnetContracts = {
+  oracle: "0xecece01cfb23b5439e04b18fe656eaf2746b9087cf68f1d48797c8f71a3dd93b",
+  router: "0x3881fdcb4a7fbcda8edc230e6f92eb57b24c0be6b44af0b5e1d0b45564f3ed00"
+};
+var TestnetPackageId = "0x22384b1841229e2be878bb7e88833c03e23ff5dc39accd050fb932120602f85e";
+var TestnetAssets = {
+  "0x2::sui::SUI": {
+    symbol: "SUI",
+    name: "Sui",
+    chainId: "103",
+    denom: "0x2::sui::SUI",
+    decimals: 9,
+    logo: "https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/sui/info/logo.png",
+    coingeckoId: "sui"
+  },
+  "0xa1ec7fc00a6f40db9693ad1415d0c193ad3906494428cf252621037bd7117e29::usdc::USDC": {
+    symbol: "USDC",
+    name: "Circle USDC",
+    chainId: "103",
+    denom: "0xa1ec7fc00a6f40db9693ad1415d0c193ad3906494428cf252621037bd7117e29::usdc::USDC",
+    decimals: 6,
+    logo: "https://raw.githubusercontent.com/cosmos/chain-registry/master/noble/images/USDCoin.png",
+    coingeckoId: "usd-coin"
+  }
+};
+
+// 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";
+
+// src/lib/helpers/bcs-parse.ts
+var import_core = require("@bolt-liquidity-hq/core");
+var import_bcs = require("@mysten/bcs");
+var extractBytes = (result, resultIndex = 0, returnValueIndex = 0) => {
+  const returnValues = result.results?.[resultIndex]?.returnValues;
+  if (!returnValues || !returnValues[returnValueIndex]) {
+    return null;
+  }
+  const [bytes] = returnValues[returnValueIndex];
+  return new Uint8Array(bytes);
+};
+var parseDevInspectResult = (result, bcsType, resultIndex = 0, returnValueIndex = 0) => {
+  const bytes = extractBytes(result, resultIndex, returnValueIndex);
+  if (!bytes) {
+    throw new import_core.InvalidObjectError("When trying to parse result, no bytes found", {
+      bcsType,
+      resultIndex,
+      returnValueIndex
+    });
+  }
+  try {
+    return bcsType.parse(bytes);
+  } catch (error) {
+    throw new import_core.ParseError("DevInspectResult", "from bcs to a typescript type", {
+      error,
+      result,
+      bcsType,
+      resultIndex,
+      returnValueIndex
+    });
+  }
+};
+var parseMultipleResults = (info, schema) => {
+  return schema.map((bcsType, index) => parseDevInspectResult(info, bcsType, 0, index));
+};
+
+// src/lib/helpers/queries.ts
+var import_core2 = 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();
+  const targetString = Array.isArray(target) ? `${target[0]}::${target[1]}::${target[2]}` : target;
+  const txArgs = args?.map(
+    (item) => typeof item === "string" ? tx.object(item) : tx.pure(item.toBytes())
+  );
+  tx.moveCall({
+    target: targetString,
+    arguments: txArgs,
+    typeArguments
+  });
+  try {
+    const result = await suiClient.devInspectTransactionBlock({
+      transactionBlock: tx,
+      sender: senderAddress ?? ZERO_ADDRESS
+    });
+    if (result.effects.status.status === "success") {
+      return result;
+    } else {
+      throw new import_core2.TransactionFailedError("N/A", "Failed to query smart contract", { result });
+    }
+  } catch (error) {
+    throw import_core2.UnexpectedError.from(error, "Failed to query smart contract", {
+      target: targetString,
+      args,
+      typeArguments
+    });
+  }
+};
+
+// src/lib/oracle/parsers.ts
+var import_core3 = require("@bolt-liquidity-hq/core");
+var import_bignumber = require("bignumber.js");
+var parseOracleConfigStructOutput = (output) => {
+  return {
+    admin: output.admin,
+    priceThresholdRatio: output.price_threshold_ratio,
+    priceExpireTime: {
+      secs: Number(output.default_price_expiry_seconds),
+      nanos: 0
+    }
+  };
+};
+var parseAssetPairStructOutput = (output) => {
+  return {
+    base: {
+      name: output.base_symbol,
+      symbol: output.base_symbol,
+      precision: output.base_precision
+    },
+    quote: {
+      name: output.quote_symbol,
+      symbol: output.quote_symbol,
+      precision: output.quote_precision
+    }
+  };
+};
+var parsePriceDataStructOutput = (response, baseDenom, quoteDenom) => {
+  return {
+    assetPair: `${baseDenom}:${quoteDenom}`,
+    price: response.price,
+    expiryTime: (0, import_bignumber.BigNumber)(response.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");
+  }
+  return parsePriceDataStructOutput(response.pair_data, baseDenom, quoteDenom);
+};
+var parseAssetPairsResponsePaginatedStructOutput = (output) => {
+  return output.asset_pairs.map((item) => parseAssetPairStructOutput(item));
+};
+var parsePricesResponsePaginatedStructOutput = (output) => {
+  return output.prices.map((item) => parsePriceDataStructOutput(item, "", ""));
+};
+
+// src/types/bcs.ts
+var import_bcs2 = 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())
+};
+var BcsAddressType = new import_bcs2.BcsType({
+  name: "address",
+  read(reader) {
+    const bytes = new Uint8Array(32);
+    for (let i = 0; i < 32; i++) {
+      bytes[i] = reader.read8();
+    }
+    return "0x" + Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+  },
+  write(value, writer) {
+    const hex = value.startsWith("0x") ? value.slice(2) : value;
+    const paddedHex = hex.padStart(64, "0");
+    for (let i = 0; i < 32; i++) {
+      const byte = parseInt(paddedHex.substr(i * 2, 2), 16);
+      writer.write8(byte);
+    }
+  }
+});
+
+// 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 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 AssetPairsResponseStruct = import_bcs3.bcs.struct("AssetPairsResponse", {
+  asset_pairs: import_bcs3.bcs.vector(AssetPairStruct)
+});
+var AssetPairsResponsePaginatedStruct = import_bcs3.bcs.struct("AssetPairsResponsePaginated", {
+  asset_pairs: import_bcs3.bcs.vector(AssetPairStruct),
+  ...PaginationStruct
+});
+var PriceDataStruct = import_bcs3.bcs.struct("PriceData", {
+  price: import_bcs3.bcs.u128(),
+  expiry_time_ms: import_bcs3.bcs.u64(),
+  last_updated_ms: import_bcs3.bcs.u64(),
+  updater: BcsAddressType
+});
+var PriceResponseStruct = import_bcs3.bcs.struct("PriceResponse", {
+  pair_data: import_bcs3.bcs.option(PriceDataStruct)
+});
+var PricesResponsePaginatedStruct = import_bcs3.bcs.struct("PricesResponsePaginated", {
+  prices: import_bcs3.bcs.vector(PriceDataStruct),
+  ...PaginationStruct
+});
+
+// src/types/router.ts
+var import_bcs5 = require("@mysten/bcs");
+var RouterConfigStruct = import_bcs5.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()
+});
+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 MarketResponseStruct = import_bcs5.bcs.struct("MarketResponse", {
+  market: import_bcs5.bcs.option(MarketStruct)
+});
+var MarketsResponseStruct = import_bcs5.bcs.struct("MarketsResponse", {
+  markets: import_bcs5.bcs.vector(MarketStruct)
+});
+var MarketsResponsePaginatedStruct = import_bcs5.bcs.struct("MarketsResponsePaginated", {
+  markets: import_bcs5.bcs.vector(MarketStruct),
+  ...PaginationStruct
+});
+var BaseLiquidityResponseStruct = import_bcs5.bcs.struct("BaseLiquidityResponse", {
+  base_assets: import_bcs5.bcs.vector(import_bcs5.bcs.string()),
+  ...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()];
+
+// 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;
+};
+
+// src/lib/oracle/get-assets.ts
+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;
+  }
+  return Object.values(uniqueOracleAssets).map(
+    (item) => client.assetsConfig[item.symbol] ?? // Fallback to minimal asset data from oracle
+    {
+      symbol: item.name,
+      name: item.name,
+      chainId: client.chainConfig.id,
+      denom: item.symbol,
+      decimals: item.precision,
+      logo: void 0,
+      coingeckoId: void 0
+    }
+  );
+};
+
+// src/lib/oracle/get-oracle-config.ts
+var getOracleConfig = async (client) => {
+  const CONFIG_FUNCTION = "config";
+  const response = await queryDevInspect(
+    client.suiClient,
+    [client.packageId, PRICE_ORACLE_MODULE, CONFIG_FUNCTION],
+    [client.contracts.oracle]
+  );
+  const output = parseDevInspectResult(response, OracleConfigStruct);
+  return parseOracleConfigStructOutput(output);
+};
+
+// src/lib/oracle/get-price.ts
+var import_bcs10 = require("@mysten/bcs");
+var import_utils = 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_utils.SUI_CLOCK_OBJECT_ID
+    ]
+  );
+  const output = parseDevInspectResult(response, PriceResponseStruct);
+  return parsePriceResponseStructOutput(output, baseDenom, quoteDenom);
+};
+
+// src/lib/oracle/get-prices.ts
+var import_bcs11 = require("@mysten/bcs");
+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 output = parseDevInspectResult(response, PricesResponsePaginatedStruct);
+    const assetPairs = parsePricesResponsePaginatedStructOutput(output);
+    result.push(...assetPairs);
+    currentCursor = output.next_cursor;
+    hasNextPage = output.has_next_page;
+  }
+  return result;
+};
+
+// src/lib/router/get-all-base-liquidity.ts
+var import_bcs12 = require("@mysten/bcs");
+
+// src/lib/router/parsers.ts
+var import_core4 = 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 = (response) => {
+  if (!response.market) {
+    throw new import_core4.NotFoundError("Market", void 0, { response });
+  }
+  return parseMarketStructOutput(response.market);
+};
+var parseMarketsResponsePaginatedStructOutput = (response) => {
+  return response.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 parseBaseLiquidityResponseStructOutput = (output) => {
+  return output.base_assets.map((item) => ({
+    baseLiquidity: {
+      denom: item,
+      amount: "10"
+    },
+    totalShares: "10"
+  }));
+};
+
+// 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_bcs12.bcs.option(import_bcs12.bcs.u64()).serialize(DEFAULT_PAGINATION_LIMIT),
+        import_bcs12.bcs.option(import_bcs12.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;
+  }
+  return result;
+};
+
+// src/lib/router/get-all-quotes-for-user.ts
+var import_bcs13 = 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)]
+  );
+  console.log(response);
+  return {};
+};
+
+// src/lib/router/get-pool-for-base.ts
+var import_bcs14 = 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)]
+  );
+  const output = parseDevInspectResult(response, MarketResponseStruct);
+  return parseMarketResponseStructOutput(output);
+};
+
+// src/lib/router/get-pools.ts
+var import_bcs15 = 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_bcs15.bcs.option(import_bcs15.bcs.u64()).serialize(DEFAULT_PAGINATION_LIMIT),
+        import_bcs15.bcs.option(import_bcs15.bcs.string()).serialize(currentCursor)
+      ]
+    );
+    const output = parseDevInspectResult(response, MarketsResponsePaginatedStruct);
+    const pools = parseMarketsResponsePaginatedStructOutput(output);
+    result.push(...pools);
+    currentCursor = output.next_cursor;
+    hasNextPage = output.has_next_page;
+  }
+  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 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 {};
+};
+
+// src/lib/settlement/get-pool-info.ts
+var import_utils2 = require("@mysten/sui/utils");
+
+// src/lib/settlement/parsers.ts
+var parseSettlementConfigStructOutput = (_poolInfoOutput, feesOutput) => {
+  return {
+    priceOracleContract: "0x",
+    // Should come from poolInfoOutput
+    protocolFeeRecipient: "0x",
+    // Should be feesOutput[1]
+    protocolFee: feesOutput[0],
+    // Protocol fee percentage
+    lpFee: feesOutput[2],
+    // LP fee percentage
+    allowanceMode: "allow",
+    // Should come from poolInfoOutput
+    lps: ["0x"],
+    // Should come from poolInfoOutput
+    minBaseOut: "1"
+    // Should come from poolInfoOutput
+  };
+};
+
+// 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)
+    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]
+    )
+  ]);
+  const infoOutput = parseMultipleResults(info, GetPoolInfoResponseStruct);
+  const feesOutput = parseMultipleResults(fees, GetFeesResponseStruct);
+  return parseSettlementConfigStructOutput(infoOutput, feesOutput);
+};
+
+// 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/client.ts
+var BoltSuiClient = class extends import_core5.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.
+   *
+   * @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.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.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.assetsConfig - (Optional) Custom asset configurations indexed by denom
+   * @param config.suiClient - (Optional) Pre-existing SuiClient to use for blockchain queries
+   *
+   * @throws {InvalidObjectError} Thrown when required configuration fields are missing
+   *
+   * @example
+   * ```typescript
+   * // Use default configuration (Sui mainnet)
+   * const client = new BoltSuiClient();
+   *
+   * // Use testnet configuration
+   * const testnetClient = new BoltSuiClient({
+   *   environment: 'testnet'
+   * });
+   *
+   * // Use custom chain configuration
+   * const customClient = new BoltSuiClient({
+   *   customOverride: {
+   *     chainConfig: {
+   *       id: 'sui-custom',
+   *       name: 'Sui Custom',
+   *       rpcEndpoint: 'https://custom-rpc.example.com'
+   *     },
+   *     packageId: '0xcustom_package_id...',
+   *     contracts: {
+   *       oracle: '0xcustom_oracle...',
+   *       router: '0xcustom_router...'
+   *     },
+   *     assetsConfig: {
+   *       '0x2::sui::SUI': {
+   *         symbol: 'SUI',
+   *         name: 'Sui',
+   *         chainId: 'sui-custom',
+   *         denom: '0x2::sui::SUI',
+   *         decimals: 9,
+   *         logo: 'https://example.com/sui.png',
+   *         coingeckoId: 'sui'
+   *       }
+   *     }
+   *   }
+   * });
+   *
+   * // Use pre-existing Sui client
+   * const clientWithCustomClient = new BoltSuiClient({
+   *   suiClient: mySuiClient
+   * });
+   * ```
+   */
+  constructor(config) {
+    const { environment = "mainnet", customOverride, suiClient } = config ?? {};
+    const defaultChainConfig = environment === "mainnet" ? MainnetChainConfig : TestnetChainConfig;
+    const defaultContracts = environment === "mainnet" ? MainnetContracts : TestnetContracts;
+    const defaultPackageId = environment === "mainnet" ? MainnetPackageId : TestnetPackageId;
+    const assetsConfig = environment === "mainnet" ? MainnetAssets : TestnetAssets;
+    const chainConfig = {
+      id: customOverride?.chainConfig?.id ?? defaultChainConfig.id,
+      name: customOverride?.chainConfig?.name ?? defaultChainConfig.name,
+      rpcEndpoint: customOverride?.chainConfig?.rpcEndpoint ?? defaultChainConfig.rpcEndpoint
+    };
+    const packageId = customOverride?.packageId ?? defaultPackageId;
+    const contracts = {
+      oracle: customOverride?.contracts?.oracle ?? defaultContracts.oracle,
+      router: customOverride?.contracts?.router ?? defaultContracts.router
+    };
+    for (const item of Object.values(customOverride?.assetsConfig ?? {})) {
+      assetsConfig[item.denom] = item;
+    }
+    super({
+      customOverride: {
+        chainConfig,
+        contracts,
+        assetsConfig
+      }
+    });
+    /**
+     * The Sui-specific chain configuration including RPC endpoint
+     */
+    __publicField(this, "chainConfig");
+    /**
+     * Package Id for the deployed Bolt contracts on Sui
+     */
+    __publicField(this, "packageId");
+    /**
+     * Instance of the Sui client to interact with the blockchain
+     */
+    __publicField(this, "suiClient");
+    this.chainConfig = chainConfig;
+    this.packageId = packageId;
+    this.suiClient = suiClient ?? new import_client.SuiClient({ url: chainConfig.rpcEndpoint });
+  }
+  // The following methods inherit their documentation from BaseClient
+  // Only add documentation here if you need to override or add implementation-specific details
+  /** @inheritdoc */
+  async getOracleConfig() {
+    return await getOracleConfig(this);
+  }
+  /** @inheritdoc */
+  async getAllOracleAssetPairs() {
+    return await getAssetPairs(this);
+  }
+  /** @inheritdoc */
+  async getPrice(baseDenom, quoteDenom) {
+    return await getPrice(this, baseDenom, quoteDenom);
+  }
+  /** @inheritdoc */
+  async getAllPrices() {
+    return await getPrices(this);
+  }
+  /** @inheritdoc */
+  async getRouterConfig() {
+    return await getRouterConfig(this);
+  }
+  /** @inheritdoc */
+  async getAllBaseAssetsLiquidity() {
+    return await getAllBaseLiquidity(this);
+  }
+  /** @inheritdoc */
+  async getAllQuotesByUser(address) {
+    return await getAllQuotesForUser(this, address);
+  }
+  /** @inheritdoc */
+  async getPoolByBaseAsset(baseDenom) {
+    return await getPoolForBase(this, baseDenom);
+  }
+  /** @inheritdoc */
+  async getAllPools() {
+    return await getPools(this);
+  }
+  // Satisfy the base class requirement
+  async getPoolConfig(poolContractAddress) {
+    return await getPoolInfo(this, poolContractAddress);
+  }
+  /** @inheritdoc */
+  async getAssets() {
+    return await getAssets(this);
+  }
+  /** @inheritdoc */
+  async getPoolConfigByBaseAsset(baseDenom) {
+    return await getPoolInfoForBase(this, baseDenom);
+  }
+  /**
+   * @inheritdoc
+   *
+   * @example
+   * ```typescript
+   * // Get signer from wallet (e.g., Sui Wallet, Suiet, etc.)
+   * const signer = // ... obtain signer from wallet
+   *
+   * // Execute swap: 1 SUI for USDC
+   * const result = await client.swap(signer, {
+   *   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
+   * });
+   *
+   * console.log(`Swap successful!`);
+   * console.log(`Transaction digest: ${result.txHash}`);
+   * console.log(`Received: ${result.amountOut} ${result.assetOut}`);
+   * console.log(`Gas cost: ${result.txOutput.effects.gasUsed.computationCost}`);
+   * console.log(`Status: ${result.txOutput.effects.status.status}`);
+   * ```
+   *
+   * @remarks
+   * 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);
+  }
+};
+//# sourceMappingURL=index.cjs.map