@gala-chain/launchpad-sdk 6.0.0 → 7.0.0-beta.2

package/dist/LaunchpadSDK.d.ts

@@ -1,9 +1,15 @@
 import { Wallet } from 'ethers';
+import { GSwap } from '@gala-chain/gswap-sdk';
 import type { BridgeFeeEstimate, BridgeInParams, BridgeOutParams, BridgeStatus, BridgeToken, BridgeTransaction, EstimateBridgeFeeParams, EthereumTransactionStatus, EthereumWalletBalanceResult, ExternalChainBalance, SolanaTransactionStatus, SolanaWalletBalanceResult } from './bridge/types/bridge.dto';
 import type { BridgeableNetwork, FetchBridgeableTokensOptions, FetchBridgeableTokensResult, IsTokenBridgeableOptions, IsTokenBridgeableResult } from './bridge/types/bridgeable-token.dto';
+import type { Environment } from './config/environments';
 import { EventsBatcherService } from './services/EventsBatcherService';
 import { GdexStreamService } from './services/GdexStreamService';
 import type { StreamEventCallbacks } from './services/StreamWebSocketService';
+import { LaunchpadWrites } from './launchpad/writes';
+import type { HttpRequestor } from './launchpad/bundle-submission';
+import type { LaunchpadSigner } from './signing';
+import { TokenWrites } from './tokens/transfers';
 import type { GetAIModerationOptions, GetAIModerationResult, GetAIModerationSettingsResult, GetAIModerationStatusResult, TriggerAIModerationOptions, TriggerAIModerationResult, UpdateAIModerationSettingsOptions, UpdateAIModerationSettingsResult } from './types/ai-moderation.dto';
 import type { ApiKeyData, ApiKeyListResponse, CreateApiKeyOptions, CreateApiKeyResponse, ListApiKeysOptions, UpdateApiKeyOptions } from './types/api-key.dto';
 import type { ActiveUsersResult, BanListResult, BanStatusResult, CreateBanOptions, CreateBanResult, CreateGlobalBanOptions, CreateGlobalBanResult, GetActiveUsersOptions, GetBanStatusOptions, GetGlobalBanOptions, GlobalBanListResult, GlobalBanStatusResult, ListBansOptions, ListGlobalBansOptions, RemoveBanOptions, RemoveBanResult, RemoveGlobalBanOptions, RemoveGlobalBanResult } from './types/ban.dto';
@@ -16,7 +22,7 @@ import type { AddressFormat, ApiResponse, SDKConfig, TokenClassKey, TokenId } fr
 import type { ActionFlagOptions, ActionFlagResult, CreateFlagOptions, CreateFlagResult, DismissFlagOptions, DismissFlagResult, FlagListResult, ListFlagsOptions, ListGlobalFlagsOptions } from './types/content-flag.dto';
 import type { AddContentReactionOptions, AddContentReactionResult, RemoveContentReactionOptions, RemoveContentReactionResult } from './types/content-reactions.dto';
 import type { FetchTokenStatsResult } from './types/engagement-stats.dto';
-import type { AmountCalculationResult, DexAggregatedVolumeSummary, DexSeason, FetchPoolsOptions, GalaChainTokenDetails, GraduationCalculationResult, GraphDataResult, LaunchTokenData, LeaderboardResult, PoolData, PoolsResult, SaleDetailsResult, TokenBadgesResult, TokenClassWithSupply, TokenDistributionResult, TokenHolder, TokenSpotPrice, TradeQuoteParams, UserHolderContext, ValidateTokenResponse } from './types/launchpad.dto';
+import type { AmountCalculationResult, DexAggregatedVolumeSummary, DexSeason, FetchPoolsOptions, GalaChainTokenDetails, GraduationCalculationResult, GraphDataResult, LaunchTokenData, LeaderboardResult, PoolData, PoolsResult, SaleDetailsResult, TokenClassWithSupply, TokenDistributionResult, TokenHolder, TokenSpotPrice, TradeQuoteParams, UserHolderContext, ValidateTokenResponse } from './types/launchpad.dto';
 import type { LockTokensData, LockTokensResult, UnlockTokensData, UnlockTokensResult } from './types/lock.dto';
 import type { CreateMessageOptions, CreateMessageResult, DeleteMessageResult, FetchMessagesOptions, FetchMessagesResult, GetPinnedMessageResult, MessageStats, PinMessageResult, UpdateMessageOptions, UpdateMessageResult, UpdateTokenConfigOptions } from './types/messages.dto';
 import type { ClaimModeratorInviteOptions, ClaimModeratorInviteResult, CreateModeratorInviteOptions, CreateModeratorInviteResult, GetModeratedTokensOptions, ListModeratorInvitesOptions, ModeratedTokensResult, ModeratorInviteListResult, PublicInviteInfo, UpdateInviteRoleOptions, UpdateInviteRoleResult, UpdateModeratorInviteOptions, UpdateModeratorInviteResult } from './types/moderator.dto';
@@ -29,13 +35,12 @@ import type { GetPlatformStatsResult } from './types/platform-stats.dto';
 import type { GetRestrictedNamesResult, UpdateRestrictedNamesRequest, UpdateRestrictedNamesResult } from './types/restricted-names.dto';
 import type { TokenLaunchResult, TradeResult } from './types/result.types';
 import type { LoginResponse, RefreshResponse, SessionInfo } from './types/session-auth.dto';
-import type { EngagementStatsResult, GetEngagementStatsOptions, GlobalChatStatus } from './types/stream-chat.dto';
 import type { AddSimulcastTargetOptions, AddSimulcastTargetResult, FetchRecordingsOptions, GetStreamRoleOptions, GetTokenAccessOptions, GlobalStreamingStatus, RecordingDownloadResult, RecordingsResult, ResetStreamKeyResult, SimulcastTargetsResult, StartStreamResult, StreamCredentialsResult, StreamRoleResponse, StreamSubscribedEvent, TokenAccessResult } from './types/streaming.dto';
 import type { BanTokenOptions, BanTokenResult, GetTokenBanOptions, ListTokenBansOptions, TokenBanListResult, TokenBanStatusResult, UnbanTokenOptions, UnbanTokenResult } from './types/token-ban.dto';
 import type { PoolDetailsData, TradesResult } from './types/trade.dto';
 import type { GetTradesOptions, TradesQueryResult } from './types/trades-query.dto';
 import type { GalaChainTransferReceipt, TransferGalaData, TransferTokenData } from './types/transfer.dto';
-import type { AllReferralsResult, AvailableBalanceResult, FetchReferralsOptions, FetchReferralsSummaryOptions, FetchTokenBalanceOptions, FetchUserBalancesOptions, FetchUserBalancesResult, FetchUserReportOptions, FetchUserReportResult, GetManagedTokensOptions, LockedBalanceResult, ManagedTokensResult, ReferralsResult, ReferralsSummaryResult, ReferralUrlResult, TokenBalanceResult, UpdateProfileData, UploadProfileImageOptions, UserTokenListResult } from './types/user.dto';
+import type { AllReferralsResult, AvailableBalanceResult, FetchReferralsOptions, FetchReferralsSummaryOptions, FetchTokenBalanceOptions, GetManagedTokensOptions, LockedBalanceResult, ManagedTokensResult, ReferralsResult, ReferralsSummaryResult, ReferralUrlResult, TokenBalanceResult, UpdateProfileData, UploadProfileImageOptions, UserTokenListResult } from './types/user.dto';
 import type { BalanceUpdatedPayload, ChatMessagePayload, ChatStatusPayload, ConnectedClient, ConnectedClientsResponse, DownloadReadyPayload, FeatureStatusPayload, GetConnectedClientsOptions, ModeratorAddedPayload, ModeratorRemovedPayload, RecordingsCountUpdatedPayload, RecordingStatusPayload, SiteConfigChangedPayload, StreamCountdownPayload, StreamStatusPayload, TokenBannedPayload, TokenUnbannedPayload, TradeExecutedPayload, TypingIndicatorPayload, UserProfileUpdatedPayload, ViewerCountPayload } from './types/websocket-admin.dto';
 import type { EngagementStatsUpdatedEvent } from './types/websocket-events.dto';
 import type { GetTokenWeeklyHistoryOptions, GetTokenWeeklyHistoryResult, GetWeeklyChallengeOptions, GetWeeklyChallengeResult } from './types/weekly-challenge.dto';
@@ -43,17 +48,11 @@ import type { FetchWrappableTokensOptions, FetchWrappableTokensResult, IsTokenWr
 import { TransactionFailedError, WebSocketError, WebSocketTimeoutError } from './utils/websocket-errors';
 import type { WalletProvider } from './wallet/types';
 export { TransactionFailedError, WebSocketError, WebSocketTimeoutError, };
-import type { CalculateDexPoolQuoteOptions, CompositePoolDataResult, DexPoolQuoteResult, FetchCompositePoolDataOptions } from './types/composite-pool.dto';
-import type { DexPoolData, DexPoolsResult, FetchDexPoolsOptions } from './types/dex-pool.dto';
-import type { AddLiquidityByPriceArgs, AddLiquidityByTicksArgs, AvailableDexTokensResult, CollectFeesArgs, DexToken, ExecuteSwapResult, FetchAvailableDexTokensOptions, GetLiquidityPositionsOptions, GetLiquidityPositionsResult, GSwapPosition, PoolInfo, PoolPriceData, RemoveLiquidityArgs, SwapQuoteResult, UserAsset } from './types/gswap.dto';
-import type { GSwapAddLiquidityResult, GSwapEstimateRemoveLiquidityResult } from './types/gswap-responses.types';
-import type { LiquidityChangedCallback, LiquidityCleanupFunction, SubscribeLiquidityOptions } from './types/liquidity-monitor.dto';
 import type { BuyTokenOptions, CalculateBuyAmountForGraduationOptions, CalculateBuyAmountLocalOptions, CalculateBuyAmountOptions, CalculateSellAmountLocalOptions, CalculateSellAmountOptions, FetchTokensCreatedOptions, FetchTokensHeldOptions, FetchTokenSpotPriceParams, FetchTradesOptions, FetchVolumeDataOptions, GraduateTokenOptions, SellTokenOptions, UploadImageByTokenNameOptions } from './types/options.dto';
 import type { FetchPriceHistoryOptions, PriceHistoryResult } from './types/priceHistory.dto';
 import type { GetPinnedMessageResult as LegacyGetPinnedMessageResult, PinMessageResult as LegacyPinMessageResult, UnpinMessageResult as LegacyUnpinMessageResult } from './types/stream-chat.dto';
 import type { AvailableRolesResponse } from './types/streaming.dto';
 import type { AuthenticatedEvent, BanEnforcementEvent, ChatStatusChangedEvent, ConnectionEvent, ContentFlaggedEvent, ContentReactionAddedEvent, ContentReactionRemovedEvent, DownloadReadyEvent, FlagResolvedEvent, RecordingsCountUpdatedEvent, RecordingStatusChangedEvent, RoomLeftEvent, RoomSubscribedEvent, SimulcastStatusChangedEvent, StreamChatDeletedEvent, StreamChatMessageEvent, StreamChatPinnedEvent, StreamChatUnpinnedEvent, StreamChatUpdatedEvent, StreamControlStatusChangedEvent, StreamCountdownUpdatedEvent, StreamLanguageUpdatedEvent, StreamReactionEvent, StreamStatusChangedEvent, TokenSubscribedEvent, TokenUnsubscribedEvent, UserBannedEvent, UserTypingEvent, UserUnbannedEvent, ViewerCountChangedEvent } from './types/streaming-events.dto';
-import type { CleanupFunction, SubscribeSwapOptions, SwapEventCallback, SwapMonitorConfig } from './types/swap-monitor.dto';
 /**
  * Configuration for initializing the Launchpad SDK
  *
@@ -71,7 +70,7 @@ import type { CleanupFunction, SubscribeSwapOptions, SwapEventCallback, SwapMoni
  * // Environment-based configuration (recommended)
  * const config: LaunchpadSDKConfig = {
  *   wallet,
- *   env: 'STAGE',  // or 'PROD'
+ *   env: 'stage',  // or 'prod'
  *   timeout: 30000,
  *   debug: false
  * };
@@ -79,8 +78,8 @@ import type { CleanupFunction, SubscribeSwapOptions, SwapEventCallback, SwapMoni
  * // With URL overrides
  * const configWithOverrides: LaunchpadSDKConfig = {
  *   wallet,
- *   env: 'PROD',
- *   galaChainBaseUrl: 'https://custom-gateway.example.com'
+ *   env: 'prod',
+ *   gatewayBaseUrl: 'https://custom-gateway.example.com'
  * };
  * ```
  */
@@ -89,9 +88,9 @@ import type { CleanupFunction, SubscribeSwapOptions, SwapEventCallback, SwapMoni
  * Contains configuration values excluding sensitive wallet data
  * @since 4.0.20
  */
-export type LaunchpadSDKConfigResponse = Omit<LaunchpadSDKConfig, 'wallet' | 'walletProvider' | 'streamAdminApiKey' | 'userApiKey' | 'accessToken' | 'headers'> & {
-    /** Current environment (STAGE or PROD) */
-    environment: 'STAGE' | 'PROD';
+export type LaunchpadSDKConfigResponse = Omit<LaunchpadSDKConfig, 'wallet' | 'walletProvider' | 'signer' | 'httpRequestor' | 'streamAdminApiKey' | 'userApiKey' | 'accessToken' | 'headers'> & {
+    /** Current environment (`stage` or `prod`). */
+    environment: Environment;
     /** GalaChain gas fee in GALA (fixed at "1" GALA) */
     gasFee: string;
     /** Stream admin API key presence indicator — always '[REDACTED]' if configured */
@@ -104,6 +103,12 @@ export type LaunchpadSDKConfigResponse = Omit<LaunchpadSDKConfig, 'wallet' | 'wa
     headers?: Record<string, '[REDACTED]'>;
 };
 export interface LaunchpadSDKConfig extends SDKConfig {
+    /** Native or typed-data signer used by the v6 write surfaces. */
+    signer?: LaunchpadSigner;
+    /** Registered GalaChain address used as the write sender and bundler header. */
+    walletAddress?: string;
+    /** Fetch-compatible requestor used by v6 write surfaces and tests. */
+    httpRequestor?: HttpRequestor;
     /**
      * The ethers wallet for authentication (optional)
      * - Required for: Trading (buy/sell), transfers, token creation, profile updates
@@ -130,7 +135,7 @@ export interface LaunchpadSDKConfig extends SDKConfig {
      * const provider = new PrivateKeyProvider('0x...');
      * const sdk = new LaunchpadSDK({
      *   walletProvider: provider,
-     *   env: 'PROD'
+     *   env: 'prod'
      * });
      * ```
      *
@@ -144,13 +149,13 @@ export interface LaunchpadSDKConfig extends SDKConfig {
      *
      * const sdk = new LaunchpadSDK({
      *   walletProvider: provider,
-     *   env: 'PROD'
+     *   env: 'prod'
      * });
      * ```
      */
     walletProvider?: WalletProvider;
     /** Optional GalaChain gateway URL override - defaults based on main API environment */
-    galaChainBaseUrl?: string;
+    gatewayBaseUrl?: string;
     /** Optional Bundle service URL override - defaults based on main API environment */
     bundleBaseUrl?: string;
     /** Optional WebSocket URL override for transaction monitoring - defaults based on main API environment */
@@ -163,6 +168,8 @@ export interface LaunchpadSDKConfig extends SDKConfig {
     dexBackendBaseUrl?: string;
     /** Optional Launchpad Frontend URL override - defaults based on main API environment */
     launchpadFrontendUrl?: string;
+    /** Optional Launchpad API URL override used by launchpad write confirmation reads. */
+    launchpadBaseUrl?: string;
     /** Optional global slippage tolerance factor (e.g., 0.05 = 5% slippage tolerance) - defaults to 0.15 */
     slippageToleranceFactor?: number;
     /** Optional global reverse bonding curve fee slippage factor (e.g., 0.01 = 1% fee slippage) - defaults to 0.01 */
@@ -218,8 +225,8 @@ export interface LaunchpadSDKConfig extends SDKConfig {
      * Optional Ethereum RPC URL override for bridge operations.
      *
      * If not provided, defaults to Gala internal endpoints:
-     * - PROD: `https://eth.gala.games`
-     * - STAGE: `https://dev.eth.gala.games`
+     * - prod: `https://eth.gala.games`
+     * - stage: `https://dev.eth.gala.games`
      *
      * @example
      * ```typescript
@@ -234,8 +241,8 @@ export interface LaunchpadSDKConfig extends SDKConfig {
      * Optional Solana RPC URL override for bridge operations.
      *
      * If not provided, defaults to public Solana endpoints:
-     * - PROD: `https://api.mainnet-beta.solana.com`
-     * - STAGE: `https://api.devnet.solana.com`
+     * - prod: `https://api.mainnet-beta.solana.com`
+     * - stage: `https://api.devnet.solana.com`
      *
      * For faster/more reliable operations, use a dedicated RPC provider like Helius.
      *
@@ -259,7 +266,7 @@ export interface LaunchpadSDKConfig extends SDKConfig {
      * ```typescript
      * const sdk = new LaunchpadSDK({
      *   wallet,
-     *   streamWebSocketUrl: 'wss://stream.gala.com'
+     *   streamWebSocketUrl: getEnvironmentConfig('stage').launchpadBaseUrl
      * });
      * ```
      */
@@ -276,73 +283,13 @@ export interface LaunchpadSDKConfig extends SDKConfig {
      */
     streamAdminApiKey?: string;
 }
-/**
- * Main Launchpad SDK class providing access to all Gala Launchpad functionality
- *
- * This is the primary entry point for interacting with the Gala Launchpad backend.
- * It provides a clean, type-safe interface for all API operations including pool creation,
- * token trading, and user management.
- *
- * Features:
- * - Automatic signature-based authentication
- * - Type-safe API interfaces
- * - Built-in error handling and retry logic
- * - Address format conversion (eth|xxx ↔ 0xxxx)
- * - Bonding curve trading for launchpad tokens
- * - EIP-712 signature generation for all wallet types
- * - Bundle transaction processing
- * - Real-time transaction monitoring via WebSocket
- * - Comprehensive validation
- *
- * @category Main SDK
- * @since 1.0.0
- * @agent-capability Primary interface for all Gala Launchpad operations including token creation, trading, and user management
- * @agent-prerequisites Initialized with valid LaunchpadSDKConfig containing wallet
- * @agent-errors
- * - WALLET_001: Invalid wallet configuration - Reinitialize with valid ethers.js Wallet
- * - NETWORK_001: Connection timeout - Check network and retry with higher timeout
- * - AUTH_001: Authentication failed - Verify wallet has valid private key
- * @agent-example
- * ```typescript
- * import { Wallet } from 'ethers';
- * import { LaunchpadSDK, createWallet } from '@gala-chain/launchpad-sdk';
- *
- * // Generate or import wallet
- * const wallet = createWallet(process.env.PRIVATE_KEY).wallet;
- *
- * // Initialize SDK
- * const sdk = new LaunchpadSDK({
- *   wallet,
- *   debug: true
- * });
- *
- * // Verify setup
- * console.log('SDK Address:', sdk.getAddress()); // eth|{address}
- * console.log('Ethereum Address:', sdk.getEthereumAddress()); // 0x{address}
- *
- * // SDK is ready for operations
- * const balance = await sdk.fetchGalaBalance(sdk.getAddress());
- * ```
- *
- * @example Error handling pattern
- * ```typescript
- * try {
- *   const transactionId = await sdk.launchToken(tokenData);
- *   console.log('Token launched successfully:', transactionId);
- *   return transactionId;
- * } catch (error) {
- *   console.error('Operation failed:', error.message);
- *   // Implement retry logic or alternative action
- * }
- * ```
- */
 export declare class LaunchpadSDK {
     /** Default slippage tolerance factor (15%) - Higher for volatile bonding curve tokens */
     static readonly DEFAULT_SLIPPAGE_TOLERANCE_FACTOR = 0.15;
     /** Default reverse bonding curve fee slippage factor (1%) - Applied to maxAcceptableReverseBondingCurveFee */
     static readonly DEFAULT_MAX_ACCEPTABLE_REVERSE_BONDING_CURVE_FEE_SLIPPAGE_FACTOR = 0.01;
     /** Default maximum total supply for launchpad tokens (10,000,000) - Used when token-specific maxSupply not provided */
-    static readonly DEFAULT_LAUNCHPAD_TOKEN_MAX_SUPPLY = 10000000;
+    static readonly DEFAULT_LAUNCHPAD_TOKEN_MAX_SUPPLY: 10000000;
     /** Default calculation mode for all amount calculations - 'local' for instant client-side bonding curve calculations */
     static readonly DEFAULT_CALCULATE_AMOUNT_MODE: 'local' | 'external';
     private wallet;
@@ -361,8 +308,8 @@ export declare class LaunchpadSDK {
     private readonly slippageToleranceFactor;
     private readonly maxAcceptableReverseBondingCurveFeeSlippageFactor;
     private readonly calculateAmountMode;
-    private readonly pricingConcurrency;
     private readonly logger;
+    private readonly dexClient;
     private readonly tokenResolverService;
     private readonly launchpadService;
     private readonly galaChainService;
@@ -370,9 +317,6 @@ export declare class LaunchpadSDK {
     private readonly bundleService;
     private readonly websocketService;
     private readonly priceHistoryService;
-    private readonly gswapService;
-    private readonly dexPoolService;
-    private readonly dexQuoteService;
     private readonly cache;
     private _bridgeService?;
     private _bridgeableTokenService?;
@@ -405,6 +349,10 @@ export declare class LaunchpadSDK {
     private readonly nftCollectionService;
     private readonly tradingQuotesService;
     private readonly launchpadAPI;
+    /** v6 launchpad write surface. */
+    readonly launchpad: LaunchpadWrites;
+    /** v6 native token write surface. */
+    readonly tokens: TokenWrites;
     constructor(config: LaunchpadSDKConfig);
     /**
      * Creates a temporary SDK instance with a different wallet for privateKey override operations.
@@ -416,6 +364,18 @@ export declare class LaunchpadSDK {
      * @throws Error if privateKey format is invalid
      */
     private createOverrideSdk;
+    /**
+     * Access the shared GSwap DEX client.
+     *
+     * @returns The single `@gala-chain/gswap-sdk` client configured with this SDK's signer and hosts.
+     *
+     * @example
+     * ```typescript
+     * const quote = await sdk.dex.quoting.quoteExactInput('GALA', 'GUSDC', '1');
+     * console.log(quote.amountOut);
+     * ```
+     */
+    get dex(): GSwap;
     /**
      * Gets the authenticated user's address in backend format
      *
@@ -664,7 +624,7 @@ export declare class LaunchpadSDK {
      *
      * @category Configuration
      * @returns SDK configuration object including:
-     *   - environment: Current environment (STAGE or PROD)
+     *   - environment: Current environment (`stage` or `prod`)
      *   - gasFee: GalaChain gas fee (fixed at "1" GALA)
      *   - slippageToleranceFactor: Effective slippage tolerance
      *   - calculateAmountMode: Calculation mode (local or external)
@@ -722,17 +682,17 @@ export declare class LaunchpadSDK {
      *
      * @example Get token URL
      * ```typescript
-     * const sdk = new LaunchpadSDK({ wallet, env: 'PROD' });
+     * const sdk = new LaunchpadSDK({ wallet, env: 'prod' });
      * const url = sdk.getUrlByTokenName('dragnrkti');
      * console.log(url);
-     * // Output: https://lpad-frontend-prod1.defi.gala.com/buy-sell/dragnrkti
+     * // Output: `${getEnvironmentConfig('prod').launchpadFrontendUrl}/buy-sell/dragnrkti`
      * ```
      *
      * @example With custom frontend URL
      * ```typescript
      * const sdk = new LaunchpadSDK({
      *   wallet,
-     *   env: 'STAGE',
+     *   env: 'stage',
      *   launchpadFrontendUrl: 'https://custom-frontend.example.com'
      * });
      * const url = sdk.getUrlByTokenName('mytoken');
@@ -872,266 +832,6 @@ export declare class LaunchpadSDK {
         tokenName?: string;
         type?: 'recent' | 'popular';
     }): Promise<PoolsResult>;
-    /**
-     * Fetch DEX pools with pagination and filtering
-     *
-     * Queries the GalaSwap DEX backend for available liquidity pools with support for:
-     * - Pagination (max 20 per page)
-     * - Sorting by TVL, 30-day volume, or 1-day volume
-     * - Search filtering by token symbols
-     *
-     * Perfect for discovering trading pairs and analyzing liquidity across the DEX.
-     *
-     * @category DEX Pool Discovery
-     * @param options Optional pagination, sorting, and filtering options
-     * @returns Promise<DexPoolsResult> Paginated pool data with metadata
-     * @since 3.28.0
-     *
-     * @example Fetch top 10 pools by volume
-     * ```typescript
-     * const result = await sdk.fetchDexPools({
-     *   sortBy: 'volume1d',
-     *   sortOrder: 'desc',
-     *   pageSize: 10
-     * });
-     *
-     * console.log(`Found ${result.total} total pools`);
-     * console.log(`Showing page ${result.page} of ${result.totalPages}`);
-     *
-     * result.items.forEach(pool => {
-     *   console.log(`${pool.poolName}: $${pool.tvl.toFixed(2)} TVL`);
-     * });
-     * ```
-     *
-     * @example Search for GALA pools
-     * ```typescript
-     * const galaPools = await sdk.fetchDexPools({
-     *   search: 'GALA',
-     *   pageSize: 20
-     * });
-     *
-     * console.log(`Found ${galaPools.items.length} GALA trading pairs`);
-     * ```
-     *
-     * @example Get pools sorted by TVL (default)
-     * ```typescript
-     * const topTvl = await sdk.fetchDexPools({
-     *   sortBy: 'tvl',
-     *   sortOrder: 'desc',
-     *   pageSize: 5
-     * });
-     * ```
-     */
-    fetchDexPools(options?: FetchDexPoolsOptions): Promise<DexPoolsResult>;
-    /**
-     * Fetch ALL DEX pools with automatic pagination
-     *
-     * Convenience method that automatically handles pagination to retrieve all available
-     * DEX pools in one call. Uses maximum page size (20) internally for efficiency.
-     *
-     * This is useful when you need complete pool data regardless of result size.
-     * For large result sets or when you prefer manual pagination, use fetchDexPools().
-     *
-     * @category DEX Pool Discovery
-     * @param options Optional sorting and filtering options (no pagination fields)
-     * @returns Promise<DexPoolsResult> All pools with flattened pagination metadata
-     * @since 3.28.0
-     *
-     * @example Fetch all pools sorted by TVL
-     * ```typescript
-     * const allPools = await sdk.fetchAllDexPools({
-     *   sortBy: 'tvl',
-     *   sortOrder: 'desc'
-     * });
-     *
-     * console.log(`Total pools: ${allPools.total}`);
-     *
-     * // Find top GALA pools
-     * const galaPools = allPools.items
-     *   .filter(p => p.poolName.includes('GALA'))
-     *   .slice(0, 10);
-     *
-     * galaPools.forEach(pool => {
-     *   console.log(`${pool.poolName}: APR ${pool.apr1d.toFixed(2)}%`);
-     * });
-     * ```
-     *
-     * @example Analyze token pairs
-     * ```typescript
-     * const allPools = await sdk.fetchAllDexPools();
-     *
-     * // Find pools by token
-     * const guscPairs = allPools.items.filter(p =>
-     *   p.poolName.includes('GUSDC')
-     * );
-     *
-     * console.log(`GUSDC trading pairs: ${guscPairs.length}`);
-     * ```
-     */
-    fetchAllDexPools(options?: Omit<FetchDexPoolsOptions, 'page' | 'limit'>): Promise<DexPoolsResult>;
-    /**
-     * Fetch composite pool data from GalaChain for offline DEX quote calculations
-     *
-     * Retrieves complete pool state including liquidity, tick data, token balances, and decimals.
-     * This data is required for offline quote calculations using local bonding curve math.
-     *
-     * The composite pool data can be fetched once and reused for multiple quote calculations,
-     * making it efficient for bulk pricing operations.
-     *
-     * @param options Pool identification options with token pair and fee tier
-     * @returns CompositePoolDataResult containing complete pool state for offline calculations
-     * @throws DexPoolNotFoundError if the pool does not exist
-     * @throws DexQuoteError on API or conversion errors
-     * @since 3.32.0
-     * @category DEX Quotes
-     *
-     * @example Fetch and reuse composite pool data
-     * ```typescript
-     * // Step 1: Fetch composite data (one network call)
-     * const composite = await sdk.fetchCompositePoolData({
-     *   token0: 'GALA|Unit|none|none',
-     *   token1: 'Token|Unit|BENE|client:5c806869e7fd0e2384461ce9',
-     *   fee: 3000  // 0.30%
-     * });
-     *
-     * // Step 2: Calculate multiple quotes using same composite data (instant, local)
-     * const quote1 = await sdk.calculateDexPoolQuoteExactAmountLocal({
-     *   compositePoolData: composite,
-     *   fromToken: 'GALA|Unit|none|none',
-     *   toToken: 'Token|Unit|BENE|client:5c806869e7fd0e2384461ce9',
-     *   amount: '100'
-     * });
-     *
-     * const quote2 = await sdk.calculateDexPoolQuoteExactAmountLocal({
-     *   compositePoolData: composite,
-     *   fromToken: 'GALA|Unit|none|none',
-     *   toToken: 'Token|Unit|BENE|client:5c806869e7fd0e2384461ce9',
-     *   amount: '500'
-     * });
-     *
-     * // Step 3: Compare with a real-time quote from the DEX backend
-     * const liveQuote = await sdk.calculateDexPoolQuoteExactAmountExternal({
-     *   compositePoolData: composite,
-     *   fromToken: 'GALA|Unit|none|none',
-     *   toToken: 'Token|Unit|BENE|client:5c806869e7fd0e2384461ce9',
-     *   amount: '100'
-     * });
-     * ```
-     */
-    fetchCompositePoolData(options: FetchCompositePoolDataOptions): Promise<CompositePoolDataResult>;
-    /**
-     * Calculate DEX pool quote using LOCAL client-side calculation
-     *
-     * Instant quotes without network calls using pre-fetched composite pool data and
-     * the @gala-chain/dex bonding curve math library.
-     *
-     * Perfect for bulk pricing operations, simulations, and price discovery where
-     * network latency is unacceptable.
-     *
-     * @param options Quote calculation options (must include pre-fetched compositePoolData)
-     * @returns DexPoolQuoteResult with input/output amounts and execution prices
-     * @throws DexQuoteError on calculation errors
-     * @since 3.32.0
-     * @category DEX Quotes
-     *
-     * @example Fast bulk pricing
-     * ```typescript
-     * const composite = await sdk.fetchCompositePoolData({
-     *   token0: 'GALA|Unit|none|none',
-     *   token1: 'Token|Unit|BENE|client:123',
-     *   fee: 3000
-     * });
-     *
-     * // Get 100 instant quotes without any network calls
-     * const amounts = ['10', '50', '100', '500', '1000'];
-     * const quotes = await Promise.all(
-     *   amounts.map(amount =>
-     *     sdk.calculateDexPoolQuoteExactAmountLocal({
-     *       compositePoolData: composite,
-     *       fromToken: 'GALA|Unit|none|none',
-     *       toToken: 'Token|Unit|BENE|client:123',
-     *       amount
-     *     })
-     *   )
-     * );
-     * ```
-     */
-    calculateDexPoolQuoteExactAmountLocal(options: CalculateDexPoolQuoteOptions): Promise<DexPoolQuoteResult>;
-    /**
-     * Calculate DEX pool quote using the external DEX backend endpoint
-     *
-     * Real-time quotes using current backend pool state. Slower than local calculation
-     * and useful for final price verification.
-     *
-     * @param options Quote calculation options (compositePoolData provides token metadata)
-     * @returns DexPoolQuoteResult with current pool state
-     * @throws DexQuoteError on network or calculation errors
-     * @since 3.32.0
-     * @category DEX Quotes
-     *
-     * @example Verify quote with live chain data
-     * ```typescript
-     * const composite = await sdk.fetchCompositePoolData({
-     *   token0: 'GALA|Unit|none|none',
-     *   token1: 'Token|Unit|BENE|client:123',
-     *   fee: 3000
-     * });
-     *
-     * // Local estimate (instant)
-     * const estimate = await sdk.calculateDexPoolQuoteExactAmountLocal({
-     *   compositePoolData: composite,
-     *   fromToken: 'GALA|Unit|none|none',
-     *   toToken: 'Token|Unit|BENE|client:123',
-     *   amount: '1000'
-     * });
-     *
-     * // Live verification from the DEX backend
-     * const liveQuote = await sdk.calculateDexPoolQuoteExactAmountExternal({
-     *   compositePoolData: composite,
-     *   fromToken: 'GALA|Unit|none|none',
-     *   toToken: 'Token|Unit|BENE|client:123',
-     *   amount: '1000'
-     * });
-     *
-     * console.log(`Difference: ${estimate.amount1} vs ${liveQuote.amount1}`);
-     * ```
-     */
-    calculateDexPoolQuoteExactAmountExternal(options: CalculateDexPoolQuoteOptions): Promise<DexPoolQuoteResult>;
-    /**
-     * Calculate DEX pool quote with automatic mode selection
-     *
-     * Main quote calculation method that delegates to local or external based on mode parameter.
-     * Defaults to local (instant) calculation.
-     *
-     * @param options Quote calculation options
-     * @param mode 'local' (instant, client-side) or 'external' (real-time, backend) - defaults to 'local'
-     * @returns DexPoolQuoteResult with amounts and prices
-     * @since 3.32.0
-     * @category DEX Quotes
-     *
-     * @example Using default local mode
-     * ```typescript
-     * const quote = await sdk.calculateDexPoolQuoteExactAmount({
-     *   compositePoolData: composite,
-     *   fromToken: 'GALA|Unit|none|none',
-     *   toToken: 'Token|Unit|BENE|client:123',
-     *   amount: '1000'
-     * });
-     * // Returns instant local quote
-     * ```
-     *
-     * @example Explicit external mode for real-time
-     * ```typescript
-     * const liveQuote = await sdk.calculateDexPoolQuoteExactAmount({
-     *   compositePoolData: composite,
-     *   fromToken: 'GALA|Unit|none|none',
-     *   toToken: 'Token|Unit|BENE|client:123',
-     *   amount: '1000'
-     * }, 'external');
-     * // Returns a real-time quote from the DEX backend
-     * ```
-     */
-    calculateDexPoolQuoteExactAmount(options: CalculateDexPoolQuoteOptions, mode?: 'local' | 'external'): Promise<DexPoolQuoteResult>;
     /**
      * Fetch token ownership distribution with holder percentages
      *
@@ -1311,37 +1011,13 @@ export declare class LaunchpadSDK {
      * ```
      */
     fetchUserHolderContext(tokenName: string, userAddress: string): Promise<UserHolderContext>;
-    /**
-     * Fetch token achievement badges and metadata
-     *
-     * Retrieves badge data for a token including achievement milestones, special recognitions,
-     * and platform-assigned attributes. Badges provide additional context about token
-     * performance, community engagement, and platform status.
-     *
-     * @category Token Information
-     * @param tokenName - Token name to fetch badges for (e.g., 'anime', 'mytoken')
-     * @returns Promise with badge data including badge types, timestamps, and metadata
-     * @throws {ValidationError} If tokenName is invalid or empty
-     * @throws {NetworkError} If API request fails
-     * @since 4.0.4-beta.0
-     *
-     * @example Fetch token badges
-     * ```typescript
-     * const badges = await sdk.fetchTokenBadges('anime');
-     * console.log(`Token has ${badges.length} badges`);
-     * badges.forEach(badge => {
-     *   console.log(`Badge: ${badge.name} - ${badge.description}`);
-     * });
-     * ```
-     */
-    fetchTokenBadges(tokenName: string): Promise<TokenBadgesResult>;
     /**
      * Fetch USD spot price for any token with smart routing
      *
      * Unified smart router that accepts either tokenName (launchpad tokens) or tokenId (DEX tokens).
      * Automatically detects token type and routes to the correct backend:
      * - **tokenName** → Launchpad token with graduation detection (bonding curve or DEX pricing)
-     * - **tokenId** → DEX Backend API `/v1/trade/price` (direct pricing)
+     * - **tokenId** → DEX Backend API `/market/price` (direct pricing)
      *
      * @param params Options with either tokenName or tokenId (mutually exclusive)
      * @returns Promise<TokenSpotPrice> Single token's spot price data
@@ -2144,6 +1820,9 @@ export declare class LaunchpadSDK {
      * @internal
      */
     private getContentReactionService;
+    private toLegacyPinnedMessage;
+    private buildMessageFetchOptions;
+    private resolveReferralAddress;
     /**
      * Get or create the MessagesService instance.
      *
@@ -2291,13 +1970,13 @@ export declare class LaunchpadSDK {
     /**
      * Request SOL airdrop from Solana devnet faucet.
      *
-     * Only available in STAGE environment (Solana devnet) for testing purposes.
+     * Only available in stage environment (Solana devnet) for testing purposes.
      * Will throw an error if called in production environment.
      *
      * @param amount - Amount of SOL to request (default: 1, max: 2 per request)
      * @param address - Optional recipient Solana address (defaults to configured wallet)
      * @returns Transaction signature
-     * @throws Error if not in STAGE environment, Solana not configured, or airdrop fails
+     * @throws Error if not in stage environment, Solana not configured, or airdrop fails
      *
      * @example Airdrop 1 SOL to configured wallet
      * ```typescript
@@ -3533,32 +3212,6 @@ export declare class LaunchpadSDK {
      *
      * Deprecated: Chat status is now included in token details (GET /v1/tokens/:tokenName)
      */
-    /**
-     * Get engagement statistics for a token.
-     *
-     * Returns aggregated engagement metrics including:
-     * - Chat: message count, unique chatters, session start time
-     * - Comments: total count, unique commenters
-     *
-     * Chat stats are scoped to the current/last stream session.
-     * Comment stats are all-time for the token.
-     *
-     * @param options - Token name to fetch stats for
-     * @returns Promise resolving with engagement statistics
-     *
-     * @since 5.10.0
-     * @category Chat
-     *
-     * @example Get engagement stats
-     * ```typescript
-     * const stats = await sdk.getEngagementStats({ tokenName: 'mytoken' });
-     * console.log('Chat messages:', stats.chat.messageCount);
-     * console.log('Unique chatters:', stats.chat.uniqueChatters);
-     * console.log('Total comments:', stats.comments.count);
-     * console.log('Unique commenters:', stats.comments.uniqueCommenters);
-     * ```
-     */
-    getEngagementStats(options: GetEngagementStatsOptions): Promise<EngagementStatsResult>;
     /**
      * Disable chat for a specific token.
      *
@@ -3600,31 +3253,6 @@ export declare class LaunchpadSDK {
         tokenName: string;
         status?: string;
     }>;
-    /**
-     * Get global chat status.
-     *
-     * Returns platform-wide chat status.
-     *
-     * @returns Promise resolving to global chat status
-     *
-     * @since 5.1.0
-     * @category Chat
-     */
-    getGlobalChatStatus(): Promise<GlobalChatStatus>;
-    /**
-     * Enable or disable chat globally (Admin only).
-     *
-     * Controls platform-wide chat capability.
-     *
-     * @param enabled - Whether chat should be enabled
-     * @returns Promise resolving when updated
-     * @throws Error if admin API key is not configured
-     *
-     * @since 5.1.0
-     * @category Chat
-     * @admin Requires streamAdminApiKey configuration
-     */
-    setGlobalChatEnabled(enabled: boolean): Promise<GlobalChatStatus>;
     /**
      * Get the currently pinned chat message for a token (v6.x.0+)
      *
@@ -7736,7 +7364,7 @@ export declare class LaunchpadSDK {
      * **Use simple `tokenName`** (e.g., `"anime"`), NOT full TokenClassKey format.
      *
      * This method is for **bonding curve tokens only** (pre-graduation). For DEX trading
-     * of graduated tokens, use {@link executeSwap} with full TokenClassKey format.
+     * of graduated tokens, use `sdk.dex.swaps.swap()` (the {@link GSwap} client exposed via {@link dex}) with full TokenClassKey format.
      *
      * ```typescript
      * // ✅ CORRECT - Simple token name
@@ -7857,7 +7485,7 @@ export declare class LaunchpadSDK {
      * **Use simple `tokenName`** (e.g., `"anime"`), NOT full TokenClassKey format.
      *
      * This method is for **bonding curve tokens only** (pre-graduation). For DEX trading
-     * of graduated tokens, use {@link executeSwap} with full TokenClassKey format.
+     * of graduated tokens, use `sdk.dex.swaps.swap()` (the {@link GSwap} client exposed via {@link dex}) with full TokenClassKey format.
      *
      * ```typescript
      * // ✅ CORRECT - Simple token name
@@ -8201,54 +7829,6 @@ export declare class LaunchpadSDK {
      * ```
      */
     fetchTokenStats(tokenName: string): Promise<FetchTokenStatsResult>;
-    /**
-     * Fetch all token balances for a user (v7.1.0+)
-     *
-     * Returns a paginated list of all tokens held by the user with balance information,
-     * graduation status, and optional USD/GALA valuations.
-     *
-     * @param options Fetch options (address required, pageSize optional)
-     * @returns User balance results
-     * @throws ValidationError if address format is invalid
-     *
-     * @category User Account
-     * @since 7.1.0
-     *
-     * @example
-     * ```typescript
-     * const result = await sdk.fetchUserBalances({
-     *   address: 'eth|...',
-     *   pageSize: 20
-     * });
-     * console.log(`User holds ${result.balances.length} tokens`);
-     * ```
-     */
-    fetchUserBalances(options: FetchUserBalancesOptions): Promise<FetchUserBalancesResult>;
-    /**
-     * Fetch comprehensive user report (Overseer only) (v7.1.0+)
-     *
-     * Returns detailed profile, activity, and reputation information for a user.
-     * This endpoint is restricted to overseers and requires JWT authentication.
-     *
-     * @param options Fetch options (address required)
-     * @returns User report result
-     * @throws ValidationError if address format is invalid
-     * @throws ConfigurationError if JWT is not configured
-     *
-     * @category User Account
-     * @since 7.1.0
-     *
-     * @example
-     * ```typescript
-     * const result = await sdk.fetchUserReport({
-     *   address: 'eth|...'
-     * });
-     * const { profile, activity, reputation } = result.report;
-     * console.log(`User: ${profile.fullName}`);
-     * console.log(`Tokens created: ${activity.tokensCreated}`);
-     * ```
-     */
-    fetchUserReport(options: FetchUserReportOptions): Promise<FetchUserReportResult>;
     /**
      * Fetch user profile information by wallet address
      *
@@ -9088,784 +8668,85 @@ export declare class LaunchpadSDK {
      */
     private warmCacheFromPools;
     /**
-     * Get a swap quote for exact input amount
-     *
-     * Queries GalaSwap DEX for a quote when swapping from one token to another,
-     * specifying the exact amount you want to spend.
+     * Connect to WebSocket for real-time events
      *
-     * ## Token Format (IMPORTANT)
+     * Establishes a WebSocket connection for receiving real-time transaction status updates.
+     * This method returns immediately - connection happens asynchronously.
      *
-     * **Use full `tokenClassKey` format** (e.g., `"GALA|Unit|none|none"`), NOT simple names.
+     * @category WebSocket
+     * @since 3.29.0
      *
+     * @example Connect WebSocket
      * ```typescript
-     * // ✅ CORRECT - Full tokenClassKey format
-     * await sdk.getSwapQuoteExactInput('GALA|Unit|none|none', 'GUSDC|Unit|none|eth:0xa0b...', '100');
-     *
-     * // ❌ WRONG - Bare symbols throw ValidationError
-     * await sdk.getSwapQuoteExactInput('GALA', 'GUSDC', '100'); // Error!
+     * const sdk = createLaunchpadSDK({ wallet });
+     * sdk.connectWebSocket();
      * ```
      *
-     * Current Implementation (v3.32.0):
-     * - Delegates to GSwapService which uses GSwap SDK quoting engine
-     * - Returns quote with estimated output, fee tier, and price impact
-     * - Automatically selects optimal liquidity pool for best pricing
-     *
-     * @category DEX Trading
-     * @param fromToken Source token in pipe-delimited format (e.g., "GALA|Unit|none|none")
-     * @param toToken Destination token in pipe-delimited format (e.g., "GUSDC|Unit|none|none")
-     * @param amount Amount of source token to spend
-     * @returns Promise<SwapQuoteResult> Quote with estimated output and fees
-     * @throws ValidationError if bare symbols are provided (use full tokenId format)
-     * @since 3.23.0
-     *
-     * @example Get swap quote
+     * @example Pre-connect before transactions
      * ```typescript
-     * const quote = await sdk.getSwapQuoteExactInput('GALA|Unit|none|none', 'GUSDC|Unit|none|none', '100');
-     * console.log(`Spend: 100 GALA`);
-     * console.log(`Receive: ~${quote.estimatedOutput} GUSDC`);
-     * console.log(`Price impact: ${quote.priceImpact}%`);
+     * const sdk = createLaunchpadSDK({ wallet });
+     * sdk.connectWebSocket(); // Connect first
+     *
+     * const result = await sdk.buy({ tokenName: 'anime', amount: '10' });
+     * // WebSocket ready to monitor transaction immediately
      * ```
      */
-    getSwapQuoteExactInput(fromToken: string, toToken: string, amount: string): Promise<SwapQuoteResult>;
+    connectWebSocket(): void;
     /**
-     * Get a swap quote for exact output amount
-     *
-     * Queries GalaSwap DEX for a quote when swapping from one token to another,
-     * specifying the exact amount you want to receive.
+     * Disconnect from WebSocket
      *
-     * ## Token Format (IMPORTANT)
+     * Closes the WebSocket connection and cleans up all listeners.
+     * Safe to call even if not connected.
      *
-     * **Use full `tokenClassKey` format** (e.g., `"GALA|Unit|none|none"`), NOT simple names.
+     * @category WebSocket
+     * @since 3.29.0
      *
+     * @example Disconnect WebSocket
      * ```typescript
-     * // ✅ CORRECT - Full tokenClassKey format
-     * await sdk.getSwapQuoteExactOutput('GALA|Unit|none|none', 'GUSDC|Unit|none|eth:0xa0b...', '50');
-     *
-     * // ❌ WRONG - Bare symbols throw ValidationError
-     * await sdk.getSwapQuoteExactOutput('GALA', 'GUSDC', '50'); // Error!
+     * sdk.disconnectWebSocket();
      * ```
+     */
+    disconnectWebSocket(): void;
+    /**
+     * Check if WebSocket is connected
      *
-     * Current Implementation (v3.32.0):
-     * - Delegates to GSwapService which uses GSwap SDK quoting engine
-     * - Calculates required input amount for exact output target
-     * - Returns quote with required input, fee tier, and price impact
-     * - Ensures amount constraints are satisfied with slippage buffer
+     * @returns true if WebSocket is currently connected, false otherwise
      *
-     * @category DEX Trading
-     * @param fromToken Source token in pipe-delimited format (e.g., "GALA|Unit|none|none")
-     * @param toToken Destination token in pipe-delimited format (e.g., "GUSDC|Unit|none|none")
-     * @param amount Desired amount of destination token to receive
-     * @returns Promise<SwapQuoteResult> Quote with required input and fees
-     * @throws ValidationError if bare symbols are provided (use full tokenId format)
-     * @since 3.23.0
+     * @category WebSocket
+     * @since 3.29.0
      *
-     * @example Get swap quote for exact output
+     * @example Check connection status
      * ```typescript
-     * const quote = await sdk.getSwapQuoteExactOutput('GALA|Unit|none|none', 'GUSDC|Unit|none|none', '50');
-     * console.log(`To receive: 50 GUSDC`);
-     * console.log(`Need to spend: ~${quote.inputAmount} GALA`);
-     * console.log(`Price impact: ${quote.priceImpact}%`);
+     * if (sdk.isWebSocketConnected()) {
+     *   console.log('Real-time features enabled');
+     * } else {
+     *   console.log('Real-time features disabled');
+     * }
      * ```
      */
-    getSwapQuoteExactOutput(fromToken: string, toToken: string, amount: string): Promise<SwapQuoteResult>;
+    isWebSocketConnected(): boolean;
     /**
-     * Execute a token swap on GalaSwap DEX
-     *
-     * Executes a swap transaction with slippage protection. Requires a signer wallet.
-     * Use quote methods first to get expected output amounts.
+     * Subscribe to WebSocket events on a specific channel
      *
-     * ## Token Format (IMPORTANT)
+     * Allows custom subscription to WebSocket events. Returns a cleanup function
+     * that removes the listener when called.
      *
-     * **Use full `tokenClassKey` format** (e.g., `"GALA|Unit|none|none"`), NOT simple names.
+     * @typeParam T - Type of event data
+     * @param channel - Event channel name
+     * @param callback - Function called when event is received
+     * @returns Cleanup function to unsubscribe from the event
      *
-     * This method is for **DEX trading only** (graduated tokens, GALA, GUSDC, etc.).
-     * For bonding curve tokens (pre-graduation), use {@link buy} or {@link sell} with simple tokenName.
+     * @category WebSocket
+     * @since 3.29.0
      *
+     * @example Subscribe to custom channel
      * ```typescript
-     * // ✅ CORRECT - Full tokenClassKey format
-     * await sdk.executeSwap('GALA|Unit|none|none', 'GUSDC|Unit|none|eth:0xa0b...', '100', output, fee);
-     *
-     * // ❌ WRONG - Bare symbols throw ValidationError
-     * await sdk.executeSwap('GALA', 'GUSDC', '100', output, fee); // Error!
-     *
-     * // ❌ WRONG - Simple token names don't work here
-     * await sdk.executeSwap('anime', 'GALA|Unit|none|none', ...); // Error!
-     * ```
-     *
-     * **Common TokenClassKeys:**
-     * - GALA: `'GALA|Unit|none|none'`
-     * - GUSDC: `'GUSDC|Unit|none|eth:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48'`
-     * - Graduated token: Get from pool's `tokenClassKey` field
-     *
-     * @category DEX Trading
-     * @param fromToken Source token in pipe-delimited format (e.g., "GALA|Unit|none|none")
-     * @param toToken Destination token in pipe-delimited format (e.g., "GUSDC|Unit|none|none")
-     * @param inputAmount Amount of source token to spend
-     * @param estimatedOutput Expected output amount from quote
-     * @param feeTier Fee tier for the swap (500, 3000, or 10000 basis points)
-     * @param slippageTolerance Maximum acceptable slippage (default: 0.01 = 1%)
-     * @returns Promise<ExecuteSwapResult> Swap result with transaction details
-     * @since 3.23.0
-     * @throws ValidationError if wallet is not configured or if bare symbols are provided
-     *
-     * @example Execute swap
-     * ```typescript
-     * // 1. Get quote first
-     * const quote = await sdk.getSwapQuoteExactInput('GALA|Unit|none|none', 'GUSDC|Unit|none|none', '100');
-     *
-     * // 2. Execute swap with quoted amounts
-     * const result = await sdk.executeSwap(
-     *   'GALA|Unit|none|none',
-     *   'GUSDC|Unit|none|none',
-     *   '100',
-     *   quote.estimatedOutput,
-     *   quote.feeTier,
-     *   0.01  // 1% slippage tolerance
-     * );
-     *
-     * console.log(`Swapped successfully!`);
-     * console.log(`Transaction: ${result.transactionId}`);
-     * ```
-     */
-    executeSwap(fromToken: string, toToken: string, inputAmount: string, estimatedOutput: string, feeTier: number, slippageTolerance?: number): Promise<ExecuteSwapResult>;
-    /**
-     * Get user's token assets/balances from GalaSwap
-     *
-     * Retrieves all token balances for a wallet address.
-     *
-     * @category DEX Trading
-     * @param walletAddress User's wallet address
-     * @returns Promise<UserAsset[]> Array of user assets with balances
-     * @since 3.23.0
-     *
-     * @example Get user assets
-     * ```typescript
-     * const assets = await sdk.getSwapUserAssets(sdk.getEthereumAddress());
-     * assets.forEach(asset => {
-     *   console.log(`${asset.symbol}: ${asset.balance}`);
-     * });
-     * ```
-     */
-    getSwapUserAssets(walletAddress: string): Promise<UserAsset[]>;
-    /**
-     * Get all user assets across all pages (auto-paginated)
-     *
-     * Automatically handles pagination to fetch all assets a user holds.
-     * Optimization: Stops fetching when quantity=0 is encountered (results are ordered by quantity desc).
-     *
-     * @category DEX Trading
-     * @param walletAddress User's wallet address
-     * @returns Promise<UserAsset[]> All user assets with balances > 0 and rich metadata
-     * @since 3.23.0
-     * @since 4.1.0 Now returns rich metadata (image, name, description, verified)
-     */
-    getAllSwapUserAssets(walletAddress: string): Promise<UserAsset[]>;
-    /**
-     * Fetch available DEX tokens (token discovery)
-     *
-     * Fetches all tokens available on the DEX without requiring a wallet address.
-     * Use for token discovery, listings, and market analysis.
-     *
-     * @category DEX Trading
-     * @param options Fetch options (search, limit, page)
-     * @returns Promise<AvailableDexTokensResult> Paginated result with token metadata
-     * @since 4.1.0
-     *
-     * @example Fetch first page of available tokens
-     * ```typescript
-     * const result = await sdk.fetchAvailableDexTokens({ limit: 20, page: 1 });
-     * console.log(`Found ${result.count} tokens on DEX`);
-     * result.tokens.forEach(token => {
-     *   console.log(`${token.symbol}: ${token.name} (${token.image})`);
-     * });
-     * ```
-     *
-     * @example Search for tokens
-     * ```typescript
-     * const result = await sdk.fetchAvailableDexTokens({ search: 'GALA', limit: 10, page: 1 });
-     * console.log(`Found ${result.count} tokens matching 'GALA'`);
-     * ```
-     */
-    fetchAvailableDexTokens(options?: FetchAvailableDexTokensOptions): Promise<AvailableDexTokensResult>;
-    /**
-     * Fetch all available DEX tokens (auto-paginated)
-     *
-     * Fetches ALL tokens available on the DEX with automatic pagination.
-     * Use for complete token listings and comprehensive market analysis.
-     *
-     * @category DEX Trading
-     * @param options Fetch options (search filter)
-     * @returns Promise<DexToken[]> All available tokens on the DEX
-     * @since 4.1.0
-     *
-     * @example Fetch all tokens
-     * ```typescript
-     * const tokens = await sdk.fetchAllAvailableDexTokens();
-     * console.log(`Total tokens on DEX: ${tokens.length}`);
-     *
-     * // Filter verified tokens
-     * const verified = tokens.filter(t => t.verified);
-     * console.log(`Verified tokens: ${verified.length}`);
-     * ```
-     *
-     * @example Search all tokens
-     * ```typescript
-     * const tokens = await sdk.fetchAllAvailableDexTokens({ search: 'SDK' });
-     * tokens.forEach(token => console.log(`${token.symbol}: ${token.description}`));
-     * ```
-     */
-    fetchAllAvailableDexTokens(options?: Omit<FetchAvailableDexTokensOptions, 'page' | 'limit'>): Promise<DexToken[]>;
-    /**
-     * Get pool information for a token pair
-     *
-     * Retrieves liquidity and fee tier information for a trading pair.
-     *
-     * @category DEX Trading
-     * @param tokenA First token in pipe-delimited format (e.g., "GALA|Unit|none|none")
-     * @param tokenB Second token in pipe-delimited format (e.g., "GUSDC|Unit|none|none")
-     * @returns Promise<PoolInfo> Pool information with liquidity and available fee tiers
-     * @throws ValidationError if bare symbols are provided (use full tokenId format)
-     * @since 3.23.0
-     *
-     * @example Get pool info
-     * ```typescript
-     * const poolInfo = await sdk.getSwapPoolInfo('GALA|Unit|none|none', 'GUSDC|Unit|none|none');
-     * console.log(`Liquidity: ${poolInfo.liquidity}`);
-     * console.log(`Available fees: ${poolInfo.feeTiers.join(', ')} bps`);
-     * console.log(`Active swaps: ${poolInfo.swapCount}`);
-     * ```
-     */
-    getSwapPoolInfo(tokenA: string, tokenB: string): Promise<PoolInfo>;
-    /**
-     * Get current market price for a DEX pool
-     *
-     * Fetches the current pool state (sqrtPrice and tick) from the GalaChain Gateway
-     * and calculates the token1/token0 price ratio. This is useful for determining
-     * the current price and whether a liquidity position is in-range.
-     *
-     * @category DEX Market Data
-     * @since 3.31.0
-     *
-     * @param token0 - First token in pipe-delimited format (e.g., "GALA|Unit|none|none")
-     * @param token1 - Second token in pipe-delimited format (e.g., "GUSDC|Unit|none|none")
-     * @param fee - Fee tier in basis points (500, 3000, or 10000)
-     * @returns PoolPriceData with current price, sqrtPrice, tick, and liquidity
-     * @throws ValidationError if bare symbols are provided (use full tokenId format)
-     *
-     * @example Get current pool price
-     * ```typescript
-     * const priceData = await sdk.getSwapPoolPrice('GALA|Unit|none|none', 'GUSDC|Unit|none|none', 3000);
-     * console.log(`Current price: ${priceData.price} GUSDC per GALA`);
-     * console.log(`Current tick: ${priceData.tick}`);
-     * console.log(`Pool liquidity: ${priceData.liquidity}`);
-     *
-     * // Determine if position is in-range
-     * const position = await sdk.getSwapLiquidityPositionById(ownerAddress, positionId);
-     * const inRange = priceData.tick >= position.tickLower && priceData.tick <= position.tickUpper;
-     * console.log(`Position in-range: ${inRange}`);
-     * ```
-     */
-    getSwapPoolPrice(token0: string, token1: string, fee: number): Promise<PoolPriceData>;
-    /**
-     * Get liquidity positions for a wallet (single page)
-     *
-     * Retrieves a single page of liquidity positions for the specified wallet address.
-     * Includes position details like token pair, liquidity amount, and accumulated fees.
-     * Optionally fetches real-time pricing for each position's pool.
-     *
-     * For complete enumeration across all pages, use getAllSwapUserLiquidityPositions().
-     *
-     * @category DEX Liquidity Management
-     * @since 3.25.0
-     *
-     * @param ownerAddress - Wallet address (eth|0x... format or standard 0x...)
-     * @param pageSize - Optional page size for positions to return
-     * @param bookmarkOrOptions - Optional pagination bookmark (deprecated) or options object
-     * @param options - Optional options object with pricing configuration
-     * @returns Object with items array (liquidity positions), optional nextBookmark for pagination, and optional prices map
-     *
-     * @example Get single page of positions
-     * ```typescript
-     * const result = await sdk.getSwapUserLiquidityPositions('eth|0x123...');
-     * console.log(`Positions on page: ${result.items.length}`);
-     * result.items.forEach(pos => {
-     *   console.log(`Position ${pos.positionId}:`);
-     *   console.log(`  Tokens: ${pos.token0} / ${pos.token1}`);
-     *   console.log(`  Liquidity: ${pos.liquidity}`);
-     *   console.log(`  Fee0: ${pos.feeAmount0}, Fee1: ${pos.feeAmount1}`);
-     * });
-     *
-     * // Fetch next page if bookmark available
-     * if (result.nextBookmark) {
-     *   const nextPage = await sdk.getSwapUserLiquidityPositions('eth|0x123...', undefined, result.nextBookmark);
-     * }
-     * ```
-     *
-     * @example Get positions with real-time pricing (5 concurrent requests)
-     * ```typescript
-     * const result = await sdk.getSwapUserLiquidityPositions('eth|0x123...', 10, { withPrices: true });
-     * result.items.forEach(pos => {
-     *   const poolKey = `${pos.token0}|${pos.token1}|${pos.feeTier}`;
-     *   const price = result.prices?.get(poolKey);
-     *   if (price) {
-     *     console.log(`Current price: 1 ${pos.token0} = ${price.currentPrice} ${pos.token1}`);
-     *   }
-     * });
-     * ```
-     */
-    getSwapUserLiquidityPositions(ownerAddress: string, limit?: number, bookmarkOrOptions?: string | GetLiquidityPositionsOptions, options?: GetLiquidityPositionsOptions): Promise<GetLiquidityPositionsResult>;
-    /**
-     * Get ALL user liquidity positions with automatic pagination
-     *
-     * Fetches all liquidity positions for a wallet across all pages automatically.
-     * This is the recommended method for complete position enumeration.
-     * Optionally fetches real-time pricing for each position's pool.
-     *
-     * @category DEX Liquidity Management
-     * @since 3.31.3
-     *
-     * @param ownerAddress - User's wallet address
-     * @param options - Optional options object with pricing configuration
-     * @returns Array of all liquidity positions (auto-paginated) or result object with positions and pricing
-     *
-     * @example Get all positions automatically
-     * ```typescript
-     * const allPositions = await sdk.getAllSwapUserLiquidityPositions('eth|0x123...');
-     * console.log(`Total positions: ${allPositions.length}`);
-     * allPositions.forEach(pos => {
-     *   console.log(`Position ${pos.positionId}:`);
-     *   console.log(`  Tokens: ${pos.token0} / ${pos.token1}`);
-     *   console.log(`  Liquidity: ${pos.liquidity}`);
-     *   console.log(`  Fees: ${pos.feeAmount0} ${pos.token0}, ${pos.feeAmount1} ${pos.token1}`);
-     * });
-     * ```
-     *
-     * @example Get all positions with real-time pricing (default 5 concurrent requests)
-     * ```typescript
-     * const result = await sdk.getAllSwapUserLiquidityPositions('eth|0x123...', { withPrices: true });
-     * console.log(`Total positions: ${result.items.length}`);
-     * result.items.forEach(pos => {
-     *   const poolKey = `${pos.token0}|${pos.token1}|${pos.feeTier}`;
-     *   const price = result.prices?.get(poolKey);
-     *   if (price) {
-     *     console.log(`Current price: 1 ${pos.token0} = ${price.currentPrice} ${pos.token1}`);
-     *     console.log(`Price Impact: ${price.priceImpact}%`);
-     *   }
-     * });
-     * ```
-     *
-     * @example Get all positions with custom concurrency (10 concurrent pricing requests)
-     * ```typescript
-     * const result = await sdk.getAllSwapUserLiquidityPositions('eth|0x123...', {
-     *   withPrices: true,
-     *   pricingConcurrency: 10  // Speed up pricing with more concurrent requests
-     * });
-     * ```
-     */
-    getAllSwapUserLiquidityPositions(ownerAddress: string, options?: GetLiquidityPositionsOptions): Promise<GSwapPosition[] | GetLiquidityPositionsResult>;
-    /**
-     * Get specific liquidity position by token pair
-     *
-     * Retrieves a specific liquidity position identified by the owner, token pair, and price range.
-     *
-     * @category DEX Liquidity Management
-     * @since 3.25.0
-     *
-     * @param ownerAddress - Wallet address
-     * @param position - Position specifier:
-     *   - token0: First token in pipe-delimited format (e.g., "GALA|Unit|none|none")
-     *   - token1: Second token in pipe-delimited format (e.g., "GUSDC|Unit|none|none")
-     *   - fee: Fee tier (500, 3000, or 10000 basis points)
-     *   - tickLower/tickUpper: Tick boundaries
-     * @returns Liquidity position details or undefined if not found
-     * @throws ValidationError if bare symbols are provided (use full tokenId format)
-     *
-     * @example Get position by token pair
-     * ```typescript
-     * const position = await sdk.getSwapLiquidityPosition(
-     *   'eth|0x123...',
-     *   {
-     *     token0: 'GALA|Unit|none|none',
-     *     token1: 'GUSDC|Unit|none|none',
-     *     fee: 3000,
-     *     tickLower: -60,
-     *     tickUpper: 60
-     *   }
-     * );
-     * ```
-     */
-    getSwapLiquidityPosition(ownerAddress: string, position: {
-        token0: string;
-        token1: string;
-        fee: number;
-        tickLower: number;
-        tickUpper: number;
-    }): Promise<GSwapPosition>;
-    /**
-     * Get liquidity position by position ID
-     *
-     * Retrieves a specific liquidity position by its unique identifier.
-     * Optionally accepts token information for more efficient compound key lookups.
-     *
-     * @category DEX Liquidity Management
-     * @since 3.25.0
-     *
-     * @param ownerAddress - Wallet address
-     * @param positionId - Unique position identifier
-     * @param token0 - Optional token0 for compound key lookup (improves lookup reliability)
-     * @param token1 - Optional token1 for compound key lookup (improves lookup reliability)
-     * @param feeTier - Optional fee tier for compound key lookup (improves lookup reliability)
-     * @param tickLower - Optional lower tick boundary for compound key lookup
-     * @param tickUpper - Optional upper tick boundary for compound key lookup
-     * @returns Liquidity position details
-     *
-     * @example Get position by ID with token information
-     * ```typescript
-     * const position = await sdk.getSwapLiquidityPositionById(
-     *   'eth|0x123...',
-     *   'pos-abc123',
-     *   'GALA',
-     *   'GUSDC',
-     *   3000,
-     *   -1080,  // tickLower
-     *   900     // tickUpper
-     * );
-     * ```
-     */
-    getSwapLiquidityPositionById(ownerAddress: string, positionId: string, token0?: string | Record<string, unknown>, token1?: string | Record<string, unknown>, feeTier?: number, tickLower?: number, tickUpper?: number): Promise<GSwapPosition>;
-    /**
-     * Fetch a single liquidity position using ONLY the compound key (most efficient)
-     *
-     * Makes a direct HTTP call to GalaChain Gateway using token0, token1, fee, and tick range.
-     * This is the most efficient method when you already have all position parameters.
-     *
-     * @param params - Position lookup parameters (all required):
-     *   - token0: First token in pipe-delimited format (e.g., "GALA|Unit|none|none")
-     *   - token1: Second token in pipe-delimited format (e.g., "GUSDC|Unit|none|none")
-     *   - fee: Fee tier (500, 3000, or 10000 basis points)
-     *   - tickLower: Lower tick boundary
-     *   - tickUpper: Upper tick boundary
-     *   - owner: Wallet address (e.g., "eth|0x...")
-     * @returns Detailed liquidity position information
-     * @throws ValidationError if bare symbols are provided (use full tokenId format)
-     *
-     * @example
-     * ```typescript
-     * const position = await sdk.fetchSwapPositionDirect({
-     *   token0: 'GALA|Unit|none|none',
-     *   token1: 'GUSDC|Unit|none|none',
-     *   fee: 3000,
-     *   tickLower: -26440,
-     *   tickUpper: -22390,
-     *   owner: 'eth|A278F228BB9Ea280C537763974FF1c1d427c85bb'
-     * });
-     * ```
-     *
-     * @category DEX Liquidity Queries
-     * @since 3.35.0
-     *
-     * @remarks
-     * - Single direct HTTP call (most efficient path)
-     * - Does NOT require or accept positionId
-     * - No GSwap SDK dependency
-     * - All parameters are required
-     */
-    fetchSwapPositionDirect(params: {
-        token0: string;
-        token1: string;
-        fee: number;
-        tickLower: number;
-        tickUpper: number;
-        owner: string;
-    }): Promise<GSwapPosition>;
-    /**
-     * Estimate tokens to receive when removing liquidity
-     *
-     * Previews the amounts of tokens that would be received
-     * if liquidity were removed at current market prices.
-     *
-     * @category DEX Liquidity Management
-     * @since 3.25.0
-     *
-     * @param args - Removal estimation parameters:
-     *   - token0: First token in pipe-delimited format (e.g., "GALA|Unit|none|none")
-     *   - token1: Second token in pipe-delimited format (e.g., "GUSDC|Unit|none|none")
-     *   - fee: Fee tier (500, 3000, or 10000 basis points)
-     *   - liquidity: Liquidity amount to remove
-     *   - tickLower: Lower tick boundary
-     *   - tickUpper: Upper tick boundary
-     *   - owner: Wallet address (e.g., "eth|0x...")
-     * @returns Estimated token amounts
-     * @throws ValidationError if bare symbols are provided (use full tokenId format)
-     *
-     * @example Estimate liquidity removal
-     * ```typescript
-     * const estimate = await sdk.getSwapEstimateRemoveLiquidity({
-     *   token0: 'GALA|Unit|none|none',
-     *   token1: 'GUSDC|Unit|none|none',
-     *   fee: 3000,
-     *   liquidity: '1000000',
-     *   tickLower: -60,
-     *   tickUpper: 60,
-     *   owner: 'eth|0x1234...'
-     * });
-     * console.log(`Would receive: ${estimate.amount0} + ${estimate.amount1}`);
-     * ```
-     */
-    getSwapEstimateRemoveLiquidity(args: {
-        token0: string;
-        token1: string;
-        fee: number;
-        liquidity: string;
-        tickLower: number;
-        tickUpper: number;
-        owner: string;
-    }): Promise<GSwapEstimateRemoveLiquidityResult>;
-    /**
-     * Add liquidity using price range
-     *
-     * Creates a new liquidity position by specifying the desired price range.
-     * The SDK automatically calculates the appropriate tick boundaries.
-     * Recommended for most users.
-     *
-     * ## Token Format (IMPORTANT)
-     *
-     * **Use full `tokenClassKey` format** for token0 and token1.
-     *
-     * ```typescript
-     * // ✅ CORRECT - Full tokenClassKey format
-     * { token0: 'GALA|Unit|none|none', token1: 'GUSDC|Unit|none|eth:0xa0b...' }
-     *
-     * // ❌ WRONG - Bare symbols throw ValidationError
-     * { token0: 'GALA', token1: 'GUSDC' } // Error!
-     * ```
-     *
-     * @category DEX Liquidity Management
-     * @since 3.25.0
-     *
-     * @param args - Liquidity parameters with price range:
-     *   - token0: First token in pipe-delimited format (e.g., "GALA|Unit|none|none")
-     *   - token1: Second token in pipe-delimited format (e.g., "GUSDC|Unit|none|none")
-     *   - fee: Fee tier (500, 3000, or 10000 basis points)
-     *   - minPrice/maxPrice: Price range boundaries
-     *   - amount0Desired/amount1Desired: Token amounts to provide
-     * @returns Transaction result with position ID
-     * @throws {TypeError} If required parameters are missing or of wrong type
-     * @throws ValidationError if bare symbols are provided (use full tokenId format)
-     *
-     * @example Add liquidity with price range
-     * ```typescript
-     * const result = await sdk.addSwapLiquidityByPrice({
-     *   token0: 'GALA|Unit|none|none',
-     *   token1: 'GUSDC|Unit|none|none',
-     *   fee: 3000,
-     *   minPrice: '0.90',
-     *   maxPrice: '1.10',
-     *   amount0Desired: '1000',
-     *   amount1Desired: '1000',
-     *   amount0Min: '900',
-     *   amount1Min: '900'
-     * });
-     * console.log(`Position created: ${result.positionId}`);
-     * ```
-     */
-    addSwapLiquidityByPrice(args: AddLiquidityByPriceArgs): Promise<GSwapAddLiquidityResult & {
-        timestamp?: Date;
-        wait?: (timeoutMs?: number) => Promise<void>;
-    }>;
-    /**
-     * Add liquidity using tick range
-     *
-     * Creates a new liquidity position by specifying exact tick boundaries.
-     * For advanced users who need precise control over the price range.
-     *
-     * @category DEX Liquidity Management
-     * @since 3.25.0
-     *
-     * @param args - Liquidity parameters with tick range:
-     *   - token0: First token in pipe-delimited format (e.g., "GALA|Unit|none|none")
-     *   - token1: Second token in pipe-delimited format (e.g., "GUSDC|Unit|none|none")
-     *   - feeTier: Fee tier (500, 3000, or 10000 basis points)
-     *   - tickLower/tickUpper: Exact tick boundaries
-     *   - amount0Desired/amount1Desired: Token amounts to provide
-     * @returns Transaction result with position ID
-     * @throws {ValidationError} If wallet is not configured or if bare symbols are provided
-     * @throws {TypeError} If required parameters are missing or of wrong type
-     *
-     * @example Add liquidity with tick range
-     * ```typescript
-     * const result = await sdk.addSwapLiquidityByTicks({
-     *   token0: 'GALA|Unit|none|none',
-     *   token1: 'GUSDC|Unit|none|none',
-     *   feeTier: 3000,
-     *   tickLower: -60,
-     *   tickUpper: 60,
-     *   amount0Desired: '1000',
-     *   amount1Desired: '1000'
-     * });
-     * console.log(`Position created: ${result.positionId}`);
-     * ```
-     */
-    addSwapLiquidityByTicks(args: AddLiquidityByTicksArgs): Promise<GSwapAddLiquidityResult & {
-        timestamp?: Date;
-        wait?: (timeoutMs?: number) => Promise<void>;
-    }>;
-    /**
-     * Remove liquidity from a position
-     *
-     * Withdraws liquidity and underlying tokens from an open position.
-     * Can be used to close the position entirely or reduce exposure.
-     *
-     * **Important:** This method requires full pool information (token0, token1, fee, tickLower, tickUpper)
-     * to resolve token class keys and construct the transaction. You must either:
-     * 1. Provide these directly if you know the pool details, or
-     * 2. Fetch them using `getSwapLiquidityPositionById()` if you only have the position ID
-     *
-     * @category DEX Liquidity Management
-     * @since 3.25.0
-     *
-     * @param args - Removal parameters:
-     *   - token0: First token in pipe-delimited format (e.g., "GALA|Unit|none|none")
-     *   - token1: Second token in pipe-delimited format (e.g., "GUSDC|Unit|none|none")
-     *   - fee: Fee tier (500, 3000, or 10000 basis points)
-     *   - tickLower/tickUpper: Tick boundaries
-     *   - liquidity: Liquidity amount to remove
-     * @returns Transaction result confirming removal
-     * @throws {TypeError} If required pool parameters are missing
-     * @throws ValidationError if bare symbols are provided (use full tokenId format)
-     *
-     * @example Remove liquidity with known pool details
-     * ```typescript
-     * const result = await sdk.removeSwapLiquidity({
-     *   token0: 'GALA|Unit|none|none',
-     *   token1: 'GUSDC|Unit|none|none',
-     *   fee: 3000,
-     *   tickLower: -10000,
-     *   tickUpper: 10000,
-     *   liquidity: '1000000000000000000',
-     *   amount0Min: '0',
-     *   amount1Min: '0'
-     * });
-     * ```
-     *
-     * @example Remove liquidity by fetching position first
-     * ```typescript
-     * const position = await sdk.getSwapLiquidityPositionById(walletAddress, positionId);
-     * const result = await sdk.removeSwapLiquidity({
-     *   token0: position.token0,  // Already in pipe-delimited format from API
-     *   token1: position.token1,
-     *   fee: position.feeTier,
-     *   tickLower: position.tickLower,
-     *   tickUpper: position.tickUpper,
-     *   liquidity: position.liquidity
-     * });
-     * ```
-     */
-    removeSwapLiquidity(args: RemoveLiquidityArgs): Promise<GSwapAddLiquidityResult>;
-    /**
-     * Collect accumulated position fees
-     *
-     * Harvests accumulated trading fees from a liquidity position without
-     * modifying the position itself.
-     *
-     * @category DEX Liquidity Management
-     * @since 3.25.0
-     *
-     * @param args - Collection parameters with position details
-     * @returns Transaction result with collected amounts
-     * @throws {ValidationError} If wallet is not configured
-     * @throws {TypeError} If required parameters are missing or of wrong type
-     *
-     * @example Collect fees
-     * ```typescript
-     * const result = await sdk.collectSwapPositionFees({
-     *   ownerAddress: 'eth|0x123...',
-     *   positionId: 'pos-abc123'
-     * });
-     * console.log(`Collected: ${result.amount0} token0, ${result.amount1} token1`);
-     * ```
-     */
-    collectSwapPositionFees(args: CollectFeesArgs): Promise<GSwapAddLiquidityResult>;
-    /**
-     * Connect to WebSocket for real-time events
-     *
-     * Establishes a WebSocket connection for receiving real-time transaction status updates.
-     * This method returns immediately - connection happens asynchronously.
-     *
-     * @category WebSocket
-     * @since 3.29.0
-     *
-     * @example Connect WebSocket
-     * ```typescript
-     * const sdk = createLaunchpadSDK({ wallet });
-     * sdk.connectWebSocket();
-     * ```
-     *
-     * @example Pre-connect before transactions
-     * ```typescript
-     * const sdk = createLaunchpadSDK({ wallet });
-     * sdk.connectWebSocket(); // Connect first
-     *
-     * const result = await sdk.buy({ tokenName: 'anime', amount: '10' });
-     * // WebSocket ready to monitor transaction immediately
-     * ```
-     */
-    connectWebSocket(): void;
-    /**
-     * Disconnect from WebSocket
-     *
-     * Closes the WebSocket connection and cleans up all listeners.
-     * Safe to call even if not connected.
-     *
-     * @category WebSocket
-     * @since 3.29.0
-     *
-     * @example Disconnect WebSocket
-     * ```typescript
-     * sdk.disconnectWebSocket();
-     * ```
-     */
-    disconnectWebSocket(): void;
-    /**
-     * Check if WebSocket is connected
-     *
-     * @returns true if WebSocket is currently connected, false otherwise
-     *
-     * @category WebSocket
-     * @since 3.29.0
-     *
-     * @example Check connection status
-     * ```typescript
-     * if (sdk.isWebSocketConnected()) {
-     *   console.log('Real-time features enabled');
-     * } else {
-     *   console.log('Real-time features disabled');
-     * }
-     * ```
-     */
-    isWebSocketConnected(): boolean;
-    /**
-     * Subscribe to WebSocket events on a specific channel
-     *
-     * Allows custom subscription to WebSocket events. Returns a cleanup function
-     * that removes the listener when called.
-     *
-     * @typeParam T - Type of event data
-     * @param channel - Event channel name
-     * @param callback - Function called when event is received
-     * @returns Cleanup function to unsubscribe from the event
-     *
-     * @category WebSocket
-     * @since 3.29.0
-     *
-     * @example Subscribe to custom channel
-     * ```typescript
-     * const unsubscribe = sdk.subscribeToEvent<PoolCreatedEvent>(
-     *   'pool:created',
-     *   (event) => {
-     *     console.log(`New pool: ${event.token0}/${event.token1}`);
-     *   }
-     * );
+     * const unsubscribe = sdk.subscribeToEvent<PoolCreatedEvent>(
+     *   'pool:created',
+     *   (event) => {
+     *     console.log(`New pool: ${event.token0}/${event.token1}`);
+     *   }
+     * );
      *
      * // Later: Stop listening
      * unsubscribe();
@@ -9881,61 +8762,7 @@ export declare class LaunchpadSDK {
      * cleanup2();
      * ```
      */
-    subscribeToEvent<T>(channel: string, callback: (data: T) => void): () => void;
-    /**
-     * Watch for new DEX pool creation events in real-time
-     *
-     * Polls for newly created DEX pools at regular intervals and invokes the callback
-     * for each new pool detected. Automatically deduplicates pools to avoid duplicate callbacks.
-     *
-     * **Memory Management:** This watcher maintains a bounded history of the 1000 most recently
-     * seen pools using LRU (Least Recently Used) cleanup. This prevents unbounded memory growth
-     * even when watching for extended periods.
-     *
-     * @param callback - Called when a new pool is created
-     * @param options - Configuration options for pool watching
-     * @param options.intervalMs - Poll interval in milliseconds (default: 30000 / 30 seconds)
-     * @param options.minTVL - Only notify about pools with TVL >= minTVL (optional, in USD)
-     * @param options.tokens - Only notify about pools containing these token symbols (optional)
-     * @returns Cleanup function to stop watching
-     *
-     * @category Watchers
-     * @since 3.29.0
-     *
-     * @example Watch all new pools
-     * ```typescript
-     * const unsubscribe = sdk.onDexPoolCreation((pool) => {
-     *   console.log(`New pool: ${pool.poolName}`);
-     *   console.log(`TVL: $${(pool.token0Tvl + pool.token1Tvl) / 2}`);
-     * });
-     *
-     * // Later: stop watching
-     * unsubscribe();
-     * ```
-     *
-     * @example Watch high-value pools only
-     * ```typescript
-     * const unsubscribe = sdk.onDexPoolCreation(
-     *   (pool) => {
-     *     console.log(`High-value pool: ${pool.poolName}`);
-     *   },
-     *   { minTVL: 100000 } // Only pools with >$100k TVL
-     * );
-     * ```
-     *
-     * @example Watch specific token pairs
-     * ```typescript
-     * const unsubscribe = sdk.onDexPoolCreation(
-     *   (pool) => console.log(`GALA pool: ${pool.poolName}`),
-     *   { tokens: ['GALA', 'GUSDC'], intervalMs: 15000 }
-     * );
-     * ```
-     */
-    onDexPoolCreation(callback: (pool: DexPoolData) => void | Promise<void>, options?: {
-        intervalMs?: number;
-        minTVL?: number;
-        tokens?: string[];
-    }): () => void;
+    subscribeToEvent<T>(channel: string, callback: (data: T) => void): () => void;
     /**
      * Watch for new launchpad token creation events in real-time
      *
@@ -9980,116 +8807,6 @@ export declare class LaunchpadSDK {
     }): () => void;
     private static readonly TOKEN_CREATION_SOCKET_WAIT_ATTEMPTS;
     private static readonly TOKEN_CREATION_SOCKET_POLL_INTERVAL_MS;
-    private static readonly DEX_POOL_SOCKET_WAIT_ATTEMPTS;
-    private static readonly DEX_POOL_SOCKET_POLL_INTERVAL_MS;
-    /**
-     * Normalize fee tier to standard format (500, 3000, or 10000)
-     *
-     * Handles various fee formats: percentage strings ("0.3", "1"), basis points (500, 3000, 10000)
-     *
-     * @param value - Fee value in any format
-     * @returns Normalized fee tier (500, 3000, 10000) or null if invalid
-     * @private
-     */
-    private normalizeFee;
-    /**
-     * Extract a field from an object with multiple possible key names
-     *
-     * @param obj - Object to search
-     * @param keys - Possible key names to try in order
-     * @returns Value of first matching key or empty string
-     * @private
-     */
-    private extractField;
-    /**
-     * Check if a string looks like a pool pair format
-     *
-     * Format: "token0/token1/fee" or full format with class keys
-     *
-     * @param value - Value to check
-     * @returns Normalized pool pair string or null
-     * @private
-     */
-    private looksLikePoolPair;
-    /**
-     * Build pool pair from object with token and fee fields
-     *
-     * Tries multiple field name patterns to extract token0, token1, and fee
-     *
-     * @param obj - Object potentially containing pool data
-     * @returns Pool pair string or null
-     * @private
-     */
-    private buildPoolPairFromObject;
-    /**
-     * Parse pool pair string into token0, token1, and fee
-     *
-     * Format: "token0ClassKey/token1ClassKey/feeTier"
-     * Example: "GALA|Unit|none|none/GUSDC|Unit|none|none/10000"
-     *
-     * @param poolPairString - Pool pair string
-     * @returns Pool data or null if invalid
-     * @private
-     */
-    private parsePoolPairString;
-    /**
-     * Serialize balance token object to classKey format
-     * Used by buildPoolPairFromBalances to convert balance objects to token symbols
-     *
-     * Format: "collection|category|type|additionalKey"
-     * Example: "GALA|Unit|none|none"
-     *
-     * @param balance - Balance object with collection, category, type fields
-     * @returns Serialized token string or empty string if invalid
-     * @private
-     */
-    private serializeBalanceToken;
-    /**
-     * Build pool pair from balance delta objects
-     * Handles extraction from swap and liquidity events that include balance changes
-     *
-     * Looks for:
-     * - userBalanceDelta, balanceDelta, or delta objects
-     * - token0Balance/token0/baseBalance/primaryBalance fields
-     * - token1Balance/token1/quoteBalance/secondaryBalance fields
-     * - Fee from poolFee, feeTier, fee, feeTierBps, or liquidityFeeBps
-     *
-     * @param obj - Object that may contain balance delta data
-     * @returns Pool pair string or null if extraction failed
-     * @private
-     */
-    private buildPoolPairFromBalances;
-    /**
-     * Extract pool data from WebSocket event payload
-     *
-     * Tries multiple patterns in order to find pool data:
-     * 1. Direct poolPair string
-     * 2. Direct poolPair field
-     * 3. Balance delta patterns (from swap/liquidity events) - CRITICAL for event detection
-     * 4. Object fields (token0, token1, fee)
-     * 5. Nested pool object
-     *
-     * Order matches reference implementation (newPoolsWatch.js) for maximum compatibility
-     *
-     * @param payload - WebSocket event payload
-     * @returns Pool data or null if not found
-     * @private
-     */
-    private extractPoolDataFromPayload;
-    /**
-     * Check if a pool matches the optional filters
-     *
-     * Implements position-independent token matching:
-     * - tokenFilter matches if token appears in EITHER position (token0 OR token1)
-     * - pairTokens matches if BOTH tokens are present regardless of order
-     * - feeTierFilter matches the fee tier
-     *
-     * @param pool - Pool data to check
-     * @param options - Optional filters
-     * @returns true if pool matches all specified filters
-     * @private
-     */
-    private matchesPoolFilter;
     /**
      * Check if a token creation event matches the optional creator filter
      *
@@ -10194,421 +8911,6 @@ export declare class LaunchpadSDK {
         creatorFilter?: string;
         onError?: (error: Error) => void;
     }): () => void;
-    /**
-     * Recursively walk WebSocket event payload to find all pools
-     *
-     * Exhaustively searches through entire payload tree, including nested objects.
-     * Matches reference implementation (newPoolsWatch.js walkPayload) for complete event coverage.
-     *
-     * Uses WeakSet to track visited objects and prevent infinite loops on circular references.
-     * Deduplicates pools using the provided seenPools Set.
-     *
-     * @param payload - Event payload to walk (can be string, object, or any value)
-     * @param seenPools - Set of already-seen pool pair strings (for deduplication)
-     * @param visited - WeakSet of visited objects (to prevent circular reference loops)
-     * @returns Array of newly discovered pool data objects
-     * @private
-     */
-    private walkPayloadForPools;
-    /**
-     * Subscribe to real-time DEX pool creation broadcasts
-     *
-     * Listens to WebSocket broadcasts for DEX pool creation events globally.
-     * Provides real-time notifications when new liquidity pools are added (~1-2 second latency).
-     *
-     * **Use Case:**
-     * Monitor for graduated tokens becoming swappable on the DEX. When a token graduates from
-     * bonding curve to DEX, a pool is created and this subscription notifies in real-time.
-     *
-     * **Position-Independent Token Matching:**
-     * Token filters work regardless of position (token0 vs token1):
-     * - `tokenFilter: 'GALA'` matches both GALA/USDC and USDC/GALA pools
-     * - `pairTokens: ['GALA', 'USDC']` matches the specific pair in any order
-     *
-     * **Connection Management:**
-     * - If WebSocket is already connected, listener is registered immediately
-     * - If not connected, automatically initiates connection with 3-second timeout
-     * - Connection failures are logged and can be handled via error callback
-     *
-     * **Cleanup Function:**
-     * - Safe to call multiple times (idempotent)
-     * - Removes listener and cleans up tracking state
-     * - Returns immediately if listener was never registered
-     *
-     * @param callback - Called when a new DEX pool is created
-     * @param options - Optional filtering and error handling
-     * @param options.tokenFilter - Only receive pools containing this token (in either position)
-     * @param options.pairTokens - Only receive pools with this specific token pair (order-independent)
-     * @param options.feeTierFilter - Only receive pools with this fee tier (500, 3000, or 10000)
-     * @param options.onError - Called if WebSocket connection fails
-     * @returns Cleanup function to stop listening - safe to call multiple times
-     *
-     * @category Real-time Monitoring
-     * @since 4.1.0
-     *
-     * @throws Error if WebSocket service not initialized
-     *
-     * @example Listen to all new pools
-     * ```typescript
-     * const cleanup = sdk.subscribeToDexPoolAdded((pool) => {
-     *   console.log(`New pool: ${pool.token0}/${pool.token1} (${pool.fee}% fee)`);
-     * });
-     *
-     * // Stop listening when done
-     * cleanup();
-     * ```
-     *
-     * @example Listen for GALA pools only
-     * ```typescript
-     * const cleanup = sdk.subscribeToDexPoolAdded(
-     *   (pool) => {
-     *     if (pool.token0 === 'GALA' || pool.token1 === 'GALA') {
-     *       console.log(`GALA pool created: ${pool.poolPair}`);
-     *     }
-     *   },
-     *   { tokenFilter: 'GALA' }
-     * );
-     * ```
-     *
-     * @example Monitor specific pair with fee tier
-     * ```typescript
-     * const cleanup = sdk.subscribeToDexPoolAdded(
-     *   (pool) => {
-     *     console.log(`GALA/GUSDC 0.3% pool created!`);
-     *   },
-     *   {
-     *     pairTokens: ['GALA', 'GUSDC'],
-     *     feeTierFilter: 3000,  // 0.3%
-     *     onError: (error) => console.error('Connection failed:', error)
-     *   }
-     * );
-     * ```
-     *
-     * @example Monitor graduated tokens (all pools, real-time)
-     * ```typescript
-     * // Watch for ANY new pools - indicates graduated tokens
-     * const cleanup = sdk.subscribeToDexPoolAdded(
-     *   (pool) => {
-     *     console.log(`Graduated token detected: ${pool.token0}/${pool.token1}`);
-     *     // Could trigger automatic trading strategies
-     *   }
-     * );
-     * ```
-     */
-    subscribeToDexPoolAdded(callback: (pool: {
-        token0: string;
-        token1: string;
-        fee: string;
-        poolPair: string;
-    }) => void, options?: {
-        tokenFilter?: string;
-        pairTokens?: [string, string];
-        feeTierFilter?: string | number;
-        onError?: (error: Error) => void;
-    }): () => void;
-    /**
-     * Subscribe to real-time DEX swap execution events
-     *
-     * Monitors all completed swaps on the DEX globally with real-time notifications (~1-2 second latency).
-     * Provides offline price predictions and delta-based pool state updates for arbitrage bot use cases.
-     *
-     * **Architecture:**
-     * The backend broadcasts transaction confirmation events for completed swaps to ALL connected clients.
-     * This listener captures "ExecuteSwap" events and provides:
-     * - Real-time swap transaction data (tokens, amounts, fees)
-     * - Offline price quotes using cached pool state (~25-50ms vs network requests)
-     * - Delta-based pool updates (~15-25ms vs full refetch ~200-400ms)
-     * - Performance metrics (latency percentiles, cache hit rates, throughput)
-     *
-     * **Position-Independent Token Matching:**
-     * Token filters work regardless of position (token0 vs token1):
-     * - `tokenFilter: 'GALA'` matches both GALA/USDC and USDC/GALA swaps
-     * - `pairTokens: ['GALA', 'USDC']` matches the specific pair in any order
-     *
-     * **Connection Management:**
-     * - If WebSocket is already connected, listener is registered immediately
-     * - If not connected, automatically initiates connection with 3-second timeout
-     * - Connection failures are logged and can be handled via error callback
-     *
-     * **Cleanup Function:**
-     * - Safe to call multiple times (idempotent)
-     * - Removes listener and cleans up tracking state
-     * - Returns immediately if listener was never registered
-     *
-     * @param callback - Called when a swap completes with enriched swap data
-     * @param options - Optional filtering, configuration, and error handling
-     * @param options.tokenFilter - Only receive swaps containing this token (in either position)
-     * @param options.pairTokens - Only receive swaps with this specific token pair (order-independent)
-     * @param options.feeTierFilter - Only receive swaps with this fee tier (500, 3000, or 10000)
-     * @param options.userFilter - Only receive swaps from this wallet address
-     * @param options.memoryProfile - Cache memory profile: 'conservative' (55MB), 'moderate' (250MB), 'aggressive' (530MB)
-     * @param options.maxPools - Maximum pools to cache (default: 500)
-     * @param options.enableDeltaOptimization - Use delta updates instead of full refetch (default: true)
-     * @param options.enableOfflineQuotes - Calculate offline quotes for known pools (default: true)
-     * @param options.debug - Enable debug logging (default: false)
-     * @param options.onError - Called if WebSocket connection fails
-     * @returns Cleanup function to stop listening - safe to call multiple times
-     *
-     * @category Real-time Monitoring
-     * @since 4.2.0
-     *
-     * @throws Error if WebSocket service not initialized
-     *
-     * @example Listen to all swaps globally
-     * ```typescript
-     * const cleanup = sdk.subscribeToDexSwapExecuted((swap) => {
-     *   console.log(`Swap: ${swap.token0} → ${swap.token1}`);
-     *   console.log(`Amount: ${swap.amount0} / ${swap.amount1}`);
-     *   if (swap.estimatedPrice) {
-     *     console.log(`Price: ${swap.estimatedPrice}`);
-     *   }
-     * });
-     *
-     * // Stop listening when done
-     * cleanup();
-     * ```
-     *
-     * @example Arbitrage bot - monitor GALA/GUSDC swaps with offline pricing
-     * ```typescript
-     * const cleanup = sdk.subscribeToDexSwapExecuted(
-     *   async (swap) => {
-     *     if (swap.estimatedPrice && swap.poolStateUpdated) {
-     *       // Price calculated instantly using cached pool state
-     *       console.log(`Arbitrage opportunity: ${swap.estimatedPrice}`);
-     *
-     *       // Trigger trading logic
-     *       await executeArbitrageStrategy(swap);
-     *     }
-     *   },
-     *   {
-     *     pairTokens: ['GALA', 'GUSDC'],
-     *     memoryProfile: 'aggressive',    // Max cache for arbitrage
-     *     enableDeltaOptimization: true,  // Fast updates
-     *     enableOfflineQuotes: true,      // Instant pricing
-     *     onError: (error) => console.error('Swap monitoring failed:', error)
-     *   }
-     * );
-     * ```
-     *
-     * @example Monitor specific token with fee tier
-     * ```typescript
-     * const cleanup = sdk.subscribeToDexSwapExecuted(
-     *   (swap) => {
-     *     console.log(`GALA 0.3% pool swap: ${swap.amount0}`);
-     *   },
-     *   {
-     *     tokenFilter: 'GALA',
-     *     feeTierFilter: 3000,  // 0.3% fee tier
-     *   }
-     * );
-     * ```
-     *
-     * @example Health monitoring for swap monitoring system
-     * ```typescript
-     * let swapMonitor: MultiPoolStateManager | null = null;
-     *
-     * const cleanup = sdk.subscribeToDexSwapExecuted(
-     *   (swap) => {
-     *     console.log(`Swap processed in <50ms:`, swap.poolStateUpdated);
-     *   },
-     *   {
-     *     memoryProfile: 'moderate',
-     *     onError: (error) => console.error('Connection failed:', error)
-     *   }
-     * );
-     *
-     * // Can get health metrics
-     * // const health = swapMonitor?.getHealth();
-     * // console.log(`Cache hit rate: ${health.metrics.cacheHitRate}%`);
-     * ```
-     */
-    subscribeToDexSwapExecuted(callback: SwapEventCallback, options?: SubscribeSwapOptions & SwapMonitorConfig): CleanupFunction;
-    /**
-     * Subscribe to real-time DEX liquidity addition events
-     *
-     * Monitors all liquidity additions on the DEX globally with real-time notifications.
-     * All liquidity events are broadcast to all connected clients - you can monitor
-     * market-wide liquidity activity, not just your own transactions.
-     *
-     * **Use Cases:**
-     * - LP position tracking: Monitor when users add liquidity to positions
-     * - Whale watching: Detect large liquidity additions
-     * - Market analysis: Track overall DEX liquidity growth
-     * - Position management: React to liquidity changes in pools you care about
-     *
-     * **Position-Independent Token Matching:**
-     * Token filters work regardless of position (token0 vs token1):
-     * - `tokenFilter: 'GALA'` matches liquidity additions to any GALA pool
-     * - `pairTokens: ['GALA', 'GUSDC']` matches the specific pair in any order
-     *
-     * @param callback - Called when liquidity is added with event data
-     * @param options - Optional filtering and error handling
-     * @param options.positionId - Only receive events for this LP position NFT
-     * @param options.poolHash - Only receive events for this pool
-     * @param options.tokenFilter - Only receive events containing this token (in either position)
-     * @param options.pairTokens - Only receive events with this specific token pair (order-independent)
-     * @param options.feeTierFilter - Only receive events with this fee tier (500, 3000, or 10000)
-     * @param options.userFilter - Only receive events from this wallet address
-     * @param options.minAmount - Only receive events where at least one amount exceeds this value
-     * @param options.onError - Called if WebSocket connection fails
-     * @returns Cleanup function to stop listening - safe to call multiple times
-     *
-     * @category Real-time Monitoring
-     * @since 4.3.0
-     *
-     * @throws Error if WebSocket service not initialized
-     *
-     * @example Listen to all liquidity additions
-     * ```typescript
-     * const cleanup = sdk.subscribeToDexLiquidityAdded((event) => {
-     *   console.log(`Liquidity added: ${event.amounts[0]} / ${event.amounts[1]}`);
-     *   console.log(`Position: ${event.positionId}`);
-     *   console.log(`Pool: ${event.poolHash}`);
-     * });
-     *
-     * // Stop listening when done
-     * await cleanup();
-     * ```
-     *
-     * @example Track specific pool liquidity
-     * ```typescript
-     * const cleanup = sdk.subscribeToDexLiquidityAdded(
-     *   (event) => {
-     *     console.log(`GALA/GUSDC liquidity: +${event.amounts[0]} GALA`);
-     *   },
-     *   {
-     *     pairTokens: ['GALA', 'GUSDC'],
-     *     feeTierFilter: 3000,  // 0.3% fee tier
-     *   }
-     * );
-     * ```
-     *
-     * @example Whale watching
-     * ```typescript
-     * const cleanup = sdk.subscribeToDexLiquidityAdded(
-     *   (event) => {
-     *     console.log(`🐋 Large liquidity add detected!`);
-     *     console.log(`Amount: ${event.amounts[0]} / ${event.amounts[1]}`);
-     *     console.log(`User: ${event.userAddress}`);
-     *   },
-     *   { minAmount: '10000' }  // Only large additions
-     * );
-     * ```
-     */
-    subscribeToDexLiquidityAdded(callback: LiquidityChangedCallback, options?: SubscribeLiquidityOptions): LiquidityCleanupFunction;
-    /**
-     * Subscribe to real-time DEX liquidity removal events
-     *
-     * Monitors all liquidity removals on the DEX globally with real-time notifications.
-     * All liquidity events are broadcast to all connected clients - you can monitor
-     * market-wide liquidity activity, not just your own transactions.
-     *
-     * **Use Cases:**
-     * - LP exit tracking: Monitor when users remove liquidity from positions
-     * - Whale watching: Detect large liquidity withdrawals
-     * - Market analysis: Track overall DEX liquidity changes
-     * - Risk management: React to liquidity decreases in pools you trade
-     *
-     * @param callback - Called when liquidity is removed with event data
-     * @param options - Optional filtering and error handling
-     * @param options.positionId - Only receive events for this LP position NFT
-     * @param options.poolHash - Only receive events for this pool
-     * @param options.tokenFilter - Only receive events containing this token (in either position)
-     * @param options.pairTokens - Only receive events with this specific token pair (order-independent)
-     * @param options.feeTierFilter - Only receive events with this fee tier (500, 3000, or 10000)
-     * @param options.userFilter - Only receive events from this wallet address
-     * @param options.minAmount - Only receive events where at least one amount exceeds this value
-     * @param options.onError - Called if WebSocket connection fails
-     * @returns Cleanup function to stop listening - safe to call multiple times
-     *
-     * @category Real-time Monitoring
-     * @since 4.3.0
-     *
-     * @throws Error if WebSocket service not initialized
-     *
-     * @example Listen to all liquidity removals
-     * ```typescript
-     * const cleanup = sdk.subscribeToDexLiquidityRemoved((event) => {
-     *   console.log(`Liquidity removed: ${event.amounts[0]} / ${event.amounts[1]}`);
-     *   console.log(`Position: ${event.positionId}`);
-     * });
-     *
-     * await cleanup();
-     * ```
-     *
-     * @example Track position exits
-     * ```typescript
-     * const cleanup = sdk.subscribeToDexLiquidityRemoved(
-     *   (event) => {
-     *     console.log(`Position ${event.positionId} reduced liquidity`);
-     *   },
-     *   { positionId: 'my-position-id' }
-     * );
-     * ```
-     */
-    subscribeToDexLiquidityRemoved(callback: LiquidityChangedCallback, options?: SubscribeLiquidityOptions): LiquidityCleanupFunction;
-    /**
-     * Subscribe to all DEX liquidity changes
-     *
-     * Monitors all liquidity operations on the DEX globally with real-time notifications.
-     * The backend broadcasts position change events without distinguishing between
-     * add and remove operations.
-     *
-     * **Use Cases:**
-     * - Complete liquidity tracking: Monitor all LP activity in a pool
-     * - Position monitoring: Track changes to specific positions
-     * - Dashboard displays: Show real-time liquidity activity feed
-     *
-     * @param callback - Called when liquidity changes with event data
-     * @param options - Optional filtering and error handling
-     * @returns Cleanup function to stop listening - safe to call multiple times
-     *
-     * @category Real-time Monitoring
-     * @since 4.3.0
-     *
-     * @throws Error if WebSocket service not initialized
-     *
-     * @example Monitor all liquidity activity
-     * ```typescript
-     * const cleanup = sdk.subscribeToDexLiquidityChanged((event) => {
-     *   console.log(`Liquidity changed: ${event.amounts[0]} / ${event.amounts[1]}`);
-     *   console.log(`Pool: ${event.poolHash}`);
-     *   console.log(`Position: ${event.positionId}`);
-     * });
-     *
-     * await cleanup();
-     * ```
-     *
-     * @example Track specific pool liquidity
-     * ```typescript
-     * const cleanup = sdk.subscribeToDexLiquidityChanged(
-     *   (event) => {
-     *     console.log(`Pool activity: ${event.amounts[0]} / ${event.amounts[1]}`);
-     *     console.log(`User: ${event.userAddress}`);
-     *   },
-     *   { pairTokens: ['GALA', 'GUSDC'] }
-     * );
-     * ```
-     */
-    subscribeToDexLiquidityChanged(callback: LiquidityChangedCallback, options?: SubscribeLiquidityOptions): LiquidityCleanupFunction;
-    /**
-     * Internal method for subscribing to liquidity events
-     *
-     * @internal
-     */
-    private subscribeToDexLiquidityEvents;
-    /**
-     * Check if a liquidity event matches the specified filters
-     *
-     * @internal
-     */
-    private matchesLiquidityFilter;
-    /**
-     * Normalize fee tier to basis points
-     *
-     * @internal
-     */
-    private normalizeFeeTier;
     /**
      * Get the fee to claim an NFT collection
      * @category NFT Collections