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

package/dist/services/PoolStateManager.d.ts

@@ -0,0 +1,176 @@
+/**
+ * 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/services/PoolStateManager.d.ts.map

@@ -0,0 +1 @@
+{"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/services/PriceHistoryService.d.ts

@@ -0,0 +1,207 @@
+/**
+ * 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/services/PriceHistoryService.d.ts.map

@@ -0,0 +1 @@
+{"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/services/RestrictedNamesService.d.ts

@@ -0,0 +1,80 @@
+/**
+ * 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/services/RestrictedNamesService.d.ts.map

@@ -0,0 +1 @@
+{"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/services/SignatureService.d.ts

@@ -0,0 +1,113 @@
+/**
+ * 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/services/SignatureService.d.ts.map

@@ -0,0 +1 @@
+{"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"}