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

package/dist/index.js

@@ -5,11 +5,15 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
 // src/lib/client.ts
 import { BaseClient, MissingParameterError as MissingParameterError2 } from "@bolt-liquidity-hq/core";
 import { SuiClient } from "@mysten/sui/client";
-import { normalizeStructTag as normalizeStructTag5 } from "@mysten/sui/utils";
+import { normalizeStructTag as normalizeStructTag6 } from "@mysten/sui/utils";
 import axios from "axios";
 
+// src/config/common.ts
+import { normalizeStructTag, SUI_TYPE_ARG } from "@mysten/sui/utils";
+var SUI_TOKEN_DENOM = normalizeStructTag(SUI_TYPE_ARG);
+
 // src/config/mainnet.ts
-import { SUI_DECIMALS, SUI_TYPE_ARG } from "@mysten/sui/utils";
+import { SUI_DECIMALS } from "@mysten/sui/utils";
 var MainnetChainConfig = {
   name: "Sui",
   id: "101",
@@ -21,13 +25,13 @@ var MainnetContracts = {
 };
 var MainnetPackageId = "0x...";
 var MainnetPoolGlobalConfigId = "0x...";
-var MainnetNativeTokenDenom = SUI_TYPE_ARG;
+var MainnetNativeTokenDenom = SUI_TOKEN_DENOM;
 var MainnetAssets = {
-  [SUI_TYPE_ARG]: {
+  [SUI_TOKEN_DENOM]: {
     symbol: "SUI",
     name: "Sui",
     chainId: "101",
-    denom: SUI_TYPE_ARG,
+    denom: SUI_TOKEN_DENOM,
     decimals: SUI_DECIMALS,
     logo: "https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/sui/info/logo.png",
     coingeckoId: "sui"
@@ -45,7 +49,7 @@ var MainnetAssets = {
 var MainnetPools = [];
 
 // src/config/testnet.ts
-import { SUI_DECIMALS as SUI_DECIMALS2, SUI_TYPE_ARG as SUI_TYPE_ARG2 } from "@mysten/sui/utils";
+import { SUI_DECIMALS as SUI_DECIMALS2 } from "@mysten/sui/utils";
 var TestnetConfigUrl = "https://phi-labs-ltd.github.io/sui-outpost/testnet.json";
 var TestnetChainConfig = {
   name: "Sui Testnet",
@@ -58,14 +62,14 @@ var TestnetContracts = {
 };
 var TestnetPackageId = "";
 var TestnetPoolGlobalConfigId = "";
-var TestnetNativeTokenDenom = SUI_TYPE_ARG2;
+var TestnetNativeTokenDenom = SUI_TOKEN_DENOM;
 var TestnetHelperAssets = ["::test_btc::TEST_BTC", "::test_usdt::TEST_USDT"];
 var TestnetAssets = {
-  [SUI_TYPE_ARG2]: {
+  [SUI_TOKEN_DENOM]: {
     symbol: "SUI",
     name: "Sui",
     chainId: "103",
-    denom: SUI_TYPE_ARG2,
+    denom: SUI_TOKEN_DENOM,
     decimals: SUI_DECIMALS2,
     logo: "https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/sui/info/logo.png",
     coingeckoId: "sui"
@@ -85,7 +89,7 @@ var TestnetAssets = {
     chainId: "103",
     denom: "::test_btc::TEST_BTC",
     decimals: 8,
-    logo: "https://github.com/cosmos/chain-registry/blob/master/_non-cosmos/bitcoin/images/btc.png",
+    logo: "https://raw.githubusercontent.com/cosmos/chain-registry/refs/heads/master/_non-cosmos/bitcoin/images/btc.svg",
     coingeckoId: "bitcoin"
   },
   "::test_usdt::TEST_USDT": {
@@ -94,11 +98,14 @@ var TestnetAssets = {
     chainId: "103",
     denom: "::test_usdt::TEST_USDT",
     decimals: 6,
-    logo: "https://github.com/cosmos/chain-registry/blob/master/_non-cosmos/ethereum/images/usdt.png",
+    logo: "https://raw.githubusercontent.com/cosmos/chain-registry/refs/heads/master/_non-cosmos/ethereum/images/usdt.svg",
     coingeckoId: "tether"
   }
 };
 
+// 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";
@@ -140,7 +147,7 @@ var parseDevInspectResult = (result, bcsType, resultIndex = 0, returnValueIndex
 
 // src/lib/helpers/coin-manager.ts
 import { InsufficientFundsError, MissingParameterError } from "@bolt-liquidity-hq/core";
-import { SUI_TYPE_ARG as SUI_TYPE_ARG3 } from "@mysten/sui/utils";
+import { normalizeStructTag as normalizeStructTag2 } from "@mysten/sui/utils";
 var CoinManager = class {
   /**
    * Creates a new CoinManager instance.
@@ -507,7 +514,7 @@ var CoinManager = class {
    */
   async prepareCoinInput(tx, coinType, amount, options = {}, owner) {
     const ownerAddress = this.getOwnerAddress(owner);
-    if (coinType === SUI_TYPE_ARG3) {
+    if (normalizeStructTag2(coinType) === SUI_TOKEN_DENOM) {
       const [coin] = tx.splitCoins(tx.gas, [amount]);
       return coin;
     }
@@ -579,7 +586,7 @@ import {
 } from "@bolt-liquidity-hq/core";
 import { bcs as bcs2 } from "@mysten/bcs";
 import { Transaction as Transaction2 } from "@mysten/sui/transactions";
-import { normalizeStructTag, SUI_CLOCK_OBJECT_ID, SUI_TYPE_ARG as SUI_TYPE_ARG4 } from "@mysten/sui/utils";
+import { SUI_CLOCK_OBJECT_ID } from "@mysten/sui/utils";
 import { BigNumber } from "bignumber.js";
 var buildSwapTxArgs = async (client, swapParams, signer) => {
   const { assetIn, amountIn, assetOut, minimumAmountOut, receiver } = swapParams;
@@ -587,14 +594,15 @@ var buildSwapTxArgs = async (client, swapParams, signer) => {
   if (!pool) {
     throw new NotFoundError(`Pool for the pair ${assetIn}/${assetOut}`);
   }
-  const isSell = normalizeStructTag(assetIn) === pool.baseDenom;
-  const FUNCTION_NAME = isSell ? "swap_sell" : "swap_buy";
+  const FUNCTION_NAME = pool.isInverse ? "swap_sell" : "swap_buy";
   const finalSigner = client.getSigner(signer);
   const tx = new Transaction2();
-  const coinManager = new CoinManager(client.suiClient, finalSigner.toSuiAddress());
+  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,
@@ -602,10 +610,10 @@ var buildSwapTxArgs = async (client, swapParams, signer) => {
       SUI_CLOCK_OBJECT_ID,
       coinInput,
       bcs2.u64().serialize(amountIn),
-      bcs2.option(bcs2.string()).serialize(minimumAmountOut),
+      bcs2.option(bcs2.u64()).serialize(minimumAmountOut),
       bcs2.option(bcs2.string()).serialize(receiver)
     ],
-    typeArguments: [isSell ? assetIn : assetOut, isSell ? assetOut : assetIn],
+    typeArguments: [pool.isInverse ? assetIn : assetOut, pool.isInverse ? assetOut : assetIn],
     tx
   };
 };
@@ -621,15 +629,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 TransactionFailedError2(result.digest, result.effects?.status.error, { result });
+      }
     } else {
-      throw new TransactionFailedError2(result.digest, result.effects?.status.error, { result });
+      const result = await signer.signAndExecuteTransaction({
+        transaction: tx
+      });
+      if (!result.digest) {
+        throw new TransactionFailedError2("not found");
+      }
+      const fullTx = await suiClient.waitForTransaction({
+        digest: result.digest,
+        options
+      });
+      return fullTx;
     }
   } catch (error) {
     throw UnexpectedError2.from(error, "Failed to execute transaction", {
@@ -672,13 +694,20 @@ var estimateTxGasPrice = async (suiClient, senderAddress, target, args, typeArgu
     const totalGasCost = BigNumber(gasUsed.computationCost).plus(gasUsed.storageCost).minus(gasUsed.storageRebate);
     const adjustedGasCost = totalGasCost.times(gasAdjustment);
     return {
-      denom: SUI_TYPE_ARG4,
+      denom: SUI_TOKEN_DENOM,
       amount: adjustedGasCost.toFixed(0, BigNumber.ROUND_CEIL)
     };
   } catch {
     return;
   }
 };
+var getSignerAddress = (signer) => {
+  const address = "address" in signer ? signer.address : signer.toSuiAddress?.();
+  if (!address) {
+    throw new NotFoundError("Signer account's address");
+  }
+  return address;
+};
 
 // src/lib/oracle/parsers.ts
 import { InvalidObjectError as InvalidObjectError2 } from "@bolt-liquidity-hq/core";
@@ -713,20 +742,20 @@ var parseAssetPairStructOutput = (output) => {
 var parseAssetPairsResponseStructOutput = (output) => {
   return output.map((item) => parseAssetPairStructOutput(item.info));
 };
-var parsePriceDataStructOutput = (output, baseDenom, quoteDenom) => {
+var parsePriceDataStructOutput = (output, baseDenom, quoteDenom, isInverted) => {
   return {
     baseDenom,
     quoteDenom,
     price: output.price.price,
     expiryTime: BigNumber2(output.price.expiry).times(1e6).toFixed(),
-    isInverse: false
+    isInverse: isInverted ?? false
   };
 };
 var parsePriceResponseStructOutput = (output, baseDenom, quoteDenom) => {
   if (!output.pair_data) {
     throw new InvalidObjectError2("Can't find pair data price");
   }
-  return parsePriceDataStructOutput(output.pair_data, baseDenom, quoteDenom);
+  return parsePriceDataStructOutput(output.pair_data, baseDenom, quoteDenom, output.is_inverted);
 };
 
 // src/types/bcs.ts
@@ -789,11 +818,8 @@ var PriceDataStruct = bcs4.struct("PriceData", {
   updater: BcsAddressType
 });
 var PriceResponseStruct = bcs4.struct("PriceResponse", {
-  pair_data: bcs4.option(PriceDataStruct)
-});
-var PricesResponsePaginatedStruct = bcs4.struct("PricesResponsePaginated", {
-  prices: bcs4.vector(PriceDataStruct),
-  ...PaginationStruct
+  pair_data: bcs4.option(PriceDataStruct),
+  is_inverted: bcs4.bool()
 });
 
 // src/types/router.ts
@@ -830,6 +856,14 @@ var BaseLiquidityResponseStruct = bcs5.struct("BaseLiquidityResponse", {
   base_assets: bcs5.vector(BaseLiquidityInfoStruct),
   ...PaginationStruct
 });
+var SwapSimulationResultStruct = bcs5.struct("SwapSimulationResult", {
+  amount_out: bcs5.u128(),
+  dynamic_fee_pct: bcs5.u64(),
+  ideal_quote_amt: bcs5.u128(),
+  swap_fee: bcs5.u64(),
+  lp_fee: bcs5.u64(),
+  protocol_fee: bcs5.u64()
+});
 
 // src/types/pool.ts
 import { bcs as bcs6 } from "@mysten/bcs";
@@ -863,13 +897,19 @@ var getAssetPairs = async (client) => {
 };
 
 // src/lib/oracle/get-assets.ts
-import { normalizeStructTag as normalizeStructTag2 } from "@mysten/sui/utils";
+import { normalizeStructTag as normalizeStructTag3 } from "@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[normalizeStructTag3(item.base.symbol)] = {
+      ...item.base,
+      symbol: normalizeStructTag3(item.base.symbol)
+    };
+    uniqueOracleAssets[normalizeStructTag3(item.quote.symbol)] = {
+      ...item.quote,
+      symbol: normalizeStructTag3(item.quote.symbol)
+    };
   }
   return Object.values(uniqueOracleAssets).map(
     (item) => client.assetsConfig[item.symbol] ?? // Fallback to minimal asset data from oracle
@@ -877,7 +917,7 @@ var getAssets = async (client) => {
       symbol: item.name,
       name: item.name,
       chainId: client.chainConfig.id,
-      denom: normalizeStructTag2(item.symbol),
+      denom: normalizeStructTag3(item.symbol),
       decimals: item.precision,
       logo: void 0,
       coingeckoId: void 0
@@ -912,7 +952,7 @@ var getPrice = async (client, baseDenom, quoteDenom) => {
 
 // src/lib/oracle/get-prices.ts
 import { NotFoundError as NotFoundError2 } from "@bolt-liquidity-hq/core";
-import { normalizeStructTag as normalizeStructTag3 } from "@mysten/sui/utils";
+import { normalizeStructTag as normalizeStructTag4 } from "@mysten/sui/utils";
 var getPrices = async (client) => {
   const oracleObject = await client.suiClient.getObject({
     id: client.contracts.oracle,
@@ -947,8 +987,8 @@ var getPrices = async (client) => {
         const pairKey = dynamicFields.data[index]?.name?.value;
         if (fields && pairKey) {
           prices.push({
-            baseDenom: normalizeStructTag3(pairKey.base.name),
-            quoteDenom: normalizeStructTag3(pairKey.quote.name),
+            baseDenom: normalizeStructTag4(pairKey.base.name),
+            quoteDenom: normalizeStructTag4(pairKey.quote.name),
             price: fields.price,
             expiryTime: fields.expiry
           });
@@ -967,7 +1007,7 @@ var estimateSwapExactInGasFees = async (client, swapParams, signer, gasAdjustmen
   const swapArgs = await buildSwapTxArgs(client, swapParams, signer);
   return await estimateTxGasPrice(
     client.suiClient,
-    swapArgs.signer.toSuiAddress(),
+    swapArgs.signerAddress,
     swapArgs.target,
     swapArgs.args,
     swapArgs.typeArguments,
@@ -993,9 +1033,9 @@ var getAllQuotesForUser = async (_client, _lpAddress) => {
 // src/lib/router/get-pool-by-denom.ts
 import { NotFoundError as NotFoundError3 } from "@bolt-liquidity-hq/core";
 var getPoolByDenom = async (client, baseDenom, quoteDenom) => {
-  const result = await client.routerClient.getPool(baseDenom, quoteDenom);
+  const result = await client.routerClient.getPool(quoteDenom, baseDenom);
   if (!result) {
-    throw new NotFoundError3("Pool", `Didn't find a pool to swap ${baseDenom} for ${quoteDenom}`);
+    throw new NotFoundError3("Pool", `Didn't find a pool to swap ${quoteDenom} for ${baseDenom}`);
   }
   return result;
 };
@@ -1011,26 +1051,47 @@ var getRouterConfig = async (_client) => {
   throw new NotImplementedError3("getRouterConfig on Sui Client");
 };
 
+// src/lib/router/parsers.ts
+import { NotFoundError as NotFoundError4 } from "@bolt-liquidity-hq/core";
+import { BigNumber as BigNumber3 } from "bignumber.js";
+var parseSwapSimulationResultStructOutput = (output, poolAddress, assetOut) => {
+  return {
+    poolAddress,
+    amountOut: output.amount_out,
+    assetOut,
+    protocolFee: output.protocol_fee,
+    lpFee: output.lp_fee,
+    dynamicFeePercentage: BigNumber3(output.dynamic_fee_pct).div(BASIS_POINTS).toFixed(),
+    totalFees: output.swap_fee
+  };
+};
+
 // src/lib/router/router-client/RouterClient.ts
-import { normalizeStructTag as normalizeStructTag4 } from "@mysten/sui/utils";
+import { normalizeStructTag as normalizeStructTag5 } from "@mysten/sui/utils";
 var RouterClient = class {
   constructor(pools) {
     this.pools = pools;
   }
   getPool(denomIn, denomOut) {
-    const normalizedDenomIn = normalizeStructTag4(denomIn);
-    const normalizedDenomOut = normalizeStructTag4(denomOut);
+    const normalizedDenomIn = normalizeStructTag5(denomIn);
+    const normalizedDenomOut = normalizeStructTag5(denomOut);
     const directPairPool = this.pools.find(
-      (item) => item.baseDenom === normalizedDenomIn && item.quoteDenoms.includes(normalizedDenomOut)
+      (item) => item.baseDenom === normalizedDenomOut && item.quoteDenoms.includes(normalizedDenomIn)
     );
     if (directPairPool) {
-      return directPairPool;
+      return {
+        ...directPairPool,
+        isInverse: false
+      };
     }
     const inversePairPool = this.pools.find(
-      (item) => item.baseDenom === normalizedDenomOut && item.quoteDenoms.includes(normalizedDenomIn)
+      (item) => item.baseDenom === normalizedDenomIn && item.quoteDenoms.includes(normalizedDenomOut)
     );
     if (inversePairPool) {
-      return inversePairPool;
+      return {
+        ...inversePairPool,
+        isInverse: true
+      };
     }
     return;
   }
@@ -1039,6 +1100,28 @@ var RouterClient = class {
   }
 };
 
+// src/lib/router/simulate-swap.ts
+import {
+  NotFoundError as NotFoundError5
+} from "@bolt-liquidity-hq/core";
+import { bcs as bcs7 } from "@mysten/bcs";
+import { SUI_CLOCK_OBJECT_ID as SUI_CLOCK_OBJECT_ID2 } from "@mysten/sui/utils";
+var simulateSwap = async (client, { assetIn, amountIn, assetOut }) => {
+  const pool = await client.routerClient.getPool(assetIn, assetOut);
+  if (!pool) {
+    throw new NotFoundError5("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, SUI_CLOCK_OBJECT_ID2, bcs7.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);
@@ -1060,15 +1143,16 @@ var swapExactIn = async (client, swapParams, signer) => {
 };
 
 // src/lib/settlement/get-pool-info.ts
-import { SUI_TYPE_ARG as SUI_TYPE_ARG5 } from "@mysten/sui/utils";
+import { NotFoundError as NotFoundError6 } from "@bolt-liquidity-hq/core";
 
 // src/lib/settlement/parsers.ts
+import { BigNumber as BigNumber4 } from "bignumber.js";
 var parseSettlementConfigStructOutput = (routerClient, poolFeesInfo, protocolFeesInfo, priceOracleContract) => {
   return {
     priceOracleContract,
     protocolFeeRecipient: protocolFeesInfo.bolt_fee_addr,
-    protocolFee: poolFeesInfo.swap_fee_pct,
-    lpFee: poolFeesInfo.lp_fee_pct,
+    protocolFee: BigNumber4(poolFeesInfo.swap_fee_pct).div(BASIS_POINTS).toFixed(),
+    lpFee: BigNumber4(poolFeesInfo.lp_fee_pct).div(BASIS_POINTS).toFixed(),
     allowanceMode: "allow",
     // Should come from pool config
     lps: routerClient.getPools().map((item) => item.poolAddress),
@@ -1081,22 +1165,24 @@ var parseSettlementConfigStructOutput = (routerClient, poolFeesInfo, protocolFee
 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 NotFoundError6(`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],
-      // TODO: get the base token of the pool to pass it here instead of hardcoded SUI token
-      [SUI_TYPE_ARG5]
+      [pool.baseDenom]
     ),
     // Query protocol fee information
     queryDevInspect(
       client.suiClient,
       [client.packageId, POOL_MODULE, GET_PROTOCOL_FEES_INFO_FUNCTION],
       [contractAddress],
-      // TODO: get the base token of the pool to pass it here instead of hardcoded SUI token
-      [SUI_TYPE_ARG5]
+      [pool.baseDenom]
     )
   ]);
   const poolFeesInfoOutput = parseDevInspectResult(poolFeesInfo, PoolFeesInfoStruct);
@@ -1436,6 +1522,10 @@ var BoltSuiClient = class extends 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.
    *
@@ -1487,8 +1577,8 @@ var BoltSuiClient = class extends BaseClient {
       for (const item of pools) {
         this.routerClient.pools.push({
           poolAddress: item.pool_object_id,
-          baseDenom: normalizeStructTag5(item.base),
-          quoteDenoms: Object.values(assets).map((auxAsset) => normalizeStructTag5(auxAsset)).filter((auxAsset) => auxAsset !== normalizeStructTag5(item.base))
+          baseDenom: normalizeStructTag6(item.base),
+          quoteDenoms: Object.values(assets).map((auxAsset) => normalizeStructTag6(auxAsset)).filter((auxAsset) => auxAsset !== normalizeStructTag6(item.base))
         });
       }
     }
@@ -1513,11 +1603,11 @@ export {
   PoolInfoStruct,
   PriceDataStruct,
   PriceResponseStruct,
-  PricesResponsePaginatedStruct,
   ProtocolFeesInfoStruct,
   RawPairStruct,
   RawPriceStruct,
   RouterConfigStruct,
+  SwapSimulationResultStruct,
   TypeNameStruct
 };
 //# sourceMappingURL=index.js.map