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

package/dist/index.cjs

@@ -53,14 +53,15 @@ __export(index_exports, {
   RawPairStruct: () => RawPairStruct,
   RawPriceStruct: () => RawPriceStruct,
   RouterConfigStruct: () => RouterConfigStruct,
+  SwapSimulationResultStruct: () => SwapSimulationResultStruct,
   TypeNameStruct: () => TypeNameStruct
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/lib/client.ts
-var import_core13 = require("@bolt-liquidity-hq/core");
+var import_core15 = require("@bolt-liquidity-hq/core");
 var import_client = require("@mysten/sui/client");
-var import_utils9 = require("@mysten/sui/utils");
+var import_utils10 = require("@mysten/sui/utils");
 var import_axios = __toESM(require("axios"), 1);
 
 // src/config/common.ts
@@ -158,6 +159,9 @@ var TestnetAssets = {
   }
 };
 
+// src/lib/constants/defaults.ts
+var BASIS_POINTS = 1e4;
+
 // src/lib/constants/sui-objects.ts
 var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000000000000000000000000000";
 var PRICE_ORACLE_MODULE = "price_oracle";
@@ -641,8 +645,7 @@ var buildSwapTxArgs = async (client, swapParams, signer) => {
   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 FUNCTION_NAME = pool.isInverse ? "swap_sell" : "swap_buy";
   const finalSigner = client.getSigner(signer);
   const tx = new import_transactions2.Transaction();
   const signerAddress = getSignerAddress(finalSigner);
@@ -661,7 +664,7 @@ var buildSwapTxArgs = async (client, swapParams, signer) => {
       import_bcs2.bcs.option(import_bcs2.bcs.u64()).serialize(minimumAmountOut),
       import_bcs2.bcs.option(import_bcs2.bcs.string()).serialize(receiver)
     ],
-    typeArguments: [isSell ? assetIn : assetOut, isSell ? assetOut : assetIn],
+    typeArguments: [pool.isInverse ? assetIn : assetOut, pool.isInverse ? assetOut : assetIn],
     tx
   };
 };
@@ -904,6 +907,14 @@ var BaseLiquidityResponseStruct = import_bcs6.bcs.struct("BaseLiquidityResponse"
   base_assets: import_bcs6.bcs.vector(BaseLiquidityInfoStruct),
   ...PaginationStruct
 });
+var SwapSimulationResultStruct = import_bcs6.bcs.struct("SwapSimulationResult", {
+  amount_out: import_bcs6.bcs.u128(),
+  dynamic_fee_pct: import_bcs6.bcs.u64(),
+  ideal_quote_amt: import_bcs6.bcs.u128(),
+  swap_fee: import_bcs6.bcs.u64(),
+  lp_fee: import_bcs6.bcs.u64(),
+  protocol_fee: import_bcs6.bcs.u64()
+});
 
 // src/types/pool.ts
 var import_bcs8 = require("@mysten/bcs");
@@ -919,7 +930,6 @@ var PoolFeesInfoStruct = import_bcs8.bcs.struct("PoolFeesInfo", {
   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()
 });
@@ -1089,6 +1099,21 @@ var getRouterConfig = async (_client) => {
   throw new import_core11.NotImplementedError("getRouterConfig on Sui Client");
 };
 
+// src/lib/router/parsers.ts
+var import_core12 = require("@bolt-liquidity-hq/core");
+var import_bignumber3 = require("bignumber.js");
+var parseSwapSimulationResultStructOutput = (output, poolAddress, assetOut) => {
+  return {
+    poolAddress,
+    amountOut: output.amount_out,
+    assetOut,
+    protocolFee: output.protocol_fee,
+    lpFee: output.lp_fee,
+    dynamicFeePercentage: (0, import_bignumber3.BigNumber)(output.dynamic_fee_pct).div(BASIS_POINTS).toFixed(),
+    totalFees: output.swap_fee
+  };
+};
+
 // src/lib/router/router-client/RouterClient.ts
 var import_utils8 = require("@mysten/sui/utils");
 var RouterClient = class {
@@ -1102,13 +1127,19 @@ var RouterClient = class {
       (item) => item.baseDenom === normalizedDenomOut && item.quoteDenoms.includes(normalizedDenomIn)
     );
     if (directPairPool) {
-      return directPairPool;
+      return {
+        ...directPairPool,
+        isInverse: false
+      };
     }
     const inversePairPool = this.pools.find(
       (item) => item.baseDenom === normalizedDenomIn && item.quoteDenoms.includes(normalizedDenomOut)
     );
     if (inversePairPool) {
-      return inversePairPool;
+      return {
+        ...inversePairPool,
+        isInverse: true
+      };
     }
     return;
   }
@@ -1117,6 +1148,26 @@ var RouterClient = class {
   }
 };
 
+// src/lib/router/simulate-swap.ts
+var import_core13 = require("@bolt-liquidity-hq/core");
+var import_bcs10 = require("@mysten/bcs");
+var import_utils9 = require("@mysten/sui/utils");
+var simulateSwap = async (client, { assetIn, amountIn, assetOut }) => {
+  const pool = await client.routerClient.getPool(assetIn, assetOut);
+  if (!pool) {
+    throw new import_core13.NotFoundError("Pool", `Didn't find a pool to swap ${assetIn} for ${assetOut}`);
+  }
+  const FUNCTION_NAME = pool.isInverse ? "simulate_sell_swap" : "simulate_buy_swap";
+  const response = await queryDevInspect(
+    client.suiClient,
+    [client.packageId, POOL_MODULE, FUNCTION_NAME],
+    [pool.poolAddress, client.contracts.oracle, import_utils9.SUI_CLOCK_OBJECT_ID, import_bcs10.bcs.u64().serialize(amountIn)],
+    [pool.isInverse ? assetIn : assetOut, pool.isInverse ? assetOut : assetIn]
+  );
+  const output = parseDevInspectResult(response, SwapSimulationResultStruct);
+  return parseSwapSimulationResultStructOutput(output, pool.poolAddress, assetOut);
+};
+
 // src/lib/router/swap-exact-in.ts
 var swapExactIn = async (client, swapParams, signer) => {
   const swapArgs = await buildSwapTxArgs(client, swapParams, signer);
@@ -1138,16 +1189,16 @@ var swapExactIn = async (client, swapParams, signer) => {
 };
 
 // src/lib/settlement/get-pool-info.ts
-var import_core12 = require("@bolt-liquidity-hq/core");
+var import_core14 = require("@bolt-liquidity-hq/core");
 
 // src/lib/settlement/parsers.ts
-var import_bignumber3 = require("bignumber.js");
-var parseSettlementConfigStructOutput = (routerClient, poolFeesInfo, protocolFeesInfo, priceOracleContract) => {
+var import_bignumber4 = require("bignumber.js");
+var parseSettlementConfigStructOutput = (routerClient, poolFeesInfo, priceOracleContract) => {
   return {
     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(),
+    protocolFeeRecipient: "0x",
+    protocolFee: (0, import_bignumber4.BigNumber)(poolFeesInfo.swap_fee_pct).div(BASIS_POINTS).toFixed(),
+    lpFee: (0, import_bignumber4.BigNumber)(poolFeesInfo.lp_fee_pct).div(BASIS_POINTS).toFixed(),
     allowanceMode: "allow",
     // Should come from pool config
     lps: routerClient.getPools().map((item) => item.poolAddress),
@@ -1159,33 +1210,20 @@ var parseSettlementConfigStructOutput = (routerClient, poolFeesInfo, protocolFee
 // src/lib/settlement/get-pool-info.ts
 var getPoolInfo = async (client, contractAddress) => {
   const GET_POOL_FEES_INFO_FUNCTION = "get_pool_fees_info";
-  const GET_PROTOCOL_FEES_INFO_FUNCTION = "get_protocol_fees_info";
   const pool = client.routerClient.pools.find((item) => item.poolAddress === contractAddress);
   if (!pool) {
-    throw new import_core12.NotFoundError(`Pool with the address ${contractAddress}`);
+    throw new import_core14.NotFoundError(`Pool with the address ${contractAddress}`);
   }
-  const [poolFeesInfo, protocolFeesInfo] = await Promise.all([
-    // Query pool fee information
-    queryDevInspect(
-      client.suiClient,
-      [client.packageId, POOL_MODULE, GET_POOL_FEES_INFO_FUNCTION],
-      [contractAddress],
-      [pool.baseDenom]
-    ),
-    // Query protocol fee information
-    queryDevInspect(
-      client.suiClient,
-      [client.packageId, POOL_MODULE, GET_PROTOCOL_FEES_INFO_FUNCTION],
-      [contractAddress],
-      [pool.baseDenom]
-    )
-  ]);
+  const poolFeesInfo = await queryDevInspect(
+    client.suiClient,
+    [client.packageId, POOL_MODULE, GET_POOL_FEES_INFO_FUNCTION],
+    [contractAddress],
+    [pool.baseDenom]
+  );
   const poolFeesInfoOutput = parseDevInspectResult(poolFeesInfo, PoolFeesInfoStruct);
-  const protocolFeesInfoOutput = parseDevInspectResult(protocolFeesInfo, ProtocolFeesInfoStruct);
   return parseSettlementConfigStructOutput(
     client.routerClient,
     poolFeesInfoOutput,
-    protocolFeesInfoOutput,
     client.contracts.oracle
   );
 };
@@ -1197,7 +1235,7 @@ var getPoolInfoByDenom = async (client, baseDenom, quoteDenom) => {
 };
 
 // src/lib/client.ts
-var BoltSuiClient = class extends import_core13.BaseClient {
+var BoltSuiClient = class extends import_core15.BaseClient {
   /**
    * Creates a new instance of the BoltSuiClient.
    *
@@ -1369,7 +1407,7 @@ var BoltSuiClient = class extends import_core13.BaseClient {
   getSigner(newSigner) {
     this.signer = newSigner ?? this.signer;
     if (!this.signer) {
-      throw new import_core13.MissingParameterError("signer");
+      throw new import_core15.MissingParameterError("signer");
     }
     return this.signer;
   }
@@ -1517,6 +1555,10 @@ var BoltSuiClient = class extends import_core13.BaseClient {
     await this.loadConfigFromUrl();
     return await estimateSwapExactInGasFees(this, params, signer, gasAdjustment);
   }
+  /** @inheritdoc */
+  async simulateSwap(params) {
+    return await simulateSwap(this, params);
+  }
   /**
    * Loads configuration from a remote URL for testnet environments.
    *
@@ -1568,8 +1610,8 @@ var BoltSuiClient = class extends import_core13.BaseClient {
       for (const item of pools) {
         this.routerClient.pools.push({
           poolAddress: item.pool_object_id,
-          baseDenom: (0, import_utils9.normalizeStructTag)(item.base),
-          quoteDenoms: Object.values(assets).map((auxAsset) => (0, import_utils9.normalizeStructTag)(auxAsset)).filter((auxAsset) => auxAsset !== (0, import_utils9.normalizeStructTag)(item.base))
+          baseDenom: (0, import_utils10.normalizeStructTag)(item.base),
+          quoteDenoms: Object.values(assets).map((auxAsset) => (0, import_utils10.normalizeStructTag)(auxAsset)).filter((auxAsset) => auxAsset !== (0, import_utils10.normalizeStructTag)(item.base))
         });
       }
     }