@gala-chain/launchpad-sdk 8.0.2 → 9.0.0-rc.0

package/dist/services/PriceHistoryService.d.ts

@@ -1,209 +0,0 @@
-/**
- * Price History Service
- *
- * Handles fetching historical price data for DEX tokens via DEX Backend API.
- *
- * Features:
- * - DEX Backend API integration for token price history
- * - Pagination matching SDK conventions
- * - Date range filtering
- * - Token filtering by TokenClassKey
- * - Comprehensive error handling
- *
- * @category Services
- * @since 3.13.0
- */
-import type { FetchPriceHistoryOptions, PriceHistoryResult } from '../types/priceHistory.dto';
-import type { HttpClient } from '../utils/http';
-import { BaseService } from './BaseService';
-import type { TokenResolverService } from './TokenResolverService';
-/**
- * Price History Service Class
- *
- * Manages API-based price history queries via DEX Backend API.
- * Supports optional token name resolution via TokenResolverService for convenience.
- *
- * @example
- * ```typescript
- * const httpClient = new HttpClient(config);
- * const tokenResolverService = new TokenResolverService(...);
- * const service = new PriceHistoryService(httpClient, false, tokenResolverService);
- *
- * // Using tokenId
- * const history = await service.fetchPriceHistory({
- *   tokenId: { collection: 'GUSDC', category: 'Unit', type: 'none', additionalKey: 'eth:...' },
- *   from: new Date('2024-01-01'),
- *   to: new Date('2024-01-31'),
- *   page: 1,
- *   limit: 20
- * });
- *
- * // Using tokenName (auto-resolves to tokenId)
- * const history = await service.fetchPriceHistory({
- *   tokenName: 'demonkpop',
- *   from: new Date('2024-01-01'),
- *   to: new Date('2024-01-31')
- * });
- * ```
- */
-export declare class PriceHistoryService extends BaseService {
-    private readonly tokenResolverService;
-    /**
-     * Create a new PriceHistoryService instance
-     * @param httpClient HTTP client for DEX Backend API
-     * @param debugMode Enable debug logging (default: false)
-     * @param tokenResolverService Optional TokenResolverService for token name resolution
-     */
-    constructor(httpClient: HttpClient, debugMode?: boolean, tokenResolverService?: TokenResolverService);
-    /**
-     * Helper method: Resolve a token name to its full token class key
-     *
-     * Uses TokenResolverService to resolve a token name to vault address, then extracts
-     * the complete token class key in pipe-delimited format for use with DEX Backend API.
-     *
-     * @param tokenName Simple token name (e.g., "demonkpop", "shoewars")
-     * @returns Promise<string> Full token class key: "collection|category|type|additionalKey"
-     * @throws ConfigurationError if TokenResolverService is not available
-     * @throws NetworkError if token resolution fails
-     * @throws ValidationError if token name is invalid
-     *
-     * @example
-     * ```typescript
-     * const tokenClassKey = await service.fetchTokenClassKeyByTokenName('demonkpop');
-     * // Returns: "Token|Unit|DKP|eth:4A65D29213de2939373ff9eB63AC38730F192C84"
-     * ```
-     *
-     * @since 3.20.0
-     */
-    fetchTokenClassKeyByTokenName(tokenName: string): Promise<string>;
-    /**
-     * Fetch price history for a token with pagination (v3.20.0+)
-     *
-     * Fetches historical price snapshots from DEX Backend API with flexible token identification.
-     * Returns paginated results matching SDK conventions.
-     *
-     * Supports three token identification methods (choose exactly ONE):
-     * 1. tokenName: Simple token name (e.g., "demonkpop") - auto-resolves to full tokenId
-     * 2. tokenId string: Pipe-delimited format (e.g., "Token|Unit|USDC|eth:123...")
-     * 3. tokenId object: Explicit TokenClassKey object with collection, category, type, additionalKey
-     *
-   * @param options Fetch options including token ID (name or full), date range, timeframe, and pagination
-     * @returns Promise<PriceHistoryResult> Price snapshots with pagination metadata
-     * @throws NetworkError if API request fails
-     * @throws ValidationError if parameters are invalid or both tokenName and tokenId are provided
-     *
-   * @updated 8.1.0 - Uses the market price-series endpoint and local pagination
-     *
-     * @example
-     * ```typescript
-     * // NEW (v3.20.0+): Using simple token name (recommended for convenience)
-     * const result = await service.fetchPriceHistory({
-     *   tokenName: 'demonkpop',  // Simple, intuitive token name
-     *   from: new Date('2024-01-01'),
-     *   to: new Date('2024-01-31'),
-     *   pageSize: 20
-     * });
-     *
-     * // Using tokenId object format (explicit, no lookup required)
-     * const result = await service.fetchPriceHistory({
-     *   tokenId: {
-     *     collection: 'GUSDC',
-     *     category: 'Unit',
-     *     type: 'none',
-     *     additionalKey: 'none'
-     *   },
-     *   from: new Date('2024-01-01'),
-     *   to: new Date('2024-01-31'),
-     *   pageSize: 20
-     * });
-     *
-     * // Using tokenId string format (backward compatible)
-     * const result = await service.fetchPriceHistory({
-     *   tokenId: 'GUSDC|Unit|none|none',
-     *   pageSize: 20
-     * });
-     *
-     * // Analyzing volatility with date filtering
-     * const thirtyDays = await service.fetchPriceHistory({
-     *   tokenName: 'demonkpop',
-     *   from: new Date(Date.now() - 30 * 24 * 60 * 60 * 1000),
-     *   to: new Date(),
-     *   sortOrder: 'ASC',
-     *   pageSize: 50
-     * });
-     * ```
-     *
-     * @since 3.20.0 - Added tokenName parameter support with auto-resolution
-     * @updated 7.0.0 - Migrated from page-based to offset-based pagination
-     */
-    fetchPriceHistory(options: FetchPriceHistoryOptions): Promise<PriceHistoryResult>;
-    /**
-     * Transform DEX Backend API response to SDK PriceHistoryResult format
-     * @internal
-     */
-    private transformApiResponseToPriceHistory;
-    /**
-     * Fetch all price history for a token with automatic pagination (v3.20.0+)
-     *
-     * Convenience method that automatically iterates through all pages from DEX Backend API and combines results.
-     * Returns all available price snapshots matching the filter criteria in a single response.
-   * No pagination parameters are needed; this method handles offset pagination internally.
-     *
-     * Supports three token identification methods (choose exactly ONE):
-     * 1. tokenName: Simple token name (e.g., "demonkpop") - auto-resolves to full tokenId
-     * 2. tokenId string: Pipe-delimited format (e.g., "Token|Unit|USDC|eth:123...")
-     * 3. tokenId object: Explicit TokenClassKey object with collection, category, type, additionalKey
-     *
-     * @param options Fetch options including token ID (name or full), date range, and sort order
-     * @returns Promise<PriceHistoryResult> All price snapshots with combined total count
-     * @throws NetworkError if API request fails or exceeds maximum pages
-     * @throws ValidationError if parameters are invalid or both tokenName and tokenId are provided
-     *
-     * @example
-     * ```typescript
-     * // NEW (v3.20.0+): Using simple token name with auto-pagination (recommended)
-     * const result = await service.fetchAllPriceHistory({
-     *   tokenName: 'demonkpop',  // Simple token name - auto-resolves
-     *   from: new Date('2024-01-01'),
-     *   to: new Date('2024-12-31'),
-     *   sortOrder: 'ASC'
-     * });
-     *
-     * console.log(`Total snapshots: ${result.total}`);
-     * console.log(`Snapshots returned: ${result.snapshots.length}`);
-     *
-     * // Using tokenId string format (backward compatible, no auto-resolution)
-     * const result = await service.fetchAllPriceHistory({
-     *   tokenId: 'Token|Unit|USDC|eth:123...',
-     *   from: new Date('2024-01-01'),
-     *   to: new Date('2024-01-31'),
-     *   sortOrder: 'DESC'
-     * });
-     *
-     * // Volatility analysis over full year (100+ snapshots with auto-pagination)
-     * const yearData = await service.fetchAllPriceHistory({
-     *   tokenName: 'demonkpop',
-     *   from: new Date('2023-01-01'),
-     *   to: new Date('2023-12-31'),
-     *   sortOrder: 'ASC'
-     * });
-     *
-     * const prices = yearData.snapshots.map(s => parseFloat(s.price));
-     * const avgPrice = prices.reduce((a, b) => a + b) / prices.length;
-     * console.log(`Average price over year: $${avgPrice.toFixed(8)}`);
-     * ```
-     *
-     * @since 3.20.0 - Added tokenName parameter support with auto-resolution
-   * @updated 8.1.0 - Uses the market price-series endpoint and local pagination
-     */
-    fetchAllPriceHistory(options: Omit<FetchPriceHistoryOptions, 'cursor' | 'pageSize'>): Promise<PriceHistoryResult>;
-    /**
-     * Validate fetch options
-     * Ensures exactly one of tokenName or tokenId is provided (mutual exclusivity)
-     * @private
-     */
-    private validateOptions;
-    /** Selects the backend-supported window for date-filtered callers. */
-    private inferTimeframe;
-}
-//# sourceMappingURL=PriceHistoryService.d.ts.map

package/dist/services/PriceHistoryService.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PriceHistoryService.d.ts","sourceRoot":"","sources":["../../src/services/PriceHistoryService.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EACV,wBAAwB,EAExB,kBAAkB,EAGnB,MAAM,2BAA2B,CAAC;AAOnC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAWhD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAEnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,qBAAa,mBAAoB,SAAQ,WAAW;IAClD,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAmC;IAExE;;;;;OAKG;gBACS,UAAU,EAAE,UAAU,EAAE,SAAS,GAAE,OAAe,EAAE,oBAAoB,CAAC,EAAE,oBAAoB;IAK3G;;;;;;;;;;;;;;;;;;;OAmBG;IACG,6BAA6B,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAyDvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2DG;IACG,iBAAiB,CAAC,OAAO,EAAE,wBAAwB,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAgEvF;;;OAGG;IACH,OAAO,CAAC,kCAAkC;IAwC1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqDG;IACG,oBAAoB,CACxB,OAAO,EAAE,IAAI,CAAC,wBAAwB,EAAE,QAAQ,GAAG,UAAU,CAAC,GAC7D,OAAO,CAAC,kBAAkB,CAAC;IAyC9B;;;;OAIG;IACH,OAAO,CAAC,eAAe;IA4BvB,sEAAsE;IACtE,OAAO,CAAC,cAAc;CAUvB"}

package/dist/services/WrapService.d.ts

@@ -1,171 +0,0 @@
-/**
- * WrapService - Cross-channel token wrapping/unwrapping
- *
- * Handles internal GalaChain channel bridges:
- * - Wrap: MUSIC (music channel) → GMUSIC (asset channel)
- * - Unwrap: GMUSIC (asset channel) → MUSIC (music channel)
- *
- * This is different from external bridges (Ethereum/Solana) - wrap/unwrap
- * operates entirely within GalaChain across different channels.
- *
- * @category Services
- * @since 4.0.18
- */
-import type { Wallet } from 'ethers';
-import type { GalaConnectClient } from '../bridge/GalaConnectClient.js';
-import type { GalaChainSigner } from '../signing/signers.js';
-import type { TokenId } from '../types/common.js';
-import type { UnwrapTokenOptions, WrapTokenOptions, WrapUnwrapFeeEstimate, WrapUnwrapResult, WrapUnwrapStatusResult } from '../types/wrappable-token.dto.js';
-import type { Logger } from '../utils/Logger.js';
-import { LoggerBase } from './BaseService.js';
-import type { WrappableTokenService } from './WrappableTokenService.js';
-/**
- * Configuration for WrapService
- */
-export interface WrapServiceConfig {
-    /** GalaConnect client for DEX API platform (same as bridge operations) */
-    galaConnectClient: GalaConnectClient;
-    /** WrappableTokenService for token metadata */
-    wrappableTokenService: WrappableTokenService;
-    /** Optional native GalaChain signer. */
-    signer?: GalaChainSigner;
-    /** Wallet used to create a native signer when signer is omitted. */
-    wallet?: Wallet;
-    /** Wallet address (for sender) */
-    walletAddress?: string;
-    /** Logger instance */
-    logger?: Logger;
-}
-/**
- * WrapService - Cross-channel token wrapping/unwrapping
- *
- * Provides methods to wrap tokens from their native channel to the asset channel
- * (e.g., MUSIC → GMUSIC) and unwrap them back (GMUSIC → MUSIC).
- *
- * @example
- * ```typescript
- * // Wrap MUSIC to GMUSIC for DEX trading
- * const wrapResult = await wrapService.wrapToken({
- *   tokenId: 'MUSIC',
- *   amount: '100',
- * });
- *
- * // Unwrap GMUSIC back to MUSIC
- * const unwrapResult = await wrapService.unwrapToken({
- *   tokenId: 'GMUSIC',
- *   amount: '50',
- * });
- * ```
- */
-export declare class WrapService extends LoggerBase {
-    private readonly galaConnectClient;
-    private readonly wrappableTokenService;
-    private readonly nativeSigner;
-    private readonly walletAddress;
-    constructor(config: WrapServiceConfig);
-    /**
-     * Wrap a token to its asset-channel counterpart
-     *
-     * Transfers a token from its native channel to the asset channel.
-     * Example: MUSIC (music channel) → GMUSIC (asset channel)
-     *
-     * @param options - Wrap options including tokenId and amount
-     * @returns Promise<WrapUnwrapResult> - Transaction result
-     *
-     * @example
-     * ```typescript
-     * const result = await wrapService.wrapToken({
-     *   tokenId: 'MUSIC',
-     *   amount: '100',
-     * });
-     * console.log(`Wrapped ${result.amount} ${result.fromToken} → ${result.toToken}`);
-     * ```
-     *
-     * @throws {ValidationError} If token is not wrappable or already on asset channel
-     */
-    wrapToken(options: WrapTokenOptions): Promise<WrapUnwrapResult>;
-    /**
-     * Unwrap a token back to its native channel
-     *
-     * Transfers a token from the asset channel back to its native channel.
-     * Example: GMUSIC (asset channel) → MUSIC (music channel)
-     *
-     * @param options - Unwrap options including tokenId and amount
-     * @returns Promise<WrapUnwrapResult> - Transaction result
-     *
-     * @example
-     * ```typescript
-     * const result = await wrapService.unwrapToken({
-     *   tokenId: 'GMUSIC',
-     *   amount: '50',
-     * });
-     * console.log(`Unwrapped ${result.amount} ${result.fromToken} → ${result.toToken}`);
-     * ```
-     *
-     * @throws {ValidationError} If token is not unwrappable or not on asset channel
-     */
-    unwrapToken(options: UnwrapTokenOptions): Promise<WrapUnwrapResult>;
-    /**
-     * Estimate fees for a wrap operation
-     *
-     * @param tokenId - Token to wrap
-     * @param amount - Amount to wrap
-     * @returns Promise<WrapUnwrapFeeEstimate> - Fee estimate
-     * @throws ValidationError if tokenId or amount is required but not provided
-     */
-    estimateWrapFee(tokenId: TokenId, _amount: string): Promise<WrapUnwrapFeeEstimate>;
-    /**
-     * Estimate fees for an unwrap operation
-     *
-     * @param tokenId - Token to unwrap
-     * @param amount - Amount to unwrap
-     * @returns Promise<WrapUnwrapFeeEstimate> - Fee estimate
-     * @throws ValidationError if tokenId or amount is required but not provided
-     */
-    estimateUnwrapFee(tokenId: TokenId, _amount: string): Promise<WrapUnwrapFeeEstimate>;
-    /**
-     * Get status of a wrap/unwrap transaction
-     *
-     * Cross-channel wrapping completes immediately (synchronous on-chain).
-     * This method returns the completed status for the given transaction ID.
-     *
-     * @param transactionId - Transaction ID to check
-     * @returns WrapUnwrapStatusResult - Current status (always completed for wrap/unwrap)
-     * @throws ValidationError if transactionId is required but not provided
-     */
-    getWrapStatus(transactionId: string): WrapUnwrapStatusResult;
-    private executeWrapOrUnwrap;
-    private estimateChannelFee;
-    /**
-     * Execute a cross-channel bridge (wrap or unwrap)
-     *
-     * Uses the shared native GalaChain signer for the bridge request.
-     *
-     * @see docs/api-calls/swapBridgeOut.txt for working payload example
-     */
-    private executeChannelBridge;
-    /**
-     * Execute wrap bridge request with comprehensive error handling
-     *
-     * Uses direct try-catch (not withErrorHandling wrapper) because this method
-     * returns structured error responses (WrapUnwrapResult with success: false)
-     * rather than throwing. This is appropriate for a private helper method that
-     * normalizes errors into the return type.
-     */
-    private executeWrapBridgeRequest;
-    /**
-     * Determine channel routing for wrap/unwrap operation
-     *
-     * The destinationChannelId determines where tokens go:
-     * - Wrap: native channel → asset channel (destinationChannelId = ASSET = 1)
-     * - Unwrap: asset channel → native channel (destinationChannelId = MUSIC = 3)
-     */
-    private determineChannelRouting;
-    private getCounterpartOrThrow;
-    private getWrappableTokenOrThrow;
-    /**
-     * Format tokenId for error messages using centralized stringification
-     */
-    private formatTokenId;
-}
-//# sourceMappingURL=WrapService.d.ts.map

package/dist/services/WrapService.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"WrapService.d.ts","sourceRoot":"","sources":["../../src/services/WrapService.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAGrC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AACxE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE7D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,KAAK,EACV,kBAAkB,EAElB,gBAAgB,EAChB,qBAAqB,EACrB,gBAAgB,EAChB,sBAAsB,EACvB,MAAM,iCAAiC,CAAC;AAKzC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAEjD,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AAcxE;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,0EAA0E;IAC1E,iBAAiB,EAAE,iBAAiB,CAAC;IACrC,+CAA+C;IAC/C,qBAAqB,EAAE,qBAAqB,CAAC;IAC7C,wCAAwC;IACxC,MAAM,CAAC,EAAE,eAAe,CAAC;IACzB,oEAAoE;IACpE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,kCAAkC;IAClC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,sBAAsB;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AA4CD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,WAAY,SAAQ,UAAU;IACzC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAoB;IACtD,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAwB;IAC9D,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA8B;IAC3D,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAqB;gBAEvC,MAAM,EAAE,iBAAiB;IAarC;;;;;;;;;;;;;;;;;;;OAmBG;IACG,SAAS,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAIrE;;;;;;;;;;;;;;;;;;;OAmBG;IACG,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAIzE;;;;;;;OAOG;IACG,eAAe,CACnB,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,qBAAqB,CAAC;IAIjC;;;;;;;OAOG;IACG,iBAAiB,CACrB,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,qBAAqB,CAAC;IAIjC;;;;;;;;;OASG;IACH,aAAa,CAAC,aAAa,EAAE,MAAM,GAAG,sBAAsB;YAsB9C,mBAAmB;YA+BnB,kBAAkB;IAoChC;;;;;;OAMG;YACW,oBAAoB;IA0ElC;;;;;;;OAOG;YACW,wBAAwB;IAqItC;;;;;;OAMG;IACH,OAAO,CAAC,uBAAuB;YAwBjB,qBAAqB;YAYrB,wBAAwB;IAYtC;;OAEG;IACH,OAAO,CAAC,aAAa;CAMtB"}

package/dist/services/WrappableTokenCache.d.ts

@@ -1,100 +0,0 @@
-/**
- * Wrappable Token Cache Service
- *
- * Permanent in-memory cache for wrappable tokens fetched from DEX API.
- * Wrappable tokens are GalaChain-internal token pairs that can be
- * wrapped/unwrapped into each other (e.g., MUSIC <-> GMUSIC).
- *
- * ## Cache Architecture
- * - **Primary Index**: Map<tokenId, token> - O(1) by stringifiedTokenClassKey
- * - **Persistence**: Entire SDK lifetime (never expires)
- * - **Memory**: ~500-800 bytes per token (plus ~50 bytes per index entry)
- *
- * ## Caching Strategy
- * - Metadata always cached by fetchWrappableTokens/fetchAllWrappableTokens
- * - Balance methods preheat cache while returning user-specific data
- * - No network separation (wrapping is GalaChain-internal)
- *
- * @category Services
- * @since 4.0.18
- */
-import type { WrappableToken, WrappableTokenCacheStats } from '../types/wrappable-token.dto.js';
-import { BatchedCacheService } from './BatchedCacheService.js';
-/**
- * Wrappable Token Cache
- *
- * High-performance permanent cache for wrappable token data.
- * Tokens are indexed by their stringifiedTokenClassKey for O(1) lookups.
- *
- * @example Basic usage
- * ```typescript
- * const cache = new WrappableTokenCache();
- *
- * // Cache all tokens
- * cache.setAll(wrappableTokens);
- *
- * // Check if cached
- * if (cache.has()) {
- *   const tokens = cache.getAll();
- * }
- *
- * // Get specific token by tokenId
- * const music = cache.getByTokenId('$MUSIC|Unit|none|none');
- * ```
- */
-export declare class WrappableTokenCache extends BatchedCacheService<WrappableToken, WrappableTokenCacheStats> {
-    constructor(debugMode?: boolean);
-    /**
-     * Extract the cache key from a wrappable token
-     *
-     * @param token - Wrappable token
-     * @returns The stringifiedTokenClassKey as the key
-     */
-    protected extractKey(token: WrappableToken): string;
-    /**
-     * Check if cache is populated
-     *
-     * @returns True if cache has tokens
-     */
-    has(): boolean;
-    /**
-     * Get all cached tokens
-     *
-     * @returns Array of wrappable tokens (empty if not cached)
-     */
-    getAll(): WrappableToken[];
-    /**
-     * Get a specific token by stringifiedTokenClassKey (tokenId)
-     *
-     * @param tokenId - Stringified TokenClassKey (e.g., "$MUSIC|Unit|none|none")
-     * @returns Wrappable token or undefined if not found
-     */
-    getByTokenId(tokenId: string): WrappableToken | undefined;
-    /**
-     * Get cache statistics
-     *
-     * @returns Cache statistics including token count and timestamp
-     */
-    getStats(): WrappableTokenCacheStats;
-    /**
-     * Get number of cached tokens
-     *
-     * @returns Number of cached tokens
-     */
-    size(): number;
-    /**
-     * Check if a token is wrappable (exists in cache)
-     *
-     * @param tokenId - Stringified TokenClassKey
-     * @returns True if token is cached
-     */
-    isTokenWrappable(tokenId: string): boolean;
-    /**
-     * Get wrap counterpart for a token
-     *
-     * @param tokenId - Stringified TokenClassKey
-     * @returns Counterpart token or undefined if not found
-     */
-    getWrapCounterpart(tokenId: string): WrappableToken | undefined;
-}
-//# sourceMappingURL=WrappableTokenCache.d.ts.map

package/dist/services/WrappableTokenCache.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"WrappableTokenCache.d.ts","sourceRoot":"","sources":["../../src/services/WrappableTokenCache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAChG,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,mBAAoB,SAAQ,mBAAmB,CAAC,cAAc,EAAE,wBAAwB,CAAC;gBACxF,SAAS,GAAE,OAAe;IAItC;;;;;OAKG;IACH,SAAS,CAAC,UAAU,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM;IAInD;;;;OAIG;IACM,GAAG,IAAI,OAAO;IAIvB;;;;OAIG;IACH,MAAM,IAAI,cAAc,EAAE;IAI1B;;;;;OAKG;IACI,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS;IAIhE;;;;OAIG;IACa,QAAQ,IAAI,wBAAwB;IAQpD;;;;OAIG;IACM,IAAI,IAAI,MAAM;IAIvB;;;;;OAKG;IACH,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAI1C;;;;;OAKG;IACH,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS;CAMhE"}

package/dist/services/WrappableTokenService.d.ts

@@ -1,130 +0,0 @@
-/**
- * Wrappable Token Service
- *
- * Service for fetching and caching wrappable tokens from the DEX API.
- * Provides methods to query which tokens can be wrapped/unwrapped
- * and retrieves their counterpart tokens dynamically.
- *
- * ## Key Features
- * - Dynamic token discovery (fetches from DEX API)
- * - Permanent caching for token metadata
- * - Separate balance methods for user-specific queries
- *
- * ## Caching Strategy
- * - Token metadata is always cached (fetchWrappableTokens, fetchAllWrappableTokens)
- * - Balance methods never cache (fetchWrappableTokenBalances, fetchAllWrappableTokenBalances)
- * - Cache persists for entire SDK lifetime
- *
- * @category Services
- * @since 4.0.18
- */
-import type { TokenId } from '../types/common.js';
-import type { FetchWrappableTokensOptions, FetchWrappableTokensResult, IsTokenWrappableResult, WrappableToken, WrappableTokenApiResponse, WrappableTokenCacheStats } from '../types/wrappable-token.dto.js';
-import type { HttpClient } from '../utils/http.js';
-import { AbstractTokenFetchService } from './AbstractTokenFetchService.js';
-/**
- * WrappableTokenService
- *
- * Fetches and caches wrappable token information from the DEX API.
- * Provides efficient lookups for wrap/unwrap operations.
- *
- * @example Basic usage
- * ```typescript
- * const service = new WrappableTokenService(dexApiHttp, true);
- *
- * // Fetch all wrappable tokens (cached)
- * const result = await service.fetchAllWrappableTokens();
- * console.log(`Found ${result.tokenCount} tokens`);
- *
- * // Fetch with balance data for a specific address (not cached)
- * const withBalances = await service.fetchAllWrappableTokenBalances('eth|0x1234...');
- * console.log(`Found ${withBalances.tokenCount} tokens with balances`);
- *
- * // Check if a specific token is wrappable (by tokenId)
- * const isWrappable = await service.isTokenWrappable('$MUSIC|Unit|none|none');
- * console.log(`MUSIC wrappable: ${isWrappable.isWrappable}`);
- *
- * // Get wrap counterpart
- * const counterpart = await service.getWrapCounterpart('$MUSIC|Unit|none|none');
- * console.log(`MUSIC counterpart: ${counterpart?.symbol}`); // GMUSIC
- * ```
- */
-export declare class WrappableTokenService extends AbstractTokenFetchService<WrappableTokenApiResponse, WrappableToken> {
-    private readonly cache;
-    constructor(dexApiHttp: HttpClient, debugMode?: boolean);
-    /**
-     * Build API request parameters for wrappable tokens
-     *
-     * @param _context - Unused context parameter (required by base class)
-     * @returns Query parameters with wrappable filter
-     */
-    protected buildApiParams(context?: Record<string, unknown>): Record<string, string | number | boolean>;
-    /**
-     * Transform API response tokens to SDK format
-     *
-     * @param apiTokens - Raw API response tokens
-     * @returns Array of transformed wrappable tokens
-     */
-    protected transformApiResponse(apiTokens: WrappableTokenApiResponse[]): WrappableToken[];
-    /**
-     * Fetch wrappable tokens with pagination (metadata only, cached)
-     *
-     * For user-specific balance data, use fetchWrappableTokenBalances() instead.
-     *
-     * @param options - Fetch options including pagination parameters
-     * @returns Promise resolving to fetch result with tokens array
-     * @throws NetworkError if API request fails
-     */
-    fetchWrappableTokens(options?: FetchWrappableTokensOptions): Promise<FetchWrappableTokensResult>;
-    /**
-     * Fetch ALL wrappable tokens (auto-pagination, cached)
-     *
-     * Returns cached data if available, otherwise fetches from API.
-     * For user-specific balance data, use fetchAllWrappableTokenBalances() instead.
-     *
-     * @returns Promise resolving to fetch result with all tokens
-     * @throws NetworkError if API request fails
-     */
-    fetchAllWrappableTokens(): Promise<FetchWrappableTokensResult>;
-    /**
-     * Get a wrappable token by tokenId
-     *
-     * Uses cache for efficient lookup. If cache not populated, fetches first.
-     *
-     * @param tokenId - Token identifier (pipe-delimited or TokenClassKey)
-     * @returns Promise resolving to wrappable token or undefined
-     */
-    getWrappableToken(tokenId: TokenId): Promise<WrappableToken | undefined>;
-    /**
-     * Get the wrap counterpart for a token
-     *
-     * @param tokenId - Token identifier (pipe-delimited or TokenClassKey)
-     * @returns Promise resolving to counterpart token or undefined
-     *
-     * @example
-     * ```typescript
-     * // Get GMUSIC from MUSIC
-     * const counterpart = await service.getWrapCounterpart('$MUSIC|Unit|none|none');
-     * console.log(counterpart?.symbol); // "GMUSIC"
-     * ```
-     */
-    getWrapCounterpart(tokenId: TokenId): Promise<WrappableToken | undefined>;
-    /**
-     * Check if a token is wrappable
-     *
-     * @param tokenId - Token identifier (pipe-delimited or TokenClassKey)
-     * @returns Promise resolving to wrappability result
-     */
-    isTokenWrappable(tokenId: TokenId): Promise<IsTokenWrappableResult>;
-    /**
-     * Get cache statistics
-     *
-     * @returns Cache statistics including token count and timestamp
-     */
-    getCacheStats(): WrappableTokenCacheStats;
-    /**
-     * Clear cache
-     */
-    clearCache(): void;
-}
-//# sourceMappingURL=WrappableTokenService.d.ts.map

package/dist/services/WrappableTokenService.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"WrappableTokenService.d.ts","sourceRoot":"","sources":["../../src/services/WrappableTokenService.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,KAAK,EACV,2BAA2B,EAC3B,0BAA0B,EAC1B,sBAAsB,EACtB,cAAc,EACd,yBAAyB,EACzB,wBAAwB,EACzB,MAAM,iCAAiC,CAAC;AAGzC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD,OAAO,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAC;AAI3E;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,qBAAsB,SAAQ,yBAAyB,CAClE,yBAAyB,EACzB,cAAc,CACf;IACC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAsB;gBAEhC,UAAU,EAAE,UAAU,EAAE,SAAS,GAAE,OAAe;IAK9D;;;;;OAKG;IACH,SAAS,CAAC,cAAc,CACtB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;IAK5C;;;;;OAKG;IACH,SAAS,CAAC,oBAAoB,CAAC,SAAS,EAAE,yBAAyB,EAAE,GAAG,cAAc,EAAE;IAwCxF;;;;;;;;OAQG;IACG,oBAAoB,CACxB,OAAO,GAAE,2BAAgC,GACxC,OAAO,CAAC,0BAA0B,CAAC;IAoCtC;;;;;;;;OAQG;IACG,uBAAuB,IAAI,OAAO,CAAC,0BAA0B,CAAC;IAqBpE;;;;;;;OAOG;IACG,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,cAAc,GAAG,SAAS,CAAC;IAqB9E;;;;;;;;;;;;OAYG;IACG,kBAAkB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,cAAc,GAAG,SAAS,CAAC;IAO/E;;;;;OAKG;IACG,gBAAgB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,sBAAsB,CAAC;IA6BzE;;;;OAIG;IACH,aAAa,IAAI,wBAAwB;IAIzC;;OAEG;IACH,UAAU,IAAI,IAAI;CAGnB"}

package/dist/setup.d.ts

@@ -1,8 +0,0 @@
-/**
- * Vitest setup file for test environment configuration
- *
- * This file is placed in src/ to satisfy TypeScript's rootDir configuration
- * while remaining in the test environment setup pipeline via vitest.config.ts
- */
-export {};
-//# sourceMappingURL=setup.d.ts.map

package/dist/setup.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../src/setup.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}

package/dist/signing/eip712.d.ts

@@ -1,13 +0,0 @@
-import type { EIP712Types } from './types';
-/**
- * Generate the recursive EIP-712 types used by launchpad bundle writes.
- *
- * Primitive values map to string, uint256, and bool. Nested objects become
- * named structs and arrays use the generated element type.
- *
- * @example
- * const types = generateEIP712Types('BuyWithNative', { amount: '1', exact: true });
- * console.log(types.BuyWithNative);
- */
-export declare function generateEIP712Types(typeName: string, params: Record<string, unknown>): EIP712Types;
-//# sourceMappingURL=eip712.d.ts.map

package/dist/signing/eip712.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"eip712.d.ts","sourceRoot":"","sources":["../../src/signing/eip712.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAmB,MAAM,SAAS,CAAC;AAE5D;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,WAAW,CAuFb"}