@gala-chain/launchpad-sdk 5.0.2-beta.1 → 5.0.4-beta.0

package/dist/src/utils/bignumber-helpers.d.ts

@@ -86,25 +86,21 @@ export declare function calculateSlippageAdjustedAmount(estimatedOutput: string
  */
 export declare function calculateSlippageFactor(tolerance?: number): BigNumber;
 /**
- * Convert tick to sqrt ratio for liquidity calculations
+ * Calculate inverse slippage factor (1 + tolerance)
  *
- * Re-exports tickToSqrtPrice from @gala-chain/dex for Uniswap V3 liquidity calculations.
- * Maintained as a wrapper for backward compatibility.
+ * Consolidates: `new BigNumber(1).plus(tolerance)`
+ * Used for upper bound slippage calculations (e.g., maximum acceptable price).
  *
- * @param tick The tick value from the pool
- * @returns Sqrt price in Q64.96 format
+ * @param tolerance Slippage tolerance as decimal (e.g., 0.01 for 1%)
+ * @returns Inverse slippage factor (e.g., 1.01 for 1% tolerance)
  *
  * @example
  * ```typescript
- * const lowerSqrtRatio = tickToSqrtRatio(tickLower);
- * const upperSqrtRatio = tickToSqrtRatio(tickUpper);
- * const liquidityNeeded = calculateLiquidity(lowerSqrtRatio, upperSqrtRatio, ...);
+ * const upperFactor = calculateInverseSlippageFactor(0.01);  // BigNumber(1.01)
+ * const maxPrice = currentPrice.multipliedBy(upperFactor);
  * ```
- *
- * @deprecated This is a wrapper around @gala-chain/dex's tickToSqrtPrice.
- * Consider importing tickToSqrtPrice directly for new code.
  */
-export declare function tickToSqrtRatio(tick: number): BigNumber;
+export declare function calculateInverseSlippageFactor(tolerance?: number): BigNumber;
 /**
  * Convert a price to tick (Uniswap V3 math)
  *
@@ -229,6 +225,36 @@ export declare function isPositive(value: string | number | BigNumber): boolean;
  * @returns true if value < 0
  */
 export declare function isNegative(value: string | number | BigNumber): boolean;
+/**
+ * Check if a value is greater than a threshold
+ *
+ * @param value The value to check
+ * @param threshold The threshold to compare against
+ * @returns true if value > threshold
+ *
+ * @example
+ * ```typescript
+ * if (isGreaterThan(balance, '0')) {
+ *   // user has funds
+ * }
+ * ```
+ */
+export declare function isGreaterThan(value: string | number | BigNumber, threshold: string | number | BigNumber): boolean;
+/**
+ * Check if a value is less than a threshold
+ *
+ * @param value The value to check
+ * @param threshold The threshold to compare against
+ * @returns true if value < threshold
+ *
+ * @example
+ * ```typescript
+ * if (isLessThan(balance, minRequired)) {
+ *   throw new Error('Insufficient balance');
+ * }
+ * ```
+ */
+export declare function isLessThan(value: string | number | BigNumber, threshold: string | number | BigNumber): boolean;
 /**
  * Check if value is between two bounds (inclusive)
  *
@@ -293,6 +319,7 @@ export declare function decreaseByPercentage(value: string | number | BigNumber,
  *
  * @param values The values to validate
  * @throws Error if any value is not positive
+ * @internal
  *
  * @example
  * ```typescript
@@ -309,6 +336,7 @@ export declare function requirePositive(...values: BigNumber[]): void;
  *
  * @param values The values to validate
  * @throws Error if any value is negative
+ * @internal
  *
  * @example
  * ```typescript
@@ -326,6 +354,7 @@ export declare function requireNonNegative(...values: BigNumber[]): void;
  * @param paramName The parameter name for the error message
  * @param context Optional additional context (e.g., "for swap operation")
  * @throws Error with descriptive message if value is not positive
+ * @internal
  *
  * @example
  * ```typescript
@@ -336,5 +365,82 @@ export declare function requireNonNegative(...values: BigNumber[]): void;
  * // Throws: "liquidity must be positive, got: -1"
  * ```
  */
-export declare function requirePositiveWithContext(value: BigNumber, paramName: string, context?: string): void;
+export declare function requirePositiveWithContext(value: BigNumber, paramName: string, _context?: string): void;
+/**
+ * Safe division with fallback for zero denominator
+ *
+ * Prevents division by zero errors by returning a fallback value when
+ * the denominator is zero. Replaces the common pattern:
+ * `isZero(denominator) ? fallback : numerator.dividedBy(denominator)`
+ *
+ * @param numerator The dividend
+ * @param denominator The divisor
+ * @param fallback Value to return if denominator is zero (default: "0")
+ * @returns The quotient, or fallback if denominator is zero
+ *
+ * @example
+ * ```typescript
+ * // Calculate ratio with fallback
+ * const ratio = safeDivide(token0Amount, token1Amount, toBigNumber(0));
+ *
+ * // Use in slippage calculations
+ * const slippage = safeDivide(difference, originalAmount);
+ *
+ * // Pool calculations with custom fallback
+ * const fee = safeDivide(feeAmount, totalVolume, toBigNumber('0.0001'));
+ * ```
+ */
+export declare function safeDivide(numerator: string | number | BigNumber, denominator: string | number | BigNumber, fallback?: string | number | BigNumber): BigNumber;
+/**
+ * Round a Uniswap V3 tick to a valid spacing multiple
+ *
+ * Uniswap V3 ticks must be multiples of tickSpacing (e.g., 1, 10, 60, 200).
+ * This utility rounds down to the nearest valid tick spacing using integer arithmetic.
+ *
+ * Formula: `Math.floor(tick / tickSpacing) * tickSpacing`
+ *
+ * @param tick The tick value to round
+ * @param tickSpacing The tick spacing (e.g., 1, 10, 60, 200)
+ * @returns The rounded tick (multiple of tickSpacing)
+ *
+ * @example
+ * ```typescript
+ * // Round tick 1055 to nearest tick spacing of 10
+ * const rounded = roundTickToSpacing(1055, 10);  // 1050
+ *
+ * // Round tick 101 to spacing 60
+ * const rounded = roundTickToSpacing(101, 60);   // 60
+ *
+ * // Negative ticks are also supported
+ * const rounded = roundTickToSpacing(-1055, 10); // -1060
+ * ```
+ */
+export declare function roundTickToSpacing(tick: number, tickSpacing: number): number;
+/**
+ * Calculate reverse bonding curve fee amount with precision handling
+ *
+ * Consolidates the pattern of applying a fee factor to a base amount with
+ * integer rounding (down). Used extensively in bonding curve calculations
+ * for reverse fee computation and scaled amount operations.
+ *
+ * Formula: `new BigNumber(baseAmount).multipliedBy(feeFactor).integerValue(BigNumber.ROUND_DOWN)`
+ *
+ * @param baseAmount The base amount to apply fee factor to (string, number, or BigNumber)
+ * @param feeFactor The fee factor as decimal (e.g., 0.1 for 10%, 0.005 for 0.5%)
+ * @returns The scaled fee amount (rounded down to integer)
+ *
+ * @example
+ * ```typescript
+ * // Calculate 1% fee on 1000 GALA
+ * const baseAmount = new BigNumber('1000');
+ * const fee = calculateScaledFeeAmount(baseAmount, 0.01);  // BigNumber(10)
+ *
+ * // Calculate 0.5% reverse bonding curve fee
+ * const feeAmount = calculateScaledFeeAmount('5000', 0.005);  // BigNumber(25)
+ *
+ * // Fee factor from pool: reverseBondingCurveFee = 0.123456
+ * const reversed = calculateScaledFeeAmount(amount, reverseBondingCurveFee);
+ * ```
+ */
+export declare function calculateScaledFeeAmount(baseAmount: string | number | BigNumber, feeFactor: number): BigNumber;
 //# sourceMappingURL=bignumber-helpers.d.ts.map

package/dist/src/utils/bignumber-helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bignumber-helpers.d.ts","sourceRoot":"","sources":["../../../src/utils/bignumber-helpers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,SAAS,MAAM,cAAc,CAAC;AAGrC;;;;;;;;;;;;GAYG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG,SAAS,EACrD,YAAY,GAAE,MAAM,GAAG,MAAY,GAClC,SAAS,CAKX;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG,SAAS,EACrD,QAAQ,CAAC,EAAE,MAAM,GAChB,MAAM,CAER;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,+BAA+B,CAC7C,eAAe,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,EAC5C,iBAAiB,GAAE,MAAa,GAC/B,SAAS,CAIX;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,uBAAuB,CAAC,SAAS,GAAE,MAAa,GAAG,SAAS,CAE3E;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAGvD;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,MAAM,CAWtE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,EAClC,OAAO,GAAE,OAAe,GACvB,SAAS,GAAG,MAAM,CAIpB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,IAAI,SAAS,CAE1C;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAC1B,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,EAC9B,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,GAC7B,SAAS,CAEX;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAC1B,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,EAC9B,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,GAC7B,SAAS,CAEX;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,OAAO,CAElE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,OAAO,CAEtE;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,OAAO,CAEtE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,EAClC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,EAChC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,GAC/B,OAAO,CAKT;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,EAClC,UAAU,EAAE,MAAM,GACjB,SAAS,CAEX;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,EAClC,UAAU,EAAE,MAAM,GACjB,SAAS,CAEX;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,EAClC,UAAU,EAAE,MAAM,GACjB,SAAS,CAEX;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,eAAe,CAAC,GAAG,MAAM,EAAE,SAAS,EAAE,GAAG,IAAI,CAqB5D;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,MAAM,EAAE,SAAS,EAAE,GAAG,IAAI,CAqB/D;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,SAAS,EAChB,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,MAAM,GACf,IAAI,CAmBN"}
+{"version":3,"file":"bignumber-helpers.d.ts","sourceRoot":"","sources":["../../../src/utils/bignumber-helpers.ts"],"names":[],"mappings":"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"}

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

@@ -1 +1 @@
-{"version":3,"file":"bignumber-pool-cache.d.ts","sourceRoot":"","sources":["../../../src/utils/bignumber-pool-cache.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,cAAc,CAAC;AAErC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,qBAAa,kBAAkB;IAC7B;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAqC;IAElE;;;OAGG;IACH,MAAM,CAAC,QAAQ,CAAC,IAAI,YAAoB;IAExC;;;OAGG;IACH,MAAM,CAAC,QAAQ,CAAC,GAAG,YAAoB;IAEvC;;;;;;;;;;OAUG;IACH,MAAM,CAAC,QAAQ,CAAC,QAAQ,YAA0B;IAElD;;;;;OAKG;IACH,MAAM,CAAC,QAAQ,CAAC,cAAc,YAA+B;IAE7D;;;;;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"}
+{"version":3,"file":"bignumber-pool-cache.d.ts","sourceRoot":"","sources":["../../../src/utils/bignumber-pool-cache.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,cAAc,CAAC;AAIrC;;;;;;;;;;;;;;;;;;;;;;;;;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/src/utils/bondingCurveCalculations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bondingCurveCalculations.d.ts","sourceRoot":"","sources":["../../../src/utils/bondingCurveCalculations.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAGH,OAAO,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AAGjE;;;;;;;GAOG;AACH,qBAAa,sBAAsB;IACjC;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,MAAM,CAAC,qBAAqB,CAC1B,cAAc,EAAE,MAAM,EACtB,aAAa,EAAE,MAAM,GACpB,uBAAuB;IA+B1B;;;;;;;;;;;;;;;;;;;OAmBG;IACH,MAAM,CAAC,sBAAsB,CAC3B,YAAY,EAAE,MAAM,EACpB,aAAa,EAAE,MAAM,GACpB,uBAAuB;IA+B1B;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,MAAM,CAAC,sBAAsB,CAC3B,cAAc,EAAE,MAAM,EACtB,aAAa,EAAE,MAAM,EACrB,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,MAAM,EACrB,aAAa,EAAE,MAAM,GACpB,uBAAuB;IAqC1B;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,MAAM,CAAC,uBAAuB,CAC5B,YAAY,EAAE,MAAM,EACpB,aAAa,EAAE,MAAM,EACrB,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,MAAM,EACrB,aAAa,EAAE,MAAM,GACpB,uBAAuB;IAkE1B;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,MAAM,CAAC,OAAO;CAIvB"}
+{"version":3,"file":"bondingCurveCalculations.d.ts","sourceRoot":"","sources":["../../../src/utils/bondingCurveCalculations.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAGH,OAAO,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AAIjE;;;;;;;GAOG;AACH,qBAAa,sBAAsB;IACjC;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,MAAM,CAAC,qBAAqB,CAC1B,cAAc,EAAE,MAAM,EACtB,aAAa,EAAE,MAAM,GACpB,uBAAuB;IA+B1B;;;;;;;;;;;;;;;;;;;OAmBG;IACH,MAAM,CAAC,sBAAsB,CAC3B,YAAY,EAAE,MAAM,EACpB,aAAa,EAAE,MAAM,GACpB,uBAAuB;IA+B1B;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,MAAM,CAAC,sBAAsB,CAC3B,cAAc,EAAE,MAAM,EACtB,aAAa,EAAE,MAAM,EACrB,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,MAAM,EACrB,aAAa,EAAE,MAAM,GACpB,uBAAuB;IAqC1B;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,MAAM,CAAC,uBAAuB,CAC5B,YAAY,EAAE,MAAM,EACpB,aAAa,EAAE,MAAM,EACrB,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,MAAM,EACrB,aAAa,EAAE,MAAM,GACpB,uBAAuB;IAkE1B;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,MAAM,CAAC,OAAO;CAIvB"}

package/dist/src/utils/cacheWarmingHelpers.d.ts

@@ -8,7 +8,7 @@
  * @category Utilities
  * @since 3.9.2
  */
-import type { TokenMetadata } from '../services/TokenMetadataCache';
+import type { BondingCurveCacheEntry } from '../services/TokenMetadataCache';
 /**
  * Pool data fields relevant for cache warming
  *
@@ -84,7 +84,7 @@ export interface PoolDataForCaching {
  */
 export declare function extractMetadataFromPoolData(pool: PoolDataForCaching, logger?: {
     debug: (message: string) => void;
-}): Partial<TokenMetadata> | null;
+}): Partial<BondingCurveCacheEntry> | null;
 /**
  * Validate pool data structure for cache warming
  *

package/dist/src/utils/cacheWarmingHelpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cacheWarmingHelpers.d.ts","sourceRoot":"","sources":["../../../src/utils/cacheWarmingHelpers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAEpE;;;;;;GAMG;AACH,MAAM,WAAW,kBAAkB;IACjC,0CAA0C;IAC1C,SAAS,EAAE,MAAM,CAAC;IAClB,uCAAuC;IACvC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,wEAAwE;IACxE,gCAAgC,CAAC,EAAE,MAAM,CAAC;IAC1C,wEAAwE;IACxE,gCAAgC,CAAC,EAAE,MAAM,CAAC;CAC3C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,kBAAkB,EACxB,MAAM,CAAC,EAAE;IAAE,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;CAAE,GAC5C,OAAO,CAAC,aAAa,CAAC,GAAG,IAAI,CA2C/B;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,kBAAkB,CAW/E"}
+{"version":3,"file":"cacheWarmingHelpers.d.ts","sourceRoot":"","sources":["../../../src/utils/cacheWarmingHelpers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AAG7E;;;;;;GAMG;AACH,MAAM,WAAW,kBAAkB;IACjC,0CAA0C;IAC1C,SAAS,EAAE,MAAM,CAAC;IAClB,uCAAuC;IACvC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,wEAAwE;IACxE,gCAAgC,CAAC,EAAE,MAAM,CAAC;IAC1C,wEAAwE;IACxE,gCAAgC,CAAC,EAAE,MAAM,CAAC;CAC3C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,kBAAkB,EACxB,MAAM,CAAC,EAAE;IAAE,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;CAAE,GAC5C,OAAO,CAAC,sBAAsB,CAAC,GAAG,IAAI,CA6CxC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,kBAAkB,CAW/E"}

package/dist/src/utils/data-transform-patterns.d.ts

@@ -0,0 +1,393 @@
+/**
+ * Data Transformation Utility Patterns
+ *
+ * Consolidates reusable data transformation patterns used across the SDK
+ * for API response normalization, DTO conversion, and array manipulation.
+ *
+ * Patterns consolidated:
+ * - transformRawApiTokenToDomainModel: Convert raw API token to domain model (4+ occurrences)
+ * - extractFieldWithFallbackPath: Extract value using multiple field path candidates (11+ occurrences)
+ * - normalizeDataWithMapping: Transform array with field renaming and transformation (4+ occurrences)
+ * - deduplicateByKey: Remove duplicates from array based on key function (6+ occurrences)
+ *
+ * @category Utilities
+ * @since 5.17.0
+ */
+/**
+ * Token domain model representing normalized token structure
+ *
+ * @since 5.17.0
+ */
+export interface DomainToken {
+    name: string;
+    symbol: string;
+    decimals: number;
+    address?: string;
+    verified?: boolean;
+}
+/**
+ * Transform raw API token response to SDK domain model
+ *
+ * Converts raw token data from various API sources (DEX, GalaChain, etc.)
+ * to a normalized domain model with sensible defaults.
+ *
+ * Consolidates 4+ occurrences in:
+ * - GSwapAssetService.transformRawTokenToDexToken()
+ * - GSwapAssetService.transformRawTokenToUserAsset()
+ * - GSwapService token transformation logic
+ *
+ * Handles:
+ * - Missing fields with defaults (decimals: 8, verified: false, etc.)
+ * - Field name variations (tokenName vs name, tokenSymbol vs symbol)
+ * - Symbol fallback chain: symbol → tokenSymbol → collection → ''
+ * - Validates required fields (name, symbol) exist and are non-empty
+ *
+ * @param rawToken - Raw token object from API response (may have missing fields)
+ * @returns Normalized token domain model with required fields and defaults applied
+ * @throws Error if required fields (name, symbol) are missing or empty
+ *
+ * @example Basic transformation
+ * ```typescript
+ * const rawToken = {
+ *   tokenName: 'Anime',
+ *   tokenSymbol: 'ANI',
+ *   decimals: 18,
+ *   verified: true,
+ *   address: '0xabc123...'
+ * };
+ *
+ * const domain = transformRawApiTokenToDomainModel(rawToken);
+ * // Returns: {
+ * //   name: 'Anime',
+ * //   symbol: 'ANI',
+ * //   decimals: 18,
+ * //   verified: true,
+ * //   address: '0xabc123...'
+ * // }
+ * ```
+ *
+ * @example With missing optional fields
+ * ```typescript
+ * const minimalToken = {
+ *   name: 'GALA',
+ *   symbol: 'GALA'
+ * };
+ *
+ * const domain = transformRawApiTokenToDomainModel(minimalToken);
+ * // Returns: {
+ * //   name: 'GALA',
+ * //   symbol: 'GALA',
+ * //   decimals: 8,  // default
+ * //   verified: false  // default
+ * // }
+ * ```
+ *
+ * @example With field name variations
+ * ```typescript
+ * const apiResponse = {
+ *   tokenName: 'Demon K-Pop',
+ *   tokenSymbol: 'DEMONKPOP',
+ *   decimals: 18
+ * };
+ *
+ * const domain = transformRawApiTokenToDomainModel(apiResponse);
+ * // Normalizes both name and symbol field names automatically
+ * ```
+ *
+ * @example Error on missing required field
+ * ```typescript
+ * transformRawApiTokenToDomainModel({ name: 'Test' });
+ * // Throws: Error('Token symbol is required')
+ * ```
+ */
+export declare function transformRawApiTokenToDomainModel(rawToken: unknown): DomainToken;
+/**
+ * Extract field value from object using fallback path chain
+ *
+ * Tries multiple field paths in order (both flat and nested) and returns
+ * the first one that has a non-empty value. Supports nested paths like
+ * "response.data.error" for deep object traversal.
+ *
+ * Consolidates 11+ occurrences in:
+ * - LiquidityEventExtractor field extraction
+ * - SwapEventExtractor field extraction
+ * - Response handler fallback logic
+ *
+ * Note: extractFieldWithCandidates() already exists in object-extractors.ts
+ * for simple field name candidates. This function extends that pattern to
+ * support nested paths (dot-notation) for deeper object traversal.
+ *
+ * @template T - Type of the default value (inferred from defaultValue parameter)
+ * @param obj - Object to extract field from (can be any type, will check for object)
+ * @param fieldPaths - Array of field paths to try in order (e.g., ['id', 'error.code', 'response.data.message'])
+ * @param defaultValue - Value to return if no field path has a value (default: null)
+ * @returns First non-empty value found, or defaultValue if none found
+ *
+ * @example Basic field extraction
+ * ```typescript
+ * const obj = { id: '123', transactionId: null };
+ *
+ * const id = extractFieldWithFallbackPath(obj, ['id', 'transactionId']);
+ * // Returns: '123'
+ * ```
+ *
+ * @example With nested paths
+ * ```typescript
+ * const response = {
+ *   data: {
+ *     error: {
+ *       code: 'VALIDATION_ERROR'
+ *     }
+ *   }
+ * };
+ *
+ * const errorCode = extractFieldWithFallbackPath(
+ *   response,
+ *   ['error.code', 'code', 'message'],
+ *   'UNKNOWN'
+ * );
+ * // Returns: 'VALIDATION_ERROR'
+ * ```
+ *
+ * @example With default value
+ * ```typescript
+ * const obj = { name: null };
+ *
+ * const name = extractFieldWithFallbackPath(
+ *   obj,
+ *   ['name', 'displayName', 'title'],
+ *   'Unknown'
+ * );
+ * // Returns: 'Unknown' (all paths empty, uses default)
+ * ```
+ *
+ * @example With type-safe default
+ * ```typescript
+ * const obj = { count: null };
+ *
+ * const count: number = extractFieldWithFallbackPath(
+ *   obj,
+ *   ['count', 'total', 'size'],
+ *   0
+ * );
+ * // Returns: 0 (type inferred from defaultValue)
+ * ```
+ *
+ * @example Error case - non-object input
+ * ```typescript
+ * const value = extractFieldWithFallbackPath(null, ['field'], null);
+ * // Returns: null (input is null, not an object)
+ * ```
+ */
+export declare function extractFieldWithFallbackPath<T = unknown>(obj: unknown, fieldPaths: string[], defaultValue?: T): T | null;
+/**
+ * Transform array of objects with field mapping and transformation functions
+ *
+ * Maps field names from source objects to target field names, with optional
+ * transformation functions applied per field. Replaces manual map/reduce patterns.
+ *
+ * Consolidates 4+ occurrences in:
+ * - DTO → Domain conversions
+ * - API response field renaming
+ * - Array normalization workflows
+ *
+ * @template T - Type of items in source array
+ * @template R - Type of items in result array
+ * @param items - Array of source objects to transform
+ * @param mapping - Record mapping target field names to transformation functions.
+ *                  Each function receives the source object and returns the value
+ *                  for that field. Undefined values are omitted from result.
+ * @returns Array of transformed objects with mapped field names
+ *
+ * @example Basic field renaming
+ * ```typescript
+ * interface ApiUser {
+ *   user_name: string;
+ *   user_email: string;
+ *   created_at: string;
+ * }
+ *
+ * const apiUsers: ApiUser[] = [
+ *   { user_name: 'alice', user_email: 'alice@example.com', created_at: '2025-01-01' }
+ * ];
+ *
+ * const domainUsers = normalizeDataWithMapping(apiUsers, {
+ *   name: (item) => item.user_name,
+ *   email: (item) => item.user_email,
+ *   createdAt: (item) => item.created_at
+ * });
+ *
+ * // Returns: [{ name: 'alice', email: 'alice@example.com', createdAt: '2025-01-01' }]
+ * ```
+ *
+ * @example With type transformations
+ * ```typescript
+ * interface RawPrice {
+ *   symbol: string;
+ *   price: string;
+ *   timestamp: string;
+ * }
+ *
+ * interface PriceData {
+ *   symbol: string;
+ *   price: number;
+ *   date: Date;
+ * }
+ *
+ * const rawPrices: RawPrice[] = [
+ *   { symbol: 'BTC', price: '42500.50', timestamp: '2025-01-11T10:00:00Z' }
+ * ];
+ *
+ * const prices = normalizeDataWithMapping<RawPrice, PriceData>(rawPrices, {
+ *   symbol: (item) => item.symbol,
+ *   price: (item) => parseFloat(item.price), // Transform string to number
+ *   date: (item) => new Date(item.timestamp) // Transform string to Date
+ * });
+ *
+ * // Returns: [{ symbol: 'BTC', price: 42500.5, date: Date }]
+ * ```
+ *
+ * @example Conditional field inclusion
+ * ```typescript
+ * interface RawEvent {
+ *   id: string;
+ *   name: string;
+ *   description?: string;
+ *   verified?: boolean;
+ * }
+ *
+ * interface Event {
+ *   id: string;
+ *   title: string;
+ *   notes?: string;
+ *   trusted?: boolean;
+ * }
+ *
+ * const events = normalizeDataWithMapping<RawEvent, Event>(rawData, {
+ *   id: (item) => item.id,
+ *   title: (item) => item.name,
+ *   notes: (item) => item.description, // undefined if not present
+ *   trusted: (item) => item.verified // undefined if not present
+ * });
+ *
+ * // Undefined fields are omitted from result objects
+ * ```
+ *
+ * @example Merging multiple source fields
+ * ```typescript
+ * interface TokenData {
+ *   first_name: string;
+ *   last_name: string;
+ *   amount: string;
+ * }
+ *
+ * interface TokenInfo {
+ *   fullName: string;
+ *   quantity: number;
+ * }
+ *
+ * const tokens = normalizeDataWithMapping<TokenData, TokenInfo>(data, {
+ *   fullName: (item) => `${item.first_name} ${item.last_name}`,
+ *   quantity: (item) => parseFloat(item.amount)
+ * });
+ * ```
+ */
+export declare function normalizeDataWithMapping<T extends Record<string, unknown>, R extends Record<string, unknown>>(items: T[], mapping: Record<keyof R, (item: T) => unknown>): Partial<R>[];
+/**
+ * Remove duplicate items from array based on key function
+ *
+ * Returns a new array with duplicate items removed, maintaining original order.
+ * Determines uniqueness by comparing the result of keyFn for each item.
+ *
+ * Consolidates 6+ occurrences of deduplication patterns in:
+ * - Event deduplication (by transaction ID, pool ID, etc.)
+ * - Position result deduplication
+ * - Pool discovery deduplication
+ *
+ * Related to groupByKey() in array-helpers.ts but returns deduplicated array
+ * instead of grouped Map structure.
+ *
+ * @template T - Type of items in array
+ * @param items - Array of items to deduplicate (may contain duplicates)
+ * @param keyFn - Function that computes uniqueness key for each item
+ * @param keepFirst - If true, keeps first occurrence; if false, keeps last (default: true)
+ * @returns New array with duplicates removed, original order maintained
+ *
+ * @example Basic deduplication
+ * ```typescript
+ * interface Position {
+ *   id: string;
+ *   amount: string;
+ * }
+ *
+ * const positions: Position[] = [
+ *   { id: '1', amount: '100' },
+ *   { id: '2', amount: '200' },
+ *   { id: '1', amount: '150' }, // Duplicate ID
+ * ];
+ *
+ * const unique = deduplicateByKey(positions, (pos) => pos.id);
+ * // Returns: [{ id: '1', amount: '100' }, { id: '2', amount: '200' }]
+ * // (first occurrence of id '1' is kept)
+ * ```
+ *
+ * @example String key deduplication
+ * ```typescript
+ * interface Event {
+ *   txId: string;
+ *   type: string;
+ *   timestamp: number;
+ * }
+ *
+ * const events: Event[] = [
+ *   { txId: 'abc', type: 'swap', timestamp: 1000 },
+ *   { txId: 'def', type: 'liquidity', timestamp: 2000 },
+ *   { txId: 'abc', type: 'swap', timestamp: 1500 }, // Duplicate txId
+ * ];
+ *
+ * const deduplicated = deduplicateByKey(events, (e) => e.txId);
+ * // Returns: [{ txId: 'abc', type: 'swap', timestamp: 1000 }, ...]
+ * ```
+ *
+ * @example Keep last occurrence
+ * ```typescript
+ * const items = [
+ *   { id: 'a', value: 1 },
+ *   { id: 'b', value: 2 },
+ *   { id: 'a', value: 3 }, // Same id, newer value
+ * ];
+ *
+ * const lastOccurrence = deduplicateByKey(
+ *   items,
+ *   (item) => item.id,
+ *   false // Keep last occurrence
+ * );
+ * // Returns: [{ id: 'b', value: 2 }, { id: 'a', value: 3 }]
+ * ```
+ *
+ * @example Composite key deduplication
+ * ```typescript
+ * interface Pair {
+ *   token0: string;
+ *   token1: string;
+ *   fee: number;
+ * }
+ *
+ * const pairs: Pair[] = [
+ *   { token0: 'GALA', token1: 'GUSDC', fee: 3000 },
+ *   { token0: 'GALA', token1: 'GWETH', fee: 3000 },
+ *   { token0: 'GALA', token1: 'GUSDC', fee: 3000 }, // Duplicate
+ * ];
+ *
+ * const uniquePairs = deduplicateByKey(
+ *   pairs,
+ *   (pair) => `${pair.token0}/${pair.token1}/${pair.fee}`
+ * );
+ * // Returns: [
+ * //   { token0: 'GALA', token1: 'GUSDC', fee: 3000 },
+ * //   { token0: 'GALA', token1: 'GWETH', fee: 3000 }
+ * // ]
+ * ```
+ */
+export declare function deduplicateByKey<T>(items: T[], keyFn: (item: T) => unknown, keepFirst?: boolean): T[];
+//# sourceMappingURL=data-transform-patterns.d.ts.map

package/dist/src/utils/data-transform-patterns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-transform-patterns.d.ts","sourceRoot":"","sources":["../../../src/utils/data-transform-patterns.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0EG;AACH,wBAAgB,iCAAiC,CAAC,QAAQ,EAAE,OAAO,GAAG,WAAW,CAmDhF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6EG;AACH,wBAAgB,4BAA4B,CAAC,CAAC,GAAG,OAAO,EACtD,GAAG,EAAE,OAAO,EACZ,UAAU,EAAE,MAAM,EAAE,EACpB,YAAY,GAAE,CAAwB,GACrC,CAAC,GAAG,IAAI,CAmCV;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+GG;AACH,wBAAgB,wBAAwB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC3G,KAAK,EAAE,CAAC,EAAE,EACV,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,GAC7C,OAAO,CAAC,CAAC,CAAC,EAAE,CAcd;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+FG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAChC,KAAK,EAAE,CAAC,EAAE,EACV,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,EAC3B,SAAS,GAAE,OAAc,GACxB,CAAC,EAAE,CA6BL"}