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

package/dist/index.cjs

@@ -28,7 +28,7 @@ module.exports = __toCommonJS(index_exports);
 
 // src/lib/client.ts
 var import_arch3 = require("@archwayhq/arch3.js");
-var import_core3 = require("@bolt-liquidity-hq/core");
+var import_core4 = require("@bolt-liquidity-hq/core");
 var import_cosmwasm_stargate = require("@cosmjs/cosmwasm-stargate");
 
 // src/config/archway-mainnet.ts
@@ -42,6 +42,7 @@ var ArchwayMainnetContracts = {
   oracle: "archway1cr5l0tvhqsdjfzun4jkwqfzv7fadu598hultcra4jrljgwl639wsksmd28",
   router: "archway1vu2ctevyav3wlka9yn7hmcm0xnlltklnnceqaanpuh0eete80xgsymc3ln"
 };
+var ArchwayMainnetNativeTokenDenom = "aarch";
 var ArchwayMainnetAssets = {
   aarch: {
     symbol: "ARCH",
@@ -5240,6 +5241,7 @@ var ArchwayTestnetContracts = {
   oracle: "archway1ehpghtr0v95kfx648dck7pvs08d6ah97l99xkx87t2zx8tcyen0s9n90x4",
   router: "archway1rtdlmwgedg2vnsdyp3l23yr8eh7gspndt0x5cv5n9vxnerm374cs8lxk25"
 };
+var ArchwayTestnetNativeTokenDenom = "aconst";
 var ArchwayTestnetAssets = {
   aconst: {
     symbol: "CONST",
@@ -5448,8 +5450,10 @@ var parseQueryOracleConfigResponse = (response) => {
   };
 };
 var parsePriceRepresentation = (priceRepresentation) => {
+  const [baseDenom, quoteDenom] = priceRepresentation.asset_pair.split(":");
   return {
-    assetPair: priceRepresentation.asset_pair,
+    baseDenom: baseDenom ?? "",
+    quoteDenom: quoteDenom ?? "",
     price: priceRepresentation.price,
     expiryTime: priceRepresentation.expiry_time
   };
@@ -5494,6 +5498,76 @@ var getPrices = async (client) => {
   return parseQueryPricesResponse(response);
 };
 
+// src/lib/router/estimate-swap-exact-in-gas-fees.ts
+var import_core2 = require("@bolt-liquidity-hq/core");
+var import_encoding = require("@cosmjs/encoding");
+var import_bignumber = require("bignumber.js");
+var import_tx = require("cosmjs-types/cosmwasm/wasm/v1/tx");
+
+// src/lib/helpers/transactions.ts
+var import_core = require("@bolt-liquidity-hq/core");
+var getSignerAddress = async (signer) => {
+  const accounts = await signer.getAccounts();
+  if (!accounts?.[0]) {
+    throw new import_core.NotFoundError("Signer account's address");
+  }
+  return accounts[0].address;
+};
+
+// src/lib/router/estimate-swap-exact-in-gas-fees.ts
+var estimateSwapExactInGasFees = async (client, { assetIn, amountIn, assetOut, minimumAmountOut, receiver }, signer, gasAdjustment = import_core2.DEFAULT_GAS_ADJUSTMENT) => {
+  const { signer: finalSigner, signingCosmWasmClient } = await client.getSignerWithSigningClient(signer);
+  const address = await getSignerAddress(finalSigner);
+  const message = [
+    {
+      typeUrl: "/cosmwasm.wasm.v1.MsgExecuteContract",
+      value: import_tx.MsgExecuteContract.fromPartial({
+        contract: client.contracts.router,
+        funds: [
+          {
+            amount: amountIn,
+            denom: assetIn
+          }
+        ],
+        msg: (0, import_encoding.toUtf8)(
+          JSON.stringify({
+            swap_exact_in: {
+              want_out: assetOut,
+              minimum_base_out: minimumAmountOut,
+              receiver
+            }
+          })
+        ),
+        sender: address
+      })
+    }
+  ];
+  const SIMULATION_MEMO = "Swap simulation from Bolt SDK";
+  if ("calculateFee" in signingCosmWasmClient) {
+    try {
+      const result = await signingCosmWasmClient.calculateFee(
+        address,
+        message,
+        SIMULATION_MEMO,
+        gasAdjustment
+      );
+      return result.amount[0];
+    } catch {
+      return;
+    }
+  } else {
+    try {
+      const result = await signingCosmWasmClient.simulate(address, message, SIMULATION_MEMO);
+      return {
+        amount: (0, import_bignumber.BigNumber)(result).times(gasAdjustment).toFixed(0),
+        denom: client.nativeTokenDenom
+      };
+    } catch {
+      return;
+    }
+  }
+};
+
 // src/lib/router/parsers.ts
 var parseMarketRepresentation = (marketRepresentation) => {
   return {
@@ -5575,27 +5649,17 @@ var getRouterConfig = async (client) => {
 };
 
 // src/lib/router/swap-exact-in.ts
-var import_core2 = require("@bolt-liquidity-hq/core");
+var import_core3 = require("@bolt-liquidity-hq/core");
 
 // src/lib/constants/events.ts
 var BOLT_SWAP_EVENT_TYPE = "wasm-bolt_swap";
 var BOLT_COIN_RECEIVED_EVENT_TYPE = "coin_received";
 var BOLT_COIN_RECEIVED_EVENT_AMOUNT_KEY = "amount";
 
-// src/lib/helpers/transactions.ts
-var import_core = require("@bolt-liquidity-hq/core");
-var getSignerAddress = async (signer) => {
-  const accounts = await signer.getAccounts();
-  if (!accounts?.[0]) {
-    throw new import_core.NotFoundError("Signer account's address");
-  }
-  return accounts[0].address;
-};
-
 // src/lib/router/swap-exact-in.ts
-var swapExactIn = async (client, signer, { assetIn, amountIn, assetOut, minimumAmountOut, receiver }) => {
-  const signingCosmWasmClient = await client.getSigningCosmWasmClient(signer);
-  const address = await getSignerAddress(signer);
+var swapExactIn = async (client, { assetIn, amountIn, assetOut, minimumAmountOut, receiver }, signer) => {
+  const { signer: finalSigner, signingCosmWasmClient } = await client.getSignerWithSigningClient(signer);
+  const address = await getSignerAddress(finalSigner);
   const txOutput = await signingCosmWasmClient.execute(
     address,
     client.contracts.router,
@@ -5614,7 +5678,7 @@ var swapExactIn = async (client, signer, { assetIn, amountIn, assetOut, minimumA
     (item) => item.type === BOLT_SWAP_EVENT_TYPE
   );
   if (boltSwapEventIndex === -1) {
-    throw new import_core2.TransactionEventNotFoundError(
+    throw new import_core3.TransactionEventNotFoundError(
       BOLT_SWAP_EVENT_TYPE,
       "After the transaction was executed, no successful swap event was emitted, the transaction may have failed"
     );
@@ -5627,14 +5691,14 @@ var swapExactIn = async (client, signer, { assetIn, amountIn, assetOut, minimumA
       )?.value;
       if (amountWithDenomOut) {
         try {
-          amountOut = (0, import_core2.getCoinFromAmountWithDenomString)(amountWithDenomOut).amount;
+          amountOut = (0, import_core3.getCoinFromAmountWithDenomString)(amountWithDenomOut).amount;
           break;
         } catch {
         }
       }
     }
   if (!amountOut) {
-    throw new import_core2.TransactionEventNotFoundError(
+    throw new import_core3.TransactionEventNotFoundError(
       BOLT_COIN_RECEIVED_EVENT_TYPE,
       "After the transaction was executed, no coin received event was emitted, the transaction may have failed"
     );
@@ -5676,17 +5740,18 @@ var getSettlementConfigForBase = async (client, baseDenom) => {
 };
 
 // src/lib/client.ts
-var BoltCosmWasmClient = class extends import_core3.BaseClient {
+var BoltCosmWasmClient = class extends import_core4.BaseClient {
   /**
    * Creates a new instance of the BoltCosmWasmClient.
    *
    * The client automatically configures itself based on the specified chain and environment,
-   * loading the appropriate contract addresses, chain configuration, and assets from configuration files.
+   * 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.chain - (Optional) The specific CosmWasm chain to connect to. Defaults to 'archway'
-   * @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
@@ -5695,8 +5760,10 @@ var BoltCosmWasmClient = class extends import_core3.BaseClient {
    * @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., "aarch")
    * @param config.customOverride.assetsConfig - (Optional) Custom asset configurations indexed by denom
    * @param config.cosmWasmClient - (Optional) Pre-existing CosmWasmClient to use for blockchain queries
+   * @param config.signer - (Optional) Pre-existing OfflineSigner for transaction signing
    * @param config.signingCosmWasmClient - (Optional) Pre-existing SigningCosmWasmClient to use for blockchain transactions
    *
    * @throws {InvalidTypeError} Thrown when an unsupported chain is specified
@@ -5724,6 +5791,7 @@ var BoltCosmWasmClient = class extends import_core3.BaseClient {
    *       oracle: 'archway1custom_oracle...',
    *       router: 'archway1custom_router...'
    *     },
+   *     nativeTokenDenom: 'aarch',
    *     assetsConfig: {
    *       'aarch': {
    *         symbol: 'ARCH',
@@ -5741,6 +5809,7 @@ var BoltCosmWasmClient = class extends import_core3.BaseClient {
    * // Use pre-existing CosmWasm clients
    * const clientWithCustomClients = new BoltCosmWasmClient({
    *   cosmWasmClient: myCosmWasmClient,
+   *   signer: mySigner,
    *   signingCosmWasmClient: mySigningClient
    * });
    * ```
@@ -5751,19 +5820,22 @@ var BoltCosmWasmClient = class extends import_core3.BaseClient {
       chain = "archway",
       customOverride,
       cosmWasmClient,
+      signer,
       signingCosmWasmClient
     } = config ?? {};
     let defaultChainConfig;
     let defaultContracts;
+    let defaultNativeTokenDenom;
     let assetsConfig;
     switch (chain) {
       case "archway":
         defaultChainConfig = environment === "mainnet" ? ArchwayMainnetChainConfig : ArchwayTestnetChainConfig;
         defaultContracts = environment === "mainnet" ? ArchwayMainnetContracts : ArchwayTestnetContracts;
+        defaultNativeTokenDenom = environment === "mainnet" ? ArchwayMainnetNativeTokenDenom : ArchwayTestnetNativeTokenDenom;
         assetsConfig = environment === "mainnet" ? ArchwayMainnetAssets : ArchwayTestnetAssets;
         break;
       default:
-        throw new import_core3.InvalidTypeError("A valid value of CosmWasmChain", chain);
+        throw new import_core4.InvalidTypeError("A valid value of CosmWasmChain", chain);
     }
     const chainConfig = {
       id: customOverride?.chainConfig?.id ?? defaultChainConfig.id,
@@ -5775,6 +5847,7 @@ var BoltCosmWasmClient = class extends import_core3.BaseClient {
       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;
     }
@@ -5782,6 +5855,7 @@ var BoltCosmWasmClient = class extends import_core3.BaseClient {
       customOverride: {
         chainConfig,
         contracts,
+        nativeTokenDenom,
         assetsConfig
       }
     });
@@ -5794,6 +5868,11 @@ var BoltCosmWasmClient = class extends import_core3.BaseClient {
      * @private
      */
     __publicField(this, "_cosmWasmClient");
+    /**
+     * Cached instance of the Signer for transaction execution
+     * @private
+     */
+    __publicField(this, "_signer");
     /**
      * Cached instance of the signing CosmWasm client for transaction execution
      * @private
@@ -5806,6 +5885,7 @@ var BoltCosmWasmClient = class extends import_core3.BaseClient {
     this.chainConfig = chainConfig;
     this.chain = chain;
     this._cosmWasmClient = cosmWasmClient;
+    this._signer = signer;
     this._signingCosmWasmClient = signingCosmWasmClient;
   }
   /**
@@ -5831,18 +5911,18 @@ var BoltCosmWasmClient = class extends import_core3.BaseClient {
     return this._cosmWasmClient;
   }
   /**
-   * Gets or creates a signing CosmWasm client instance for transaction execution.
+   * Gets or creates a signing CosmWasm client instance along with the signer for transaction execution.
    *
-   * This method implements lazy initialization and caching of the signing client.
+   * This method implements lazy initialization and caching of both the signing client and signer.
    * A signer must be provided either on first call or to replace the cached instance.
    * The appropriate client type is selected based on the configured chain.
    *
-   * @param signer - Optional offline signer for transaction signing. Required on first call
-   *                 or to replace the existing signer
+   * @param newSigner - Optional offline signer for transaction signing. Required on first call
+   *                    or to replace the existing signer
    *
-   * @returns A promise that resolves to the signing CosmWasm client instance
+   * @returns A promise that resolves to an object containing both the signer and signing client
    *
-   * @throws {MissingParameterError} Thrown when no signer is provided and no cached client exists
+   * @throws {MissingParameterError} Thrown when no signer is provided and no cached signer exists
    *
    * @example
    * ```typescript
@@ -5850,20 +5930,27 @@ var BoltCosmWasmClient = class extends import_core3.BaseClient {
    * const signer = await DirectSecp256k1HdWallet.fromMnemonic("my mnemonic goes here", {
    *  prefix: 'archway',
    * });
-   * const signingClient = await boltClient.getSigningCosmWasmClient(signer);
+   * const { signer: cachedSigner, signingCosmWasmClient } = await boltClient.getSignerWithSigningClient(signer);
    *
-   * // Subsequent calls can reuse the cached client
-   * const cachedClient = await boltClient.getSigningCosmWasmClient();
+   * // Subsequent calls can reuse the cached signer and client
+   * const { signer, signingCosmWasmClient: client } = await boltClient.getSignerWithSigningClient();
    * ```
    */
-  async getSigningCosmWasmClient(signer) {
-    if (!this._signingCosmWasmClient || signer) {
-      if (!signer) {
-        throw new import_core3.MissingParameterError("signer");
+  async getSignerWithSigningClient(newSigner) {
+    if (!this._signingCosmWasmClient || !this._signer || newSigner) {
+      this._signer = newSigner ?? this._signer;
+      if (!this._signer) {
+        throw new import_core4.MissingParameterError("signer");
       }
-      this._signingCosmWasmClient = await (this.chain === "archway" ? import_arch3.SigningArchwayClient : import_cosmwasm_stargate.SigningCosmWasmClient).connectWithSigner(this.chainConfig.rpcEndpoint, signer);
+      this._signingCosmWasmClient = await (this.chain === "archway" ? import_arch3.SigningArchwayClient : import_cosmwasm_stargate.SigningCosmWasmClient).connectWithSigner(this.chainConfig.rpcEndpoint, this._signer);
+    }
+    if (!this._signer) {
+      throw new import_core4.MissingParameterError("signer");
     }
-    return this._signingCosmWasmClient;
+    return {
+      signer: this._signer,
+      signingCosmWasmClient: this._signingCosmWasmClient
+    };
   }
   // The following methods inherit their documentation from BaseClient
   // Only add documentation here if you need to override or add implementation-specific details
@@ -5924,13 +6011,13 @@ var BoltCosmWasmClient = class extends import_core3.BaseClient {
    * const signer = await window.keplr.getOfflineSignerAuto(chainId);
    *
    * // Execute swap: 1 ARCH for USDC
-   * const result = await client.swap(signer, {
+   * const result = await client.swap({
    *   assetIn: "aarch",
    *   amountIn: "1000000000000000000", // 1 ARCH (18 decimals)
    *   assetOut: "ibc/43897B9739BD63E3A08A88191999C632E052724AB96BD4C74AE31375C991F48D", // USDC IBC denom
    *   minimumAmountOut: "1950000000", // Minimum 1950 USDC expected
    *   receiver: "archway1..." // Optional custom receiver
-   * });
+   * }, signer);
    *
    * console.log(`Swap successful!`);
    * console.log(`Transaction hash: ${result.txHash}`);
@@ -5943,8 +6030,38 @@ var BoltCosmWasmClient = class extends import_core3.BaseClient {
    * This implementation returns a CosmWasm ExecuteResult as the transaction output,
    * which includes details like gas used, block height, transaction hash, 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 (e.g., from Keplr wallet)
+   * const signer = await window.keplr.getOfflineSignerAuto(chainId);
+   *
+   * // Estimate gas for swapping 1 ARCH to USDC
+   * const gasEstimate = await client.estimateSwapGasFees({
+   *   assetIn: "aarch",
+   *   amountIn: "1000000000000000000", // 1 ARCH
+   *   assetOut: "ibc/43897B9739BD63E3A08A88191999C632E052724AB96BD4C74AE31375C991F48D", // USDC
+   *   minimumAmountOut: "1950000000" // Min 1950 USDC
+   * }, signer, 1.3); // 30% safety margin
+   *
+   * if (gasEstimate) {
+   *   console.log(`Estimated gas: ${gasEstimate.amount} ${gasEstimate.denom}`);
+   * }
+   * ```
+   *
+   * @remarks
+   * - For CosmWasm chains, gas is always paid in the native token (e.g., "aarch" for Archway)
+   * - The returned amount is in the smallest denomination (6 decimals for most Cosmos chains)
+   * - Gas estimation uses CosmWasm's simulation capabilities
+   * - The gasAdjustment parameter helps account for variations in actual execution
+   */
+  async estimateSwapGasFees(params, signer, gasAdjustment) {
+    return await estimateSwapExactInGasFees(this, params, signer, gasAdjustment);
   }
 };
 //# sourceMappingURL=index.cjs.map