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

package/dist/src/services/DexService.d.ts

@@ -1,433 +0,0 @@
-/**
- * DEX API Service
- *
- * This service handles DEX API spot price operations for tokens.
- * It provides methods to fetch current USD spot prices for DEX tokens
- * and calculate spot prices for launchpad tokens.
- */
-import type { TokenId } from '../types/common';
-import type { DexAggregatedVolumeSummary, DexSeason, GalaChainTokenDetails, LeaderboardResult, TokenSpotPrice } from '../types/launchpad.dto';
-import type { AmountCalculationResult } from '../types/launchpad.dto';
-import type { CalculateBuyAmountOptions, FetchTokenSpotPriceParams } from '../types/options.dto';
-import type { HttpClient } from '../utils/http';
-import { LoggerBase } from './BaseService';
-import type { GalaChainService } from './GalaChainService';
-import type { TokenMetadataCache } from './TokenMetadataCache';
-/**
- * DexService handles DEX API spot price operations
- *
- * This service provides access to token pricing information from the DEX API.
- * It supports both single and multiple token price queries, as well as
- * calculated spot prices for launchpad tokens.
- *
- * ## Caching Strategy
- * Optional TokenMetadataCache for symbol caching. When provided, DexService will:
- * - Check cache for token symbols before fetching from API
- * - Cache symbols after successful API fetch
- * - Reduces API calls by 50% on repeated token symbol queries
- *
- * @category Services
- * @since 1.0.0
- */
-export declare class DexService extends LoggerBase {
-    private readonly dexBackendHttp?;
-    private readonly cache?;
-    private readonly galaChainService?;
-    constructor(dexBackendHttp?: HttpClient | undefined, cache?: TokenMetadataCache | undefined, galaChainService?: GalaChainService | undefined, debugMode?: boolean);
-    /**
-     * Fetch USD spot price for DEX tokens with tokenId
-     *
-     * Smart router that accepts either tokenName or tokenId (mutually exclusive).
-     * LaunchpadSDK handles routing logic automatically:
-     * - tokenName: Routes to bonding curve calculation (launchpad tokens)
-     * - tokenId: Routes to DEX Backend API (graduated/DEX tokens)
-     *
-     * **Price Source:**
-     * - DEX Backend API `/v1/trade/price` endpoint
-     * - Real-time spot prices from active DEX trading
-     * - USD-denominated pricing (via GALA/USD base pair)
-     *
-     * **Token Format Support:**
-     * - Pipe-delimited: `Token|Unit|GDOG|eth:0x...`
-     * - Object format: `{ collection: 'Token', category: 'Unit', type: 'GDOG', additionalKey: 'eth:0x...' }`
-     * - Auto-converts to dollar-delimited for API: `Token$Unit$GDOG$eth:0x...`
-     *
-     * @param params Options with either tokenName or tokenId (mutually exclusive)
-     * @returns Promise<TokenSpotPrice> Token symbol and USD price
-     * @throws ValidationError if neither tokenName nor tokenId provided
-     * @throws ValidationError if both tokenName and tokenId provided
-     * @throws NetworkError if API request fails
-     * @category Spot Price
-     * @since 3.0.0
-     *
-     * @example DEX token pricing (tokenId)
-     * ```typescript
-     * const price = await dexService.fetchTokenPrice({
-     *   tokenId: 'Token|Unit|GDOG|eth:0x...'
-     * });
-     * console.log(`${price.symbol}: $${price.price}`);
-     * // Output: GDOG: $0.00123
-     * ```
-     *
-     * @example Object format tokenId
-     * ```typescript
-     * const price = await dexService.fetchTokenPrice({
-     *   tokenId: {
-     *     collection: 'Token',
-     *     category: 'Unit',
-     *     type: 'BENE',
-     *     additionalKey: 'client:123'
-     *   }
-     * });
-     * ```
-     *
-     * @internal
-     */
-    fetchTokenPrice(params: FetchTokenSpotPriceParams): Promise<TokenSpotPrice>;
-    /**
-     * Internal method: Fetch spot price from DEX Backend API
-     *
-     * Queries the DEX Backend API for real-time spot prices of tokens actively
-     * trading on GalaSwap. Includes intelligent caching for token symbols to reduce
-     * API calls by 50% on repeated queries.
-     *
-     * **Price Calculation:**
-     * - Fetches token/GALA pair price from DEX
-     * - Converts to USD using GALA/USD base rate
-     * - Returns final USD-denominated price
-     *
-     * **Symbol Resolution:**
-     * 1. Check TokenMetadataCache (if available) - instant
-     * 2. Fetch from GalaChain token registry - authoritative
-     * 3. Fallback to token format parsing - best effort
-     *
-     * **Caching Strategy:**
-     * - Cache hit: Symbol returned instantly (no API call)
-     * - Cache miss: Fetch from GalaChain, cache for future queries
-     * - 50% reduction in API calls for repeated token queries
-     *
-     * @internal
-     * @param tokenId Token ID in pipe-delimited or object format
-     * @returns Promise<TokenSpotPrice> Spot price with symbol and USD price
-     * @throws NetworkError if token not found on DEX
-     * @throws NetworkError if API request fails
-     * @category Spot Price
-     * @since 3.0.0
-     */
-    private _fetchDexTokenSpotPrice;
-    /**
-     * Calculate spot price for a launchpad token using bonding curve mathematics
-     *
-     * Computes USD spot price for active bonding curve tokens by:
-     * 1. Calculating tokens received for 1 GALA (bonding curve)
-     * 2. Fetching GALA/USD spot price (DEX)
-     * 3. Computing token/USD price (GALA price ÷ tokens per GALA)
-     *
-     * **Graduation Detection:**
-     * - If token is graduated (saleStatus = 'Finished'), routes to DEX spot price
-     * - If token is active bonding curve, uses calculation above
-     * - Automatic routing ensures correct price source
-     *
-     * **Bonding Curve Pricing:**
-     * Uses exponential bonding curve: price = e^(k × supply)
-     * - Current supply determines current price point on curve
-     * - Higher supply = higher price (built-in scarcity)
-     * - 1 GALA buys fewer tokens as supply grows
-     *
-     * @param tokenName Launchpad token name (e.g., 'anime', 'demonkpop')
-     * @param calculateBuyAmount Callback to calculate buy amount via bonding curve
-     * @param fetchPoolDetails Optional callback to check graduation status
-     * @returns Promise<TokenSpotPrice> Token symbol and USD spot price
-     * @throws NetworkError if calculation fails
-     * @throws ValidationError if token name is invalid
-     * @category Spot Price
-     * @since 2.0.0
-     * @internal
-     */
-    fetchLaunchpadTokenSpotPrice(tokenName: string, calculateBuyAmount: (options: CalculateBuyAmountOptions) => Promise<AmountCalculationResult>, fetchPoolDetails?: (tokenName: string) => Promise<unknown>): Promise<TokenSpotPrice>;
-    /**
-     * Fetch comprehensive token details from GalaChain
-     *
-     * Queries the authoritative GalaChain token registry via FetchTokenClasses endpoint
-     * to retrieve complete token metadata including symbol, decimals, name, image,
-     * description, and blockchain-specific information.
-     *
-     * This method serves as the source of truth for token metadata by using the native
-     * GalaChain API instead of a secondary DEX index. This ensures:
-     * - Complete metadata for all tokens (including native GALA token)
-     * - Direct blockchain source of truth
-     * - Support for both native tokens and wrapped DEX tokens
-     *
-     * @param tokenId Token identifier (flexible format: string or object)
-     * @returns Promise<GalaChainTokenDetails> Token metadata from GalaChain
-     *
-     * @example String format
-     * ```typescript
-     * const details = await dexService.fetchTokenDetails('Token|Unit|BENE|client:xxxx');
-     * console.log(details.symbol);    // 'BENE'
-     *
-     * // Also works for native OG coins
-     * const gala = await dexService.fetchTokenDetails('GALA|Unit|none|none');
-     * console.log(gala.symbol);       // 'GALA'
-     * const gusdc = await dexService.fetchTokenDetails('GUSDC|Unit|none|none');
-     * console.log(gusdc.symbol);      // 'GUSDC'
-     * ```
-     *
-     * @example Object format
-     * ```typescript
-     * const details = await dexService.fetchTokenDetails({
-     *   collection: 'GUSDC',
-     *   category: 'Unit',
-     *   type: 'none',
-     *   additionalKey: 'none'
-     * });
-     * ```
-     *
-     * @throws ValidationError if tokenId format is invalid
-     * @throws NetworkError if API request fails or token not found
-     */
-    fetchTokenDetails(tokenId: TokenId): Promise<GalaChainTokenDetails>;
-    /**
-     * Fetch all available DEX leaderboard seasons
-     *
-     * Retrieves complete list of competitive trading seasons with their time ranges
-     * and rule configurations. Use season IDs with `fetchDexLeaderboardBySeasonId()`
-     * to query rankings.
-     *
-     * **Season Structure:**
-     * - id: Unique season identifier (used for queries)
-     * - name: Display name (e.g., "Season 1", "Winter 2025")
-     * - start: Season start date (Date object)
-     * - end: Season end date (Date object)
-     * - rulesId: Rule set identifier (scoring multipliers, XP rates)
-     *
-     * **Response Handling:**
-     * Supports multiple API response formats:
-     * - Direct array: `[...seasons...]`
-     * - Wrapped: `{ data: [...seasons...] }`
-     * - Nested: `{ data: { seasons: [...] } }`
-     *
-     * @returns Promise<DexSeason[]> Array of all seasons with time ranges
-     * @throws NetworkError If API request fails
-     * @category DEX Leaderboard
-     * @since 3.23.0
-     *
-     * @example List all seasons
-     * ```typescript
-     * const seasons = await dexService.fetchAllDexSeasons();
-     * seasons.forEach(season => {
-     *   console.log(`${season.name}: ${season.start.toISOString()} - ${season.end.toISOString()}`);
-     * });
-     * // Output:
-     * // Season 1: 2025-01-01T00:00:00Z - 2025-03-31T23:59:59Z
-     * // Season 2: 2025-04-01T00:00:00Z - 2025-06-30T23:59:59Z
-     * ```
-     *
-     * @example Find specific season by name
-     * ```typescript
-     * const seasons = await dexService.fetchAllDexSeasons();
-     * const winterSeason = seasons.find(s => s.name.includes('Winter'));
-     * if (winterSeason) {
-     *   const leaderboard = await dexService.fetchDexLeaderboardBySeasonId(winterSeason.id);
-     * }
-     * ```
-     *
-     * @internal
-     */
-    fetchAllDexSeasons(): Promise<DexSeason[]>;
-    /**
-     * Find the currently active DEX leaderboard season
-     *
-     * Determines which season is active by comparing current time with season start/end dates.
-     * Returns null if no season is currently active (between seasons or before first season).
-     *
-     * **Active Season Detection:**
-     * - Fetches all seasons via `fetchAllDexSeasons()`
-     * - Finds season where: `now >= season.start && now <= season.end`
-     * - Returns first matching season (should only be one)
-     * - Returns null if no match found
-     *
-     * **Use Cases:**
-     * - Display current leaderboard automatically
-     * - Show "No active season" message when null
-     * - Redirect users to current competition rankings
-     *
-     * @returns Promise<DexSeason | null> Current season or null if none active
-     * @throws NetworkError If API request fails
-     * @category DEX Leaderboard
-     * @since 3.23.0
-     *
-     * @example Get current season and leaderboard
-     * ```typescript
-     * const currentSeason = await dexService.fetchCurrentDexSeason();
-     * if (currentSeason) {
-     *   console.log(`Active season: ${currentSeason.name}`);
-     *   const leaderboard = await dexService.fetchDexLeaderboardBySeasonId(currentSeason.id);
-     *   console.log(`Top trader: ${leaderboard.entries[0].wallet} with ${leaderboard.entries[0].totalXp} XP`);
-     * } else {
-     *   console.log('No active season - check back later!');
-     * }
-     * ```
-     *
-     * @internal
-     */
-    fetchCurrentDexSeason(): Promise<DexSeason | null>;
-    /**
-     * Fetch DEX leaderboard for a specific season
-     *
-     * Returns complete leaderboard rankings with XP metrics, achievement titles, and
-     * reward distribution percentages. Non-paginated response includes all entries
-     * (typically 100-200 participants).
-     *
-     * **Leaderboard Entry Structure:**
-     * - wallet: Participant wallet address (eth|0x...)
-     * - rank: Position (1 = top trader, 2 = second, etc.)
-     * - totalXp: Cumulative XP earned this season
-     * - distributionPercent: Share of prize pool (0-100)
-     * - liquidityXp: XP from providing liquidity
-     * - tradingXp: XP from trading actions
-     * - masteryTitles: Achievement badges (e.g., "Volume Master", "LP Whale")
-     *
-     * **XP Calculation (Standard Rules):**
-     * - Buy token: +10 XP per GALA spent
-     * - Sell token: +5 XP per GALA received
-     * - DEX swap: +1 XP per $1 USD volume
-     * - Add liquidity: +bonus XP based on pool tier and size
-     * - Hold liquidity: +passive XP over time
-     *
-     * **Mastery Titles:**
-     * - Type: 'liquidity' (LP achievements) or 'trade' (trading achievements)
-     * - Order: Priority for display (lower = more prestigious)
-     * - Example titles: "Liquidity Legend", "Volume King", "Diamond Hands"
-     *
-     * @param seasonId Season identifier number (must be positive integer)
-     * @returns Promise<LeaderboardResult> Complete leaderboard with rankings and metrics
-     * @throws RequiredFieldError If seasonId is invalid
-     * @throws NetworkError If API request fails
-     * @category DEX Leaderboard
-     * @since 3.23.0
-     *
-     * @example Fetch season 3 leaderboard
-     * ```typescript
-     * const leaderboard = await dexService.fetchDexLeaderboardBySeasonId(3);
-     * console.log(`Season ${leaderboard.seasonId} - ${leaderboard.totalEntries} traders`);
-     *
-     * // Display top 5
-     * leaderboard.entries.slice(0, 5).forEach(entry => {
-     *   console.log(`#${entry.rank}: ${entry.wallet} - ${entry.totalXp} XP (${entry.distributionPercent}% rewards)`);
-     *   entry.masteryTitles.forEach(title => console.log(`  🏆 ${title.name}`));
-     * });
-     * ```
-     *
-     * @example Find your rank
-     * ```typescript
-     * const myWallet = 'eth|0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb';
-     * const leaderboard = await dexService.fetchDexLeaderboardBySeasonId(3);
-     * const myEntry = leaderboard.entries.find(e => e.wallet === myWallet);
-     *
-     * if (myEntry) {
-     *   console.log(`Your rank: #${myEntry.rank}`);
-     *   console.log(`Your XP: ${myEntry.totalXp} (Trading: ${myEntry.tradingXp}, LP: ${myEntry.liquidityXp})`);
-     *   console.log(`Reward share: ${myEntry.distributionPercent}%`);
-     * } else {
-     *   console.log('Not ranked this season - start trading!');
-     * }
-     * ```
-     *
-     * @internal
-     */
-    fetchDexLeaderboardBySeasonId(seasonId: number): Promise<LeaderboardResult>;
-    /**
-     * Fetch leaderboard for the currently active season
-     *
-     * Convenience method combining `fetchCurrentDexSeason()` and `fetchDexLeaderboardBySeasonId()`.
-     * Automatically detects the current season and fetches its leaderboard. Returns null if no
-     * season is active (between seasons).
-     *
-     * **Use Cases:**
-     * - Display current leaderboard without knowing season ID
-     * - Homepage "Current Rankings" widget
-     * - "Live Competition" page
-     *
-     * **Workflow:**
-     * 1. Fetch all seasons → find active season by date
-     * 2. If active season found → fetch its leaderboard
-     * 3. If no active season → return null
-     *
-     * @returns Promise<LeaderboardResult | null> Current leaderboard or null if no active season
-     * @throws NetworkError If API request fails
-     * @category DEX Leaderboard
-     * @since 3.23.0
-     *
-     * @example Display current leaderboard
-     * ```typescript
-     * const currentLeaderboard = await dexService.fetchCurrentDexLeaderboard();
-     * if (currentLeaderboard) {
-     *   console.log(`Season ${currentLeaderboard.seasonId} Rankings:`);
-     *   currentLeaderboard.entries.slice(0, 10).forEach(entry => {
-     *     console.log(`${entry.rank}. ${entry.wallet}: ${entry.totalXp} XP`);
-     *   });
-     * } else {
-     *   console.log('No active season - next season coming soon!');
-     * }
-     * ```
-     *
-     * @internal
-     */
-    fetchCurrentDexLeaderboard(): Promise<LeaderboardResult | null>;
-    /**
-     * Fetch DEX aggregated volume summary with trend metrics
-     *
-     * Returns platform-wide trading volume statistics across all DEX pools with
-     * multi-timeframe comparisons. Shows total USD volume and percentage changes
-     * relative to previous periods.
-     *
-     * **Volume Metrics:**
-     * - volume1d: 24-hour trading volume (USD)
-     * - volume1dDelta: % change vs previous 24 hours
-     * - volume7d: 7-day rolling volume (USD)
-     * - volume7dDelta: % change vs previous 7 days
-     * - volume30d: 30-day rolling volume (USD)
-     * - volume30dDelta: % change vs previous 30 days
-     *
-     * **Delta Interpretation:**
-     * - Positive delta (+10.5): Volume increased by 10.5%
-     * - Negative delta (-5.2): Volume decreased by 5.2%
-     * - Zero delta (0): No change from previous period
-     *
-     * **Use Cases:**
-     * - Platform health dashboard
-     * - Volume trend charts
-     * - Market activity indicators
-     * - "Trading volume up/down X%" alerts
-     *
-     * @returns Promise<DexAggregatedVolumeSummary> Volume metrics and deltas
-     * @throws NetworkError If API request fails
-     * @category Volume Analytics
-     * @since 4.0.0
-     *
-     * @example Display volume summary
-     * ```typescript
-     * const volumeSummary = await dexService.fetchDexAggregatedVolumeSummary();
-     *
-     * console.log(`24h Volume: $${volumeSummary.volume1d.toLocaleString()} (${volumeSummary.volume1dDelta > 0 ? '+' : ''}${volumeSummary.volume1dDelta.toFixed(2)}%)`);
-     * console.log(`7d Volume: $${volumeSummary.volume7d.toLocaleString()} (${volumeSummary.volume7dDelta > 0 ? '+' : ''}${volumeSummary.volume7dDelta.toFixed(2)}%)`);
-     * console.log(`30d Volume: $${volumeSummary.volume30d.toLocaleString()} (${volumeSummary.volume30dDelta > 0 ? '+' : ''}${volumeSummary.volume30dDelta.toFixed(2)}%)`);
-     * ```
-     *
-     * @example Volume trend indicator
-     * ```typescript
-     * const volumeSummary = await dexService.fetchDexAggregatedVolumeSummary();
-     *
-     * if (volumeSummary.volume1dDelta > 10) {
-     *   console.log('🚀 High trading activity - volume up ' + volumeSummary.volume1dDelta.toFixed(1) + '%');
-     * } else if (volumeSummary.volume1dDelta < -10) {
-     *   console.log('📉 Low trading activity - volume down ' + Math.abs(volumeSummary.volume1dDelta).toFixed(1) + '%');
-     * } else {
-     *   console.log('📊 Stable trading activity');
-     * }
-     * ```
-     */
-    fetchDexAggregatedVolumeSummary(): Promise<DexAggregatedVolumeSummary>;
-}
-//# sourceMappingURL=DexService.d.ts.map

package/dist/src/services/DexService.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"DexService.d.ts","sourceRoot":"","sources":["../../../src/services/DexService.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,OAAO,KAAK,EAAgB,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC7D,OAAO,KAAK,EACV,0BAA0B,EAC1B,SAAS,EACT,qBAAqB,EAGrB,iBAAiB,EACjB,cAAc,EACf,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AACtE,OAAO,KAAK,EAAE,yBAAyB,EAAE,yBAAyB,EAAE,MAAM,sBAAsB,CAAC;AAQjG,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAShD,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE/D;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,UAAW,SAAQ,UAAU;IAEtC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAC;IAChC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC;IACvB,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAC;gBAFjB,cAAc,CAAC,EAAE,UAAU,YAAA,EAC3B,KAAK,CAAC,EAAE,kBAAkB,YAAA,EAC1B,gBAAgB,CAAC,EAAE,gBAAgB,YAAA,EACpD,SAAS,GAAE,OAAe;IAK5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgDG;IACG,eAAe,CAAC,MAAM,EAAE,yBAAyB,GAAG,OAAO,CAAC,cAAc,CAAC;IA6BjF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;YAEW,uBAAuB;IA0GrC;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACG,4BAA4B,CAChC,SAAS,EAAE,MAAM,EACjB,kBAAkB,EAAE,CAAC,OAAO,EAAE,yBAAyB,KAAK,OAAO,CAAC,uBAAuB,CAAC,EAE5F,gBAAgB,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,GACzD,OAAO,CAAC,cAAc,CAAC;IAiF1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwCG;IACG,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,qBAAqB,CAAC;IAgDzE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8CG;IACG,kBAAkB,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;IAmFhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACG,qBAAqB,IAAI,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC;IAkBxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+DG;IACG,6BAA6B,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC;IA4GjF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;IACG,0BAA0B,IAAI,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC;IAWrE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoDG;IACG,+BAA+B,IAAI,OAAO,CAAC,0BAA0B,CAAC;CAqC7E"}

package/dist/src/services/EventsBatcherService.d.ts

@@ -1,111 +0,0 @@
-/**
- * Events batching service for SDK event tracking
- *
- * Buffers events client-side and flushes in configurable batches to the backend.
- * Handles automatic batching on time/count thresholds and page lifecycle.
- *
- * @since 8.2.0
- */
-import type { EventsBatcherStats, EventsConfig } from '../types/events.dto';
-import type { HttpClient } from '../utils/http';
-/**
- * Service for batching and flushing events to the backend
- *
- * Usage:
- * ```typescript
- * const batcher = new EventsBatcherService(httpClient, {
- *   batchSize: 20,
- *   flushIntervalMs: 3000
- * });
- *
- * batcher.track('token_buy', { tokenName: 'PEPE', amount: '100' });
- * await batcher.flush(); // Manual flush
- * ```
- */
-export declare class EventsBatcherService {
-    private readonly httpClient;
-    private readonly logger;
-    private readonly config;
-    private eventBuffer;
-    private flushTimer;
-    private isShuttingDown;
-    private totalQueued;
-    private totalFlushed;
-    private totalDropped;
-    private lastFlushTime;
-    private lastError;
-    constructor(httpClient: HttpClient, config?: EventsConfig);
-    /**
-     * Track an event
-     *
-     * @param eventType - Type of event
-     * @param payload - Event payload data
-     * @param options - Optional tracking options
-     */
-    track(eventType: string, payload: Record<string, unknown>, options?: {
-        userAddress?: string;
-        tokenName?: string;
-        sessionId?: string;
-        immediate?: boolean;
-    }): void;
-    /**
-     * Manually flush all buffered events
-     */
-    flush(): Promise<void>;
-    /**
-     * Get current statistics
-     */
-    getStats(): EventsBatcherStats;
-    /**
-     * Configure batching options
-     */
-    configure(options: Partial<EventsConfig>): void;
-    /**
-     * Graceful shutdown - flush remaining events
-     *
-     * @param timeoutMs - Max time to wait for flush (default: 5000)
-     */
-    shutdown(timeoutMs?: number): Promise<void>;
-    /**
-     * Add event to buffer
-     */
-    private buffer;
-    /**
-     * Schedule a flush
-     */
-    private scheduleFlush;
-    /**
-     * Cancel any pending flush
-     */
-    private cancelFlushTimer;
-    /**
-     * Submit events to backend
-     */
-    private submitEvents;
-    /**
-     * Setup page lifecycle listeners (browser only)
-     */
-    private setupPageLifecycleListeners;
-    /**
-     * Remove page lifecycle listeners
-     */
-    private removePageLifecycleListeners;
-    /**
-     * Handle visibility change (page hidden/shown)
-     */
-    private handleVisibilityChange;
-    /**
-     * Handle page unload
-     */
-    private handleBeforeUnload;
-    /**
-     * Flush using sendBeacon (browser only, doesn't wait for response)
-     */
-    private flushWithBeacon;
-    /**
-     * Get the base URL from the HTTP client for sendBeacon
-     * This is a workaround since sendBeacon needs absolute URLs
-     */
-    private getBaseUrl;
-}
-//# sourceMappingURL=EventsBatcherService.d.ts.map

package/dist/src/services/EventsBatcherService.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"EventsBatcherService.d.ts","sourceRoot":"","sources":["../../../src/services/EventsBatcherService.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAY,kBAAkB,EAAsB,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAC1G,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAGhD;;;;;;;;;;;;;GAaG;AACH,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAa;IACxC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAyB;IAGhD,OAAO,CAAC,WAAW,CAAkB;IACrC,OAAO,CAAC,UAAU,CAA8C;IAChE,OAAO,CAAC,cAAc,CAAS;IAG/B,OAAO,CAAC,WAAW,CAAK;IACxB,OAAO,CAAC,YAAY,CAAK;IACzB,OAAO,CAAC,YAAY,CAAK;IACzB,OAAO,CAAC,aAAa,CAAqB;IAC1C,OAAO,CAAC,SAAS,CAAqB;gBAE1B,UAAU,EAAE,UAAU,EAAE,MAAM,GAAE,YAAiB;IAgB7D;;;;;;OAMG;IACI,KAAK,CACV,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChC,OAAO,CAAC,EAAE;QACR,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,SAAS,CAAC,EAAE,OAAO,CAAC;KACrB,GACA,IAAI;IAuBP;;OAEG;IACU,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAyBnC;;OAEG;IACI,QAAQ,IAAI,kBAAkB;IAmBrC;;OAEG;IACI,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,YAAY,CAAC,GAAG,IAAI;IAkBtD;;;;OAIG;IACU,QAAQ,CAAC,SAAS,GAAE,MAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAoB9D;;OAEG;IACH,OAAO,CAAC,MAAM;IAoBd;;OAEG;IACH,OAAO,CAAC,aAAa;IAcrB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAOxB;;OAEG;YACW,YAAY;IAQ1B;;OAEG;IACH,OAAO,CAAC,2BAA2B;IAenC;;OAEG;IACH,OAAO,CAAC,4BAA4B;IAcpC;;OAEG;IACH,OAAO,CAAC,sBAAsB,CAK5B;IAEF;;OAEG;IACH,OAAO,CAAC,kBAAkB,CAKxB;IAEF;;OAEG;IACH,OAAO,CAAC,eAAe;IA8BvB;;;OAGG;IACH,OAAO,CAAC,UAAU;CAMnB"}

package/dist/src/services/GSwapAssetService.d.ts

@@ -1,96 +0,0 @@
-/**
- * GSwapAssetService - User Asset and Token Discovery
- *
- * Provides asset and token query operations:
- * - User asset queries (getUserAssets, getAllUserAssets)
- * - Token discovery (fetchAvailableDexTokens, fetchAllAvailableDexTokens)
- *
- * This service handles user portfolio queries and DEX token discovery.
- */
-import type { AxiosInstance } from 'axios';
-import type { AvailableDexTokensResult, DexToken, FetchAvailableDexTokensOptions, UserAsset } from '../types/gswap.dto';
-import { LoggerBase } from './BaseService';
-/**
- * Configuration for GSwapAssetService
- */
-export interface GSwapAssetServiceConfig {
-    dexBackendBaseUrl: string;
-    dexBackendHttp?: AxiosInstance;
-    debugMode?: boolean;
-}
-/**
- * Asset and token query operations for GSwap DEX
- *
- * @since 5.15.0
- */
-export declare class GSwapAssetService extends LoggerBase {
-    private dexBackendHttp;
-    constructor(config: GSwapAssetServiceConfig);
-    /**
-     * Parse token string to TokenClassKey with flexible format handling
-     * Handles plain symbols (GALA), pipe-delimited (GALA|Unit|none|none), etc.
-     */
-    private parseTokenFlexible;
-    /**
-     * Transform raw token from API response to DexToken
-     */
-    private transformRawTokenToDexToken;
-    /**
-     * Transform raw token from API response to UserAsset
-     */
-    private transformRawTokenToUserAsset;
-    /**
-     * Get user's DEX token assets (paginated)
-     *
-     * @param walletAddress User wallet address
-     * @param limit Max results per page (default 20)
-     * @param page Page number (1-based, default 1)
-     * @returns User assets with balances
-     */
-    getUserAssets(walletAddress: string, limit?: number, page?: number): Promise<{
-        assets: UserAsset[];
-        count: number;
-        page: number;
-        limit: number;
-        hasMore: boolean;
-    }>;
-    /**
-     * Get all user's DEX token assets (auto-paginated)
-     *
-     * @param walletAddress User wallet address
-     * @returns All user assets with balances
-     */
-    getAllUserAssets(walletAddress: string): Promise<UserAsset[]>;
-    /**
-     * Fetch available DEX tokens (paginated)
-     *
-     * @param options Query options (search, limit, page)
-     * @returns Available tokens with pagination info
-     *
-     * @example
-     * ```typescript
-     * // Fetch first page of tokens
-     * const result = await service.fetchAvailableDexTokens({ limit: 20, page: 1 });
-     * console.log(`Found ${result.count} total tokens`);
-     * console.log(`Page ${result.page} of ${Math.ceil(result.count / result.limit)}`);
-     * ```
-     *
-     * @example
-     * ```typescript
-     * // Search for tokens by name
-     * const result = await service.fetchAvailableDexTokens({ search: 'GALA', page: 1 });
-     * result.tokens.forEach(token => {
-     *   console.log(`${token.symbol}: ${token.name}`);
-     * });
-     * ```
-     */
-    fetchAvailableDexTokens(options?: FetchAvailableDexTokensOptions): Promise<AvailableDexTokensResult>;
-    /**
-     * Fetch all available DEX tokens (auto-paginated)
-     *
-     * @param options Query options (search only, no pagination)
-     * @returns All available tokens
-     */
-    fetchAllAvailableDexTokens(options?: Omit<FetchAvailableDexTokensOptions, 'page' | 'limit'>): Promise<DexToken[]>;
-}
-//# sourceMappingURL=GSwapAssetService.d.ts.map

package/dist/src/services/GSwapAssetService.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"GSwapAssetService.d.ts","sourceRoot":"","sources":["../../../src/services/GSwapAssetService.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAG3C,OAAO,KAAK,EACV,wBAAwB,EACxB,QAAQ,EACR,8BAA8B,EAC9B,SAAS,EACV,MAAM,oBAAoB,CAAC;AAU5B,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAqB3C;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,iBAAiB,EAAE,MAAM,CAAC;IAC1B,cAAc,CAAC,EAAE,aAAa,CAAC;IAC/B,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED;;;;GAIG;AACH,qBAAa,iBAAkB,SAAQ,UAAU;IAC/C,OAAO,CAAC,cAAc,CAAgB;gBAE1B,MAAM,EAAE,uBAAuB;IAW3C;;;OAGG;IACH,OAAO,CAAC,kBAAkB;IAe1B;;OAEG;IACH,OAAO,CAAC,2BAA2B;IAiBnC;;OAEG;IACH,OAAO,CAAC,4BAA4B;IAgCpC;;;;;;;OAOG;IACG,aAAa,CACjB,aAAa,EAAE,MAAM,EACrB,KAAK,GAAE,MAAW,EAClB,IAAI,GAAE,MAAU,GACf,OAAO,CAAC;QACT,MAAM,EAAE,SAAS,EAAE,CAAC;QACpB,KAAK,EAAE,MAAM,CAAC;QACd,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,MAAM,CAAC;QACd,OAAO,EAAE,OAAO,CAAC;KAClB,CAAC;IAgDF;;;;;OAKG;IACG,gBAAgB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;IAmCnE;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACG,uBAAuB,CAC3B,OAAO,GAAE,8BAAmC,GAC3C,OAAO,CAAC,wBAAwB,CAAC;IAkDpC;;;;;OAKG;IACG,0BAA0B,CAC9B,OAAO,GAAE,IAAI,CAAC,8BAA8B,EAAE,MAAM,GAAG,OAAO,CAAM,GACnE,OAAO,CAAC,QAAQ,EAAE,CAAC;CAiCvB"}