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

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

@@ -1,176 +0,0 @@
-/**
- * Pool State Manager
- *
- * Orchestrates efficient pool state tracking through incremental swap deltas
- * instead of full refetches. Provides the main API for arbitrage bots and other
- * applications needing real-time pool state with minimal network latency.
- *
- * Core features:
- * - Cached pool state with incremental updates (10-15x faster than full refetches)
- * - Automatic validation and drift detection
- * - Graceful fallback to full refetch on errors
- * - Performance monitoring and metrics
- * - Support for both exact input and exact output swaps
- *
- * Performance: ~30-50ms per swap (vs 200-400ms for full refetch)
- *
- * @packageDocumentation
- */
-import type { Pool, TickData } from '@gala-chain/dex';
-import BigNumber from 'bignumber.js';
-import type { CompositePoolDataResult } from '../types/composite-pool.dto';
-import type { PoolStateMetadata, SwapDeltaResult, SwapEventData } from '../types/pool-state-delta.dto';
-import { LoggerBase } from './BaseService';
-/**
- * Configuration for PoolStateManager behavior
- *
- * @category Pool State Manager
- */
-export interface PoolStateManagerConfig {
-    /** Safety limit for maximum iterations in swap calculation (default: 100) */
-    maxIterations?: number;
-    /** Enable BigNumber cache for performance (default: true) */
-    enableBigNumberCache?: boolean;
-    /** BigNumber rounding mode (default: ROUND_DOWN) */
-    roundingMode?: BigNumber.RoundingMode;
-    /** Enable debug logging (default: false) */
-    debug?: boolean;
-    /** Maximum swaps to apply before forcing full refetch (default: 50) */
-    maxSwapsSinceRefetch?: number;
-    /** Maximum cumulative drift percentage before forcing refetch (default: 5%) */
-    maxCumulativeDrift?: number;
-    /**
-     * Callback for when full refetch is needed
-     * Allows client to provide fresh pool data when drift accumulates
-     */
-    onRefetchNeeded?: (pool: Pool, tickDataMap: Record<string, TickData>) => Promise<CompositePoolDataResult>;
-    /**
-     * Enable strict validation mode (default: false)
-     * Throws errors instead of warnings for validation failures
-     */
-    strictValidation?: boolean;
-    /** Enable performance warnings when swap calculation exceeds threshold (default: true) */
-    enablePerformanceWarnings?: boolean;
-    /** Performance warning threshold in milliseconds (default: 100ms) */
-    performanceWarningThreshold?: number;
-}
-/**
- * Efficient pool state manager using incremental swap deltas
- *
- * Main orchestrator for the monkey-patching strategy that avoids full pool refetches.
- * Coordinates SwapDeltaCalculator, PoolStateValidator, and other utilities to provide
- * a fast, accurate view of pool state with minimal network calls.
- *
- * Usage:
- * ```typescript
- * const manager = new PoolStateManager(compositePoolData, config);
- *
- * // Apply swaps incrementally (fast - ~30-50ms)
- * const result = await manager.applySwapDelta(swapEvent);
- *
- * // Get current pool state
- * const currentPool = manager.getPoolState();
- * const metadata = manager.getMetadata();
- * ```
- *
- * @category Pool State Manager
- * @since 3.33.0
- */
-export declare class PoolStateManager extends LoggerBase {
-    private readonly config;
-    private readonly validationConfig;
-    /** Current cached pool state */
-    private pool;
-    /** Current tick data map */
-    private tickDataMap;
-    /** Metadata about cache state and drift tracking */
-    private metadata;
-    /** Performance metrics for last swap */
-    private lastSwapMetrics?;
-    /**
-     * Calculate hash of critical pool state for validation
-     *
-     * @param pool Pool to hash
-     * @returns Hash string of pool state
-     */
-    private static calculatePoolStateHash;
-    /**
-     * Initialize PoolStateManager with initial pool state
-     *
-     * @param poolData Initial composite pool data (from fetchCompositePoolData)
-     * @param config Optional configuration overrides
-     * @throws Error if poolData is invalid
-     */
-    constructor(poolData: CompositePoolDataResult, config?: PoolStateManagerConfig);
-    /**
-     * Apply a swap delta to the cached pool state
-     *
-     * Calculates how the swap affects pool state, validates the result,
-     * and updates the cache incrementally. Much faster than full refetch.
-     *
-     * @param swapEvent The swap event to apply
-     * @returns Result with updated pool state and metadata
-     * @throws Error if swap calculation or validation fails (in strict mode)
-     */
-    applySwapDelta(swapEvent: SwapEventData): Promise<SwapDeltaResult>;
-    /**
-     * Force a full refetch of pool state
-     *
-     * Resets all drift tracking and reloads pool state from the provided data.
-     * Use this after receiving a full fetchCompositePoolData response.
-     *
-     * @param poolData Fresh pool data from fetchCompositePoolData
-     */
-    forceFullRefetch(poolData: CompositePoolDataResult): void;
-    /**
-     * Get current pool state
-     *
-     * @returns Current cached Pool object
-     */
-    getPoolState(): Pool;
-    /**
-     * Get current tick data
-     *
-     * @returns Copy of current tick data map
-     */
-    getTickDataMap(): Record<string, TickData>;
-    /**
-     * Get metadata about cache state
-     *
-     * @returns Current PoolStateMetadata
-     */
-    getMetadata(): PoolStateMetadata;
-    /**
-     * Get performance metrics from last swap
-     *
-     * @returns Performance metrics or undefined if no swap applied yet
-     */
-    getLastSwapMetrics(): {
-        calculationTimeMs: number;
-        swapSteps: number;
-        timestamp: number;
-    } | undefined;
-    /**
-     * Check if a full refetch is recommended
-     *
-     * @returns true if drift or swap count thresholds exceeded
-     */
-    isRefetchRecommended(): boolean;
-    /**
-     * Reset the manager to initial state (clears all cached data)
-     *
-     * @param poolData Initial pool data to reload
-     */
-    reset(poolData: CompositePoolDataResult): void;
-}
-/**
- * Factory function for creating a PoolStateManager instance
- *
- * Simplifies initialization by bundling common configuration.
- *
- * @param poolData Initial pool data
- * @param options Configuration options
- * @returns New PoolStateManager instance
- */
-export declare function createPoolStateManager(poolData: CompositePoolDataResult, options?: PoolStateManagerConfig): PoolStateManager;
-//# sourceMappingURL=PoolStateManager.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"PoolStateManager.d.ts","sourceRoot":"","sources":["../../../src/services/PoolStateManager.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,SAAS,MAAM,cAAc,CAAC;AAErC,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AAC3E,OAAO,KAAK,EACV,iBAAiB,EACjB,eAAe,EACf,aAAa,EACd,MAAM,+BAA+B,CAAC;AAWvC,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C;;;;GAIG;AACH,MAAM,WAAW,sBAAsB;IACrC,6EAA6E;IAC7E,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB,6DAA6D;IAC7D,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAE/B,oDAAoD;IACpD,YAAY,CAAC,EAAE,SAAS,CAAC,YAAY,CAAC;IAEtC,4CAA4C;IAC5C,KAAK,CAAC,EAAE,OAAO,CAAC;IAEhB,uEAAuE;IACvE,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAE9B,+EAA+E;IAC/E,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAE5B;;;OAGG;IACH,eAAe,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,KAAK,OAAO,CAAC,uBAAuB,CAAC,CAAC;IAE1G;;;OAGG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAE3B,0FAA0F;IAC1F,yBAAyB,CAAC,EAAE,OAAO,CAAC;IAEpC,qEAAqE;IACrE,2BAA2B,CAAC,EAAE,MAAM,CAAC;CACtC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,gBAAiB,SAAQ,UAAU;IAC9C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAErB;IACF,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAA4B;IAE7D,gCAAgC;IAChC,OAAO,CAAC,IAAI,CAAO;IAEnB,4BAA4B;IAC5B,OAAO,CAAC,WAAW,CAA2B;IAE9C,oDAAoD;IACpD,OAAO,CAAC,QAAQ,CAAoB;IAEpC,wCAAwC;IACxC,OAAO,CAAC,eAAe,CAAC,CAItB;IAEF;;;;;OAKG;IACH,OAAO,CAAC,MAAM,CAAC,sBAAsB;IAKrC;;;;;;OAMG;gBACS,QAAQ,EAAE,uBAAuB,EAAE,MAAM,CAAC,EAAE,sBAAsB;IAiE9E;;;;;;;;;OASG;IACG,cAAc,CAAC,SAAS,EAAE,aAAa,GAAG,OAAO,CAAC,eAAe,CAAC;IAuKxE;;;;;;;OAOG;IACH,gBAAgB,CAAC,QAAQ,EAAE,uBAAuB,GAAG,IAAI;IAYzD;;;;OAIG;IACH,YAAY,IAAI,IAAI;IAIpB;;;;OAIG;IACH,cAAc,IAAI,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC;IAI1C;;;;OAIG;IACH,WAAW,IAAI,iBAAiB;IAIhC;;;;OAIG;IACH,kBAAkB,IAAI;QAAE,iBAAiB,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS;IAOrG;;;;OAIG;IACH,oBAAoB,IAAI,OAAO;IAO/B;;;;OAIG;IACH,KAAK,CAAC,QAAQ,EAAE,uBAAuB,GAAG,IAAI;CAgB/C;AAED;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,uBAAuB,EACjC,OAAO,CAAC,EAAE,sBAAsB,GAC/B,gBAAgB,CAElB"}

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

@@ -1,207 +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, and cursor-based 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 - Migrated to cursor-based 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 needed - this method handles it internally using cursor-based pagination.
-     *
-     * 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 - Migrated to cursor-based 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;
-}
-//# sourceMappingURL=PriceHistoryService.d.ts.map

package/dist/src/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,EAEV,wBAAwB,EACxB,kBAAkB,EACJ,MAAM,2BAA2B,CAAC;AAMlD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAQhD,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;IAoFvF;;;OAGG;IACH,OAAO,CAAC,kCAAkC;IAmE1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;CA4BxB"}

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

@@ -1,80 +0,0 @@
-/**
- * Restricted Names Service (v7.0.0+)
- *
- * Service for managing restricted token names via the simplified GET/PUT API.
- *
- * @category Services
- * @since 7.0.0
- */
-import type { JwtAuth } from '../auth/JwtAuth';
-import type { GetRestrictedNamesResult, UpdateRestrictedNamesRequest, UpdateRestrictedNamesResult } from '../types/restricted-names.dto';
-import type { HttpClient } from '../utils/http';
-import { StreamTokenServiceBase } from './StreamTokenServiceBase';
-/**
- * Restricted Names Service Class
- *
- * Provides methods for:
- * - Getting the restricted token names content (Overseer only)
- * - Updating the restricted token names content (Overseer only)
- *
- * The content is stored as newline-separated words for simplicity.
- *
- * @example
- * ```typescript
- * const restrictedNamesService = new RestrictedNamesService(httpClient, undefined, jwtAuth);
- *
- * // Get restricted names (Overseer only)
- * const result = await restrictedNamesService.getRestrictedNames();
- * if (result.success) {
- *   const words = result.data.content.split('\n').filter(w => w.trim());
- *   console.log('Restricted words:', words);
- * }
- *
- * // Update restricted names (Overseer only)
- * const updated = await restrictedNamesService.updateRestrictedNames({
- *   content: 'scam\nrug\nfake\nfraud\n'
- * });
- * if (updated.success) {
- *   console.log('Restricted names updated');
- * }
- * ```
- */
-export declare class RestrictedNamesService extends StreamTokenServiceBase {
-    constructor(httpClient: HttpClient, _launchpadApiUrl: string | undefined, jwtAuth: JwtAuth | undefined, userApiKey?: string);
-    /**
-     * Get the restricted token names content (Overseer only)
-     *
-     * @returns Promise resolving to the restricted names response or error
-     *
-     * @example
-     * ```typescript
-     * const result = await service.getRestrictedNames();
-     * if (result.success) {
-     *   console.log(result.data.content); // "scam\nrug\nfake\n..."
-     * }
-     * ```
-     */
-    getRestrictedNames(): Promise<GetRestrictedNamesResult>;
-    /**
-     * Update the restricted token names content (Overseer only)
-     *
-     * Replaces the entire list with newline-separated words.
-     *
-     * @param request - Request containing newline-separated content
-     * @returns Promise resolving to success or error
-     *
-     * @throws {ValidationError} If content is not provided or invalid
-     *
-     * @example
-     * ```typescript
-     * const result = await service.updateRestrictedNames({
-     *   content: 'scam\nrug\nfake\nfraud'
-     * });
-     * if (result.success) {
-     *   console.log('Updated successfully');
-     * }
-     * ```
-     */
-    updateRestrictedNames(request: UpdateRestrictedNamesRequest): Promise<UpdateRestrictedNamesResult>;
-}
-//# sourceMappingURL=RestrictedNamesService.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"RestrictedNamesService.d.ts","sourceRoot":"","sources":["../../../src/services/RestrictedNamesService.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAE/C,OAAO,KAAK,EAEV,wBAAwB,EACxB,4BAA4B,EAE5B,2BAA2B,EAC5B,MAAM,+BAA+B,CAAC;AAEvC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAElE;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,qBAAa,sBAAuB,SAAQ,sBAAsB;gBAE9D,UAAU,EAAE,UAAU,EACtB,gBAAgB,EAAE,MAAM,GAAG,SAAS,EACpC,OAAO,EAAE,OAAO,GAAG,SAAS,EAC5B,UAAU,CAAC,EAAE,MAAM;IAKrB;;;;;;;;;;;;OAYG;IACG,kBAAkB,IAAI,OAAO,CAAC,wBAAwB,CAAC;IAmB7D;;;;;;;;;;;;;;;;;;;OAmBG;IACG,qBAAqB,CACzB,OAAO,EAAE,4BAA4B,GACpC,OAAO,CAAC,2BAA2B,CAAC;CAwBxC"}

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

@@ -1,113 +0,0 @@
-/**
- * EIP-712 Signature Service for Bonding Curve Transactions
- *
- * This service handles EIP-712 signature generation for bonding curve operations
- * using ethers.js Wallet. It replicates the exact signature generation process
- * used in the frontend to ensure compatibility with the GalaChain backend.
- *
- * ## Supported Signing Method:
- * - ethers.js Wallet (signTypedData)
- *
- * ## Key Features:
- * - Dynamic EIP-712 type generation
- * - Personal sign prefix calculation
- * - Full compatibility with GalaChain backend
- *
- * @category Services
- * @since 2.0.0
- */
-import { LoggerBase } from './BaseService';
-/**
- * EIP-712 Types structure for typed data signing
- */
-type EIP712Types = Record<string, Array<{
-    name: string;
-    type: string;
-}>>;
-/**
- * Wallet provider interface for signing operations
- */
-export interface WalletProvider {
-    signTypedData?: (domain: EIP712Domain, types: EIP712Types, payload: Record<string, unknown>) => Promise<string>;
-    signMessage?: (message: string) => Promise<string>;
-    getNetwork?: () => Promise<{
-        name: string;
-        chainId: number | bigint;
-    }>;
-}
-/**
- * DTO type for chain calls (extends ChainCallDTO pattern)
- */
-type SignableDTO = Record<string, unknown>;
-/**
- * Domain structure for EIP-712
- */
-interface EIP712Domain {
-    name: string;
-    chainId: number;
-}
-/**
- * Service for handling EIP-712 signatures for bonding curve operations
- */
-export declare class SignatureService extends LoggerBase {
-    private walletProvider;
-    constructor(walletProvider: WalletProvider, debug?: boolean);
-    /**
-     * Sign DTO using EIP-712 typed data signature
-     *
-     * Generates a cryptographic signature for a bonding curve transaction DTO using EIP-712
-     * standard. The signature proves ownership and authorizes the transaction without revealing
-     * the private key. Includes personal sign prefix calculation for replay protection.
-     *
-     * **Process**:
-     * 1. Generate EIP-712 types from DTO structure
-     * 2. Calculate personal sign prefix (replay protection)
-     * 3. Sign with ethers.js Wallet (signTypedData)
-     * 4. Return augmented DTO with signature, types, and domain
-     *
-     * **Compatibility**: Matches frontend signature generation exactly.
-     *
-     * @param dto DTO to sign (ChainCallDTO-compatible object)
-     * @param methodName Method name for EIP-712 type generation (e.g., 'LaunchTokenDTO')
-     * @param _walletAddress User's wallet address (unused, kept for compatibility)
-     * @returns Promise resolving to signed DTO with signature, types, and domain fields
-     * @throws Error if wallet provider doesn't support typed data signing
-     * @category Cryptography
-     * @since 2.0.0
-     *
-     * @example Sign buy transaction DTO
-     * ```typescript
-     * const signedDTO = await signatureService.signDTO(
-     *   {
-     *     tokenName: 'anime',
-     *     amount: '1000',
-     *     slippageTolerance: '0.01'
-     *   },
-     *   'BuyTokenDTO',
-     *   'eth|1234...'
-     * );
-     * console.log('Signature:', signedDTO.signature);
-     * // Ready for bundle submission
-     * ```
-     */
-    signDTO(dto: SignableDTO, methodName: string, _walletAddress: string): Promise<SignableDTO & {
-        signature: string;
-        types?: EIP712Types;
-        domain?: EIP712Domain;
-    }>;
-    /**
-     * Sign with ethers.js Wallet using signTypedData
-     *
-     * Supports both direct ethers.js Wallet instances and Web3 providers
-     * with dynamic network detection capabilities.
-     */
-    private signWithEthersWallet;
-    /**
-     * Generate EIP-712 types from DTO structure
-     * Dynamically creates type definitions based on DTO fields
-     * EXACTLY matches frontend implementation from readWriteUtils.ts
-     */
-    private generateEIP712Types;
-}
-export {};
-//# sourceMappingURL=SignatureService.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"SignatureService.d.ts","sourceRoot":"","sources":["../../../src/services/SignatureService.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAWH,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C;;GAEG;AACH,KAAK,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC,CAAC;AAEzE;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,YAAY,EAAE,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IAChH,WAAW,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACnD,UAAU,CAAC,EAAE,MAAM,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC,CAAC;CACxE;AAED;;GAEG;AACH,KAAK,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAE3C;;GAEG;AACH,UAAU,YAAY;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,qBAAa,gBAAiB,SAAQ,UAAU;IAE5C,OAAO,CAAC,cAAc;gBAAd,cAAc,EAAE,cAAc,EACtC,KAAK,GAAE,OAAe;IAKxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqCG;IACG,OAAO,CACX,GAAG,EAAE,WAAW,EAChB,UAAU,EAAE,MAAM,EAClB,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,WAAW,GAAG;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,WAAW,CAAC;QAAC,MAAM,CAAC,EAAE,YAAY,CAAA;KAAE,CAAC;IAoC3F;;;;;OAKG;YACW,oBAAoB;IA8ClC;;;;OAIG;IACH,OAAO,CAAC,mBAAmB;CA+F5B"}