@clonegod/ttd-base-common 1.0.26 → 1.1.2

package/dist/quote/get_base_token_price.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.get_base_token_price_info = get_base_token_price_info;
+const ttd_core_1 = require("@clonegod/ttd-core");
+const DEFI_LLAMA_BASE_CHAIN = 'base';
+const GECKO_BASE_NETWORK = 'base';
+const BATCH_SIZE = 10;
+const BATCH_DELAY_MS = 1000;
+async function fetchFromDefiLlama(addresses) {
+    const result = new Map();
+    if (addresses.length === 0)
+        return result;
+    const keys = addresses.map(a => `${DEFI_LLAMA_BASE_CHAIN}:${a}`).join(',');
+    const url = `https://coins.llama.fi/prices/current/${keys}`;
+    const res = await ttd_core_1.HttpUtil.get(url);
+    if (!res?.coins)
+        return result;
+    for (const addr of addresses) {
+        const key = `${DEFI_LLAMA_BASE_CHAIN}:${addr}`;
+        const c = res.coins[key];
+        if (c?.price != null) {
+            result.set(addr, {
+                _id: addr.toLowerCase(),
+                address: addr,
+                symbol: c.symbol,
+                decimals: c.decimals,
+                price: String(c.price),
+                update_time: c.timestamp ? new Date(c.timestamp * 1000).toISOString() : new Date().toISOString(),
+            });
+        }
+    }
+    return result;
+}
+async function fetchFromGeckoTerminal(addresses) {
+    const result = new Map();
+    if (addresses.length === 0)
+        return result;
+    const url = `https://api.geckoterminal.com/api/v2/networks/${GECKO_BASE_NETWORK}/tokens/multi/${addresses.join(',')}`;
+    const res = await ttd_core_1.HttpUtil.get(url);
+    if (!res?.data)
+        return result;
+    for (const item of res.data) {
+        const attr = item?.attributes;
+        if (!attr?.address || attr.price_usd == null)
+            continue;
+        result.set(attr.address, {
+            _id: attr.address.toLowerCase(),
+            address: attr.address,
+            symbol: attr.symbol,
+            decimals: attr.decimals,
+            price: String(attr.price_usd),
+            update_time: new Date().toISOString(),
+        });
+    }
+    return result;
+}
+async function get_base_token_price_info(addresses, opts) {
+    addresses = Array.from(new Set(addresses.map(a => a.toLowerCase())));
+    const result = new Map();
+    if (addresses.length === 0)
+        return result;
+    const channels = [
+        { name: 'DefiLlama', fn: fetchFromDefiLlama },
+        { name: 'GeckoTerminal', fn: fetchFromGeckoTerminal },
+    ];
+    let remaining = [...addresses];
+    for (const ch of channels) {
+        if (remaining.length === 0)
+            break;
+        const batches = (0, ttd_core_1.chunkArray)(remaining, BATCH_SIZE);
+        (0, ttd_core_1.log_debug)(`[get_base_token_price] ${ch.name}: ${remaining.length} addrs in ${batches.length} batches`);
+        for (let i = 0; i < batches.length; i++) {
+            try {
+                const hit = await ch.fn(batches[i]);
+                for (const [k, v] of hit)
+                    result.set(k, v);
+            }
+            catch (e) {
+                (0, ttd_core_1.log_warn)(`[get_base_token_price] ${ch.name} batch ${i + 1} error: ${e?.message ?? e}`);
+            }
+            if (i < batches.length - 1)
+                await (0, ttd_core_1.sleep)(BATCH_DELAY_MS);
+        }
+        remaining = remaining.filter(a => !result.has(a));
+    }
+    if (opts?.source === 'force_fetch' && result.size === 0) {
+        throw new Error(`Unable to fetch price for any token: ${addresses.join(', ')}`);
+    }
+    return result;
+}

package/dist/quote/index.d.ts

@@ -1,2 +1,9 @@
 export * from './event';
 export * from './pricing';
+export * from './tick';
+export * from './depth';
+export * from './verify';
+export * from './price_feed_handler';
+export * from './quote_amount';
+export * from './preload_token_prices';
+export * from './get_base_token_price';

package/dist/quote/index.js

@@ -16,3 +16,10 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./event"), exports);
 __exportStar(require("./pricing"), exports);
+__exportStar(require("./tick"), exports);
+__exportStar(require("./depth"), exports);
+__exportStar(require("./verify"), exports);
+__exportStar(require("./price_feed_handler"), exports);
+__exportStar(require("./quote_amount"), exports);
+__exportStar(require("./preload_token_prices"), exports);
+__exportStar(require("./get_base_token_price"), exports);

package/dist/quote/preload_token_prices.d.ts

@@ -0,0 +1,2 @@
+import { StandardPoolInfoType } from '@clonegod/ttd-core';
+export declare function preloadTokenPrices(pool_list: StandardPoolInfoType[], label?: string): Promise<void>;

package/dist/quote/preload_token_prices.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preloadTokenPrices = preloadTokenPrices;
+const ttd_core_1 = require("@clonegod/ttd-core");
+const get_base_token_price_1 = require("./get_base_token_price");
+async function preloadTokenPrices(pool_list, label = 'Quote') {
+    if (!pool_list || pool_list.length === 0)
+        return;
+    const addrSet = new Set();
+    for (const pool of pool_list) {
+        if (pool.tokenA?.address)
+            addrSet.add(pool.tokenA.address.toLowerCase());
+        if (pool.tokenB?.address)
+            addrSet.add(pool.tokenB.address.toLowerCase());
+    }
+    const addresses = Array.from(addrSet);
+    if (addresses.length === 0)
+        return;
+    try {
+        const priceMap = await (0, get_base_token_price_1.get_base_token_price_info)(addresses, { source: 'force_fetch' });
+        const got = [];
+        const miss = [];
+        for (const a of addresses) {
+            if (priceMap.get(a)?.price)
+                got.push(a);
+            else
+                miss.push(a);
+        }
+        (0, ttd_core_1.log_info)(`[${label}] preloadTokenPrices done, total=${addresses.length}, got=${got.length}, miss=${miss.length}`);
+        if (miss.length > 0) {
+            (0, ttd_core_1.log_warn)(`[${label}] preloadTokenPrices missing: ${miss.join(', ')}`);
+        }
+    }
+    catch (err) {
+        (0, ttd_core_1.log_warn)(`[${label}] preloadTokenPrices error (non-fatal): ${err.message}`);
+    }
+}

package/dist/quote/price_feed_handler.d.ts

@@ -0,0 +1,15 @@
+import type { QuoteResultType, StandardPoolInfoType } from '@clonegod/ttd-core';
+interface PriceFeedData {
+    blockNumber: number;
+    token0Symbol?: string;
+    token1Symbol?: string;
+    askToken0InToken1?: string;
+    bidToken0InToken1?: string;
+    askToken1InToken0?: string;
+    bidToken1InToken0?: string;
+}
+export declare function buildQuoteFromPriceFeed(poolInfo: StandardPoolInfoType, data: PriceFeedData): {
+    askQuote: QuoteResultType;
+    bidQuote: QuoteResultType;
+} | null;
+export {};

package/dist/quote/price_feed_handler.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildQuoteFromPriceFeed = buildQuoteFromPriceFeed;
+const ttd_core_1 = require("@clonegod/ttd-core");
+function buildQuoteFromPriceFeed(poolInfo, data) {
+    const quoteTokenSymbol = (poolInfo.quote_token || '').toUpperCase();
+    const tokenA = poolInfo.tokenA;
+    const tokenB = poolInfo.tokenB;
+    if (!tokenA || !tokenB) {
+        (0, ttd_core_1.log_warn)(`[PriceFeed] poolInfo missing tokenA/tokenB: ${poolInfo.pool_address}`);
+        return null;
+    }
+    const normSymbol = (s) => {
+        const u = (s || '').toUpperCase();
+        return u === 'WETH' ? 'ETH' : u;
+    };
+    const tokenAIsQuote = normSymbol(tokenA.symbol) === normSymbol(quoteTokenSymbol);
+    const tokenBIsQuote = normSymbol(tokenB.symbol) === normSymbol(quoteTokenSymbol);
+    if (!tokenAIsQuote && !tokenBIsQuote) {
+        (0, ttd_core_1.log_warn)(`[PriceFeed] quote_token "${quoteTokenSymbol}" 在池子配置里找不到 (tokenA=${tokenA.symbol}, tokenB=${tokenB.symbol}, pool=${poolInfo.pool_name})`);
+        return null;
+    }
+    let askPrice;
+    let bidPrice;
+    let baseToken;
+    let quoteToken;
+    if (tokenAIsQuote) {
+        quoteToken = tokenA;
+        baseToken = tokenB;
+        askPrice = data.askToken1InToken0;
+        bidPrice = data.bidToken1InToken0;
+    }
+    else {
+        quoteToken = tokenB;
+        baseToken = tokenA;
+        askPrice = data.askToken0InToken1;
+        bidPrice = data.bidToken0InToken1;
+    }
+    if (!askPrice || !bidPrice) {
+        (0, ttd_core_1.log_warn)(`[PriceFeed] Missing price for pool=${poolInfo.pool_name}, direction=${tokenAIsQuote ? 'token1InToken0' : 'token0InToken1'}, feedSymbols=[${data.token0Symbol}/${data.token1Symbol}]`);
+        return null;
+    }
+    const makeQuoteResult = (price, input, output) => ({
+        inputToken: input,
+        outputToken: output,
+        slippageBps: 0,
+        amountIn: 0,
+        amountOut: 0,
+        amountOutMin: 0,
+        priceImpact: 0,
+        price,
+    });
+    const askQuote = makeQuoteResult(askPrice, quoteToken, baseToken);
+    const bidQuote = makeQuoteResult(bidPrice, baseToken, quoteToken);
+    return { askQuote, bidQuote };
+}

package/dist/quote/pricing/fee_helpers.d.ts

@@ -0,0 +1,13 @@
+import { AmmPoolState, ClmmPoolState, InfinityPoolState } from '../../types/pool_state';
+export declare const V4_DYNAMIC_FEE_FLAG = 8388608;
+export declare function calculateSwapFeePpm(protocolFeePpm: number, lpFeePpm: number): number;
+export declare function decodeV4ProtocolFee(encodedProtocolFee: number, zeroForOne: boolean): number;
+export declare function v2EffectiveFeeBps(state: AmmPoolState): number;
+export declare function v3EffectiveFeeBps(state: ClmmPoolState): number;
+export declare function v4EffectiveFeeBps(state: InfinityPoolState): number;
+export declare function v4EffectiveFeePpm(state: InfinityPoolState): number;
+export declare function v4DirectionalFeePpm(state: InfinityPoolState, zeroForOne: boolean): number;
+export declare function buildInfinityPoolSdkFee(state: InfinityPoolState): {
+    fee: number;
+    protocolFee: number;
+};

package/dist/quote/pricing/fee_helpers.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.V4_DYNAMIC_FEE_FLAG = void 0;
+exports.calculateSwapFeePpm = calculateSwapFeePpm;
+exports.decodeV4ProtocolFee = decodeV4ProtocolFee;
+exports.v2EffectiveFeeBps = v2EffectiveFeeBps;
+exports.v3EffectiveFeeBps = v3EffectiveFeeBps;
+exports.v4EffectiveFeeBps = v4EffectiveFeeBps;
+exports.v4EffectiveFeePpm = v4EffectiveFeePpm;
+exports.v4DirectionalFeePpm = v4DirectionalFeePpm;
+exports.buildInfinityPoolSdkFee = buildInfinityPoolSdkFee;
+exports.V4_DYNAMIC_FEE_FLAG = 0x800000;
+function calculateSwapFeePpm(protocolFeePpm, lpFeePpm) {
+    return protocolFeePpm + lpFeePpm - Math.floor(protocolFeePpm * lpFeePpm / 1000000);
+}
+function decodeV4ProtocolFee(encodedProtocolFee, zeroForOne) {
+    if (zeroForOne)
+        return encodedProtocolFee & 0xFFF;
+    return (encodedProtocolFee >> 12) & 0xFFF;
+}
+function v2EffectiveFeeBps(state) {
+    return state.protocolFeeBps;
+}
+function v3EffectiveFeeBps(state) {
+    return state.poolFee / 100;
+}
+function v4EffectiveFeeBps(state) {
+    return v4EffectiveFeePpm(state) / 100;
+}
+function v4EffectiveFeePpm(state) {
+    if (state.lastSwapFee != null) {
+        return state.lastSwapFee;
+    }
+    if (state.poolKeyFee !== exports.V4_DYNAMIC_FEE_FLAG) {
+        return state.poolKeyFee;
+    }
+    const lp = state.slot0LpFee ?? 0;
+    const proto = state.slot0ProtocolFee ?? 0;
+    const proto0to1 = proto & 0xFFF;
+    const proto1to0 = (proto >> 12) & 0xFFF;
+    const fee0to1 = calculateSwapFeePpm(proto0to1, lp);
+    const fee1to0 = calculateSwapFeePpm(proto1to0, lp);
+    return Math.max(fee0to1, fee1to0);
+}
+function v4DirectionalFeePpm(state, zeroForOne) {
+    if (state.lastSwapFee != null) {
+        return state.lastSwapFee;
+    }
+    if (state.poolKeyFee !== exports.V4_DYNAMIC_FEE_FLAG) {
+        return state.poolKeyFee;
+    }
+    const lp = state.slot0LpFee ?? 0;
+    const proto = state.slot0ProtocolFee ?? 0;
+    const directionalProto = decodeV4ProtocolFee(proto, zeroForOne);
+    return calculateSwapFeePpm(directionalProto, lp);
+}
+function buildInfinityPoolSdkFee(state) {
+    if (state.lastSwapFee != null) {
+        return { fee: state.lastSwapFee, protocolFee: 0 };
+    }
+    if (state.poolKeyFee !== exports.V4_DYNAMIC_FEE_FLAG) {
+        return { fee: state.poolKeyFee, protocolFee: 0 };
+    }
+    return {
+        fee: state.slot0LpFee ?? 0,
+        protocolFee: state.slot0ProtocolFee ?? 0,
+    };
+}

package/dist/quote/pricing/index.d.ts

@@ -1,2 +1,4 @@
-export * from './token_price_cache';
 export * from './pool';
+export * from './sdk_token_factory';
+export * from './pool_state_initializer';
+export * from './fee_helpers';

package/dist/quote/pricing/index.js

@@ -14,5 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./token_price_cache"), exports);
 __exportStar(require("./pool"), exports);
+__exportStar(require("./sdk_token_factory"), exports);
+__exportStar(require("./pool_state_initializer"), exports);
+__exportStar(require("./fee_helpers"), exports);

package/dist/quote/pricing/pool_state_initializer.d.ts

@@ -0,0 +1,12 @@
+import { AmmPoolState, ClmmPoolState, InfinityPoolState } from "../../types/pool_state";
+declare function withInitRetry<T>(fn: () => Promise<T>, label: string): Promise<T>;
+export { withInitRetry };
+export declare class PoolStateInitializer {
+    static initAmmPool(provider: any, poolAddress: string, dexId: string, ethersLib: any, opts?: {
+        aerodromePoolFactoryAddress?: string;
+    }): Promise<AmmPoolState>;
+    static initClmmPool(provider: any, poolAddress: string, ethersLib: any, poolAbi?: any[]): Promise<ClmmPoolState>;
+    static initInfinityPool(provider: any, poolKey: string, poolManagerAddress: string, poolManagerAbi: any, ethersLib: any, decodeParameters: (params: string) => {
+        tickSpacing: number;
+    }): Promise<InfinityPoolState>;
+}

package/dist/quote/pricing/pool_state_initializer.js

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PoolStateInitializer = void 0;
+exports.withInitRetry = withInitRetry;
+const ttd_core_1 = require("@clonegod/ttd-core");
+async function withInitRetry(fn, label) {
+    try {
+        return await fn();
+    }
+    catch (err) {
+        (0, ttd_core_1.log_warn)(`[PoolStateInitializer] ${label} attempt 1 failed: ${err?.message || err}, retrying once...`);
+        try {
+            return await fn();
+        }
+        catch (err2) {
+            (0, ttd_core_1.log_error)(`[PoolStateInitializer] ${label} retry also failed`, err2 instanceof Error ? err2 : new Error(String(err2)));
+            const addrMatch = label.match(/0x[0-9a-fA-F]+/);
+            const identity = (addrMatch?.[0] || label).toLowerCase();
+            ttd_core_1.ALERT_TYPES.QUOTE_POOL_INIT_FAILED.report({
+                severity: 'critical',
+                identity,
+                scope: { pool_address: addrMatch ? identity : undefined },
+                title: `Pool init failed: ${label} — ${err2?.message || err2}`,
+                detail: { label, error: String(err2?.message || err2), stack: err2?.stack },
+            });
+            throw err2;
+        }
+    }
+}
+const V2_PAIR_ABI = [
+    'function token0() view returns (address)',
+    'function token1() view returns (address)',
+    'function getReserves() view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast)',
+];
+const AERODROME_AMM_EXTRA_ABI = [
+    'function stable() view returns (bool)',
+    'function decimals0() view returns (uint256)',
+    'function decimals1() view returns (uint256)',
+];
+const V3_POOL_ABI = [
+    'function token0() view returns (address)',
+    'function token1() view returns (address)',
+    'function fee() view returns (uint24)',
+    'function tickSpacing() view returns (int24)',
+    'function slot0() view returns (uint160 sqrtPriceX96, int24 tick, uint16 observationIndex, uint16 observationCardinality, uint16 observationCardinalityNext, uint8 feeProtocol, bool unlocked)',
+    'function liquidity() view returns (uint128)',
+];
+const AMM_FEE_MAP = {
+    'PANCAKE-AMM': 25,
+    'PANCAKE_AMM': 25,
+    'UNISWAP-AMM': 30,
+    'UNISWAP_AMM': 30,
+    'AERODROME-AMM': 30,
+    'AERODROME_AMM': 30,
+};
+const AERODROME_POOL_FACTORY_ABI = [
+    'function getFee(address pool, bool stable) view returns (uint256)',
+];
+class PoolStateInitializer {
+    static async initAmmPool(provider, poolAddress, dexId, ethersLib, opts) {
+        try {
+            const isAerodrome = dexId.toUpperCase().startsWith('AERODROME');
+            const abi = isAerodrome ? [...V2_PAIR_ABI, ...AERODROME_AMM_EXTRA_ABI] : V2_PAIR_ABI;
+            const poolContract = new ethersLib.Contract(poolAddress, abi, provider);
+            const basePromises = [
+                poolContract.getReserves(),
+                poolContract.token0(),
+                poolContract.token1(),
+            ];
+            if (isAerodrome) {
+                basePromises.push(poolContract.stable(), poolContract.decimals0(), poolContract.decimals1());
+            }
+            const results = await Promise.all(basePromises);
+            const [reserves, token0, token1] = results;
+            let protocolFeeBps = AMM_FEE_MAP[dexId] || AMM_FEE_MAP[dexId.replace('-', '_')] || 30;
+            let stable;
+            let decimals0;
+            let decimals1;
+            if (isAerodrome) {
+                stable = results[3];
+                decimals0 = results[4].toString();
+                decimals1 = results[5].toString();
+                if (opts?.aerodromePoolFactoryAddress) {
+                    try {
+                        const factory = new ethersLib.Contract(opts.aerodromePoolFactoryAddress, AERODROME_POOL_FACTORY_ABI, provider);
+                        const feeOnChain = await factory.getFee(poolAddress, stable);
+                        protocolFeeBps = Number(feeOnChain);
+                    }
+                    catch (e) {
+                        (0, ttd_core_1.log_error)(`[PoolStateInitializer] Aerodrome getFee 失败，用默认 ${protocolFeeBps}bps`, e);
+                    }
+                }
+            }
+            const state = {
+                address: poolAddress,
+                token0: token0.toLowerCase(),
+                token1: token1.toLowerCase(),
+                protocolFeeBps,
+                reserve0: reserves[0].toString(),
+                reserve1: reserves[1].toString(),
+                ...(stable !== undefined ? { stable, decimals0, decimals1 } : {}),
+            };
+            (0, ttd_core_1.log_info)(`[PoolStateInitializer] AMM pool initialized: ${poolAddress}`, {
+                token0: state.token0, token1: state.token1, protocolFeeBps: state.protocolFeeBps,
+                ...(stable !== undefined ? { stable, decimals0, decimals1 } : {}),
+            });
+            return state;
+        }
+        catch (error) {
+            (0, ttd_core_1.log_error)(`[PoolStateInitializer] Failed to init AMM pool ${poolAddress}:`, error);
+            throw error;
+        }
+    }
+    static async initClmmPool(provider, poolAddress, ethersLib, poolAbi) {
+        try {
+            const abi = poolAbi || V3_POOL_ABI;
+            const poolContract = new ethersLib.Contract(poolAddress, abi, provider);
+            const [token0, token1, fee, tickSpacing, slot0, liquidity] = await Promise.all([
+                poolContract.token0(),
+                poolContract.token1(),
+                poolContract.fee(),
+                poolContract.tickSpacing(),
+                poolContract.slot0(),
+                poolContract.liquidity(),
+            ]);
+            const [sqrtPriceX96, tick] = slot0;
+            const state = {
+                address: poolAddress,
+                token0: token0.toLowerCase(),
+                token1: token1.toLowerCase(),
+                poolFee: Number(fee),
+                tickSpacing: Number(tickSpacing),
+                tick: Number(tick),
+                sqrtPriceX96: sqrtPriceX96.toString(),
+                liquidity: liquidity.toString(),
+            };
+            (0, ttd_core_1.log_info)(`[PoolStateInitializer] CLMM pool initialized: ${poolAddress}`, {
+                token0: state.token0, token1: state.token1,
+                poolFee: state.poolFee,
+                tickSpacing: state.tickSpacing, tick: state.tick,
+            });
+            return state;
+        }
+        catch (error) {
+            (0, ttd_core_1.log_error)(`[PoolStateInitializer] Failed to init CLMM pool ${poolAddress}:`, error);
+            throw error;
+        }
+    }
+    static async initInfinityPool(provider, poolKey, poolManagerAddress, poolManagerAbi, ethersLib, decodeParameters) {
+        try {
+            const poolManagerContract = new ethersLib.Contract(poolManagerAddress, poolManagerAbi, provider);
+            const [slot0Result, liquidity, poolKeyInfo] = await Promise.all([
+                poolManagerContract.getSlot0(poolKey),
+                poolManagerContract.getLiquidity(poolKey),
+                poolManagerContract.poolIdToPoolKey(poolKey),
+            ]);
+            const [sqrtPriceX96, tick, protocolFee, lpFee] = slot0Result;
+            const [currency0, currency1, hooks, poolManager, fee, parameters] = poolKeyInfo;
+            const { tickSpacing } = decodeParameters(parameters);
+            const state = {
+                address: poolKey,
+                token0: currency0.toLowerCase ? currency0.toLowerCase() : currency0,
+                token1: currency1.toLowerCase ? currency1.toLowerCase() : currency1,
+                currency0,
+                currency1,
+                hooks,
+                poolManager,
+                parameters,
+                tickSpacing,
+                poolKeyFee: Number(fee),
+                tick: Number(tick),
+                sqrtPriceX96: sqrtPriceX96.toString(),
+                liquidity: liquidity.toString(),
+                slot0LpFee: Number(lpFee),
+                slot0ProtocolFee: Number(protocolFee),
+            };
+            (0, ttd_core_1.log_info)(`[PoolStateInitializer] Infinity pool initialized: ${poolKey}`, {
+                currency0: state.currency0, currency1: state.currency1,
+                poolKeyFee: state.poolKeyFee,
+                slot0LpFee: state.slot0LpFee, slot0ProtocolFee: state.slot0ProtocolFee,
+                tickSpacing: state.tickSpacing, tick: state.tick,
+            });
+            return state;
+        }
+        catch (error) {
+            (0, ttd_core_1.log_error)(`[PoolStateInitializer] Failed to init Infinity pool ${poolKey}:`, error);
+            throw error;
+        }
+    }
+}
+exports.PoolStateInitializer = PoolStateInitializer;

package/dist/quote/pricing/sdk_token_factory.d.ts

@@ -0,0 +1,2 @@
+import { StandardPoolInfoType } from "@clonegod/ttd-core";
+export declare function buildSdkTokenMap<T>(chainId: number, poolInfoMap: Map<string, StandardPoolInfoType>, TokenClass: new (chainId: number, address: string, decimals: number, symbol?: string, name?: string) => T): Map<string, T>;

package/dist/quote/pricing/sdk_token_factory.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSdkTokenMap = buildSdkTokenMap;
+const ttd_core_1 = require("@clonegod/ttd-core");
+function buildSdkTokenMap(chainId, poolInfoMap, TokenClass) {
+    const sdkTokens = new Map();
+    for (const poolInfo of poolInfoMap.values()) {
+        const tokens = [poolInfo.tokenA, poolInfo.tokenB];
+        for (const tokenInfo of tokens) {
+            const address = tokenInfo.address;
+            if (sdkTokens.has(address))
+                continue;
+            let symbol = tokenInfo.symbol || address.substring(0, 6);
+            let name = tokenInfo.name || `Token ${address.substring(0, 8)}`;
+            const token = new TokenClass(chainId, address, tokenInfo.decimals, symbol, name);
+            sdkTokens.set(address, token);
+            (0, ttd_core_1.log_debug)(`Created SDK Token: ${address}, symbol: ${symbol}, decimals: ${tokenInfo.decimals}`, '');
+        }
+    }
+    return sdkTokens;
+}

package/dist/quote/quote_amount.d.ts

@@ -0,0 +1,4 @@
+import { StandardPoolInfoType } from '@clonegod/ttd-core';
+import Decimal from 'decimal.js';
+export declare function getQuoteAmountUsd(poolInfo: StandardPoolInfoType): number;
+export declare function usdToTokenUiAmount(amountInUsd: number, tokenAddress: string): Promise<Decimal>;

package/dist/quote/quote_amount.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getQuoteAmountUsd = getQuoteAmountUsd;
+exports.usdToTokenUiAmount = usdToTokenUiAmount;
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const get_base_token_price_1 = require("./get_base_token_price");
+function getQuoteAmountUsd(poolInfo) {
+    const envValue = Number(process.env.QUOTE_AMOUNT_USD);
+    if (envValue > 0) {
+        return envValue;
+    }
+    return poolInfo.quote_amount_usd;
+}
+async function usdToTokenUiAmount(amountInUsd, tokenAddress) {
+    const priceMap = await (0, get_base_token_price_1.get_base_token_price_info)([tokenAddress]);
+    const price = priceMap.get(tokenAddress)?.price;
+    if (!price || price === '0') {
+        throw new Error(`price not available for ${tokenAddress}`);
+    }
+    return new decimal_js_1.default(amountInUsd).div(new decimal_js_1.default(price));
+}

package/dist/quote/tick/cached_tick_data_provider.d.ts

@@ -0,0 +1,12 @@
+import { ClmmTickCache } from './clmm_tick_cache';
+export declare class CachedTickDataProvider {
+    private tickCache;
+    private poolAddress;
+    private tickSpacing;
+    constructor(tickCache: ClmmTickCache, poolAddress: string, tickSpacing: number);
+    getTick(tick: number): Promise<{
+        liquidityNet: string;
+        liquidityGross: string;
+    }>;
+    nextInitializedTickWithinOneWord(tick: number, lte: boolean, tickSpacing: number): Promise<[number, boolean]>;
+}

package/dist/quote/tick/cached_tick_data_provider.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CachedTickDataProvider = void 0;
+const ttd_core_1 = require("@clonegod/ttd-core");
+const MIN_TICK = -887272;
+const MAX_TICK = 887272;
+class CachedTickDataProvider {
+    constructor(tickCache, poolAddress, tickSpacing) {
+        this.tickCache = tickCache;
+        this.poolAddress = poolAddress;
+        this.tickSpacing = tickSpacing;
+    }
+    async getTick(tick) {
+        const tickInfo = this.tickCache.getTickInfo(this.poolAddress, tick);
+        if (tickInfo) {
+            return {
+                liquidityNet: tickInfo.liquidityNet.toString(),
+                liquidityGross: tickInfo.liquidityGross.toString(),
+            };
+        }
+        (0, ttd_core_1.log_warn)(`[CachedTickDataProvider] tick ${tick} not in cache for pool ${this.poolAddress}`);
+        return {
+            liquidityNet: '0',
+            liquidityGross: '0',
+        };
+    }
+    async nextInitializedTickWithinOneWord(tick, lte, tickSpacing) {
+        const zeroForOne = !lte;
+        const result = this.tickCache.getNextInitializedTickWithinOneWord(this.poolAddress, tick, tickSpacing, zeroForOne);
+        if (result)
+            return result;
+        const compressed = Math.floor(tick / tickSpacing);
+        if (lte) {
+            const wordPos = compressed >> 8;
+            const minimum = (wordPos << 8) * tickSpacing;
+            return [Math.max(minimum, MIN_TICK), false];
+        }
+        else {
+            const wordPos = (compressed + 1) >> 8;
+            const maximum = (((wordPos + 1) << 8) - 1) * tickSpacing;
+            return [Math.min(maximum, MAX_TICK), false];
+        }
+    }
+}
+exports.CachedTickDataProvider = CachedTickDataProvider;