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

package/dist/utils/bignumber-pool-cache.d.ts

@@ -1,169 +0,0 @@
-import BigNumber from 'bignumber.js';
-/**
- * Singleton BigNumber cache for performance optimization.
- *
- * Caches BigNumber instances to avoid repeated parsing of the same values.
- * Typical savings: 2-5ms per swap operation by reusing instances.
- *
- * @example
- * ```typescript
- * // Use pre-cached constants
- * const zero = BigNumberPoolCache.ZERO;
- * const minLimit = BigNumberPoolCache.MIN_SQRT_RATIO;
- *
- * // Cache dynamic values
- * const amount = BigNumberPoolCache.getCached('1000000');
- * const amount2 = BigNumberPoolCache.getCached('1000000'); // Same instance!
- *
- * // Memory management (call periodically in long-running processes)
- * BigNumberPoolCache.trimCache(1000); // Keep 1000 most recent entries
- * ```
- *
- * @remarks
- * Thread-safe for read operations (Map is thread-safe for reads).
- * Cache grows unbounded unless trimCache() is called periodically.
- *
- * @see {@link https://github.com/Uniswap/v3-core/blob/main/contracts/libraries/TickMath.sol | Uniswap V3 TickMath}
- */
-export declare class BigNumberPoolCache {
-    /**
-     * Internal cache storage (string key → BigNumber instance)
-     * @internal
-     */
-    private static readonly CACHE;
-    /**
-     * Pre-cached zero constant (most frequently used value)
-     * @constant
-     */
-    static readonly ZERO: BigNumber;
-    /**
-     * Pre-cached one constant (used in arithmetic operations)
-     * @constant
-     */
-    static readonly ONE: BigNumber;
-    /**
-     * Fee denominator for Uniswap V3 (1,000,000 = 1,000,000 pips)
-     * Used for fee calculations: actualFee = feeAmount / FEE_PIPS
-     * @constant
-     * @example
-     * ```typescript
-     * // Calculate 0.3% fee (3000 fee tier)
-     * const fee = new BigNumber(3000).div(BigNumberPoolCache.FEE_PIPS);
-     * // fee = 0.003 (0.3%)
-     * ```
-     */
-    static readonly FEE_PIPS: BigNumber;
-    /**
-     * Minimum sqrt price ratio (corresponds to tick -887272)
-     * Uniswap V3 boundary: sqrtPriceX96 cannot go below this value
-     * @constant
-     * @see {@link https://github.com/Uniswap/v3-core/blob/main/contracts/libraries/TickMath.sol#L10 | Uniswap V3 MIN_TICK}
-     */
-    static readonly MIN_SQRT_RATIO: BigNumber;
-    /**
-     * Maximum sqrt price ratio (corresponds to tick 887272)
-     * Uniswap V3 boundary: sqrtPriceX96 cannot exceed this value
-     * @constant
-     * @see {@link https://github.com/Uniswap/v3-core/blob/main/contracts/libraries/TickMath.sol#L13 | Uniswap V3 MAX_TICK}
-     */
-    static readonly MAX_SQRT_RATIO: BigNumber;
-    /**
-     * Get or create cached BigNumber instance.
-     *
-     * Returns the same instance for identical values (referential equality).
-     * Avoids redundant parsing overhead for frequently used values.
-     *
-     * @param value - Numeric value (string or number)
-     * @returns Cached BigNumber instance
-     *
-     * @example
-     * ```typescript
-     * const a = BigNumberPoolCache.getCached('1000');
-     * const b = BigNumberPoolCache.getCached('1000');
-     * console.log(a === b); // true (same instance)
-     *
-     * const c = BigNumberPoolCache.getCached(1000);
-     * console.log(a === c); // true (number coerced to string key)
-     * ```
-     *
-     * @remarks
-     * - Keys are normalized to strings via `.toString()`
-     * - Cache grows unbounded unless `trimCache()` is called
-     * - O(1) lookup complexity (Map hash table)
-     */
-    static getCached(value: string | number): BigNumber;
-    /**
-     * Clear the entire cache (removes all entries).
-     *
-     * Pre-cached constants (ZERO, ONE, etc.) remain unaffected as they
-     * are static properties, not cache entries.
-     *
-     * @example
-     * ```typescript
-     * BigNumberPoolCache.clearCache();
-     * console.log(BigNumberPoolCache.getCacheStats().size); // 0
-     *
-     * // Constants still work
-     * console.log(BigNumberPoolCache.ZERO.toString()); // "0"
-     * ```
-     *
-     * @remarks
-     * Use sparingly as it discards all cached performance benefits.
-     * Prefer `trimCache()` for periodic memory management.
-     */
-    static clearCache(): void;
-    /**
-     * Get cache statistics for monitoring and debugging.
-     *
-     * @returns Object containing cache size and entry keys
-     *
-     * @example
-     * ```typescript
-     * const stats = BigNumberPoolCache.getCacheStats();
-     * console.log(`Cache size: ${stats.size}`);
-     * console.log(`Keys: ${stats.entries.join(', ')}`);
-     * ```
-     *
-     * @remarks
-     * Useful for performance profiling and memory leak detection.
-     */
-    static getCacheStats(): {
-        size: number;
-        entries: string[];
-    };
-    /**
-     * Trim cache to maximum size (FIFO eviction strategy).
-     *
-     * Keeps the N most recently inserted entries, removes oldest entries.
-     * Designed for long-running processes (arbitrage bots, market makers).
-     *
-     * @param maxSize - Maximum cache entries to retain (default: 1000)
-     *
-     * @example
-     * ```typescript
-     * // Arbitrage bot memory management pattern
-     * let swapCount = 0;
-     * async function executeSwap(params: SwapParams) {
-     *   // ... swap logic using cached BigNumbers ...
-     *
-     *   swapCount++;
-     *   if (swapCount % 100 === 0) {
-     *     BigNumberPoolCache.trimCache(1000); // Keep 1000 hot values
-     *   }
-     * }
-     * ```
-     *
-     * @remarks
-     * - Evicts oldest entries first (Map insertion order preserved)
-     * - Recommended maxSize: 500-2000 for typical trading bots
-     * - Call after every 100-500 operations in hot loops
-     * - Does not affect pre-cached constants
-     */
-    static trimCache(maxSize?: number): void;
-}
-/**
- * Default export for convenience
- * @see {@link BigNumberPoolCache}
- */
-export default BigNumberPoolCache;
-//# sourceMappingURL=bignumber-pool-cache.d.ts.map

package/dist/utils/bignumber-pool-cache.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bignumber-pool-cache.d.ts","sourceRoot":"","sources":["../../src/utils/bignumber-pool-cache.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,cAAc,CAAC;AAKrC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,qBAAa,kBAAkB;IAC7B;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAqC;IAElE;;;OAGG;IACH,MAAM,CAAC,QAAQ,CAAC,IAAI,YAAyB;IAE7C;;;OAGG;IACH,MAAM,CAAC,QAAQ,CAAC,GAAG,YAAyB;IAE5C;;;;;;;;;;OAUG;IACH,MAAM,CAAC,QAAQ,CAAC,QAAQ,YAA+B;IAEvD;;;;;OAKG;IACH,MAAM,CAAC,QAAQ,CAAC,cAAc,YAAoC;IAElE;;;;;OAKG;IACH,MAAM,CAAC,QAAQ,CAAC,cAAc,YAE5B;IAEF;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAUnD;;;;;;;;;;;;;;;;;;OAkBG;IACH,MAAM,CAAC,UAAU,IAAI,IAAI;IAIzB;;;;;;;;;;;;;;OAcG;IACH,MAAM,CAAC,aAAa,IAAI;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAA;KAAE;IAO3D;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,MAAM,CAAC,SAAS,CAAC,OAAO,GAAE,MAAa,GAAG,IAAI;CAU/C;AAED;;;GAGG;AACH,eAAe,kBAAkB,CAAC"}

package/dist/utils/composite-pool-converter.d.ts

@@ -1,121 +0,0 @@
-/**
- * Composite Pool Data Converter
- *
- * Converts raw GalaChain GetCompositePool API responses into properly
- * typed objects with BigNumber conversions for offline calculations.
- *
- * Ported from offline-quote-example/quote-local.mjs createCompositePoolDtoFromResponse()
- *
- * ## Runtime Validation Strategy for Type Assertions
- *
- * This module uses strategic `as any` type assertions to work around dependency
- * version conflicts between @gala-chain/api and @gala-chain/dex. To mitigate
- * risks from type assertions, we employ the following validation strategy:
- *
- * ### Type Assertion Patterns Used
- * 1. **TokenBalance Construction** (lines 78-79, 82-83)
- *    - Assertion: `new TokenBalance(data as unknown)`
- *    - Reason: SDK may have different @gala-chain/api version than @gala-chain/dex
- *    - Runtime Validation: BigNumber.js validates numeric conversions on line 79
- *
- * 2. **TickData Property Assignment** (lines 67-72)
- *    - Assertion: `(tickDataInstance as unknown).propertyName = value`
- *    - Reason: TickData constructor only accepts 2 params; properties are set after
- *    - Runtime Validation: All values are either boolean or BigNumber conversions
- *
- * 3. **CompositePoolDto Construction** (lines 87-91)
- *    - Assertion: `token0Balance as unknown` and `token1Balance as unknown`
- *    - Reason: TokenBalance versions may differ between dependencies
- *    - Runtime Validation: BigNumber.js automatically validates during conversions
- *
- * ### Validation Guarantees
- * - **Numeric Conversions**: BigNumber.js throws when parsing invalid numbers (NaN checks)
- * - **Object Construction**: Pool, TickData, TokenBalance throw on constructor errors
- * - **Property Access**: Type assertions limited to isolated property assignments
- * - **API Contract**: Response structure validated via TypeScript type inference
- *
- * ### When This Strategy Breaks
- * If API response structure changes or contains unexpected data types, errors
- * will occur during BigNumber conversion or object construction with clear
- * error messages indicating what data was invalid.
- *
- * @packageDocumentation
- */
-import { CompositePoolDto } from '@gala-chain/dex';
-import type { CompositePoolDataResult, GetCompositePoolResponse } from '../types/composite-pool.dto';
-/**
- * Convert GetCompositePool API response to CompositePoolDto
- *
- * Critical conversions:
- * - All numeric string fields → BigNumber
- * - Raw tick data → TickData instances
- * - Raw balances → TokenBalance instances
- *
- * ## BigNumber Precision Strategy
- *
- * All numeric fields are converted to BigNumber.js for arbitrary precision arithmetic.
- * This is critical for DeFi operations where precision loss causes calculation errors.
- *
- * **Key Fields Converted:**
- * - Pool properties: sqrtPrice, grossPoolLiquidity, liquidity, feeGrowthGlobal0/1, protocolFees, maxLiquidityPerTick
- * - Tick data: liquidityNet, liquidityGross, feeGrowthOutside0/1
- * - Token balances: quantity field
- *
- * **Precision Characteristics:**
- * - BigNumber.js maintains arbitrary precision (no floating-point errors)
- * - Supports numbers beyond JavaScript's safe integer limit (2^53-1)
- * - Suitable for token amounts with 18+ decimals (GALA, GUSDC, etc.)
- * - No rounding errors in conversions between formats
- *
- * **Use Cases:**
- * - Bonding curve calculations (exponential formulas)
- * - Swap quote computations (multiplication/division intensive)
- * - Tick-based liquidity calculations (high precision required)
- * - Multi-step DeFi operations (error accumulation must be prevented)
- *
- * @param responseData Raw API response data
- * @returns Fully typed CompositePoolDto with BigNumber conversions
- * @throws Error if response data is invalid or missing required fields
- *
- * @example Offline quote calculation with BigNumber precision
- * ```typescript
- * const response = await axios.post(GCP_URL, getCompositePoolDto);
- * const compositePool = createCompositePoolDtoFromResponse(response.data.Data);
- *
- * // All numeric values are BigNumber instances
- * const sqrtPrice = compositePool.pool.sqrtPrice; // BigNumber - no precision loss
- * const liquidity = compositePool.pool.liquidity; // BigNumber - preserves full precision
- *
- * // Safe calculations without floating-point errors
- * const calculatedAmount = liquidity.times(sqrtPrice).dividedBy(someNumber);
- * // Result is still BigNumber with full precision
- * ```
- *
- * @example Accessing pool data safely
- * ```typescript
- * const pool = compositePool.pool;
- *
- * // All these are BigNumber instances - safe for math operations
- * console.log(pool.sqrtPrice.toString()); // Full precision string representation
- * console.log(pool.liquidity.toFixed(0)); // Fixed decimal format
- * console.log(pool.feeGrowthGlobal0.multipliedBy(2)); // Precise multiplication
- * ```
- */
-/**
- * RUNTIME VALIDATION NOTES:
- * This function uses `as any` type assertions only where necessary for dependency
- * compatibility. All type assertions are followed by runtime validation through:
- * - BigNumber construction (throws on NaN or invalid numbers)
- * - Object instantiation (Pool, TickData, TokenBalance throw on errors)
- * - Numeric field assignments (guaranteed via BigNumber.js precision)
- */
-export declare function createCompositePoolDtoFromResponse(responseData: GetCompositePoolResponse['Data']): CompositePoolDto;
-/**
- * Wrap CompositePoolDto with additional metadata
- *
- * @param compositePoolDto Converted CompositePoolDto
- * @param rawResponse Raw response data for reference
- * @returns CompositePoolDataResult with full metadata
- */
-export declare function wrapCompositePoolData(compositePoolDto: CompositePoolDto, _rawResponse: GetCompositePoolResponse['Data']): CompositePoolDataResult;
-//# sourceMappingURL=composite-pool-converter.d.ts.map

package/dist/utils/composite-pool-converter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"composite-pool-converter.d.ts","sourceRoot":"","sources":["../../src/utils/composite-pool-converter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAKH,OAAO,EAAE,gBAAgB,EAAiB,MAAM,iBAAiB,CAAC;AAElE,OAAO,KAAK,EAAE,uBAAuB,EAAC,wBAAwB,EAAE,MAAM,6BAA6B,CAAC;AAGpG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH;;;;;;;GAOG;AACH,wBAAgB,kCAAkC,CAChD,YAAY,EAAE,wBAAwB,CAAC,MAAM,CAAC,GAC7C,gBAAgB,CAoIlB;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,gBAAgB,EAAE,gBAAgB,EAClC,YAAY,EAAE,wBAAwB,CAAC,MAAM,CAAC,GAC7C,uBAAuB,CAczB"}

package/dist/utils/pool-pair-parser.d.ts

@@ -1,57 +0,0 @@
-/**
- * Pool Pair Parser
- *
- * Utilities for parsing poolPair strings from DEX pool discovery into components
- * and converting pipe-delimited token formats to TypeClass objects.
- *
- * @packageDocumentation
- */
-import type { TokenClassKey } from '../types/common';
-/**
- * Parse poolPair string from fetchDexPools() into token0, token1, and fee components
- *
- * Format: "token0/token1/fee"
- * Example: "GALA|Unit|none|none/Token|Unit|BENE|client:5c806869e7fd0e2384461ce9/3000"
- *
- * Each token is in pipe-delimited format: "collection|category|type|additionalKey"
- *
- * @param poolPair Pool pair string from fetchDexPools() result
- * @returns Object with token0, token1 (both in pipe-delimited format), and fee tier
- * @throws Error if poolPair format is invalid
- *
- * @example
- * ```typescript
- * const { token0, token1, fee } = parsePoolPair(
- *   'GALA|Unit|none|none/Token|Unit|BENE|client:123/3000'
- * );
- * // → { token0: 'GALA|Unit|none|none', token1: 'Token|Unit|BENE|client:123', fee: 3000 }
- * ```
- */
-export declare function parsePoolPair(poolPair: string): {
-    token0: string;
-    token1: string;
-    fee: number;
-};
-/**
- * Convert pipe-delimited token string to TokenClassKey object
- *
- * Format: "collection|category|type|additionalKey"
- * Example: "GALA|Unit|none|none" or "Token|Unit|BENE|client:5c806869e7fd0e2384461ce9"
- *
- * Delegates to parsePipeDelimitedToken() from token-parser.ts.
- *
- * @param pipeDelimitedToken Token string in pipe-delimited format
- * @returns TokenClassKey object with all components
- * @throws ValidationError if token format is invalid
- *
- * @example
- * ```typescript
- * const tokenClass = pipeDelimitedToTokenClassKey('GALA|Unit|none|none');
- * // → { collection: 'GALA', category: 'Unit', type: 'none', additionalKey: 'none' }
- *
- * const tokenClass2 = pipeDelimitedToTokenClassKey('Token|Unit|BENE|client:123');
- * // → { collection: 'Token', category: 'Unit', type: 'BENE', additionalKey: 'client:123' }
- * ```
- */
-export declare function pipeDelimitedToTokenClassKey(pipeDelimitedToken: string): TokenClassKey;
-//# sourceMappingURL=pool-pair-parser.d.ts.map

package/dist/utils/pool-pair-parser.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pool-pair-parser.d.ts","sourceRoot":"","sources":["../../src/utils/pool-pair-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAOrD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG;IAC/C,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;CACb,CA4CA;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,4BAA4B,CAAC,kBAAkB,EAAE,MAAM,GAAG,aAAa,CAatF"}

package/dist/utils/pool-state-validator.d.ts

@@ -1,207 +0,0 @@
-/**
- * Pool State Validator
- *
- * Multi-tier validation system for detecting state drift and triggering refetches.
- * Implements three validation levels:
- * - Tier 1: Fast validation (<5ms) - Always run on every swap delta
- * - Tier 2: Moderate validation (~10-15ms) - Run periodically with chain data comparison
- * - Tier 3: Full validation (~50-100ms) - Compare cached state with fresh network fetch
- *
- * @packageDocumentation
- */
-import type { Pool } from '@gala-chain/dex';
-import type BigNumber from 'bignumber.js';
-import type { CompositePoolDataResult } from '../types/composite-pool.dto';
-import type { PoolStateValidationResult, SwapEventData } from '../types/pool-state-delta.dto';
-/**
- * Configuration for pool state validation
- *
- * @category Pool State
- */
-export interface PoolStateValidationConfig {
-    /**
-     * Maximum acceptable drift percentage before triggering refetch
-     * @default 0.001 (0.1%)
-     */
-    maxDriftThreshold: number;
-    /**
-     * Maximum liquidity change percentage allowed in single swap
-     * @default 0.5 (50%)
-     */
-    maxLiquidityChangePct: number;
-    /**
-     * Maximum tick drift allowed between tick and calculated tick from sqrtPrice
-     * @default 1 (allow 1 tick rounding error)
-     */
-    maxTickDrift: number;
-    /**
-     * Maximum tick count difference percentage for full validation
-     * @default 0.1 (10%)
-     */
-    maxTickCountDriftPct: number;
-    /**
-     * Maximum price drift percentage for full validation
-     * @default 0.001 (0.1%)
-     */
-    maxPriceDriftPct: number;
-    /**
-     * Maximum liquidity drift percentage for full validation
-     * @default 0.01 (1.0%)
-     */
-    maxLiquidityDriftPct: number;
-}
-/**
- * Three-tier pool state validation system
- *
- * Provides fast, moderate, and full validation strategies for detecting
- * state drift in cached DEX pool data.
- *
- * @category Pool State
- */
-export declare class PoolStateValidator {
-    private static readonly logger;
-    /**
-     * Default validation configuration
-     */
-    static readonly DEFAULT_CONFIG: PoolStateValidationConfig;
-    /**
-     * Tier 1: Fast validation (<5ms)
-     *
-     * Quick sanity checks run on EVERY swap delta application.
-     * Detects obvious calculation errors immediately without expensive operations.
-     *
-     * Checks:
-     * 1. Price moved in correct direction based on swap direction
-     * 2. Liquidity didn't change drastically (>50% in one swap)
-     * 3. Fee growth never decreased (monotonically increasing)
-     * 4. Protocol fees only increased
-     *
-     * @param originalPool Original pool state before swap
-     * @param updatedPool Pool state after applying swap delta
-     * @param swapEvent The swap event that was applied
-     * @param config Optional validation configuration
-     * @returns true if all critical checks pass, false if errors detected
-     *
-     * @example
-     * ```typescript
-     * const isValid = PoolStateValidator.fastValidation(
-     *   originalPool,
-     *   updatedPool,
-     *   swapEvent
-     * );
-     *
-     * if (!isValid) {
-     *   console.error('Fast validation failed - immediate refetch recommended');
-     * }
-     * ```
-     */
-    static fastValidation(originalPool: Pool, updatedPool: Pool, swapEvent: SwapEventData, config?: PoolStateValidationConfig): boolean;
-    /**
-     * Tier 2: Moderate validation (~10-15ms)
-     *
-     * More expensive validation with actual value comparisons.
-     * Run periodically (e.g., every 10 swaps) or manually.
-     * Compares calculated state with actual chain data when available.
-     *
-     * Checks:
-     * 1. Compare calculated sqrtPrice with actual chain data (if provided)
-     * 2. Verify tick/price consistency
-     * 3. Ensure fee growth is monotonic
-     * 4. Validate liquidity is positive
-     *
-     * @param updatedPool Pool state from calculation
-     * @param swapEvent Original swap event (may contain actual chain data)
-     * @param config Optional validation configuration
-     * @returns Detailed validation result with drift detection
-     *
-     * @example
-     * ```typescript
-     * const result = PoolStateValidator.moderateValidation(
-     *   updatedPool,
-     *   swapEvent,
-     *   { maxDriftThreshold: 0.001 }
-     * );
-     *
-     * if (result.shouldRefetch) {
-     *   console.log(`Refetch recommended: ${result.refetchReason}`);
-     *   console.log(`Drift: ${result.driftPercentage}%`);
-     * }
-     * ```
-     */
-    static moderateValidation(updatedPool: Pool, swapEvent: SwapEventData, config?: PoolStateValidationConfig): PoolStateValidationResult;
-    /**
-     * Tier 3: Full validation (~50-100ms)
-     *
-     * Complete validation by fetching fresh chain data and comparing.
-     * Only run when other validations suggest drift or on-demand.
-     * This is expensive (~50-100ms) so use sparingly.
-     *
-     * Compares:
-     * 1. Price drift between cached and fresh data
-     * 2. Liquidity drift between cached and fresh data
-     * 3. Tick data completeness (missing ticks in cache)
-     *
-     * @param poolKey Pool identifier for logging
-     * @param cachedPoolData Current cached pool state
-     * @param fetchFn Async function that fetches fresh pool data from chain
-     * @returns Detailed validation result with drift analysis
-     *
-     * @example
-     * ```typescript
-     * const result = await PoolStateValidator.fullValidation(
-     *   'GALA-BENE-3000',
-     *   cachedPoolData,
-     *   async () => await sdk.fetchCompositePoolData({
-     *     token0: 'GALA|Unit|none|none',
-     *     token1: 'Token|Unit|BENE|client:123',
-     *     fee: 3000
-     *   })
-     * );
-     *
-     * if (result.shouldRefetch) {
-     *   // Use fresh data from fetchFn result
-     *   console.log(`Validation errors: ${result.validationErrors}`);
-     * }
-     * ```
-     */
-    static fullValidation(poolKey: string, cachedPoolData: CompositePoolDataResult, fetchFn: () => Promise<CompositePoolDataResult>): Promise<PoolStateValidationResult>;
-    /**
-     * Calculate percentage difference between two values
-     *
-     * @param calculated Calculated/cached value
-     * @param actual Actual chain value
-     * @returns Percentage difference (0.5 = 0.5%)
-     *
-     * @example
-     * ```typescript
-     * const drift = PoolStateValidator.calculateDriftPercentage(
-     *   new BigNumber('1000'),
-     *   new BigNumber('1005')
-     * );
-     * console.log(`Drift: ${drift}%`); // "Drift: 0.5%"
-     * ```
-     */
-    static calculateDriftPercentage(calculated: BigNumber, actual: BigNumber): number;
-    /**
-     * Build a PoolStateValidationResult object
-     *
-     * @param isValid Whether validation passed
-     * @param driftPercentage Drift detected (as percentage)
-     * @param shouldRefetch Whether refetch is recommended
-     * @param errors Array of error messages
-     * @returns Structured validation result
-     *
-     * @example
-     * ```typescript
-     * const result = PoolStateValidator.buildValidationResult(
-     *   false,
-     *   1.5,
-     *   true,
-     *   ['Price drift exceeded threshold']
-     * );
-     * console.log(result.refetchReason); // 'drift'
-     * ```
-     */
-    static buildValidationResult(isValid: boolean, driftPercentage: number, shouldRefetch: boolean, errors?: string[]): PoolStateValidationResult;
-}
-//# sourceMappingURL=pool-state-validator.d.ts.map

package/dist/utils/pool-state-validator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pool-state-validator.d.ts","sourceRoot":"","sources":["../../src/utils/pool-state-validator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAE5C,OAAO,KAAK,SAAS,MAAM,cAAc,CAAC;AAE1C,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AAC3E,OAAO,KAAK,EACV,yBAAyB,EACzB,aAAa,EACd,MAAM,+BAA+B,CAAC;AAMvC;;;;GAIG;AACH,MAAM,WAAW,yBAAyB;IACxC;;;OAGG;IACH,iBAAiB,EAAE,MAAM,CAAC;IAE1B;;;OAGG;IACH,qBAAqB,EAAE,MAAM,CAAC;IAE9B;;;OAGG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB;;;OAGG;IACH,oBAAoB,EAAE,MAAM,CAAC;IAE7B;;;OAGG;IACH,gBAAgB,EAAE,MAAM,CAAC;IAEzB;;;OAGG;IACH,oBAAoB,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;;;GAOG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAG3B;IAEH;;OAEG;IACH,MAAM,CAAC,QAAQ,CAAC,cAAc,EAAE,yBAAyB,CAOvD;IAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,MAAM,CAAC,cAAc,CACnB,YAAY,EAAE,IAAI,EAClB,WAAW,EAAE,IAAI,EACjB,SAAS,EAAE,aAAa,EACxB,MAAM,GAAE,yBAA6D,GACpE,OAAO;IAqHV;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,MAAM,CAAC,kBAAkB,CACvB,WAAW,EAAE,IAAI,EACjB,SAAS,EAAE,aAAa,EACxB,MAAM,GAAE,yBAA6D,GACpE,yBAAyB;IA4E5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;WACU,cAAc,CACzB,OAAO,EAAE,MAAM,EACf,cAAc,EAAE,uBAAuB,EACvC,OAAO,EAAE,MAAM,OAAO,CAAC,uBAAuB,CAAC,GAC9C,OAAO,CAAC,yBAAyB,CAAC;IA4ErC;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CAAC,wBAAwB,CAAC,UAAU,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,GAAG,MAAM;IAYjF;;;;;;;;;;;;;;;;;;;OAmBG;IACH,MAAM,CAAC,qBAAqB,CAC1B,OAAO,EAAE,OAAO,EAChB,eAAe,EAAE,MAAM,EACvB,aAAa,EAAE,OAAO,EACtB,MAAM,GAAE,MAAM,EAAO,GACpB,yBAAyB;CAsC7B"}