@gala-chain/launchpad-sdk 5.0.4-beta.6 → 5.0.4-beta.60

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

@@ -4,24 +4,100 @@
  * Centralized service for resolving token names to vault addresses and
  * GalaChain token identifiers.
  *
+ * ## CRITICAL: Never Guess TokenClassKey from TokenName!
+ *
+ * The relationship between token name and TokenClassKey is **NOT PREDICTABLE**:
+ *
+ * - `tokenName: "anime"` does NOT mean `type: "ANIME"` (could be "ANM", "ANIM", etc.)
+ * - The `additionalKey` contains the creator's ETH address - **impossible to guess**
+ * - The `type` is chosen by the token creator at launch time
+ *
+ * **ALWAYS use this service to resolve token names. Never construct TokenClassKey manually.**
+ *
+ * @example WRONG - Never do this:
+ * ```typescript
+ * // ❌ WRONG - This will FAIL for most tokens!
+ * const tokenClassKey = {
+ *   collection: "Token",
+ *   category: "Unit",
+ *   type: "ANIME",  // WRONG! Might be "ANM" or anything else
+ *   additionalKey: "???"  // IMPOSSIBLE to guess - it's an ETH address!
+ * };
+ * ```
+ *
+ * @example CORRECT - Always use the resolver:
+ * ```typescript
+ * // ✅ CORRECT - Use the resolver
+ * const tokenClassKey = await tokenResolver.resolveTokenClassKey('anime');
+ * // Returns: { collection: "Token", category: "Unit", type: "ANM", additionalKey: "eth:0x..." }
+ * ```
+ *
  * Key Features:
  * - Token name → vault address resolution
  * - Token name → TokenClassKey resolution
- * - Intelligent in-memory caching (vault addresses are immutable)
- * - Service-to-service dependency (depends on LaunchpadService)
+ * - Deep caching (both vault address AND parsed TokenClassKey)
+ * - LRU eviction to bound memory usage
+ * - Service-to-service dependency (depends on PoolService)
  * - Single responsibility: all token resolution logic in one place
  *
  * @packageDocumentation
  */
-import type { PoolService } from './PoolService';
 import type { TokenClassKey } from '../types/common';
 import { LoggerBase } from './BaseService';
+import type { PoolService } from './PoolService';
+/**
+ * Cache entry for deep caching of token resolution results.
+ *
+ * Stores both the vault address AND the parsed TokenClassKey to avoid
+ * re-parsing on subsequent calls.
+ */
+export interface TokenResolutionEntry {
+    /** GalaChain vault address (immutable after token creation) */
+    vaultAddress: string;
+    /** Parsed TokenClassKey from the vault address */
+    tokenClassKey: TokenClassKey;
+    /** Unix timestamp (ms) when this entry was cached */
+    cachedAt: number;
+}
+/**
+ * Cache statistics for monitoring and debugging.
+ */
+export interface TokenCacheStats {
+    /** Number of entries currently in cache */
+    size: number;
+    /** All cached token names (normalized to lowercase) */
+    keys: string[];
+    /** Maximum cache size before LRU eviction */
+    maxSize: number;
+    /** Number of cache hits */
+    hits: number;
+    /** Number of cache misses */
+    misses: number;
+    /** Cache hit rate (hits / total lookups) */
+    hitRate: number;
+    /** Oldest entry timestamp (ms), or null if empty */
+    oldestEntry: number | null;
+    /** Newest entry timestamp (ms), or null if empty */
+    newestEntry: number | null;
+}
 /**
  * Service for resolving token names to vault addresses and GalaChain identifiers
  *
+ * ## CRITICAL: TokenClassKey is NOT Derivable from TokenName!
+ *
+ * **NEVER guess or manually construct a TokenClassKey from a token name.**
+ *
+ * The relationship is NOT predictable because:
+ * - Token creators choose the `type` at launch time (e.g., "anime" might use "ANM")
+ * - The `additionalKey` contains the creator's ETH address (impossible to guess)
+ * - Only the backend knows the actual TokenClassKey for a given token name
+ *
+ * **ALWAYS use this service to resolve token names.**
+ *
  * This service encapsulates all token resolution logic and provides
- * intelligent caching to minimize API calls. Since vault addresses are
- * immutable after token creation, they can be safely cached indefinitely.
+ * intelligent deep caching to minimize API calls and avoid re-parsing.
+ * Since vault addresses are immutable after token creation, they can be
+ * safely cached indefinitely.
  *
  * @example
  * ```typescript
@@ -35,16 +111,36 @@ import { LoggerBase } from './BaseService';
  * // Resolve token name to GalaChain TokenClassKey
  * const tokenClassKey = await tokenResolver.resolveTokenClassKey('dragnrkti');
  * console.log('Token:', tokenClassKey);
+ *
+ * // Second call returns cached TokenClassKey (no re-parsing!)
+ * const sameKey = await tokenResolver.resolveTokenClassKey('dragnrkti');
+ * console.log(tokenClassKey === sameKey); // true (same reference!)
  * ```
  */
 export declare class TokenResolverService extends LoggerBase {
     private readonly poolService;
     /**
-     * In-memory cache for tokenName → vaultAddress mappings
-     * Key: lowercase token name
-     * Value: vault address string
+     * Maximum number of entries in the cache before LRU eviction kicks in.
+     * Set to 10,000 which handles most production use cases while
+     * bounding memory usage to ~2-5MB.
+     */
+    private static readonly MAX_CACHE_SIZE;
+    /**
+     * Deep cache for token resolution results.
+     * Key: normalized (lowercase) token name
+     * Value: TokenResolutionEntry with both vault address and parsed TokenClassKey
      */
     private cache;
+    /**
+     * LRU tracking: ordered list of keys from oldest to newest access.
+     * When cache exceeds MAX_CACHE_SIZE, oldest entries are evicted.
+     */
+    private accessOrder;
+    /**
+     * Cache statistics for monitoring
+     */
+    private cacheHits;
+    private cacheMisses;
     /**
      * Creates a new TokenResolverService instance
      *
@@ -55,7 +151,7 @@ export declare class TokenResolverService extends LoggerBase {
     /**
      * Resolves a token name to its vault address
      *
-     * This method checks the cache first, and only makes an API call if needed.
+     * This method checks the deep cache first, and only makes an API call if needed.
      * Since vault addresses never change after token creation, successful
      * resolutions are cached indefinitely.
      *
@@ -77,20 +173,44 @@ export declare class TokenResolverService extends LoggerBase {
     /**
      * Resolves a token name to GalaChain TokenClassKey format
      *
-     * This method first resolves the token name to a vault address,
-     * then parses the vault address to extract TokenClassKey components.
+     * ## CRITICAL: Never Guess TokenClassKey from TokenName!
+     *
+     * The relationship between token name and TokenClassKey is **NOT PREDICTABLE**:
+     * - `tokenName: "anime"` does NOT mean `type: "ANIME"` (could be "ANM", "ANIM", etc.)
+     * - The `additionalKey` contains the creator's ETH address - **impossible to guess**
+     *
+     * **ALWAYS use this method. Never construct TokenClassKey manually from a token name.**
+     *
+     * This method uses deep caching - the TokenClassKey is parsed once and cached,
+     * so subsequent calls return the exact same object reference (no re-parsing).
      *
      * @param tokenName Token name to resolve
-     * @returns Promise<TokenClassKey> GalaChain token identifier
+     * @returns Promise<TokenClassKey> GalaChain token identifier (cached - same reference on repeated calls)
      * @throws {Error} If token cannot be resolved or vault address is invalid
      *
      * @example
      * ```typescript
-     * const tokenClassKey = await tokenResolver.resolveTokenClassKey('dragnrkti');
+     * // ✅ CORRECT - Always use this resolver
+     * const tokenClassKey = await tokenResolver.resolveTokenClassKey('anime');
      * console.log('Collection:', tokenClassKey.collection);
      * console.log('Category:', tokenClassKey.category);
-     * console.log('Type:', tokenClassKey.type);
-     * console.log('Additional Key:', tokenClassKey.additionalKey);
+     * console.log('Type:', tokenClassKey.type);  // Might be "ANM", NOT "ANIME"!
+     * console.log('Additional Key:', tokenClassKey.additionalKey);  // eth:0x... (creator address)
+     *
+     * // Second call returns cached reference (no re-parsing, instant)
+     * const sameKey = await tokenResolver.resolveTokenClassKey('anime');
+     * console.log(tokenClassKey === sameKey);  // true - exact same object!
+     * ```
+     *
+     * @example WRONG - Never do this:
+     * ```typescript
+     * // ❌ WRONG - This will FAIL for most tokens!
+     * const tokenClassKey = {
+     *   collection: "Token",
+     *   category: "Unit",
+     *   type: "ANIME",        // WRONG! Might be "ANM" or anything
+     *   additionalKey: "???"  // IMPOSSIBLE to guess!
+     * };
      * ```
      */
     resolveTokenClassKey(tokenName: string): Promise<TokenClassKey>;
@@ -102,32 +222,61 @@ export declare class TokenResolverService extends LoggerBase {
      */
     get(tokenName: string): string | null;
     /**
-     * Caches a vault address for a token name
+     * Gets the full cache entry for a token name
+     *
+     * @param normalizedTokenName Normalized (lowercase) token name
+     * @returns Cached entry or null if not in cache
+     */
+    private getCacheEntry;
+    /**
+     * Sets a cache entry and manages LRU eviction
+     *
+     * @param normalizedTokenName Normalized (lowercase) token name
+     * @param entry Cache entry to store
+     */
+    private setCacheEntry;
+    /**
+     * Updates LRU access order for a key
+     *
+     * @param normalizedTokenName Key that was just accessed
+     */
+    private updateAccessOrder;
+    /**
+     * Evicts the least recently used entry from the cache
+     */
+    private evictOldestEntry;
+    /**
+     * Caches a vault address for a token name (legacy method, kept for backward compatibility)
      *
      * @param tokenName Token name to cache (will be normalized to lowercase)
      * @param vaultAddress Vault address to cache
      */
     set(tokenName: string, vaultAddress: string): void;
     /**
-     * Clears the entire cache
+     * Clears the entire cache and resets statistics
      *
      * Useful for testing or when you need to force fresh token resolution.
      */
     clear(): void;
     /**
-     * Gets cache statistics
+     * Gets detailed cache statistics for monitoring and debugging
      *
-     * @returns Object with cache size and all cached token names
+     * @returns Object with cache size, keys, hit rate, and timing info
      */
-    getStats(): {
-        size: number;
-        keys: string[];
-    };
+    getStats(): TokenCacheStats;
+    /**
+     * Gets the cached TokenClassKey directly without re-resolving
+     *
+     * @param tokenName Token name to lookup (case-insensitive)
+     * @returns Cached TokenClassKey or null if not in cache
+     */
+    getCachedTokenClassKey(tokenName: string): TokenClassKey | null;
     /**
      * Pre-warms the cache with known tokenName → vaultAddress mappings
      *
      * Useful for batch operations or initialization when you already
-     * know vault addresses for certain tokens.
+     * know vault addresses for certain tokens. This method will parse
+     * each vault address to also cache the TokenClassKey (deep caching).
      *
      * @param mappings Array of {tokenName, vaultAddress} objects
      *
@@ -143,6 +292,30 @@ export declare class TokenResolverService extends LoggerBase {
         tokenName: string;
         vaultAddress: string;
     }>): void;
+    /**
+     * Pre-warms the cache with known tokenName → TokenClassKey mappings
+     *
+     * More direct than preWarm() when you already have the TokenClassKey.
+     * Avoids parsing the vault address when not needed.
+     *
+     * @param mappings Array of {tokenName, vaultAddress, tokenClassKey} objects
+     *
+     * @example
+     * ```typescript
+     * tokenResolver.preWarmWithTokenClassKey([
+     *   {
+     *     tokenName: 'dragnrkti',
+     *     vaultAddress: 'service|Token$Unit$DRG$eth:0x...$launchpad',
+     *     tokenClassKey: { collection: 'Token', category: 'Unit', type: 'DRG', additionalKey: 'eth:0x...' }
+     *   }
+     * ]);
+     * ```
+     */
+    preWarmWithTokenClassKey(mappings: Array<{
+        tokenName: string;
+        vaultAddress: string;
+        tokenClassKey: TokenClassKey;
+    }>): void;
     /**
      * Parses a vault address string to extract TokenClassKey components
      *

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

@@ -1 +1 @@
-{"version":3,"file":"TokenResolverService.d.ts","sourceRoot":"","sources":["../../../src/services/TokenResolverService.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAIjD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAMrD,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAG3C;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,oBAAqB,SAAQ,UAAU;IActC,OAAO,CAAC,QAAQ,CAAC,WAAW;IAbxC;;;;OAIG;IACH,OAAO,CAAC,KAAK,CAA6B;IAE1C;;;;;OAKG;gBAC0B,WAAW,EAAE,WAAW,EAAE,SAAS,GAAE,OAAe;IAIjF;;;;;;;;;;;;;;;;;;;;OAoBG;IACG,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IA+BpE;;;;;;;;;;;;;;;;;;OAkBG;IACG,oBAAoB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAerE;;;;;OAKG;IACH,GAAG,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAIrC;;;;;OAKG;IACH,GAAG,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI;IAIlD;;;;OAIG;IACH,KAAK,IAAI,IAAI;IAIb;;;;OAIG;IACH,QAAQ,IAAI;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,EAAE,CAAA;KAAE;IAO5C;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CACL,QAAQ,EAAE,KAAK,CAAC;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAE,CAAC,GAC3D,IAAI;IAMP;;;;;;;OAOG;IACH,OAAO,CAAC,gCAAgC;CAkBzC"}
+{"version":3,"file":"TokenResolverService.d.ts","sourceRoot":"","sources":["../../../src/services/TokenResolverService.ts"],"names":[],"mappings":"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"}

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

@@ -6,11 +6,11 @@
  * @category Services
  * @since 3.6.0
  */
-import { BaseService } from './BaseService';
-import type { HttpClient } from '../utils/http';
-import type { TradesResult } from '../types/trade.dto';
 import type { FetchTradesOptions } from '../types/options.dto';
+import type { TradesResult } from '../types/trade.dto';
 import type { GetTradesOptions, TradesQueryResult } from '../types/trades-query.dto';
+import type { HttpClient } from '../utils/http';
+import { BaseService } from './BaseService';
 /**
  * Trade Service Class
  *
@@ -32,17 +32,17 @@ import type { GetTradesOptions, TradesQueryResult } from '../types/trades-query.
  * console.log(`Found ${trades.totalResults} trades across ${trades.totalPages} pages`);
  * ```
  *
- * @example Paginated trade fetching
+ * @example Cursor-based pagination
  * ```typescript
- * // Get specific page with custom limit
+ * // Fetch next page using cursor
  * const moreTrades = await tradeService.fetchTrades({
  *   tokenName: "GDOG",
- *   page: 2,
- *   limit: 20
+ *   cursor: "next_page_cursor",
+ *   pageSize: 20
  * });
  *
  * // Process trades
- * moreTrades.trades.forEach(trade => {
+ * moreTrades.items.forEach(trade => {
  *   console.log(`${trade.type}: ${trade.amount} at ${trade.price}`);
  * });
  * ```
@@ -53,11 +53,11 @@ import type { GetTradesOptions, TradesQueryResult } from '../types/trades-query.
  * const buys = await tradeService.fetchTrades({
  *   tokenName: "GUSDC",
  *   tradeType: "buy",
- *   limit: 50
+ *   pageSize: 50
  * });
  *
  * // Calculate total buy volume
- * const totalBuyVolume = buys.trades.reduce((sum, t) => sum + parseFloat(t.amount), 0);
+ * const totalBuyVolume = buys.items.reduce((sum, t) => sum + parseFloat(t.amount), 0);
  * ```
  */
 export declare class TradeService extends BaseService {
@@ -98,8 +98,8 @@ export declare class TradeService extends BaseService {
      *
      * @param options Trade fetching options
      * @param options.tokenName Token name to fetch trades for (required)
-     * @param options.page Page number (default: 1)
-     * @param options.limit Results per page (default: 10, max: 100)
+     * @param options.cursor Cursor for pagination (optional)
+     * @param options.pageSize Results per page (default: 10, max: 100)
      * @param options.tradeType Filter by trade type ('buy' | 'sell')
      * @param options.userAddress Filter by trader address
      * @param options.startDate Filter by start date
@@ -130,20 +130,20 @@ export declare class TradeService extends BaseService {
      *
      * @example Paginated trade fetching
      * ```typescript
-     * const limit = 20;
-     * let page = 1;
+     * const pageSize = 20;
+     * let cursor: string | undefined;
      * const allTrades = [];
      *
      * while (true) {
      *   const result = await tradeService.fetchTrades({
      *     tokenName: "GDOG",
-     *     page,
-     *     limit
+     *     cursor,
+     *     pageSize
      *   });
      *
      *   allTrades.push(...result.trades);
-     *   if (!result.hasNext) break;
-     *   page++;
+     *   if (!result.pageInfo.hasNextPage) break;
+     *   cursor = result.pageInfo.nextCursor;
      * }
      *
      * console.log(`Fetched ${allTrades.length} total trades`);
@@ -210,7 +210,7 @@ export declare class TradeService extends BaseService {
     fetchTrades(options: FetchTradesOptions): Promise<TradesResult>;
     /**
      * Build query parameters for trades endpoint
-     * Converts offset-based pagination to page-based pagination for backend API.
+     * Uses offset-based pagination matching backend API contract.
      */
     private buildTradesQueryParams;
     /**

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

@@ -1 +1 @@
-{"version":3,"file":"TradeService.d.ts","sourceRoot":"","sources":["../../../src/services/TradeService.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAYhD,OAAO,KAAK,EAEV,YAAY,EAEb,MAAM,oBAAoB,CAAC;AAE5B,OAAO,KAAK,EAAE,kBAAkB,EAAC,MAAM,sBAAsB,CAAC;AAE9D,OAAO,KAAK,EACV,gBAAgB,EAEhB,iBAAiB,EAAC,MAAM,2BAA2B,CAAC;AAOtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,qBAAa,YAAa,SAAQ,WAAW;IAC3C;;;;;;;;;;;OAWG;gBACS,IAAI,EAAE,UAAU,EAAE,SAAS,GAAE,OAAe;IAIxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoIG;IACG,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,YAAY,CAAC;IAgFrE;;;OAGG;IACH,OAAO,CAAC,sBAAsB;IA4C9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmEG;IACG,SAAS,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,iBAAiB,CAAC;CAgBvE"}
+{"version":3,"file":"TradeService.d.ts","sourceRoot":"","sources":["../../../src/services/TradeService.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAMH,OAAO,KAAK,EAAE,kBAAkB,EAAC,MAAM,sBAAsB,CAAC;AAE9D,OAAO,KAAK,EAGV,YAAY,EACb,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EACV,gBAAgB,EAEhB,iBAAiB,EAAC,MAAM,2BAA2B,CAAC;AAOtD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAMhD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAG5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,qBAAa,YAAa,SAAQ,WAAW;IAC3C;;;;;;;;;;;OAWG;gBACS,IAAI,EAAE,UAAU,EAAE,SAAS,GAAE,OAAe;IAIxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoIG;IACG,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,YAAY,CAAC;IAuErE;;;OAGG;IACH,OAAO,CAAC,sBAAsB;IAsD9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmEG;IACG,SAAS,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,iBAAiB,CAAC;CAgBvE"}

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

@@ -0,0 +1,162 @@
+/**
+ * Trading Quotes Service
+ *
+ * Provides backend-proxied methods for trading quotes, fees, and sale details.
+ * Uses local bonding curve math on the backend for instant quotes without GalaChain calls.
+ *
+ * **Key distinctions from existing services:**
+ * - `fetchLaunchpadFee()` → backend proxy (cached 1h) vs `GalaChainService.fetchLaunchTokenFee()` → chain direct
+ * - `fetchSaleDetails(tokenName)` → backend proxy (cached 10s, tokenName only) vs `GalaChainService.fetchPoolDetails()` → chain (vaultAddress required)
+ * - `getTradeQuote(params)` → backend local math (instant) vs `calculateBuyAmountExternal()` → chain call
+ * - `getPremintQuote(amount)` → backend local math (supply=0) — no existing equivalent
+ *
+ * @category Services
+ * @since 9.1.0
+ */
+import type { AmountCalculationResult, SaleDetailsResult, TradeQuoteParams } from '../types/launchpad.dto';
+import type { HttpClient } from '../utils/http';
+import { BaseService } from './BaseService';
+/**
+ * Trading Quotes Service Class
+ *
+ * Provides methods for:
+ * - Fetching launchpad fee (backend-cached, 1 hour TTL)
+ * - Fetching sale details by tokenName (backend-cached, 10 second TTL)
+ * - Getting trade quotes via local bonding curve math (instant, no chain call)
+ * - Getting pre-mint quotes (supply = 0 assumed, no chain call)
+ *
+ * All methods call `@Public()` backend endpoints — no authentication required.
+ *
+ * @category Services
+ * @since 9.1.0
+ *
+ * @example Fetch launchpad fee
+ * ```typescript
+ * const fee = await tradingQuotesService.fetchLaunchpadFee();
+ * console.log(`Launchpad fee: ${fee} GALA`);
+ * ```
+ *
+ * @example Get a trade quote
+ * ```typescript
+ * const quote = await tradingQuotesService.getTradeQuote({
+ *   tokenName: 'anime',
+ *   amount: '100',
+ *   type: 'NATIVE',
+ *   method: 'IN',
+ * });
+ * console.log(`You will receive: ${quote.amount} tokens`);
+ * ```
+ */
+export declare class TradingQuotesService extends BaseService {
+    /**
+     * Creates a TradingQuotesService instance
+     *
+     * @param http Configured HttpClient pointing at the launchpad backend (`baseUrl`)
+     * @param debugMode Enable debug logging (default: false)
+     */
+    constructor(http: HttpClient, debugMode?: boolean);
+    /**
+     * Fetches the current launchpad fee via the backend proxy (cached 1 hour).
+     *
+     * Distinct from `GalaChainService.fetchLaunchTokenFee()` which calls the chain
+     * directly. This version is faster due to backend caching.
+     *
+     * @returns Promise resolving to the fee amount in GALA (number)
+     * @throws {ValidationError} If the backend returns an error response
+     *
+     * @category Trading Quotes
+     * @since 9.1.0
+     *
+     * @example
+     * ```typescript
+     * const fee = await sdk.fetchLaunchpadFee();
+     * console.log(`Current launchpad fee: ${fee} GALA`);
+     * ```
+     */
+    fetchLaunchpadFee(): Promise<number>;
+    /**
+     * Fetches sale details (supply, status) for a token via backend proxy (cached 10 seconds).
+     *
+     * Distinct from `GalaChainService.fetchPoolDetails()` which requires a vaultAddress.
+     * The backend resolves the vaultAddress internally using the tokenName.
+     *
+     * @param tokenName Token name to fetch sale details for (e.g. 'anime')
+     * @returns Promise resolving to sale details including supply, quantities, and status
+     * @throws {ValidationError} If the backend returns an error response
+     *
+     * @category Trading Quotes
+     * @since 9.1.0
+     *
+     * @example
+     * ```typescript
+     * const details = await sdk.fetchSaleDetails('anime');
+     * console.log(`Supply: ${details.sellingTokenQuantity} / ${details.maxSupply}`);
+     * console.log(`Status: ${details.saleStatus}`);
+     * ```
+     */
+    fetchSaleDetails(tokenName: string): Promise<SaleDetailsResult>;
+    /**
+     * Calculates a trade quote via the backend using local bonding curve math.
+     *
+     * No chain call is made — the backend computes this instantly using its local
+     * bonding curve calculations. Faster than `calculateBuyAmountExternal()` or
+     * `calculateSellAmountExternal()` which hit GalaChain directly.
+     *
+     * @param params Quote parameters
+     * @param params.tokenName Token name (e.g. 'anime')
+     * @param params.amount Amount as a decimal string
+     * @param params.type 'MEME' (launchpad token) or 'NATIVE' (GALA)
+     * @param params.method 'IN' (spend this amount) or 'OUT' (receive this amount)
+     * @returns Promise resolving to amount calculation result with fees
+     * @throws {ValidationError} If the backend returns an error response
+     *
+     * @category Trading Quotes
+     * @since 9.1.0
+     *
+     * @example Buy: how many tokens for 100 GALA?
+     * ```typescript
+     * const quote = await sdk.getTradeQuote({
+     *   tokenName: 'anime',
+     *   amount: '100',
+     *   type: 'NATIVE',
+     *   method: 'IN',
+     * });
+     * console.log(`You will receive: ${quote.amount} tokens`);
+     * console.log(`Fee: ${quote.reverseBondingCurveFee} GALA`);
+     * ```
+     *
+     * @example Sell: how much GALA for 500 tokens?
+     * ```typescript
+     * const quote = await sdk.getTradeQuote({
+     *   tokenName: 'anime',
+     *   amount: '500',
+     *   type: 'MEME',
+     *   method: 'IN',
+     * });
+     * console.log(`You will receive: ${quote.amount} GALA`);
+     * ```
+     */
+    getTradeQuote(params: TradeQuoteParams): Promise<AmountCalculationResult>;
+    /**
+     * Calculates a pre-mint token output for a given GALA amount (supply = 0 assumed).
+     *
+     * Used during the token creation flow to show buyers what they will receive for
+     * their initial GALA investment before the token launches. No chain call required.
+     *
+     * @param amount GALA amount to spend (as a decimal string, e.g. '100')
+     * @returns Promise resolving to amount calculation result with fees
+     * @throws {ValidationError} If the backend returns an error response
+     *
+     * @category Trading Quotes
+     * @since 9.1.0
+     *
+     * @example
+     * ```typescript
+     * const premintQuote = await sdk.getPremintQuote('500');
+     * console.log(`Initial purchase will yield: ${premintQuote.amount} tokens`);
+     * console.log(`Transaction fee: ${premintQuote.transactionFee} GALA`);
+     * ```
+     */
+    getPremintQuote(amount: string): Promise<AmountCalculationResult>;
+}
+//# sourceMappingURL=TradingQuotesService.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TradingQuotesService.d.ts","sourceRoot":"","sources":["../../../src/services/TradingQuotesService.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EAAE,uBAAuB,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC3G,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAa5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,qBAAa,oBAAqB,SAAQ,WAAW;IACnD;;;;;OAKG;gBACS,IAAI,EAAE,UAAU,EAAE,SAAS,GAAE,OAAe;IAIxD;;;;;;;;;;;;;;;;;OAiBG;IACG,iBAAiB,IAAI,OAAO,CAAC,MAAM,CAAC;IAO1C;;;;;;;;;;;;;;;;;;;OAmBG;IACG,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAUrE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwCG;IACG,aAAa,CAAC,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAAC,uBAAuB,CAAC;IAe/E;;;;;;;;;;;;;;;;;;;OAmBG;IACG,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,uBAAuB,CAAC;CASxE"}