@bolt-liquidity-hq/cosmwasm-client 0.1.0-beta.2 → 0.1.0-beta.20

package/dist/index.d.cts

@@ -1,684 +1,140 @@
 import { ArchwayClient, SigningArchwayClient } from '@archwayhq/arch3.js';
+import { ChainConfig, ClientConfig, Address, Duration, Timestamp, OracleAssetPair, Coin, AllowanceMode, RouterConfig, BaseClient, OracleConfig, InvertiblePrice, Price, BaseLiquidityDetails, Pool, PoolConfig, Asset, SwapParams, SwapResult, SwapRequiredParams, SimulateSwapResult } from '@bolt-liquidity-hq/core';
 import { CosmWasmClient, SigningCosmWasmClient, ExecuteResult } from '@cosmjs/cosmwasm-stargate';
 import { OfflineSigner } from '@cosmjs/proto-signing';
 
-/**
- * Error codes used throughout the Bolt SDK to categorize different types of errors.
- *
- * These codes help in programmatic error handling and provide a consistent way
- * to identify error types across the SDK.
- *
- * @enum {number}
- * @group Errors
- * @category Error Types
- *
- * @example
- * ```typescript
- * import { BoltSdkErrorCode, BoltSdkError } from '@bolt-liquidity-hq/cosmwasm-client';
- *
- * try {
- *   await client.swapExactIn(signer, params);
- * } catch (error) {
- *   if (error instanceof BoltSdkError) {
- *     switch (error.code) {
- *       case BoltSdkErrorCode.INVALID_ADDRESS:
- *         console.error("Invalid address format");
- *         break;
- *       case BoltSdkErrorCode.TRANSACTION_EVENT_NOT_FOUND:
- *         console.error("Transaction event not found");
- *         break;
- *       default:
- *         console.error("Operation failed:", error.message);
- *     }
- *   }
- * }
- * ```
- */
-declare enum BoltSdkErrorCode {
-    /** Resource not found (pools, assets, configurations) */
-    NOT_FOUND = 0,
-    /** Invalid object structure or missing required fields */
-    INVALID_OBJECT = 1,
-    /** Type mismatch or invalid type provided */
-    INVALID_TYPE = 2,
-    /** Insufficient balance to perform the operation */
-    INSUFFICIENT_FUNDS = 3,
-    /** Invalid blockchain address format */
-    INVALID_ADDRESS = 4,
-    /** Transaction reverted or failed on-chain */
-    TRANSACTION_FAILED = 5,
-    /** Expected transaction event not found in logs */
-    TRANSACTION_EVENT_NOT_FOUND = 6,
-    /** Network connectivity or RPC communication failure */
-    NETWORK_ERROR = 7,
-    /** Invalid parameter provided to a method */
-    INVALID_PARAMETER = 8,
-    /** Required parameter is missing */
-    MISSING_PARAMETER = 9,
-    /** Numeric value outside acceptable range */
-    PARAMETER_OUT_OF_RANGE = 10
-}
-/**
- * Base interface for all Bolt SDK errors.
- *
- * All custom errors in the SDK implement this interface, providing
- * a consistent error structure with error codes for easy handling.
- *
- * @interface
- * @group Errors
- * @category Error Types
- */
-interface BoltSdkError extends Error {
-    /** The error code categorizing this error */
-    code: BoltSdkErrorCode;
-}
-/**
- * Base class for all custom errors in the Bolt SDK.
- *
- * This abstract base class provides common functionality for all SDK errors,
- * including error code assignment and proper error name setting.
- *
- * @abstract
- * @group Errors
- * @category Error Classes
- */
-declare class BoltSdkErrorBase extends Error implements BoltSdkError {
-    code: BoltSdkErrorCode;
-    /**
-     * Creates a new BoltSdkErrorBase instance.
-     *
-     * @param code - The error code categorizing this error
-     * @param message - Human-readable error message
-     */
-    constructor(code: BoltSdkErrorCode, message: string);
-}
-/**
- * Error thrown when a requested resource cannot be found.
- *
- * @group Errors
- * @category Error Classes
- */
-declare class NotFoundError extends BoltSdkErrorBase {
-    /**
-     * Creates a new NotFoundError instance.
-     *
-     * @param resource - The type of resource that was not found
-     * @param details - Optional additional details about what was searched for
-     */
-    constructor(resource: string, details?: string);
-}
-/**
- * Error thrown when an object doesn't have the expected structure.
- *
- * @group Errors
- * @category Error Classes
- */
-declare class InvalidObjectError extends BoltSdkErrorBase {
-    /**
-     * Creates a new InvalidObjectError instance.
-     *
-     * @param details - Optional description of what is invalid about the object
-     */
-    constructor(details?: string);
-}
-/**
- * Error thrown when an unexpected type is encountered.
- *
- * @group Errors
- * @category Error Classes
- */
-declare class InvalidTypeError extends BoltSdkErrorBase {
-    /**
-     * Creates a new InvalidTypeError instance.
-     *
-     * @param expectedType - The type that was expected
-     * @param receivedType - The actual type that was received
-     */
-    constructor(expectedType: string, receivedType: string);
-}
-/**
- * Error thrown when an account has insufficient funds for an operation.
- *
- * @group Errors
- * @category Error Classes
- */
-declare class InsufficientFundsError extends BoltSdkErrorBase {
-    /**
-     * Creates a new InsufficientFundsError instance.
-     *
-     * @param required - The amount required for the operation
-     * @param available - The amount available in the account
-     */
-    constructor(required: number, available: number);
-}
-/**
- * Error thrown when an invalid blockchain address is provided.
- *
- * @group Errors
- * @category Error Classes
- */
-declare class InvalidAddressError extends BoltSdkErrorBase {
-    /**
-     * Creates a new InvalidAddressError instance.
-     *
-     * @param address - The invalid address that was provided
-     */
-    constructor(address: string);
-}
-/**
- * Error thrown when a blockchain transaction fails or is reverted.
- *
- * @group Errors
- * @category Error Classes
- */
-declare class TransactionFailedError extends BoltSdkErrorBase {
-    /**
-     * Creates a new TransactionFailedError instance.
-     *
-     * @param transactionId - The transaction hash or identifier
-     * @param details - Optional details about why the transaction failed
-     */
-    constructor(transactionId: string, details?: string);
-}
-/**
- * Error thrown when an expected transaction event is not found in the logs.
- *
- * @group Errors
- * @category Error Classes
- */
-declare class TransactionEventNotFoundError extends BoltSdkErrorBase {
-    /**
-     * Creates a new TransactionEventNotFoundError instance.
-     *
-     * @param eventName - The name of the event that was expected
-     * @param details - Optional details about the context
-     */
-    constructor(eventName: string, details?: string);
-}
-/**
- * Error thrown when network communication fails.
- *
- * @group Errors
- * @category Error Classes
- */
-declare class NetworkError extends BoltSdkErrorBase {
-    /**
-     * Creates a new NetworkError instance.
-     *
-     * @param details - Optional details about the network failure
-     */
-    constructor(details?: string);
-}
-/**
- * Error thrown when an invalid parameter is provided to a method.
- *
- * @group Errors
- * @category Error Classes
- */
-declare class InvalidParameterError<T = unknown> extends BoltSdkErrorBase {
-    /**
-     * Creates a new InvalidParameterError instance.
-     *
-     * @param parameterName - The name of the invalid parameter
-     * @param expected - Description of what was expected
-     * @param receivedValue - The actual value that was provided
-     * @param details - Optional additional details or constraints
-     *
-     * @template T - The type of the received value
-     */
-    constructor(parameterName: string, expected: string, receivedValue: T, details?: string);
-}
-/**
- * Error thrown when a required parameter is missing.
- *
- * @group Errors
- * @category Error Classes
- */
-declare class MissingParameterError extends BoltSdkErrorBase {
-    /**
-     * Creates a new MissingParameterError instance.
-     *
-     * @param parameterName - The name of the missing parameter
-     * @param context - Optional context about where the parameter was expected
-     */
-    constructor(parameterName: string, context?: string);
-}
-/**
- * Error thrown when a numeric parameter is outside the acceptable range.
- *
- * @group Errors
- * @category Error Classes
- */
-declare class ParameterOutOfRangeError extends BoltSdkErrorBase {
-    /**
-     * Creates a new ParameterOutOfRangeError instance.
-     *
-     * @param parameterName - The name of the parameter that's out of range
-     * @param value - The actual value that was provided
-     * @param min - Optional minimum acceptable value (inclusive)
-     * @param max - Optional maximum acceptable value (inclusive)
-     * @param details - Optional additional details about the constraint
-     */
-    constructor(parameterName: string, value: number | bigint, min?: number | bigint, max?: number | bigint, details?: string);
-}
-
-declare enum Environment {
-    Mainnet = "mainnet",
-    Testnet = "testnet"
-}
-
-type Address = string;
-type AssetPairString = string;
-type Timestamp = string;
-interface Duration {
-    secs: string;
-    nanos: number;
-}
-interface Coin {
-    denom: string;
-    amount: string;
-}
-
-interface ClientConfig {
-    environment?: Environment;
-    override?: {
-        rpcEndpoint?: string;
-        contracts?: Partial<Contracts>;
-    };
-}
-interface Contracts {
-    oracle: Address;
-    router: Address;
-}
-
-interface OracleConfig {
-    admin: Address;
-    priceThresholdRatio: string;
-    priceExpireTime: Duration | null;
-}
-interface Price {
-    assetPair: AssetPairString;
-    price: string;
-    expiryTime: Timestamp;
-}
-interface InvertiblePrice extends Price {
-    isInverse: boolean;
-}
-interface OracleAsset {
-    name: string;
-    symbol: string;
-    precision: number;
-}
-interface OracleAssetPair {
-    base: OracleAsset;
-    quote: OracleAsset;
-}
+type CosmWasmChainConfig = ChainConfig & {
+    restEndpoint: string;
+};
 
-interface RouterConfig {
-    admin: Address;
-    defaultPriceOracleContract: Address;
-    defaultProtocolFeeRecipient: Address;
-    defaultProtocolFee: string;
-    defaultLpFee: string;
-    settlementCodeId: number;
-}
-interface Pool {
-    poolAddress: Address;
-    baseAssetSymbol: string;
-    quoteAssetsSymbols: string[];
-}
-interface SwapParams {
-    assetIn: string;
-    amountIn: string;
-    assetOut: string;
-    minimumAmountOut?: string;
-    receiver?: Address;
-}
-interface SwapResult<TTxOutput = unknown> {
-    txOutput: TTxOutput;
-    amountOut: string;
-    assetOut: string;
-    txHash: string;
-}
-
-/**
- * Abstract base client for all implementations of the Bolt SDK for different chains/networks.
- *
- * This class provides the foundation for blockchain-specific implementations,
- * defining the core interface for interacting with oracle and router contracts.
- *
- * @template TSigner - The type of the transaction signer specific to the blockchain implementation
- *
- * @example
- * ```typescript
- * class BoltCosmWasmClient extends BaseClient<OfflineSigner> {
- *   // Implementation specific to CosmWasm
- * }
- * ```
- */
-declare abstract class BaseClient<TSigner = unknown> {
-    /**
-     * The RPC endpoint URL for connecting to the blockchain network
-     */
-    rpcEndpoint: Address;
-    /**
-     * Smart contract addresses for making Bolt queries and transactions in the blockchain
-     */
-    contracts: Contracts;
-    /**
-     * Creates a new instance of the BaseClient.
-     *
-     * @param config - Optional configuration object for the client
-     * @param config.override - Override configuration for RPC endpoint and contract addresses
-     * @param config.override.rpcEndpoint - The RPC endpoint URL for the blockchain network
-     * @param config.override.contracts - Contract addresses for oracle and router
-     * @param config.override.contracts.oracle - Address of the price oracle contract
-     * @param config.override.contracts.router - Address of the swap router contract
-     *
-     * @throws {InvalidObjectError} Thrown when required configuration fields are missing
-     *
-     * @example
-     * ```typescript
-     * const client = new ConcreteClient({
-     *   override: {
-     *     rpcEndpoint: 'https://rpc.example.com',
-     *     contracts: {
-     *       oracle: 'archway1...',
-     *       router: 'archway1...'
-     *     }
-     *   }
-     * });
-     * ```
-     */
-    constructor(config?: ClientConfig);
-    /**
-     * Fetches the oracle configuration from the blockchain.
-     *
-     * @returns A promise that resolves to the oracle configuration containing
-     *          settings such as price expiration time and threshold ratio
-     *
-     * @example
-     * ```typescript
-     * const oracleConfig = await client.getOracleConfig();
-     * console.log(`Price expiration: ${oracleConfig.priceExpireTime} seconds`);
-     * ```
-     */
-    abstract getOracleConfig(): Promise<OracleConfig>;
-    /**
-     * Fetches all asset pairs supported by the oracle.
-     *
-     * @returns A promise that resolves to an array of oracle asset pairs,
-     *          each containing base and quote asset information with name, symbol and precision
-     *
-     * @example
-     * ```typescript
-     * const pairs = await client.getAllOracleAssetPairs();
-     * pairs.forEach(pair => {
-     *   console.log(`${pair.base.symbol}/${pair.quote.symbol}`);
-     *   console.log(`  Base: ${pair.base.name}`);
-     *   console.log(`  Quote: ${pair.quote.name}`);
-     * });
-     * ```
-     */
-    abstract getAllOracleAssetPairs(): Promise<OracleAssetPair[]>;
-    /**
-     * Fetches the current price for a specific base/quote asset pair.
-     *
-     * @param baseAssetSymbol - The chain symbol of the base asset (e.g., "aarch", "ibc/...")
-     * @param quoteAssetSymbol - The chain symbol of the quote asset (e.g., "aarch", "ibc/...")
-     *
-     * @returns A promise that resolves to an invertible price object containing
-     *          the current price from the oracle
-     *
-     * @example
-     * ```typescript
-     * // Get price of ARCH in terms of USDC
-     * const priceResult = await client.getPrice("aarch", "ibc/43897B9739BD63E3A08A88191999C632E052724AB96BD4C74AE31375C991F48D");
-     * console.log(`1 ARCH = ${priceResult.price} USDC`);
-     * ```
-     */
-    abstract getPrice(baseAssetSymbol: string, quoteAssetSymbol: string): Promise<InvertiblePrice>;
-    /**
-     * Fetches all available prices from the oracle.
-     *
-     * @returns A promise that resolves to an array of all current prices
-     *          available in the oracle with their respective asset pairs
-     *
-     * @example
-     * ```typescript
-     * const prices = await client.getAllPrices();
-     * prices.forEach(priceData => {
-     *   console.log(`${priceData.assetPair}: ${priceData.price}`);
-     *   console.log(`  Expires on: ${priceData.expiryTime}`);
-     * });
-     * ```
-     */
-    abstract getAllPrices(): Promise<Price[]>;
-    /**
-     * Fetches the router configuration from the blockchain.
-     *
-     * @returns A promise that resolves to the router configuration containing
-     *          settings such as default protocol fees, LP fees, and oracle configuration
-     *
-     * @example
-     * ```typescript
-     * const routerConfig = await client.getRouterConfig();
-     * console.log(`Default protocol fee: ${routerConfig.defaultProtocolFee * 100}%`);
-     * console.log(`Default LP fee: ${routerConfig.defaultLpFee * 100}%`);
-     * ```
-     */
-    abstract getRouterConfig(): Promise<RouterConfig>;
-    /**
-     * Fetches the total liquidity for all base assets across all pools.
-     *
-     * @returns A promise that resolves to a record mapping pool addresses
-     *          to their respective base asset liquidity amounts
-     *
-     * @example
-     * ```typescript
-     * const liquidity = await client.getAllBaseAssetsLiquidity();
-     * Object.entries(liquidity).forEach(([poolAddress, coin]) => {
-     *   console.log(`Pool ${poolAddress}: ${coin.amount} ${coin.denom}`);
-     * });
-     * ```
-     */
-    abstract getAllBaseAssetsLiquidity(): Promise<Record<Address, Coin>>;
-    /**
-     * Fetches all withdrawable quote assets for a specific user or liquidity provider.
-     *
-     * @param address - The blockchain address of the user or liquidity provider
-     *
-     * @returns A promise that resolves to a record mapping pool addresses
-     *          to arrays of withdrawable quote asset coins
-     *
-     * @example
-     * ```typescript
-     * const quotes = await client.getAllQuotesByUser("archway1...");
-     * Object.entries(quotes).forEach(([poolAddress, coins]) => {
-     *   console.log(`Pool ${poolAddress}:`);
-     *   coins.forEach(coin => {
-     *     console.log(`  ${coin.amount} ${coin.symbol}`);
-     *   });
-     * });
-     * ```
-     */
-    abstract getAllQuotesByUser(address: Address): Promise<Record<Address, Coin[]>>;
-    /**
-     * Fetches pool information for a specific base asset.
-     *
-     * @param baseAssetSymbol - The symbol of the base asset (e.g., "aarch", "ibc/...")
-     *
-     * @returns A promise that resolves to the pool information for the specified asset
-     *
-     * @example
-     * ```typescript
-     * const pool = await client.getPoolByBaseAsset("aarch");
-     * console.log(`Pool address: ${pool.poolAddress}`);
-     * console.log(`Base asset: ${pool.baseAssetSymbol}`);
-     * console.log('Available quote assets:');
-     * pool.quoteAssetsSymbols.forEach(symbol => {
-     *   console.log(`  - ${symbol}`);
-     * });
-     * ```
-     */
-    abstract getPoolByBaseAsset(baseAssetSymbol: string): Promise<Pool>;
-    /**
-     * Fetches information for all available pools.
-     *
-     * @returns A promise that resolves to an array containing all pool information
-     *
-     * @example
-     * ```typescript
-     * const pools = await client.getAllPools();
-     * pools.forEach(pool => {
-     *   console.log(`Pool ${pool.poolAddress}:`);
-     *   console.log(`  Base: ${pool.baseAssetSymbol}`);
-     *   console.log(`  Quotes: ${pool.quoteAssetsSymbols.join(', ')}`);
-     * });
-     * ```
-     */
-    abstract getAllPools(): Promise<Pool[]>;
-    /**
-     * Executes a "swap exact in" operation on the blockchain from one asset to another.
-     *
-     * This method performs a swap where the exact input amount is specified, and the output
-     * amount varies based on current pool conditions and fees. The transaction includes
-     * slippage protection through the optional minimumAmountOut parameter.
-     *
-     * @param signer - The transaction signer that will authorize the swap operation.
-     *                 Must have sufficient balance of the input asset.
-     * @param params - The swap configuration parameters
-     * @param params.assetIn - The denom of the asset being sold (e.g., "aarch", "ibc/...")
-     * @param params.amountIn - The exact amount of input asset to swap (in minimal denomination)
-     * @param params.assetOut - The denom of the asset being bought (e.g., "aarch", "ibc/...")
-     * @param params.minimumAmountOut - Optional minimum acceptable amount of output asset.
-     *                                  Transaction will fail if actual output would be less.
-     * @param params.receiver - Optional recipient address for the swapped assets.
-     *                         If not provided, defaults to the signer's address.
-     *
-     * @returns A promise that resolves to the swap result containing transaction
-     *          details and the actual amount of output asset received
-     *
-     * @throws Will throw an error if the swap fails due to insufficient balance,
-     *         slippage exceeding tolerance, or other transaction errors
-     *
-     * @example
-     * ```typescript
-     * // Swap exactly 1 ARCH for USDC (output amount varies)
-     * const result = await client.swapExactIn(signer, {
-     *   assetIn: "aarch",
-     *   amountIn: "1000000000000000000", // Exactly 1 ARCH (18 decimals)
-     *   assetOut: "ibc/43897B9739BD63E3A08A88191999C632E052724AB96BD4C74AE31375C991F48D", // USDC IBC denom
-     *   minimumAmountOut: "1950000000", // Accept no less than 1950 USDC
-     *   receiver: "archway1..." // Optional custom receiver
-     * });
-     *
-     * console.log(`Swapped exactly 1 ARCH`);
-     * console.log(`Received: ${result.amountOut} USDC`);
-     * console.log(`Transaction: ${result.txHash}`);
-     * ```
-     *
-     * @remarks
-     * This is a "swap exact in" operation where:
-     * - The input amount is exactly what you specify
-     * - The output amount depends on pool conditions
-     * - Fees are deducted from the output
-     * - Use minimumAmountOut to protect against excessive slippage
-     */
-    abstract swapExactIn(signer: TSigner, params: SwapParams): Promise<SwapResult>;
-}
-
-interface CosmWasmClientConfig extends ClientConfig {
+type CosmWasmClientConfig = ClientConfig<CosmWasmChainConfig> & {
     chain?: CosmWasmChain;
-}
-declare enum CosmWasmChain {
-    Archway = "archway"
-}
+    cosmWasmClient?: CosmWasmClient | ArchwayClient;
+    signer?: OfflineSigner;
+    signingCosmWasmClient?: SigningCosmWasmClient | SigningArchwayClient;
+};
+type CosmWasmChain = 'archway';
+type SignerWithSigningClient = {
+    signer: OfflineSigner;
+    signingCosmWasmClient: SigningCosmWasmClient | SigningArchwayClient;
+};
 
-interface QueryOracleConfigResponse {
+type AssetPairString = string;
+type QueryOracleConfigResponse = {
     admin: Address;
     price_threshold_ratio: string;
     price_expire_time: Duration | null;
-}
-interface PriceRepresentation {
+};
+type PriceRepresentation = {
     asset_pair: AssetPairString;
     price: string;
     expiry_time: Timestamp;
-}
-interface InvertiblePriceRepresentation extends PriceRepresentation {
+};
+type InvertiblePriceRepresentation = PriceRepresentation & {
     is_inverse: boolean;
-}
-interface QueryPriceResponse {
+};
+type QueryPriceResponse = {
     pair_data: InvertiblePriceRepresentation;
-}
-interface QueryPricesResponse {
+};
+type QueryPricesResponse = {
     prices: PriceRepresentation[];
-}
-interface QueryAssetPairsResponse {
+};
+type QueryAssetPairsResponse = {
     list: OracleAssetPair[];
-}
+};
 
-interface QueryRouterConfigResponse {
+type QuerySettlementConfigResponse = {
+    price_oracle_contract: Address;
+    protocol_fee_recipient: Address;
+    protocol_fee: string;
+    lp_fee: string;
+    allowance_mode: AllowanceMode;
+    lps: Address[];
+    min_base_out: string;
+};
+type QueryBaseLiquidityResponse = {
+    base_liquidity: Coin;
+    total_shares: string;
+};
+
+type QueryRouterConfigResponse = {
     admin: Address;
     default_price_oracle_contract: Address;
     default_protocol_fee_recipient: Address;
     default_protocol_fee: string;
     default_lp_fee: string;
     settlement_code_id: number;
-}
-interface MarketRepresentation {
+};
+type CosmWasmRouterConfig = RouterConfig & {
+    settlementCodeId: number;
+};
+type MarketRepresentation = {
     market_address: Address;
     base_asset_symbol: string;
     quote_assets_symbols: string[];
-}
-interface QueryMarketsResponse {
+};
+type QueryMarketsResponse = {
     markets: MarketRepresentation[];
-}
-interface QueryBaseLiquidityAllResponse {
-    liquidity: Record<Address, Coin>;
-}
-interface QueryQuotesForUserAllResponse {
+};
+type QueryBaseLiquidityAllResponse = {
+    liquidity: Record<Address, QueryBaseLiquidityResponse>;
+};
+type QueryQuotesForUserAllResponse = {
     quotes: Record<Address, Coin[]>;
-}
+};
+type QuerySimulateSwapExactInResponse = {
+    from_pool: Address;
+    quote_in: Coin;
+    base_out: Coin;
+    protocol_fee: string;
+    lp_fee: string;
+};
 
 /**
  * Client implementation for interacting with the Bolt Liquidity Outpost on CosmWasm-based blockchains.
  *
  * This class extends the abstract {@link BaseClient} to provide CosmWasm-specific functionality
  * for querying and executing transactions on Bolt Protocol's oracle and router smart contracts.
+ * It uses ExecuteResult as the transaction output type, providing detailed transaction execution information.
  *
- * @extends {BaseClient<OfflineSigner>}
+ * @extends {BaseClient<OfflineSigner, ExecuteResult>}
  *
  * @group Bolt API Clients
  *
  * @example
  * ```typescript
  * // Create a client for Archway mainnet
- * const client = new BoltCosmWasmClient({
- *   environment: Environment.Mainnet,
- *   chain: CosmWasmChain.Archway
- * });
+ * const client = new BoltCosmWasmClient();
  *
  * // Query oracle prices
- * const price = await client.getPrice("aarch", "ibc/43897B9739BD63E3A08A88191999C632E052724AB96BD4C74AE31375C991F48D");
+ * const price = await client.getPrice("aarch", "ibc/...");
  *
  * // Execute a swap (requires signer)
  * const signer = await DirectSecp256k1HdWallet.fromMnemonic("my mnemonic goes here", {
  *  prefix: 'archway',
  * });
- * const result = await client.swap(signer, {
+ * const result = await client.swap({
  *   assetIn: "aarch",
  *   amountIn: "1000000",
  *   assetOut: "ibc/43897B9739BD63E3A08A88191999C632E052724AB96BD4C74AE31375C991F48D"
- * });
+ * }, signer);
  * ```
  */
-declare class BoltCosmWasmClient extends BaseClient<OfflineSigner> {
+declare class BoltCosmWasmClient extends BaseClient<OfflineSigner, ExecuteResult> {
+    /**
+     * The CosmWasm-specific chain configuration including REST endpoint
+     */
+    chainConfig: CosmWasmChainConfig;
     /**
      * Cached instance of the CosmWasm client for read-only operations
      * @private
      */
     private _cosmWasmClient?;
+    /**
+     * Cached instance of the Signer for transaction execution
+     * @private
+     */
+    private _signer?;
     /**
      * Cached instance of the signing CosmWasm client for transaction execution
      * @private
@@ -692,16 +148,26 @@ declare class BoltCosmWasmClient extends BaseClient<OfflineSigner> {
      * Creates a new instance of the BoltCosmWasmClient.
      *
      * The client automatically configures itself based on the specified chain and environment,
-     * loading the appropriate contract addresses and RPC endpoints 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.override - (Optional) Overrides for RPC endpoint and contract addresses
-     * @param config.override.rpcEndpoint - (Optional) Custom RPC endpoint URL
-     * @param config.override.contracts - (Optional) Custom contract addresses
-     * @param config.override.contracts.oracle - (Optional) Custom oracle contract address
-     * @param config.override.contracts.router - (Optional) Custom router contract address
+     * @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, 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.chainConfig.restEndpoint - (Optional) Custom REST endpoint URL
+     * @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
      *
@@ -712,15 +178,43 @@ declare class BoltCosmWasmClient extends BaseClient<OfflineSigner> {
      *
      * // Use testnet configuration
      * const testnetClient = new BoltCosmWasmClient({
-     *   environment: Environment.Testnet
+     *   environment: 'testnet'
      * });
      *
-     * // Use custom RPC endpoint
+     * // Use custom chain configuration
      * const customClient = new BoltCosmWasmClient({
-     *   override: {
-     *     rpcEndpoint: 'https://custom-rpc.example.com'
+     *   customOverride: {
+     *     chainConfig: {
+     *       id: 'archway-custom-1',
+     *       name: 'Archway Custom',
+     *       rpcEndpoint: 'https://custom-rpc.example.com',
+     *       restEndpoint: 'https://custom-rest.example.com'
+     *     },
+     *     contracts: {
+     *       oracle: 'archway1custom_oracle...',
+     *       router: 'archway1custom_router...'
+     *     },
+     *     nativeTokenDenom: 'aarch',
+     *     assetsConfig: {
+     *       'aarch': {
+     *         symbol: 'ARCH',
+     *         name: 'Archway',
+     *         chainId: 'archway-custom-1',
+     *         denom: 'aarch',
+     *         decimals: 18,
+     *         logo: 'https://example.com/arch.png',
+     *         coingeckoId: 'archway'
+     *       }
+     *     }
      *   }
      * });
+     *
+     * // Use pre-existing CosmWasm clients
+     * const clientWithCustomClients = new BoltCosmWasmClient({
+     *   cosmWasmClient: myCosmWasmClient,
+     *   signer: mySigner,
+     *   signingCosmWasmClient: mySigningClient
+     * });
      * ```
      */
     constructor(config?: CosmWasmClientConfig);
@@ -742,18 +236,18 @@ declare class BoltCosmWasmClient extends BaseClient<OfflineSigner> {
      */
     getCosmWasmClient(): Promise<CosmWasmClient | ArchwayClient>;
     /**
-     * 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
@@ -761,31 +255,51 @@ declare class BoltCosmWasmClient extends BaseClient<OfflineSigner> {
      * 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();
      * ```
      */
-    getSigningCosmWasmClient(signer?: OfflineSigner): Promise<SigningCosmWasmClient | SigningArchwayClient>;
+    getSignerWithSigningClient(newSigner?: OfflineSigner): Promise<SignerWithSigningClient>;
     /** @inheritdoc */
     getOracleConfig(): Promise<OracleConfig>;
     /** @inheritdoc */
     getAllOracleAssetPairs(): Promise<OracleAssetPair[]>;
     /** @inheritdoc */
-    getPrice(baseAssetSymbol: string, quoteAssetSymbol: string): Promise<InvertiblePrice>;
+    getPrice(baseDenom: string, quoteDenom: string): Promise<InvertiblePrice>;
     /** @inheritdoc */
     getAllPrices(): Promise<Price[]>;
     /** @inheritdoc */
     getRouterConfig(): Promise<RouterConfig>;
     /** @inheritdoc */
-    getAllBaseAssetsLiquidity(): Promise<Record<Address, Coin>>;
+    getAllBaseAssetsLiquidity(): Promise<Record<Address, BaseLiquidityDetails>>;
     /** @inheritdoc */
     getAllQuotesByUser(address: Address): Promise<Record<Address, Coin[]>>;
-    /** @inheritdoc */
-    getPoolByBaseAsset(baseAssetSymbol: string): Promise<Pool>;
+    /**
+     * @inheritdoc
+     *
+     * @remarks
+     * In the CosmWasm implementation, this method only uses the `baseDenom` parameter.
+     * The optional `quoteDenom` parameter is ignored as pools are uniquely identified
+     * by their base asset in the current CosmWasm architecture.
+     */
+    getPoolByDenom(baseDenom: string): Promise<Pool>;
     /** @inheritdoc */
     getAllPools(): Promise<Pool[]>;
+    /** @inheritdoc */
+    getPoolConfig(poolContractAddress: Address): Promise<PoolConfig>;
+    /** @inheritdoc */
+    getAssets(): Promise<Asset[]>;
+    /**
+     * @inheritdoc
+     *
+     * @remarks
+     * In the CosmWasm implementation, this method only uses the `baseDenom` parameter.
+     * The optional `quoteDenom` parameter is ignored as pools are uniquely identified
+     * by their base asset in the current CosmWasm architecture.
+     */
+    getPoolConfigByDenom(baseDenom: string): Promise<PoolConfig>;
     /**
      * @inheritdoc
      *
@@ -795,21 +309,56 @@ declare class BoltCosmWasmClient extends BaseClient<OfflineSigner> {
      * 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}`);
      * console.log(`Received: ${result.amountOut} ${result.assetOut}`);
-     * console.log(`Gas used: ${result.gasUsed}`);
+     * console.log(`Gas used: ${result.txOutput.gasUsed}`);
+     * console.log(`Block height: ${result.txOutput.height}`);
+     * ```
+     *
+     * @remarks
+     * This implementation returns a CosmWasm ExecuteResult as the transaction output,
+     * which includes details like gas used, block height, transaction hash, and events.
+     */
+    swap(params: SwapParams, signer?: OfflineSigner): Promise<SwapResult<ExecuteResult>>;
+    /**
+     * @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
      */
-    swapExactIn(signer: OfflineSigner, params: SwapParams): Promise<SwapResult<ExecuteResult>>;
+    estimateSwapGasFees(params: SwapParams, signer: OfflineSigner, gasAdjustment?: number): Promise<Coin | undefined>;
+    /** @inheritdoc */
+    simulateSwap(params: SwapRequiredParams): Promise<SimulateSwapResult>;
 }
 
-export { type Address, type AssetPairString, BoltCosmWasmClient, type BoltSdkError, BoltSdkErrorBase, BoltSdkErrorCode, type ClientConfig, type Coin, type Contracts, CosmWasmChain, type CosmWasmClientConfig, type Duration, Environment, InsufficientFundsError, InvalidAddressError, InvalidObjectError, InvalidParameterError, InvalidTypeError, type InvertiblePrice, type InvertiblePriceRepresentation, type MarketRepresentation, MissingParameterError, NetworkError, NotFoundError, type OracleAsset, type OracleAssetPair, type OracleConfig, ParameterOutOfRangeError, type Pool, type Price, type PriceRepresentation, type QueryAssetPairsResponse, type QueryBaseLiquidityAllResponse, type QueryMarketsResponse, type QueryOracleConfigResponse, type QueryPriceResponse, type QueryPricesResponse, type QueryQuotesForUserAllResponse, type QueryRouterConfigResponse, type RouterConfig, type SwapParams, type SwapResult, type Timestamp, TransactionEventNotFoundError, TransactionFailedError };
+export { type AssetPairString, BoltCosmWasmClient, type CosmWasmChain, type CosmWasmChainConfig, type CosmWasmClientConfig, type CosmWasmRouterConfig, type InvertiblePriceRepresentation, type MarketRepresentation, type PriceRepresentation, type QueryAssetPairsResponse, type QueryBaseLiquidityAllResponse, type QueryBaseLiquidityResponse, type QueryMarketsResponse, type QueryOracleConfigResponse, type QueryPriceResponse, type QueryPricesResponse, type QueryQuotesForUserAllResponse, type QueryRouterConfigResponse, type QuerySettlementConfigResponse, type QuerySimulateSwapExactInResponse, type SignerWithSigningClient };