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

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

@@ -1,34 +0,0 @@
-/**
- * Public defi-backend trade read client.
- *
- * The REST transport is intentionally internal. Its methods preserve the SDK's
- * existing GalaChain-derived return types while reads are served from the
- * backend cache.
- */
-import type { GalaChainGatewayResponse, GalaChainGetPoolDataRequest, GalaChainGetPositionsRequest, GalaChainGetPositionsResponse, GalaChainGetRemoveLiquidityEstimationRequest, GalaChainGetSlot0Request, GalaChainPoolData, GalaChainRemoveLiquidityEstimation, GalaChainSlot0Data } from '../types/galachain-api.types';
-export interface DexBackendTradeClientConfig {
-    baseUrl: string;
-    timeout?: number;
-}
-export declare class DexBackendTradeClient {
-    private client;
-    constructor(config: DexBackendTradeClientConfig);
-    getPoolData(request: GalaChainGetPoolDataRequest): Promise<GalaChainPoolData>;
-    getSlot0(request: GalaChainGetSlot0Request): Promise<GalaChainSlot0Data>;
-    getPositions(request: GalaChainGetPositionsRequest): Promise<GalaChainGetPositionsResponse>;
-    getPositionById(ownerOrPositionId: string, token0Optional?: string | Record<string, unknown>, token1Optional?: string | Record<string, unknown>, feeOptional?: number, tickLowerOptional?: number, tickUpperOptional?: number, positionIdOptional?: string): Promise<GalaChainResponse<unknown>>;
-    getRemoveLiquidityEstimation(request: GalaChainGetRemoveLiquidityEstimationRequest): Promise<GalaChainRemoveLiquidityEstimation>;
-    getUserPositions(user: string, limit: number, bookmark?: string): Promise<GalaChainGetPositionsResponse>;
-    private poolParams;
-    private positionParams;
-    private toSearchParams;
-    private normalizePositions;
-    private unwrapEnvelope;
-    private validateResponse;
-    private validateTokenObjects;
-    private toTokenClassKey;
-    private asRecord;
-    private handleError;
-}
-export type GalaChainResponse<T> = GalaChainGatewayResponse<T>;
-//# sourceMappingURL=DexBackendTradeClient.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"DexBackendTradeClient.d.ts","sourceRoot":"","sources":["../../../src/services/DexBackendTradeClient.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,OAAO,KAAK,EACV,wBAAwB,EACxB,2BAA2B,EAC3B,4BAA4B,EAC5B,6BAA6B,EAC7B,4CAA4C,EAC5C,wBAAwB,EACxB,iBAAiB,EAEjB,kCAAkC,EAClC,kBAAkB,EAEnB,MAAM,8BAA8B,CAAC;AAoBtC,MAAM,WAAW,2BAA2B;IAC1C,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,qBAAa,qBAAqB;IAChC,OAAO,CAAC,MAAM,CAAgB;gBAElB,MAAM,EAAE,2BAA2B;IAIzC,WAAW,CAAC,OAAO,EAAE,2BAA2B,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAuB7E,QAAQ,CAAC,OAAO,EAAE,wBAAwB,GAAG,OAAO,CAAC,kBAAkB,CAAC;IA2BxE,YAAY,CAAC,OAAO,EAAE,4BAA4B,GAAG,OAAO,CAAC,6BAA6B,CAAC;IAmB3F,eAAe,CACnB,iBAAiB,EAAE,MAAM,EACzB,cAAc,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjD,cAAc,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjD,WAAW,CAAC,EAAE,MAAM,EACpB,iBAAiB,CAAC,EAAE,MAAM,EAC1B,iBAAiB,CAAC,EAAE,MAAM,EAC1B,kBAAkB,CAAC,EAAE,MAAM,GAC1B,OAAO,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC;IA4ChC,4BAA4B,CAChC,OAAO,EAAE,4CAA4C,GACpD,OAAO,CAAC,kCAAkC,CAAC;IAmCxC,gBAAgB,CACpB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC,6BAA6B,CAAC;IA2BzC,OAAO,CAAC,UAAU;IAQlB,OAAO,CAAC,cAAc;IAiBtB,OAAO,CAAC,cAAc;IAMtB,OAAO,CAAC,kBAAkB;IAkB1B,OAAO,CAAC,cAAc;IAQtB,OAAO,CAAC,gBAAgB;IAaxB,OAAO,CAAC,oBAAoB;IAU5B,OAAO,CAAC,eAAe;IAcvB,OAAO,CAAC,QAAQ;IAIhB,OAAO,CAAC,WAAW;CAGpB;AAED,MAAM,MAAM,iBAAiB,CAAC,CAAC,IAAI,wBAAwB,CAAC,CAAC,CAAC,CAAC"}

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

@@ -1,152 +0,0 @@
-/**
- * DEX Pool Discovery Service
- *
- * Service for querying and exploring GalaSwap DEX liquidity pools
- * with pagination, filtering, sorting, and quote-based pricing enrichment.
- *
- * @packageDocumentation
- */
-import type { DexPoolsResult, FetchDexPoolsOptions } from '../types/dex-pool.dto';
-import type { HttpClient } from '../utils/http';
-import { BaseService } from './BaseService';
-import type { GSwapService } from './GSwapService';
-/**
- * Service for fetching and exploring DEX pools on GalaSwap
- *
- * Handles pagination, filtering, sorting, and optional quote-based pricing enrichment
- * of liquidity pools across all graduated tokens and base tokens.
- *
- * @category GSwap
- * @since 3.28.0
- */
-export declare class DexPoolService extends BaseService {
-    /** Base URL for DEX backend API */
-    private readonly dexBackendBaseUrl;
-    /** GSwap service for quote-based pricing enrichment */
-    private gswapService;
-    /** Concurrency level for parallel pricing requests */
-    private pricingConcurrency;
-    /**
-     * Create a new DexPoolService instance
-     *
-     * @param http HttpClient for making API requests
-     * @param dexBackendBaseUrl Base URL for DEX backend API
-     * @param gswapService Optional GSwap service for pricing enrichment
-     * @param pricingConcurrency Concurrency level for parallel pricing requests (default: 5)
-     * @param debugMode Enable debug logging
-     */
-    constructor(http: HttpClient, dexBackendBaseUrl: string, gswapService?: GSwapService | undefined, pricingConcurrency?: number, debugMode?: boolean);
-    /**
-     * Set GSwap service for pricing enrichment
-     *
-     * @param service GSwap service instance
-     */
-    setGSwapService(service: GSwapService): void;
-    /**
-     * Set concurrency level for pricing requests
-     *
-     * @param concurrency Number of concurrent pricing requests
-     */
-    setPricingConcurrency(concurrency: number): void;
-    /**
-     * Enrich pools with quote-based pricing
-     *
-     * Uses parallel requests with concurrency control to price each pool's tokens
-     * against GUSDC (as stable reference) via `getSwapQuoteExactInput()`.
-     *
-     * Failed pricing requests are caught and logged - pools without prices are still
-     * included with all other metrics intact (graceful degradation).
-     *
-     * @param pools Pools to enrich with pricing
-     * @returns Promise resolving to pools with token0Price and token1Price populated
-     *
-     * @private
-     */
-    private enrichPoolsWithPricing;
-    /** Raw pool shape returned by `/v1/trade/pools` (fee as a legacy percent string). */
-    private fetchRawPools;
-    /** Normalize a legacy fee percent string ("0.3") or a v2 pips number (3000) to pips. */
-    private static feeToPips;
-    private normalizeV1Pool;
-    private normalizeV2Pool;
-    /**
-     * Fetch DEX pools with pagination and filtering
-     *
-     * Queries the DEX backend for available liquidity pools on BOTH contracts — the legacy
-     * DexV3Contract and the current GalaChainDex contract — merged into one sorted, paginated
-     * list. Supports:
-     * - Pagination (page/limit, max 20 per page)
-     * - Sorting by TVL, 30-day volume, or 1-day volume
-     * - Search filtering by token symbols
-     * - Optional quote-based pricing enrichment via `withPrices` option
-     *
-     * **BREAKING in 6.0.0**: previously legacy-only (backed by the now-retired `/explore/pools`,
-     * then a `/v1/trade/pools`-only stopgap). Now merges `/v1/trade/pools` and `/v2/trade/pools`.
-     * Check `contractVersion` on each result — `fee` is now numeric pips for every pool (was a
-     * percent string for legacy pools); v2 pools compute `token0TvlUsd`/`token1TvlUsd` as an even
-     * split of the pool's combined USD TVL (the contract does not report a per-token split).
-     *
-     * @param options Fetch options (all optional, page-based pagination with 1-indexed pages)
-     * @returns Promise resolving to paginated pool results
-     *
-     * @throws {Error} If HTTP request fails
-     * @throws {ValidationError} If sort options are invalid
-     *
-     * @example
-     * ```typescript
-     * // Fetch top 10 pools by volume with pricing, from either contract
-     * const result = await dexPoolService.fetchDexPools({
-     *   sortBy: 'volume1d',
-     *   sortOrder: 'desc',
-     *   limit: 10,
-     *   page: 1,
-     *   withPrices: true
-     * });
-     *
-     * console.log(`Found ${result.pageInfo.totalCount} total pools`);
-     * result.items.forEach(pool => {
-     *   const feePercent = (pool.fee / 10000).toFixed(2);
-     *   console.log(`[${pool.contractVersion}] ${pool.poolName} (${feePercent}%): ${pool.token0Price} / ${pool.token1Price}`);
-     * });
-     * ```
-     *
-     * @since 3.28.0
-     */
-    fetchDexPools(options?: FetchDexPoolsOptions): Promise<DexPoolsResult>;
-    /**
-     * Fetch ALL DEX pools with automatic pagination
-     *
-     * Convenience method that automatically handles pagination to retrieve
-     * all available DEX pools. Uses maximum page size (20) for efficiency.
-     *
-     * This is useful when you need complete pool data regardless of result size.
-     * For large result sets with pricing, note that the operation may take significant time
-     * since all pools must be priced. Consider using fetchDexPools() with explicit pagination
-     * and batching if you need to process pricing incrementally.
-     *
-     * @param options Fetch options (no pagination fields, page/limit automatically handled)
-     * @returns Promise resolving to all pools with flattened pagination
-     *
-     * @example
-     * ```typescript
-     * // Fetch all pools sorted by TVL with pricing
-     * const allPools = await dexPoolService.fetchAllDexPools({
-     *   sortBy: 'tvl',
-     *   sortOrder: 'desc',
-     *   withPrices: true  // Enable pricing for all pools
-     * });
-     *
-     * console.log(`Total pools: ${allPools.pageInfo.totalCount}`);
-     * console.log(`Priced pools: ${allPools.items.filter(p => p.token0Price).length}`);
-     *
-     * // Find top GALA pools with prices
-     * const galaPools = allPools.items
-     *   .filter(p => p.poolName.includes('GALA') && p.token0Price)
-     *   .slice(0, 10);
-     * ```
-     *
-     * @since 3.28.0
-     */
-    fetchAllDexPools(options?: Omit<FetchDexPoolsOptions, 'page' | 'limit'>): Promise<DexPoolsResult>;
-}
-//# sourceMappingURL=DexPoolService.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"DexPoolService.d.ts","sourceRoot":"","sources":["../../../src/services/DexPoolService.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,EAEV,cAAc,EACd,oBAAoB,EACrB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAGnD;;;;;;;;GAQG;AACH,qBAAa,cAAe,SAAQ,WAAW;IAC7C,mCAAmC;IACnC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAS;IAE3C,uDAAuD;IACvD,OAAO,CAAC,YAAY,CAA2B;IAE/C,sDAAsD;IACtD,OAAO,CAAC,kBAAkB,CAAa;IAEvC;;;;;;;;OAQG;gBAED,IAAI,EAAE,UAAU,EAChB,iBAAiB,EAAE,MAAM,EACzB,YAAY,GAAE,YAAY,GAAG,SAAqB,EAClD,kBAAkB,GAAE,MAAU,EAC9B,SAAS,GAAE,OAAe;IAQ5B;;;;OAIG;IACH,eAAe,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI;IAI5C;;;;OAIG;IACH,qBAAqB,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;IAKhD;;;;;;;;;;;;;OAaG;YACW,sBAAsB;IAoHpC,qFAAqF;YACvE,aAAa;IA6B3B,wFAAwF;IACxF,OAAO,CAAC,MAAM,CAAC,SAAS;IAMxB,OAAO,CAAC,eAAe;IA+BvB,OAAO,CAAC,eAAe;IAoCvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA0CG;IACG,aAAa,CAAC,OAAO,GAAE,oBAAyB,GAAG,OAAO,CAAC,cAAc,CAAC;IAgEhF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACG,gBAAgB,CACpB,OAAO,GAAE,IAAI,CAAC,oBAAoB,EAAE,MAAM,GAAG,OAAO,CAAM,GACzD,OAAO,CAAC,cAAc,CAAC;CAyC3B"}

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

@@ -1,446 +0,0 @@
-/**
- * DEX Quote Service
- *
- * Handles offline and online DEX quote calculations using composite pool data.
- * Provides three calculation modes:
- * - LOCAL: Client-side calculation (instant, no network)
- * - EXTERNAL: DEX backend calculation (real-time, slower)
- * - HYBRID: Local with external validation (best of both)
- *
- * @packageDocumentation
- */
-import type { CalculateDexPoolQuoteOptions, CompositePoolDataResult, DexPoolQuoteResult, FetchCompositePoolDataOptions } from '../types/composite-pool.dto';
-import type { HttpClient } from '../utils/http';
-import { BaseService } from './BaseService';
-/**
- * Concurrency constant for parallel composite pool fetching
- */
-export declare const COMPOSITE_POOL_FETCH_CONCURRENCY = 5;
-/**
- * Service for DEX quote calculations with composite pool data
- *
- * Provides offline and online quote calculations using DEX backend pool state.
- * Handles dependency version conflicts between @gala-chain/api and @gala-chain/dex through
- * strategic type assertions validated by BigNumber.js runtime conversions.
- *
- * ## Dependency Version Management
- *
- * **Version Conflicts:**
- * - `@gala-chain/api`: Used for TokenBalance class (imported from this package)
- * - `@gala-chain/dex`: Used for Pool, TickData, CompositePoolDto classes
- * - **Issue**: SDK may depend on different versions of @gala-chain/api than @gala-chain/dex
- * - **Solution**: Type assertions with runtime validation via BigNumber.js
- *
- * **Current Dependency Stack:**
- * ```
- * SDK
- * ├── @gala-chain/api@X.Y.Z (TokenBalance)
- * ├── @gala-chain/dex@A.B.C (Pool, TickData, CompositePoolDto)
- * ├── @gala-chain/connect (GalaChain client)
- * └── axios (HTTP requests)
- *
- * Potential Conflict: @gala-chain/dex depends on different @gala-chain/api version
- * ```
- *
- * **Type Assertion Patterns:**
- * 1. **TokenBalance Construction** - `new TokenBalance(data as unknown)`
- *    - Reason: TokenBalance class definition may differ between versions
- *    - Validation: Constructor throws on invalid data
- *
- * 2. **Property Assignment** - `(instance as unknown).propertyName = value`
- *    - Reason: TickData constructor only accepts 2 params; properties set after
- *    - Validation: All assignments use BigNumber.js conversion or primitives
- *
- * 3. **CompositePoolDto Construction** - Passing TokenBalance instances
- *    - Reason: TokenBalance types may not match exactly between versions
- *    - Validation: BigNumber.js validates all numeric conversions
- *
- * **Risk Mitigation:**
- * - ✓ BigNumber.js throws immediately on invalid numbers (NaN, non-numeric strings)
- * - ✓ Pool, TickData, TokenBalance constructors throw on structural errors
- * - ✓ All numeric fields converted to BigNumber before use
- * - ✓ String-to-number conversions validated at instantiation time
- *
- * @category GSwap
- * @since 3.32.0
- * @architecture Uses composition and dependency injection for testability
- * @note Type assertions are isolated to conversion functions; business logic uses proper types
- */
-export declare class DexQuoteService extends BaseService {
-    private readonly dexBackendBaseUrl;
-    private compositePoolFetchConcurrency;
-    /**
-     * Initialize DEX Quote Service
-     *
-     * @param http Unsigned HttpClient for DEX backend requests
-     * @param dexBackendBaseUrl Base URL for the DEX backend
-     * @param debugMode Enable debug logging
-     * @param networkTimeout Network timeout in milliseconds (default: 30000ms)
-     * @example
-     * ```typescript
-     * // Use default 30-second timeout
-     * const service = new DexQuoteService(http, dexBackendBaseUrl, false);
-     *
-     * // Use custom 60-second timeout for rate-limited APIs
-     * const service = new DexQuoteService(http, dexBackendBaseUrl, false, 60000);
-     * ```
-     */
-    constructor(http: HttpClient, dexBackendBaseUrl: string, debugMode?: boolean, _networkTimeout?: number);
-    /**
-     * Validate input parameters for fetchCompositePoolData
-     *
-     * Ensures tokens follow pipe-delimited format (collection|category|type|additionalKey)
-     * and fee tier is one of the three supported values.
-     *
-     * @private
-     * @param token0 First token in pipe-delimited format
-     * @param token1 Second token in pipe-delimited format
-     * @param fee Fee tier (500, 3000, or 10000)
-     * @throws DexQuoteError if validation fails
-     * @category Validation
-     * @since 3.32.0
-     */
-    private validateFetchCompositePoolDataInput;
-    /**
-     * Validate input parameters for quote calculation methods
-     *
-     * Ensures amount is a positive numeric string suitable for BigNumber conversion.
-     * Rejects NaN, Infinity, negative values, and non-numeric strings.
-     *
-     * @private
-     * @param amount Amount to validate (should be positive numeric string)
-     * @throws DexQuoteError if validation fails
-     * @category Validation
-     * @since 3.32.0
-     */
-    private validateQuoteAmount;
-    /**
-     * Convert SDK TokenClassKey to DexTokenClassKey for @gala-chain/dex
-     *
-     * Bridges dependency version conflicts between @gala-chain/api and @gala-chain/dex
-     * by creating a new DexTokenClassKey instance with copied field values.
-     *
-     * @private
-     * @param tokenKey SDK TokenClassKey
-     * @returns DexTokenClassKey for use with @gala-chain/dex
-     * @category Type Conversion
-     * @since 3.32.0
-     */
-    private convertTokenClassKey;
-    /**
-     * Set concurrency level for parallel composite pool fetching
-     *
-     * Controls how many composite pool data requests can be in-flight simultaneously.
-     * Higher values fetch pools faster but use more network connections. Lower values
-     * use fewer connections but take longer to fetch multiple pools.
-     *
-     * **Default**: 5 concurrent requests
-     * **Valid Range**: 1-20 (values outside this range are clamped)
-     *
-     * @param concurrency Number of concurrent requests (automatically clamped to 1-20)
-     *
-     * @example Default usage
-     * ```typescript
-     * // Fetch 3 pools with default concurrency (5)
-     * const pools = await Promise.all([
-     *   sdk.fetchCompositePoolData({ token0: 'GALA|Unit|none|none', token1: 'Token|Unit|BENE|client:123', fee: 3000 }),
-     *   sdk.fetchCompositePoolData({ token0: 'GALA|Unit|none|none', token1: 'Token|Unit|USDC|eth:0x...', fee: 500 }),
-     *   sdk.fetchCompositePoolData({ token0: 'Token|Unit|BENE|client:123', token1: 'Token|Unit|USDC|eth:0x...', fee: 3000 }),
-     * ]);
-     * ```
-     *
-     * @example Increase concurrency for faster bulk fetching
-     * ```typescript
-     * // Optimize for fetching many pools (trading bot scenario)
-     * service.setCompositePoolFetchConcurrency(15);
-     *
-     * const pools = await Promise.all(
-     *   tokenPairs.map(pair => sdk.fetchCompositePoolData(pair))
-     * );
-     * ```
-     *
-     * @example Decrease concurrency for rate-limited APIs
-     * ```typescript
-     * // Tune concurrency for rate-limited backend requests
-     * service.setCompositePoolFetchConcurrency(2);
-     *
-     * // Fetch pools one-by-one (slow but respects rate limits)
-     * for (const pair of tokenPairs) {
-     *   const composite = await sdk.fetchCompositePoolData(pair);
-     *   processPool(composite);
-     * }
-     * ```
-     *
-     * @example Reset to default
-     * ```typescript
-     * // Reset concurrency back to default (5)
-     * service.setCompositePoolFetchConcurrency(5);
-     * ```
-     */
-    setCompositePoolFetchConcurrency(concurrency: number): void;
-    /**
-     * Fetch composite pool data from the DEX backend
-     *
-     * Retrieves complete pool state including liquidity, price, tick data, and token balances.
-     * This data enables instant LOCAL quote calculations without additional network calls.
-     *
-     * **Performance Strategy:**
-     * - Fetch once → calculate 100+ quotes locally (instant, no network latency)
-     * - Network cost: ~100-500ms per fetch
-     * - Local quote cost: <1ms per calculation
-     *
-     * **Returned Data:**
-     * - Pool: liquidity, sqrtPriceX96, tick, feeGrowth
-     * - Ticks: liquidity deltas at each price point
-     * - Token balances: decimals, balances for fee calculations
-     * - Metadata: fee tier, token addresses
-     *
-     * @param options Composite pool fetch options (token0/token1 in pipe-delimited format)
-     * @returns Complete composite pool data for offline quote calculations
-     * @throws DexPoolNotFoundError if pool does not exist
-     * @throws DexQuoteError on API or conversion errors
-     * @category Pool Data
-     * @since 3.32.0
-     *
-     * @example Basic fetch
-     * ```typescript
-     * const compositePool = await sdk.fetchCompositePoolData({
-     *   token0: 'GALA|Unit|none|none',
-     *   token1: 'Token|Unit|BENE|client:123',
-     *   fee: 3000  // 0.30%
-     * });
-     * console.log('Pool liquidity:', compositePool.pool.liquidity.toString());
-     * ```
-     *
-     * @example Reuse for multiple quotes (recommended pattern)
-     * ```typescript
-     * // Fetch once
-     * const composite = await sdk.fetchCompositePoolData({
-     *   token0: 'GALA|Unit|none|none',
-     *   token1: 'Token|Unit|BENE|client:123',
-     *   fee: 3000
-     * });
-     *
-     * // Calculate many quotes locally (instant!)
-     * const quotes = await Promise.all([
-     *   sdk.calculateDexPoolQuoteExactAmountLocal({ compositePoolData: composite, amount: '100', ... }),
-     *   sdk.calculateDexPoolQuoteExactAmountLocal({ compositePoolData: composite, amount: '500', ... }),
-     *   sdk.calculateDexPoolQuoteExactAmountLocal({ compositePoolData: composite, amount: '1000', ... }),
-     * ]);
-     * ```
-     */
-    fetchCompositePoolData(options: FetchCompositePoolDataOptions): Promise<CompositePoolDataResult>;
-    /**
-     * Calculate DEX pool quote using LOCAL client-side calculation (instant, offline)
-     *
-     * Uses concentrated liquidity mathematics with pre-fetched composite pool data for
-     * instant quote calculations without network calls. Based on Uniswap V3 concentrated
-     * liquidity model with tick-based ranges.
-     *
-     * **Calculation Mode: LOCAL (Offline)**
-     * - Speed: <1ms per quote (instant)
-     * - Network: Zero network calls
-     * - Accuracy: Based on cached pool state (may be seconds stale)
-     * - Use case: UI quotes, bulk pricing, simulations
-     *
-     * **How Concentrated Liquidity Works:**
-     * Unlike constant product (x × y = k), concentrated liquidity allows:
-     * - Liquidity providers to set price ranges (via ticks)
-     * - Higher capital efficiency within active ranges
-     * - Price moves through discrete ticks, not smooth curve
-     * - Each tick has liquidity delta (added/removed at that price)
-     *
-     * **Quote Calculation Process:**
-     * 1. Determine swap direction (zeroForOne: token0 → token1 or reverse)
-     * 2. Traverse ticks from current price based on amount
-     * 3. Calculate output using sqrtPriceX96 (Q64.96 fixed-point)
-     * 4. Apply fee tier (0.05%, 0.30%, or 1.00%)
-     * 5. Return amounts and new price after swap
-     *
-     * **Result Fields:**
-     * - amount0: Input token amount (if zeroForOne) or output (if !zeroForOne)
-     * - amount1: Output token amount (if zeroForOne) or input (if !zeroForOne)
-     * - currentSqrtPrice: Current pool price (sqrt(price) × 2^96)
-     * - newSqrtPrice: Pool price after swap
-     *
-     * @param options Quote calculation options (must include compositePoolData)
-     * @returns Quote result with amounts and price data
-     * @throws DexQuoteError on calculation errors
-     * @category Quote Calculation
-     * @since 3.32.0
-     *
-     * @example Basic LOCAL quote
-     * ```typescript
-     * // Step 1: Fetch composite data (one network call)
-     * const composite = await sdk.fetchCompositePoolData({
-     *   token0: 'GALA|Unit|none|none',
-     *   token1: 'Token|Unit|BENE|client:123',
-     *   fee: 3000
-     * });
-     *
-     * // Step 2: Calculate quote (instant, local)
-     * const quote = await sdk.calculateDexPoolQuoteExactAmountLocal({
-     *   compositePoolData: composite,
-     *   fromToken: 'GALA|Unit|none|none',
-     *   toToken: 'Token|Unit|BENE|client:123',
-     *   amount: '1000'
-     * });
-     * console.log(`Spend: ${quote.amount0} GALA`);
-     * console.log(`Receive: ${quote.amount1} BENE`);
-     * ```
-     *
-     * @example Reuse composite data for multiple quotes (recommended)
-     * ```typescript
-     * // Fetch once
-     * const composite = await sdk.fetchCompositePoolData({
-     *   token0: 'GALA|Unit|none|none',
-     *   token1: 'Token|Unit|BENE|client:123',
-     *   fee: 3000
-     * });
-     *
-     * // Calculate many quotes locally (instant!)
-     * const quote1 = await sdk.calculateDexPoolQuoteExactAmountLocal({
-     *   compositePoolData: composite,
-     *   fromToken: 'GALA|Unit|none|none',
-     *   toToken: 'Token|Unit|BENE|client:123',
-     *   amount: '100'
-     * });
-     *
-     * const quote2 = await sdk.calculateDexPoolQuoteExactAmountLocal({
-     *   compositePoolData: composite,
-     *   fromToken: 'GALA|Unit|none|none',
-     *   toToken: 'Token|Unit|BENE|client:123',
-     *   amount: '5000'
-     * });
-     * // Both quotes calculated instantly using same cached pool state
-     * ```
-     */
-    calculateDexPoolQuoteExactAmountLocal(options: CalculateDexPoolQuoteOptions): Promise<DexPoolQuoteResult>;
-    /**
-     * Calculate DEX pool quote using the EXTERNAL DEX backend endpoint (real-time, accurate)
-     *
-     * Fetches a real-time quote from the DEX backend using current pool state.
-     * Always accurate but adds network latency. Best for final verification before trading.
-     *
-     * **Calculation Mode: EXTERNAL (Real-time)**
-     * - Speed: 100-500ms per quote (network latency)
-     * - Network: One network call per quote
-     * - Accuracy: Current backend pool state
-     * - Use case: Final verification, trading execution, critical accuracy
-     *
-     * **When to Use EXTERNAL vs LOCAL:**
-     * - EXTERNAL: Before trade execution, when pool changes rapidly
-     * - LOCAL: UI quotes, bulk pricing, trading simulations
-     * - HYBRID: LOCAL for display, EXTERNAL for final confirmation
-     *
-     * **Network Call Details:**
-     * - Endpoint: `/v1/trade/quote`
-     * - Authentication: None
-     * - Response: Quote calculated from current DEX pool state
-     *
-     * **Accuracy Trade-off:**
-     * - EXTERNAL: 100% accurate but slower (network roundtrip)
-     * - LOCAL: ~99.9% accurate but instant (pool state may be seconds old)
-     * - For most use cases: LOCAL is sufficient and significantly faster
-     *
-     * @param options Quote calculation options (must include compositePoolData for token info)
-     * @returns Quote result from the DEX backend
-     * @throws DexQuoteError on network or calculation errors
-     * @category Quote Calculation
-     * @since 3.32.0
-     *
-     * @example Real-time quote before trade
-     * ```typescript
-     * // Fetch composite data to get token ClassKeys
-     * const composite = await sdk.fetchCompositePoolData({
-     *   token0: 'GALA|Unit|none|none',
-     *   token1: 'Token|Unit|BENE|client:123',
-     *   fee: 3000
-     * });
-     *
-     * // Get real-time quote from the DEX backend (100-500ms)
-     * const quote = await sdk.calculateDexPoolQuoteExactAmountExternal({
-     *   compositePoolData: composite,
-     *   fromToken: 'GALA|Unit|none|none',
-     *   toToken: 'Token|Unit|BENE|client:123',
-     *   amount: '1000'
-     * });
-     * console.log(`Real-time quote: ${quote.amount1} BENE`);
-     * ```
-     *
-     * @example HYBRID strategy (recommended for trading UIs)
-     * ```typescript
-     * // Fetch once
-     * const composite = await sdk.fetchCompositePoolData({ ... });
-     *
-     * // Display LOCAL quote to user (instant)
-     * const localQuote = await sdk.calculateDexPoolQuoteExactAmountLocal({
-     *   compositePoolData: composite,
-     *   fromToken: 'GALA|Unit|none|none',
-     *   toToken: 'Token|Unit|BENE|client:123',
-     *   amount: userInput
-     * });
-     * displayToUser(localQuote); // Instant feedback
-     *
-     * // Before executing trade, verify with EXTERNAL quote (accurate)
-     * const externalQuote = await sdk.calculateDexPoolQuoteExactAmountExternal({
-     *   compositePoolData: composite,
-     *   fromToken: 'GALA|Unit|none|none',
-     *   toToken: 'Token|Unit|BENE|client:123',
-     *   amount: userInput
-     * });
-     * executeTrade(externalQuote); // Final accuracy
-     * ```
-     */
-    calculateDexPoolQuoteExactAmountExternal(options: CalculateDexPoolQuoteOptions): Promise<DexPoolQuoteResult>;
-    /**
-     * Calculate DEX pool quote with automatic mode selection (LOCAL or EXTERNAL)
-     *
-     * Convenience method that delegates to local or external quote calculation based on
-     * mode parameter. Defaults to LOCAL (instant) for optimal performance.
-     *
-     * **Mode Comparison:**
-     * ```
-     * | Mode     | Speed  | Network | Accuracy | Use Case                |
-     * |----------|--------|---------|----------|-------------------------|
-     * | LOCAL    | <1ms   | None    | 99.9%    | UI, simulations, bulk   |
-     * | EXTERNAL | 100ms+ | Yes     | 100%     | Trade execution, verify |
-     * ```
-     *
-     * **Recommended Patterns:**
-     * - Default (no mode): Uses LOCAL for instant quotes
-     * - Trading UI: LOCAL for display, EXTERNAL before execution
-     * - Bulk pricing: Always use LOCAL (no reason for network calls)
-     * - Critical accuracy: Always use EXTERNAL
-     *
-     * @param options Quote calculation options
-     * @param mode 'local' (instant, default) or 'external' (real-time) - defaults to 'local'
-     * @returns Quote result
-     * @category Quote Calculation
-     * @since 3.32.0
-     *
-     * @example Default LOCAL mode
-     * ```typescript
-     * const quote = await sdk.calculateDexPoolQuoteExactAmount({
-     *   compositePoolData: composite,
-     *   fromToken: 'GALA|Unit|none|none',
-     *   toToken: 'Token|Unit|BENE|client:123',
-     *   amount: '1000'
-     * });
-     * // Uses local calculation by default (instant)
-     * ```
-     *
-     * @example Explicit EXTERNAL mode for critical accuracy
-     * ```typescript
-     * const quote = await sdk.calculateDexPoolQuoteExactAmount({
-     *   compositePoolData: composite,
-     *   fromToken: 'GALA|Unit|none|none',
-     *   toToken: 'Token|Unit|BENE|client:123',
-     *   amount: '1000'
-     * }, 'external');
-     * // Fetches a real-time quote from the DEX backend
-     * ```
-     */
-    calculateDexPoolQuoteExactAmount(options: CalculateDexPoolQuoteOptions, mode?: 'local' | 'external'): Promise<DexPoolQuoteResult>;
-}
-//# sourceMappingURL=DexQuoteService.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"DexQuoteService.d.ts","sourceRoot":"","sources":["../../../src/services/DexQuoteService.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAOH,OAAO,KAAK,EACV,4BAA4B,EAC5B,uBAAuB,EACvB,kBAAkB,EAClB,6BAA6B,EAE9B,MAAM,6BAA6B,CAAC;AAQrC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAMhD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C;;GAEG;AACH,eAAO,MAAM,gCAAgC,IAAI,CAAC;AAElD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,qBAAa,eAAgB,SAAQ,WAAW;IAC9C,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAS;IAC3C,OAAO,CAAC,6BAA6B,CAA4C;IAEjF;;;;;;;;;;;;;;;OAeG;gBAED,IAAI,EAAE,UAAU,EAChB,iBAAiB,EAAE,MAAM,EACzB,SAAS,GAAE,OAAe,EAC1B,eAAe,GAAE,MAAc;IAMjC;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,mCAAmC;IA4C3C;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,mBAAmB;IAc3B;;;;;;;;;;;OAWG;IAEH,OAAO,CAAC,oBAAoB;IAU5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiDG;IACH,gCAAgC,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;IAO3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkDG;IACG,sBAAsB,CAC1B,OAAO,EAAE,6BAA6B,GACrC,OAAO,CAAC,uBAAuB,CAAC;IA2DnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoFG;IACG,qCAAqC,CACzC,OAAO,EAAE,4BAA4B,GACpC,OAAO,CAAC,kBAAkB,CAAC;IAmE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2EG;IACG,wCAAwC,CAC5C,OAAO,EAAE,4BAA4B,GACpC,OAAO,CAAC,kBAAkB,CAAC;IA2E9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+CG;IACG,gCAAgC,CACpC,OAAO,EAAE,4BAA4B,EACrC,IAAI,GAAE,OAAO,GAAG,UAAoB,GACnC,OAAO,CAAC,kBAAkB,CAAC;CAM/B"}