@bolt-liquidity-hq/cosmwasm-client 0.1.0-beta.1

package/dist/index.d.ts

@@ -0,0 +1,872 @@
+import { ArchwayClient, SigningArchwayClient } from '@archwayhq/arch3.js';
+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;
+}
+
+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;
+}
+
+/**
+ * Parses a coin string containing both amount and denomination into a structured Coin object.
+ *
+ * This utility function extracts the numeric amount and denomination from a concatenated string
+ * where amounts are represented as a single string
+ * (e.g., "1000000uatom", "500000000aconst").
+ *
+ * @param amountWithDenom - A string containing the amount immediately followed by the denomination,
+ *                          with no spaces or separators. The amount must be a positive integer
+ *                          (no decimals or scientific notation).
+ *
+ * @returns A Coin object containing:
+ *          - amount: The numeric portion as a string
+ *          - denom: The denomination portion as a string
+ *
+ * @throws {InvalidParameterError} Thrown when the input string doesn't match the expected format
+ *                                 or when the amount or denomination cannot be extracted
+ *
+ * @example
+ * ```typescript
+ * // Parse a standard Cosmos coin string
+ * const coin = getCoinFromAmountWithDenomString("1000000uatom");
+ * console.log(coin); // { amount: "1000000", denom: "uatom" }
+ *
+ * // Parse an IBC token
+ * const ibcCoin = getCoinFromAmountWithDenomString("500000000ibc/34F8D3402273FFA5278AE5757D81CE151ACFD4B19C494C0EE372A7229714824F");
+ * console.log(ibcCoin); // { amount: "500000000", denom: "ibc/34F8D3402273FFA5278AE5757D81CE151ACFD4B19C494C0EE372A7229714824F" }
+ *
+ * // Parse a custom token
+ * const customCoin = getCoinFromAmountWithDenomString("123456789aconst");
+ * console.log(customCoin); // { amount: "123456789", denom: "aconst" }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Invalid formats that will throw errors
+ * try {
+ *   getCoinFromAmountWithDenomString("1000000"); // Missing denom
+ * } catch (error) {
+ *   console.error("No denomination found");
+ * }
+ *
+ * try {
+ *   getCoinFromAmountWithDenomString("uatom"); // Missing amount
+ * } catch (error) {
+ *   console.error("No amount found");
+ * }
+ *
+ * try {
+ *   getCoinFromAmountWithDenomString("1000000 uatom"); // Contains space
+ * } catch (error) {
+ *   console.error("Invalid format");
+ * }
+ * ```
+ */
+declare const getCoinFromAmountWithDenomString: (amountWithDenom: string) => Coin;
+
+/**
+ * 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., "aconst", "ibc/...")
+     * @param quoteAssetSymbol - The chain symbol of the quote asset (e.g., "aconst", "ibc/...")
+     *
+     * @returns A promise that resolves to an invertible price object containing
+     *          the current price from the oracle
+     *
+     * @example
+     * ```typescript
+     * // Get price of CONST in terms of USDC
+     * const priceResult = await client.getPrice("aconst", "ibc/34F8D3402273FFA5278AE5757D81CE151ACFD4B19C494C0EE372A7229714824F");
+     * console.log(`1 CONST = ${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., "aconst", "ibc/...")
+     *
+     * @returns A promise that resolves to the pool information for the specified asset
+     *
+     * @example
+     * ```typescript
+     * const pool = await client.getPoolByBaseAsset("aconst");
+     * 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., "aconst", "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., "aconst", "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 CONST for USDC (output amount varies)
+     * const result = await client.swapExactIn(signer, {
+     *   assetIn: "aconst",
+     *   amountIn: "1000000000000000000", // Exactly 1 CONST (18 decimals)
+     *   assetOut: "ibc/34F8D3402273FFA5278AE5757D81CE151ACFD4B19C494C0EE372A7229714824F", // USDC IBC denom
+     *   minimumAmountOut: "1950000000", // Accept no less than 1950 USDC
+     *   receiver: "archway1..." // Optional custom receiver
+     * });
+     *
+     * console.log(`Swapped exactly 1 CONST`);
+     * 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 {
+    chain?: CosmWasmChain;
+}
+declare enum CosmWasmChain {
+    Archway = "archway"
+}
+
+interface QueryOracleConfigResponse {
+    admin: Address;
+    price_threshold_ratio: string;
+    price_expire_time: Duration | null;
+}
+interface PriceRepresentation {
+    asset_pair: AssetPairString;
+    price: string;
+    expiry_time: Timestamp;
+}
+interface InvertiblePriceRepresentation extends PriceRepresentation {
+    is_inverse: boolean;
+}
+interface QueryPriceResponse {
+    pair_data: InvertiblePriceRepresentation;
+}
+interface QueryPricesResponse {
+    prices: PriceRepresentation[];
+}
+interface QueryAssetPairsResponse {
+    list: OracleAssetPair[];
+}
+
+interface 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 {
+    market_address: Address;
+    base_asset_symbol: string;
+    quote_assets_symbols: string[];
+}
+interface QueryMarketsResponse {
+    markets: MarketRepresentation[];
+}
+interface QueryBaseLiquidityAllResponse {
+    liquidity: Record<Address, Coin>;
+}
+interface QueryQuotesForUserAllResponse {
+    quotes: Record<Address, Coin[]>;
+}
+
+/**
+ * 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.
+ *
+ * @extends {BaseClient<OfflineSigner>}
+ *
+ * @group Bolt API Clients
+ *
+ * @example
+ * ```typescript
+ * // Create a client for Archway mainnet
+ * const client = new BoltCosmWasmClient({
+ *   environment: Environment.Mainnet,
+ *   chain: CosmWasmChain.Archway
+ * });
+ *
+ * // Query oracle prices
+ * const price = await client.getPrice("aconst", "ibc/34F8D3402273FFA5278AE5757D81CE151ACFD4B19C494C0EE372A7229714824F");
+ *
+ * // Execute a swap (requires signer)
+ * const signer = await DirectSecp256k1HdWallet.fromMnemonic("my mnemonic goes here", {
+ *  prefix: 'archway',
+ * });
+ * const result = await client.swap(signer, {
+ *   assetIn: "aconst",
+ *   amountIn: "1000000",
+ *   assetOut: "ibc/34F8D3402273FFA5278AE5757D81CE151ACFD4B19C494C0EE372A7229714824F"
+ * });
+ * ```
+ */
+declare class BoltCosmWasmClient extends BaseClient<OfflineSigner> {
+    /**
+     * Cached instance of the CosmWasm client for read-only operations
+     * @private
+     */
+    private _cosmWasmClient?;
+    /**
+     * Cached instance of the signing CosmWasm client for transaction execution
+     * @private
+     */
+    private _signingCosmWasmClient?;
+    /**
+     * The specific CosmWasm chain this client is connected to
+     */
+    chain: CosmWasmChain;
+    /**
+     * 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.
+     *
+     * @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
+     *
+     * @throws {InvalidTypeError} Thrown when an unsupported chain is specified
+     *
+     * @example
+     * ```typescript
+     * // Use default configuration (Archway mainnet)
+     * const client = new BoltCosmWasmClient();
+     *
+     * // Use testnet configuration
+     * const testnetClient = new BoltCosmWasmClient({
+     *   environment: Environment.Testnet
+     * });
+     *
+     * // Use custom RPC endpoint
+     * const customClient = new BoltCosmWasmClient({
+     *   override: {
+     *     rpcEndpoint: 'https://custom-rpc.example.com'
+     *   }
+     * });
+     * ```
+     */
+    constructor(config?: CosmWasmClientConfig);
+    /**
+     * Gets or creates a CosmWasm client instance for read-only blockchain operations.
+     *
+     * This method implements lazy initialization and caching of the client instance.
+     * The appropriate client type (ArchwayClient or generic CosmWasmClient) is selected
+     * based on the configured chain.
+     *
+     * @returns A promise that resolves to the CosmWasm client instance
+     *
+     * @example
+     * ```typescript
+     * const client = await boltClient.getCosmWasmClient();
+     * const chainId = await client.getChainId();
+     * const height = await client.getHeight();
+     * ```
+     */
+    getCosmWasmClient(): Promise<CosmWasmClient | ArchwayClient>;
+    /**
+     * Gets or creates a signing CosmWasm client instance for transaction execution.
+     *
+     * This method implements lazy initialization and caching of the signing client.
+     * 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
+     *
+     * @returns A promise that resolves to the signing CosmWasm client instance
+     *
+     * @throws {MissingParameterError} Thrown when no signer is provided and no cached client exists
+     *
+     * @example
+     * ```typescript
+     * // First call requires a signer
+     * const signer = await DirectSecp256k1HdWallet.fromMnemonic("my mnemonic goes here", {
+     *  prefix: 'archway',
+     * });
+     * const signingClient = await boltClient.getSigningCosmWasmClient(signer);
+     *
+     * // Subsequent calls can reuse the cached client
+     * const cachedClient = await boltClient.getSigningCosmWasmClient();
+     * ```
+     */
+    getSigningCosmWasmClient(signer?: OfflineSigner): Promise<SigningCosmWasmClient | SigningArchwayClient>;
+    /** @inheritdoc */
+    getOracleConfig(): Promise<OracleConfig>;
+    /** @inheritdoc */
+    getAllOracleAssetPairs(): Promise<OracleAssetPair[]>;
+    /** @inheritdoc */
+    getPrice(baseAssetSymbol: string, quoteAssetSymbol: string): Promise<InvertiblePrice>;
+    /** @inheritdoc */
+    getAllPrices(): Promise<Price[]>;
+    /** @inheritdoc */
+    getRouterConfig(): Promise<RouterConfig>;
+    /** @inheritdoc */
+    getAllBaseAssetsLiquidity(): Promise<Record<Address, Coin>>;
+    /** @inheritdoc */
+    getAllQuotesByUser(address: Address): Promise<Record<Address, Coin[]>>;
+    /** @inheritdoc */
+    getPoolByBaseAsset(baseAssetSymbol: string): Promise<Pool>;
+    /** @inheritdoc */
+    getAllPools(): Promise<Pool[]>;
+    /**
+     * @inheritdoc
+     *
+     * @example
+     * ```typescript
+     * // Get signer (e.g., from Keplr wallet)
+     * const signer = await window.keplr.getOfflineSignerAuto(chainId);
+     *
+     * // Execute swap: 1 CONST for USDC
+     * const result = await client.swap(signer, {
+     *   assetIn: "aconst",
+     *   amountIn: "1000000000000000000", // 1 CONST (18 decimals)
+     *   assetOut: "ibc/34F8D3402273FFA5278AE5757D81CE151ACFD4B19C494C0EE372A7229714824F", // USDC IBC denom
+     *   minimumAmountOut: "1950000000", // Minimum 1950 USDC expected
+     *   receiver: "archway1..." // Optional custom receiver
+     * });
+     *
+     * console.log(`Swap successful!`);
+     * console.log(`Transaction hash: ${result.txHash}`);
+     * console.log(`Received: ${result.amountOut} ${result.assetOut}`);
+     * console.log(`Gas used: ${result.gasUsed}`);
+     * ```
+     */
+    swapExactIn(signer: OfflineSigner, params: SwapParams): Promise<SwapResult<ExecuteResult>>;
+}
+
+export { type Address, type AssetPairString, BaseClient, 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, getCoinFromAmountWithDenomString };