@bolt-liquidity-hq/cosmwasm-client 0.1.0-beta.3 → 0.1.0-beta.5

package/dist/index.d.cts

@@ -6,7 +6,14 @@ 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.
+ * to identify error types across the SDK. Error codes are organized into ranges
+ * by category for easier identification and handling.
+ *
+ * Error Code Ranges:
+ * - 1000-1999: Resource & Data Errors
+ * - 2000-2999: Blockchain Transaction Errors
+ * - 3000-3999: Infrastructure & Network Errors
+ * - 4000-4999: Validation & Input Errors
  *
  * @enum {number}
  * @group Errors
@@ -17,7 +24,7 @@ import { OfflineSigner } from '@cosmjs/proto-signing';
  * import { BoltSdkErrorCode, BoltSdkError } from '@bolt-liquidity-hq/cosmwasm-client';
  *
  * try {
- *   await client.swapExactIn(signer, params);
+ *   await client.swap(signer, params);
  * } catch (error) {
  *   if (error instanceof BoltSdkError) {
  *     switch (error.code) {
@@ -36,27 +43,27 @@ import { OfflineSigner } from '@cosmjs/proto-signing';
  */
 declare enum BoltSdkErrorCode {
     /** Resource not found (pools, assets, configurations) */
-    NOT_FOUND = 0,
+    NOT_FOUND = 1000,
     /** Invalid object structure or missing required fields */
-    INVALID_OBJECT = 1,
+    INVALID_OBJECT = 1001,
     /** Type mismatch or invalid type provided */
-    INVALID_TYPE = 2,
+    INVALID_TYPE = 1002,
     /** Insufficient balance to perform the operation */
-    INSUFFICIENT_FUNDS = 3,
+    INSUFFICIENT_FUNDS = 2000,
     /** Invalid blockchain address format */
-    INVALID_ADDRESS = 4,
+    INVALID_ADDRESS = 2001,
     /** Transaction reverted or failed on-chain */
-    TRANSACTION_FAILED = 5,
+    TRANSACTION_FAILED = 2002,
     /** Expected transaction event not found in logs */
-    TRANSACTION_EVENT_NOT_FOUND = 6,
+    TRANSACTION_EVENT_NOT_FOUND = 2003,
     /** Network connectivity or RPC communication failure */
-    NETWORK_ERROR = 7,
+    NETWORK_ERROR = 3000,
     /** Invalid parameter provided to a method */
-    INVALID_PARAMETER = 8,
+    INVALID_PARAMETER = 4000,
     /** Required parameter is missing */
-    MISSING_PARAMETER = 9,
+    MISSING_PARAMETER = 4001,
     /** Numeric value outside acceptable range */
-    PARAMETER_OUT_OF_RANGE = 10
+    PARAMETER_OUT_OF_RANGE = 4002
 }
 /**
  * Base interface for all Bolt SDK errors.
@@ -262,63 +269,73 @@ declare class ParameterOutOfRangeError extends BoltSdkErrorBase {
     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 {
+type Duration = {
     secs: number;
     nanos: number;
-}
-interface Coin {
+};
+type Coin = {
     denom: string;
     amount: string;
-}
+};
 
-interface ClientConfig {
+type Environment = 'mainnet' | 'testnet';
+type Asset = {
+    symbol: string;
+    name: string;
+    chainId: string;
+    denom: string;
+    decimals: number;
+    logo?: string;
+    coingeckoId?: string;
+};
+type ChainConfig = {
+    name: string;
+    id: string;
+    rpcEndpoint: string;
+};
+type Contracts = {
+    oracle: Address;
+    router: Address;
+};
+type AssetsConfig = Record<string, Asset>;
+
+type ClientConfig<TChainConfig = ChainConfig> = {
     environment?: Environment;
     customOverride?: {
-        rpcEndpoint?: string;
+        chainConfig?: Partial<TChainConfig>;
         contracts?: Partial<Contracts>;
+        assetsConfig?: AssetsConfig;
     };
-}
-interface Contracts {
-    oracle: Address;
-    router: Address;
-}
+};
 
-interface OracleConfig {
+type OracleConfig = {
     admin: Address;
     priceThresholdRatio: string;
     priceExpireTime: Duration | null;
-}
-interface Price {
+};
+type Price = {
     assetPair: AssetPairString;
     price: string;
     expiryTime: Timestamp;
-}
-interface InvertiblePrice extends Price {
+};
+type InvertiblePrice = Price & {
     isInverse: boolean;
-}
-interface OracleAsset {
+};
+type OracleAsset = {
     name: string;
     symbol: string;
     precision: number;
-}
-interface OracleAssetPair {
+};
+type OracleAssetPair = {
     base: OracleAsset;
     quote: OracleAsset;
-}
+};
 
-declare enum AllowanceMode {
-    Allow = "allow",
-    Disallow = "disallow"
-}
-interface PoolConfig {
+type AllowanceMode = 'allow' | 'disallow';
+type PoolConfig = {
     priceOracleContract: Address;
     protocolFeeRecipient: Address;
     protocolFee: string;
@@ -326,34 +343,38 @@ interface PoolConfig {
     allowanceMode: AllowanceMode;
     lps: Address[];
     minBaseOut: string;
-}
+};
+type BaseLiquidityDetails = {
+    baseLiquidity: Coin;
+    totalShares: string;
+};
 
-interface RouterConfig {
+type RouterConfig = {
     admin: Address;
     defaultPriceOracleContract: Address;
     defaultProtocolFeeRecipient: Address;
     defaultProtocolFee: string;
     defaultLpFee: string;
     settlementCodeId: number;
-}
-interface Pool {
+};
+type Pool = {
     poolAddress: Address;
     baseAssetSymbol: string;
     quoteAssetsSymbols: string[];
-}
-interface SwapParams {
+};
+type SwapParams = {
     assetIn: string;
     amountIn: string;
     assetOut: string;
     minimumAmountOut?: string;
     receiver?: Address;
-}
-interface SwapResult<TTxOutput = unknown> {
+};
+type 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.
@@ -362,43 +383,67 @@ interface SwapResult<TTxOutput = unknown> {
  * defining the core interface for interacting with oracle and router contracts.
  *
  * @template TSigner - The type of the transaction signer specific to the blockchain implementation
+ * @template TTxOutput - The type of the transaction output specific to the blockchain implementation
  *
  * @example
  * ```typescript
- * class BoltCosmWasmClient extends BaseClient<OfflineSigner> {
+ * class BoltCosmWasmClient extends BaseClient<OfflineSigner, ExecuteResult> {
  *   // Implementation specific to CosmWasm
  * }
  * ```
  */
-declare abstract class BaseClient<TSigner = unknown> {
+declare abstract class BaseClient<TSigner = unknown, TTxOutput = unknown> {
     /**
-     * The RPC endpoint URL for connecting to the blockchain network
+     * The blockchain network configuration containing chain ID, name, and RPC endpoint
      */
-    rpcEndpoint: Address;
+    chainConfig: ChainConfig;
     /**
      * Smart contract addresses for making Bolt queries and transactions in the blockchain
      */
     contracts: Contracts;
+    /**
+     * Configuration mapping of supported assets indexed by their symbol
+     */
+    assetsConfig: AssetsConfig;
     /**
      * Creates a new instance of the BaseClient.
      *
      * @param config - (Optional) Configuration object for the client
-     * @param config.customOverride - (Optional) Override configuration for RPC endpoint and contract addresses
-     * @param config.customOverride.rpcEndpoint - (Optional) Custom RPC endpoint URL for the blockchain network
-     * @param config.customOverride.contracts - (Optional) Custom 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 - (Optional) Override configuration containing chain settings, contracts, and assets
+     * @param config.customOverride.chainConfig - (Optional) Chain configuration object
+     * @param config.customOverride.chainConfig.id - (Optional) The chain ID of the blockchain network (e.g., "archway-1")
+     * @param config.customOverride.chainConfig.name - (Optional) The human-readable name of the chain (e.g., "Archway")
+     * @param config.customOverride.chainConfig.rpcEndpoint - (Optional) RPC endpoint URL for the blockchain network
+     * @param config.customOverride.contracts - (Optional) Contract addresses for oracle and router
+     * @param config.customOverride.contracts.oracle - (Optional) Oracle contract address
+     * @param config.customOverride.contracts.router - (Optional) Router contract address
+     * @param config.customOverride.assetsConfig - (Optional) Configuration for supported assets indexed by symbol
      *
      * @throws {InvalidObjectError} Thrown when required configuration fields are missing
      *
      * @example
      * ```typescript
      * const client = new ConcreteClient({
-     *   override: {
-     *     rpcEndpoint: 'https://rpc.example.com',
+     *   customOverride: {
+     *     chainConfig: {
+     *       id: 'archway-1',
+     *       name: 'Archway',
+     *       rpcEndpoint: 'https://rpc.example.com'
+     *     },
      *     contracts: {
-     *       oracle: 'archway1...',
-     *       router: 'archway1...'
+     *       oracle: 'archway1oracle...',
+     *       router: 'archway1router...'
+     *     },
+     *     assetsConfig: {
+     *       'ARCH': {
+     *         symbol: 'ARCH',
+     *         name: 'Archway',
+     *         chainId: 'archway-1',
+     *         denom: 'aarch',
+     *         decimals: 18,
+     *         logo: 'https://...',
+     *         coingeckoId: 'archway'
+     *       }
      *     }
      *   }
      * });
@@ -415,6 +460,8 @@ declare abstract class BaseClient<TSigner = unknown> {
      * ```typescript
      * const oracleConfig = await client.getOracleConfig();
      * console.log(`Price expiration: ${oracleConfig.priceExpireTime} seconds`);
+     * console.log(`Admin: ${oracleConfig.admin}`);
+     * console.log(`Price threshold ratio: ${oracleConfig.priceThresholdRatio}`);
      * ```
      */
     abstract getOracleConfig(): Promise<OracleConfig>;
@@ -429,26 +476,27 @@ declare abstract class BaseClient<TSigner = unknown> {
      * 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}`);
+     *   console.log(`  Base: ${pair.base.name} (${pair.base.precision} decimals)`);
+     *   console.log(`  Quote: ${pair.quote.name} (${pair.quote.precision} decimals)`);
      * });
      * ```
      */
     abstract getAllOracleAssetPairs(): Promise<OracleAssetPair[]>;
     /**
-     * Fetches the current price for a specific base/quote asset pair.
+     * Fetches the current price for a specific base/quote asset pair from the oracle.
      *
-     * @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/...")
+     * @param baseAssetSymbol - The symbol of the base asset (e.g., "ARCH", "USDC")
+     * @param quoteAssetSymbol - The symbol of the quote asset (e.g., "ARCH", "USDC")
      *
      * @returns A promise that resolves to an invertible price object containing
-     *          the current price from the oracle
+     *          the current price from the oracle and whether it's inverted
      *
      * @example
      * ```typescript
      * // Get price of ARCH in terms of USDC
-     * const priceResult = await client.getPrice("aarch", "ibc/43897B9739BD63E3A08A88191999C632E052724AB96BD4C74AE31375C991F48D");
+     * const priceResult = await client.getPrice("ARCH", "USDC");
      * console.log(`1 ARCH = ${priceResult.price} USDC`);
+     * console.log(`Is inverted: ${priceResult.isInverse}`);
      * ```
      */
     abstract getPrice(baseAssetSymbol: string, quoteAssetSymbol: string): Promise<InvertiblePrice>;
@@ -456,14 +504,14 @@ declare abstract class BaseClient<TSigner = unknown> {
      * 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
+     *          available in the oracle with their respective asset pairs and expiry times
      *
      * @example
      * ```typescript
      * const prices = await client.getAllPrices();
      * prices.forEach(priceData => {
      *   console.log(`${priceData.assetPair}: ${priceData.price}`);
-     *   console.log(`  Expires on: ${priceData.expiryTime}`);
+     *   console.log(`  Expires at: ${new Date(priceData.expiryTime * 1000).toISOString()}`);
      * });
      * ```
      */
@@ -479,6 +527,7 @@ declare abstract class BaseClient<TSigner = unknown> {
      * const routerConfig = await client.getRouterConfig();
      * console.log(`Default protocol fee: ${routerConfig.defaultProtocolFee * 100}%`);
      * console.log(`Default LP fee: ${routerConfig.defaultLpFee * 100}%`);
+     * console.log(`Oracle address: ${routerConfig.priceOracleContract}`);
      * ```
      */
     abstract getRouterConfig(): Promise<RouterConfig>;
@@ -486,17 +535,20 @@ declare abstract class BaseClient<TSigner = unknown> {
      * 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
+     *          to their respective base asset liquidity details, including
+     *          the base liquidity amount and total shares
      *
      * @example
      * ```typescript
      * const liquidity = await client.getAllBaseAssetsLiquidity();
-     * Object.entries(liquidity).forEach(([poolAddress, coin]) => {
-     *   console.log(`Pool ${poolAddress}: ${coin.amount} ${coin.denom}`);
+     * Object.entries(liquidity).forEach(([poolAddress, details]) => {
+     *   console.log(`Pool ${poolAddress}:`);
+     *   console.log(`  Base: ${details.baseLiquidity.amount} ${details.baseLiquidity.denom}`);
+     *   console.log(`  Total Shares: ${details.totalShares}`);
      * });
      * ```
      */
-    abstract getAllBaseAssetsLiquidity(): Promise<Record<Address, Coin>>;
+    abstract getAllBaseAssetsLiquidity(): Promise<Record<Address, BaseLiquidityDetails>>;
     /**
      * Fetches all withdrawable quote assets for a specific user or liquidity provider.
      *
@@ -511,7 +563,7 @@ declare abstract class BaseClient<TSigner = unknown> {
      * Object.entries(quotes).forEach(([poolAddress, coins]) => {
      *   console.log(`Pool ${poolAddress}:`);
      *   coins.forEach(coin => {
-     *     console.log(`  ${coin.amount} ${coin.symbol}`);
+     *     console.log(`  ${coin.amount} ${coin.denom}`);
      *   });
      * });
      * ```
@@ -520,13 +572,15 @@ declare abstract class BaseClient<TSigner = unknown> {
     /**
      * Fetches pool information for a specific base asset.
      *
-     * @param baseAssetSymbol - The symbol of the base asset (e.g., "aarch", "ibc/...")
+     * @param baseAssetSymbol - The symbol of the base asset (e.g., "ARCH", "ATOM")
      *
      * @returns A promise that resolves to the pool information for the specified asset
      *
+     * @throws Will throw an error if no pool exists for the specified base asset
+     *
      * @example
      * ```typescript
-     * const pool = await client.getPoolByBaseAsset("aarch");
+     * const pool = await client.getPoolByBaseAsset("ARCH");
      * console.log(`Pool address: ${pool.poolAddress}`);
      * console.log(`Base asset: ${pool.baseAssetSymbol}`);
      * console.log('Available quote assets:');
@@ -541,8 +595,6 @@ declare abstract class BaseClient<TSigner = unknown> {
      *
      * @returns A promise that resolves to an array containing all pool information
      *
-     * @throws Will throw an error if no pool exists for the specified base asset
-     *
      * @example
      * ```typescript
      * const pools = await client.getAllPools();
@@ -578,35 +630,49 @@ declare abstract class BaseClient<TSigner = unknown> {
      */
     abstract getPoolConfig(poolContractAddress: string): Promise<PoolConfig>;
     /**
-     * Fetches the configuration settings for a pool identified by its base asset symbol.
+     * Fetches all supported assets across all pools in the Bolt protocol.
      *
-     * This method retrieves the pool configuration by first looking up the pool
-     * associated with the given base asset, then fetching its configuration parameters.
+     * This method retrieves comprehensive information about all assets that can be traded,
+     * including their metadata, chain-specific details, and external identifiers.
      *
-     * @param baseAssetSymbol - The symbol of the base asset (e.g., "aarch", "ibc/...")
-     *
-     * @returns A promise that resolves to a pool configuration object containing
-     *          settings such as fees, oracle address, LP addresses, and minimum trade amounts
-     *
-     * @throws Will throw an error if no pool exists for the specified base asset
+     * @returns A promise that resolves to an array of Asset objects, each containing:
+     *          - symbol: The asset's trading symbol (e.g., "ARCH", "USDC")
+     *          - name: The full name of the asset (e.g., "Archway", "USD Coin")
+     *          - chainId: The blockchain network identifier where this asset exists
+     *          - denom: The chain-specific denomination (e.g., "aarch", "ibc/...")
+     *          - decimals: The number of decimal places for the asset
+     *          - logo: Optional URL to the asset's logo image
+     *          - coingeckoId: Optional CoinGecko identifier for price data
      *
      * @example
      * ```typescript
-     * // Get pool configuration for ARCH base asset
-     * const poolConfig = await client.getPoolConfigByBaseAsset("aarch");
-     * console.log(`Oracle: ${poolConfig.priceOracleContract}`);
-     * console.log(`Protocol fee: ${poolConfig.protocolFee * 100}%`);
-     * console.log(`LP fee: ${poolConfig.lpFee * 100}%`);
-     * console.log(`Allowance mode: ${poolConfig.allowanceMode}`);
-     * console.log(`Number of LPs: ${poolConfig.lps.length}`);
-     * console.log(`Min base output: ${poolConfig.minBaseOut}`);
+     * const assets = await client.getAllAssets();
+     *
+     * // Display all available assets
+     * assets.forEach(asset => {
+     *   console.log(`${asset.symbol} (${asset.name})`);
+     *   console.log(`  Chain: ${asset.chainId}`);
+     *   console.log(`  Denom: ${asset.denom}`);
+     *   console.log(`  Decimals: ${asset.decimals}`);
+     *   if (asset.coingeckoId) {
+     *     console.log(`  CoinGecko: ${asset.coingeckoId}`);
+     *   }
+     * });
+     *
+     * // Find a specific asset
+     * const archAsset = assets.find(a => a.symbol === 'ARCH');
+     * console.log(`ARCH denom: ${archAsset?.denom}`);
      * ```
+     *
+     * @remarks
+     * Assets returned by this method represent all tokens available for trading
+     * in the Bolt protocol. The list may vary between mainnet and testnet environments.
      */
-    abstract getPoolConfigByBaseAsset(baseAssetSymbol: string): Promise<PoolConfig>;
+    abstract getAllAssets(): Promise<Asset[]>;
     /**
-     * Executes a "swap exact in" operation on the blockchain from one asset to another.
+     * Executes a swap operation on the blockchain from one asset to another.
      *
-     * This method performs a swap where the exact input amount is specified, and the output
+     * This method performs a "swap exact in" 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.
      *
@@ -621,8 +687,11 @@ declare abstract class BaseClient<TSigner = unknown> {
      * @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
+     * @returns A promise that resolves to a SwapResult containing:
+     *          - txOutput: Transaction execution details (type varies by implementation)
+     *          - amountOut: The actual amount of output asset received (as a string)
+     *          - assetOut: The denom of the asset received
+     *          - txHash: The transaction hash
      *
      * @throws Will throw an error if the swap fails due to insufficient balance,
      *         slippage exceeding tolerance, or other transaction errors
@@ -630,7 +699,7 @@ declare abstract class BaseClient<TSigner = unknown> {
      * @example
      * ```typescript
      * // Swap exactly 1 ARCH for USDC (output amount varies)
-     * const result = await client.swapExactIn(signer, {
+     * const result = await client.swap(signer, {
      *   assetIn: "aarch",
      *   amountIn: "1000000000000000000", // Exactly 1 ARCH (18 decimals)
      *   assetOut: "ibc/43897B9739BD63E3A08A88191999C632E052724AB96BD4C74AE31375C991F48D", // USDC IBC denom
@@ -639,7 +708,7 @@ declare abstract class BaseClient<TSigner = unknown> {
      * });
      *
      * console.log(`Swapped exactly 1 ARCH`);
-     * console.log(`Received: ${result.amountOut} USDC`);
+     * console.log(`Received: ${result.amountOut} ${result.assetOut}`);
      * console.log(`Transaction: ${result.txHash}`);
      * ```
      *
@@ -649,95 +718,102 @@ declare abstract class BaseClient<TSigner = unknown> {
      * - The output amount depends on pool conditions
      * - Fees are deducted from the output
      * - Use minimumAmountOut to protect against excessive slippage
+     *
+     * The TTxOutput type parameter represents the transaction execution result type,
+     * which varies by blockchain implementation (e.g., ExecuteResult for CosmWasm).
      */
-    abstract swapExactIn(signer: TSigner, params: SwapParams): Promise<SwapResult>;
+    abstract swap(signer: TSigner, params: SwapParams): Promise<SwapResult<TTxOutput>>;
 }
 
-interface CosmWasmClientConfig extends ClientConfig {
+type CosmWasmChainConfig = ChainConfig & {
+    restEndpoint: string;
+};
+
+type CosmWasmClientConfig = ClientConfig<CosmWasmChainConfig> & {
     chain?: CosmWasmChain;
     cosmWasmClient?: CosmWasmClient | ArchwayClient;
     signingCosmWasmClient?: SigningCosmWasmClient | SigningArchwayClient;
-}
-declare enum CosmWasmChain {
-    Archway = "archway"
-}
+};
+type CosmWasmChain = 'archway';
 
-interface QueryOracleConfigResponse {
+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 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[]>;
-}
-
-interface QuerySettlementConfigResponse {
-    price_oracle_contract: Address;
-    protocol_fee_recipient: Address;
-    protocol_fee: string;
-    lp_fee: string;
-    allowance_mode: AllowanceMode;
-    lps: Address[];
-    min_base_out: 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("ARCH", "USDC");
  *
  * // Execute a swap (requires signer)
  * const signer = await DirectSecp256k1HdWallet.fromMnemonic("my mnemonic goes here", {
@@ -750,7 +826,11 @@ interface QuerySettlementConfigResponse {
  * });
  * ```
  */
-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
@@ -769,18 +849,23 @@ 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, 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) Overrides for RPC endpoint and contract addresses
-     * @param config.customOverride.rpcEndpoint - (Optional) Custom RPC endpoint URL
-     * @param config.customOverride.contracts - (Optional) Custom contract addresses
+     * @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.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.cosmWasmClient - (Optional) Custom CosmWasmClient to use for blockchain queries
-     * @param config.customOverride.signingCosmWasmClient - (Optional) Custom SigningCosmWasmClient to use for blockchain transactions
+     * @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.signingCosmWasmClient - (Optional) Pre-existing SigningCosmWasmClient to use for blockchain transactions
      *
      * @throws {InvalidTypeError} Thrown when an unsupported chain is specified
      *
@@ -791,15 +876,41 @@ 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...'
+     *     },
+     *     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,
+     *   signingCosmWasmClient: mySigningClient
+     * });
      * ```
      */
     constructor(config?: CosmWasmClientConfig);
@@ -858,7 +969,7 @@ declare class BoltCosmWasmClient extends BaseClient<OfflineSigner> {
     /** @inheritdoc */
     getRouterConfig(): Promise<RouterConfig>;
     /** @inheritdoc */
-    getAllBaseAssetsLiquidity(): Promise<Record<Address, Coin>>;
+    getAllBaseAssetsLiquidity(): Promise<Record<Address, BaseLiquidityDetails>>;
     /** @inheritdoc */
     getAllQuotesByUser(address: Address): Promise<Record<Address, Coin[]>>;
     /** @inheritdoc */
@@ -868,6 +979,33 @@ declare class BoltCosmWasmClient extends BaseClient<OfflineSigner> {
     /** @inheritdoc */
     getPoolConfig(poolContractAddress: Address): Promise<PoolConfig>;
     /** @inheritdoc */
+    getAllAssets(): Promise<Asset[]>;
+    /**
+     * Fetches the configuration settings for a pool identified by its base asset symbol.
+     *
+     * This is a convenience method that combines pool lookup and configuration retrieval.
+     * It first finds the pool associated with the given base asset, then fetches that
+     * pool's configuration parameters from its settlement contract.
+     *
+     * @param baseAssetSymbol - The symbol of the base asset (e.g., "ARCH", "ATOM")
+     *
+     * @returns A promise that resolves to a pool configuration object containing
+     *          settings such as fees, oracle address, LP addresses, and minimum trade amounts
+     *
+     * @throws Will throw an error if no pool exists for the specified base asset
+     *
+     * @example
+     * ```typescript
+     * // Get pool configuration for ARCH base asset
+     * const poolConfig = await client.getPoolConfigByBaseAsset("ARCH");
+     * console.log(`Oracle: ${poolConfig.priceOracleContract}`);
+     * console.log(`Protocol fee: ${parseFloat(poolConfig.protocolFee) * 100}%`);
+     * console.log(`LP fee: ${parseFloat(poolConfig.lpFee) * 100}%`);
+     * console.log(`Allowance mode: ${poolConfig.allowanceMode}`);
+     * console.log(`Number of LPs: ${poolConfig.lps.length}`);
+     * console.log(`Min base output: ${poolConfig.minBaseOut}`);
+     * ```
+     */
     getPoolConfigByBaseAsset(baseAssetSymbol: string): Promise<PoolConfig>;
     /**
      * @inheritdoc
@@ -889,10 +1027,15 @@ declare class BoltCosmWasmClient extends BaseClient<OfflineSigner> {
      * 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.
      */
-    swapExactIn(signer: OfflineSigner, params: SwapParams): Promise<SwapResult<ExecuteResult>>;
+    swap(signer: OfflineSigner, params: SwapParams): Promise<SwapResult<ExecuteResult>>;
 }
 
-export { type Address, AllowanceMode, 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 PoolConfig, type Price, type PriceRepresentation, type QueryAssetPairsResponse, type QueryBaseLiquidityAllResponse, type QueryMarketsResponse, type QueryOracleConfigResponse, type QueryPriceResponse, type QueryPricesResponse, type QueryQuotesForUserAllResponse, type QueryRouterConfigResponse, type QuerySettlementConfigResponse, type RouterConfig, type SwapParams, type SwapResult, type Timestamp, TransactionEventNotFoundError, TransactionFailedError };
+export { type Address, type AllowanceMode, type Asset, type AssetPairString, type AssetsConfig, BaseClient, type BaseLiquidityDetails, BoltCosmWasmClient, type BoltSdkError, BoltSdkErrorBase, BoltSdkErrorCode, type ChainConfig, type ClientConfig, type Coin, type Contracts, type CosmWasmChain, type CosmWasmChainConfig, type CosmWasmClientConfig, type Duration, type 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 PoolConfig, type Price, type PriceRepresentation, type QueryAssetPairsResponse, type QueryBaseLiquidityAllResponse, type QueryBaseLiquidityResponse, type QueryMarketsResponse, type QueryOracleConfigResponse, type QueryPriceResponse, type QueryPricesResponse, type QueryQuotesForUserAllResponse, type QueryRouterConfigResponse, type QuerySettlementConfigResponse, type RouterConfig, type SwapParams, type SwapResult, type Timestamp, TransactionEventNotFoundError, TransactionFailedError };