@clonegod/ttd-base-common 1.0.25 → 1.1.1

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

@@ -0,0 +1,42 @@
+export declare const TICK_REFRESH_INTERVAL_MS: number;
+export interface TickInfo {
+    liquidityNet: bigint;
+    liquidityGross: bigint;
+}
+export interface ClmmTickCacheConfig {
+    neighboringWords?: number;
+    refreshInterval?: number;
+    minUpdateInterval?: number;
+}
+export interface TickLensLoader {
+    loadBitmapWords(poolAddress: string, bitmapIndexes: number[]): Promise<Map<number, TickInfo>>;
+}
+export declare class ClmmTickCache {
+    private pools;
+    private refreshTimers;
+    private loadPromises;
+    private loader;
+    private config;
+    constructor(loader: TickLensLoader, config?: ClmmTickCacheConfig);
+    initPool(poolAddress: string, currentTick: number, tickSpacing: number): Promise<void>;
+    onSwap(poolAddress: string, newTick: number): Promise<void>;
+    onMint(poolAddress: string, tickLower: number, tickUpper: number, amount: bigint): void;
+    onBurn(poolAddress: string, tickLower: number, tickUpper: number, amount: bigint): void;
+    onModifyLiquidity(poolAddress: string, tickLower: number, tickUpper: number, liquidityDelta: bigint): void;
+    private applyLiquidityDelta;
+    private updateTickLiquidity;
+    getTickLiquidityNet(poolAddress: string, tickIndex: number): bigint | undefined;
+    getTickInfo(poolAddress: string, tickIndex: number): TickInfo | undefined;
+    getCachedTickIndices(poolAddress: string): number[];
+    getTickSpacing(poolAddress: string): number | undefined;
+    hasPool(poolAddress: string): boolean;
+    private scheduleFullRefresh;
+    private startPeriodicRefresh;
+    private doFullRefresh;
+    private getBitmapIndex;
+    private calcBitmapIndexes;
+    private isInCachedRange;
+    getNextInitializedTickWithinOneWord(poolAddress: string, tick: number, tickSpacing: number, zeroForOne: boolean): [number, boolean] | null;
+    clearPool(poolAddress: string): void;
+    destroy(): void;
+}

package/dist/quote/tick/clmm_tick_cache.js

@@ -0,0 +1,236 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClmmTickCache = exports.TICK_REFRESH_INTERVAL_MS = void 0;
+const ttd_core_1 = require("@clonegod/ttd-core");
+exports.TICK_REFRESH_INTERVAL_MS = Number(process.env.TICK_CACHE_FORCE_FULL_REFRESH_INTERVAL) || 60000;
+class ClmmTickCache {
+    constructor(loader, config = {}) {
+        this.pools = new Map();
+        this.refreshTimers = new Map();
+        this.loadPromises = new Map();
+        this.loader = loader;
+        this.config = {
+            neighboringWords: config.neighboringWords ?? (Number(process.env.TICK_CACHE_NEIGHBORING_WORDS) || 2),
+            refreshInterval: config.refreshInterval ?? exports.TICK_REFRESH_INTERVAL_MS,
+            minUpdateInterval: config.minUpdateInterval ?? (Number(process.env.TICK_CACHE_MIN_UPDATE_INTERVAL) || 3000),
+        };
+    }
+    async initPool(poolAddress, currentTick, tickSpacing) {
+        const bitmapIndexes = this.calcBitmapIndexes(currentTick, tickSpacing);
+        (0, ttd_core_1.log_info)(`[TickCache] Init pool ${poolAddress}: tick=${currentTick}, tickSpacing=${tickSpacing}, loading ${bitmapIndexes.length} bitmap words`);
+        const ticks = await this.loader.loadBitmapWords(poolAddress, bitmapIndexes);
+        this.pools.set(poolAddress, {
+            ticks,
+            bitmapIndexes,
+            currentTick,
+            tickSpacing,
+            lastFullLoadTime: Date.now(),
+            pendingForceRefresh: false,
+            loading: false,
+        });
+        this.startPeriodicRefresh(poolAddress);
+        (0, ttd_core_1.log_info)(`[TickCache] Pool ${poolAddress} initialized: ${ticks.size} ticks loaded`);
+    }
+    async onSwap(poolAddress, newTick) {
+        const state = this.pools.get(poolAddress);
+        if (!state)
+            return;
+        state.currentTick = newTick;
+        const currentBitmapIndex = this.getBitmapIndex(newTick, state.tickSpacing);
+        if (!state.bitmapIndexes.includes(currentBitmapIndex)) {
+            const cachedRange = `[${Math.min(...state.bitmapIndexes)}..${Math.max(...state.bitmapIndexes)}]`;
+            (0, ttd_core_1.log_info)(`[TickCache] 本地缓存 tick 缺失，开始同步 RPC 刷新: pool=${poolAddress.slice(0, 10)}..., tick=${newTick}, bitmapIndex=${currentBitmapIndex}, cachedWords=${cachedRange}`);
+            await this.scheduleFullRefresh(poolAddress);
+        }
+    }
+    onMint(poolAddress, tickLower, tickUpper, amount) {
+        this.applyLiquidityDelta(poolAddress, tickLower, tickUpper, amount);
+    }
+    onBurn(poolAddress, tickLower, tickUpper, amount) {
+        this.applyLiquidityDelta(poolAddress, tickLower, tickUpper, -amount);
+    }
+    onModifyLiquidity(poolAddress, tickLower, tickUpper, liquidityDelta) {
+        this.applyLiquidityDelta(poolAddress, tickLower, tickUpper, liquidityDelta);
+    }
+    applyLiquidityDelta(poolAddress, tickLower, tickUpper, delta) {
+        const state = this.pools.get(poolAddress);
+        if (!state) {
+            (0, ttd_core_1.log_warn)(`[TickCache] Pool ${poolAddress} not initialized, ignoring liquidity event`);
+            return;
+        }
+        const absDelta = delta < BigInt(0) ? -delta : delta;
+        let needAsyncRefresh = false;
+        needAsyncRefresh = this.updateTickLiquidity(state, tickLower, delta, absDelta, true) || needAsyncRefresh;
+        needAsyncRefresh = this.updateTickLiquidity(state, tickUpper, -delta, absDelta, false) || needAsyncRefresh;
+        if (needAsyncRefresh) {
+            this.scheduleFullRefresh(poolAddress);
+        }
+        (0, ttd_core_1.log_debug)(`[TickCache] Pool ${poolAddress}: liquidity delta applied, tickLower=${tickLower}, tickUpper=${tickUpper}, delta=${delta}`);
+    }
+    updateTickLiquidity(state, tickIndex, netDelta, grossDelta, isLower) {
+        const existing = state.ticks.get(tickIndex);
+        if (existing) {
+            existing.liquidityNet += netDelta;
+            existing.liquidityGross += (netDelta > BigInt(0) ? grossDelta : -grossDelta);
+            if (existing.liquidityGross <= BigInt(0)) {
+                state.ticks.delete(tickIndex);
+                (0, ttd_core_1.log_debug)(`[TickCache] Tick ${tickIndex} de-initialized (liquidityGross <= 0)`);
+            }
+            return false;
+        }
+        if (netDelta > BigInt(0) || grossDelta > BigInt(0)) {
+            if (this.isInCachedRange(state, tickIndex)) {
+                state.ticks.set(tickIndex, {
+                    liquidityNet: netDelta,
+                    liquidityGross: grossDelta,
+                });
+                (0, ttd_core_1.log_debug)(`[TickCache] New tick ${tickIndex} initialized in cached range`);
+                return false;
+            }
+            else {
+                (0, ttd_core_1.log_debug)(`[TickCache] New tick ${tickIndex} outside cached range, will refresh async`);
+                return true;
+            }
+        }
+        return false;
+    }
+    getTickLiquidityNet(poolAddress, tickIndex) {
+        const state = this.pools.get(poolAddress);
+        if (!state)
+            return undefined;
+        return state.ticks.get(tickIndex)?.liquidityNet;
+    }
+    getTickInfo(poolAddress, tickIndex) {
+        const state = this.pools.get(poolAddress);
+        if (!state)
+            return undefined;
+        return state.ticks.get(tickIndex);
+    }
+    getCachedTickIndices(poolAddress) {
+        const state = this.pools.get(poolAddress);
+        if (!state)
+            return [];
+        return Array.from(state.ticks.keys()).sort((a, b) => a - b);
+    }
+    getTickSpacing(poolAddress) {
+        return this.pools.get(poolAddress)?.tickSpacing;
+    }
+    hasPool(poolAddress) {
+        return this.pools.has(poolAddress);
+    }
+    async scheduleFullRefresh(poolAddress) {
+        const state = this.pools.get(poolAddress);
+        if (!state)
+            return;
+        const existing = this.loadPromises.get(poolAddress);
+        if (existing) {
+            return existing;
+        }
+        const elapsed = Date.now() - state.lastFullLoadTime;
+        if (elapsed < this.config.minUpdateInterval) {
+            return;
+        }
+        const promise = this.doFullRefresh(poolAddress).finally(() => {
+            this.loadPromises.delete(poolAddress);
+        });
+        this.loadPromises.set(poolAddress, promise);
+        return promise;
+    }
+    startPeriodicRefresh(poolAddress) {
+        const old = this.refreshTimers.get(poolAddress);
+        if (old)
+            clearInterval(old);
+        const timer = setInterval(async () => {
+            try {
+                await this.doFullRefresh(poolAddress);
+            }
+            catch (err) {
+                (0, ttd_core_1.log_warn)(`[TickCache] Periodic refresh failed for ${poolAddress}: ${err.message}`);
+            }
+        }, this.config.refreshInterval);
+        this.refreshTimers.set(poolAddress, timer);
+    }
+    async doFullRefresh(poolAddress) {
+        const state = this.pools.get(poolAddress);
+        if (!state)
+            return;
+        if (state.loading) {
+            state.pendingForceRefresh = true;
+            return;
+        }
+        state.loading = true;
+        try {
+            const bitmapIndexes = this.calcBitmapIndexes(state.currentTick, state.tickSpacing);
+            const ticks = await this.loader.loadBitmapWords(poolAddress, bitmapIndexes);
+            state.ticks = ticks;
+            state.bitmapIndexes = bitmapIndexes;
+            state.lastFullLoadTime = Date.now();
+            state.pendingForceRefresh = false;
+            (0, ttd_core_1.log_debug)(`[TickCache] Full refresh for ${poolAddress}: ${ticks.size} ticks, ${bitmapIndexes.length} words`);
+        }
+        finally {
+            state.loading = false;
+            if (state.pendingForceRefresh) {
+                state.pendingForceRefresh = false;
+                this.doFullRefresh(poolAddress).catch(() => { });
+            }
+        }
+    }
+    getBitmapIndex(tick, tickSpacing) {
+        return Math.floor(tick / tickSpacing / 256);
+    }
+    calcBitmapIndexes(currentTick, tickSpacing) {
+        const center = this.getBitmapIndex(currentTick, tickSpacing);
+        const n = this.config.neighboringWords;
+        const indexes = [];
+        for (let i = -n; i <= n; i++) {
+            indexes.push(center + i);
+        }
+        return indexes;
+    }
+    isInCachedRange(state, tickIndex) {
+        const bitmapIndex = this.getBitmapIndex(tickIndex, state.tickSpacing);
+        return state.bitmapIndexes.includes(bitmapIndex);
+    }
+    getNextInitializedTickWithinOneWord(poolAddress, tick, tickSpacing, zeroForOne) {
+        const state = this.pools.get(poolAddress);
+        if (!state)
+            return null;
+        const compressed = Math.floor(tick / tickSpacing);
+        const wordPos = compressed >> 8;
+        const wordStartTick = (wordPos << 8) * tickSpacing;
+        const wordEndTick = ((wordPos + 1) << 8) * tickSpacing;
+        const ticksInWord = Array.from(state.ticks.keys())
+            .filter(t => t >= wordStartTick && t < wordEndTick)
+            .sort((a, b) => a - b);
+        if (ticksInWord.length === 0)
+            return null;
+        if (zeroForOne) {
+            const nextTick = ticksInWord.find(t => t > tick);
+            if (nextTick !== undefined)
+                return [nextTick, true];
+        }
+        else {
+            for (let i = ticksInWord.length - 1; i >= 0; i--) {
+                if (ticksInWord[i] < tick)
+                    return [ticksInWord[i], true];
+            }
+        }
+        return null;
+    }
+    clearPool(poolAddress) {
+        this.pools.delete(poolAddress);
+        const timer = this.refreshTimers.get(poolAddress);
+        if (timer) {
+            clearInterval(timer);
+            this.refreshTimers.delete(poolAddress);
+        }
+        this.loadPromises.delete(poolAddress);
+    }
+    destroy() {
+        for (const [addr] of this.pools) {
+            this.clearPool(addr);
+        }
+    }
+}
+exports.ClmmTickCache = ClmmTickCache;

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

@@ -0,0 +1,4 @@
+export * from './clmm_tick_cache';
+export * from './tick_lens_loaders';
+export * from './cached_tick_data_provider';
+export * from './state_view_tick_loader';

package/dist/{ws → quote/tick}/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("./subscribe_v2_events"), exports);
-__exportStar(require("./subscribe_v3_events"), exports);
+__exportStar(require("./clmm_tick_cache"), exports);
+__exportStar(require("./tick_lens_loaders"), exports);
+__exportStar(require("./cached_tick_data_provider"), exports);
+__exportStar(require("./state_view_tick_loader"), exports);

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

@@ -0,0 +1,17 @@
+import { TickInfo, TickLensLoader } from './clmm_tick_cache';
+export declare class StateViewTickLensLoader implements TickLensLoader {
+    private ethersLib;
+    private provider;
+    private stateViewAddress;
+    private stateViewIface;
+    private multicallContract;
+    private tickSpacingMap;
+    constructor(params: {
+        ethersLib: any;
+        provider: any;
+        stateViewAddress: string;
+        multicallAddress?: string;
+    });
+    setTickSpacing(poolAddress: string, tickSpacing: number): void;
+    loadBitmapWords(poolAddress: string, bitmapIndexes: number[]): Promise<Map<number, TickInfo>>;
+}

package/dist/quote/tick/state_view_tick_loader.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StateViewTickLensLoader = void 0;
+const ttd_core_1 = require("@clonegod/ttd-core");
+const tick_lens_loaders_1 = require("./tick_lens_loaders");
+const STATE_VIEW_ABI = [
+    {
+        type: 'function',
+        name: 'getTickBitmap',
+        inputs: [
+            { name: 'poolId', type: 'bytes32' },
+            { name: 'tick', type: 'int16' },
+        ],
+        outputs: [
+            { name: 'tickBitmap', type: 'uint256' },
+        ],
+        stateMutability: 'view',
+    },
+    {
+        type: 'function',
+        name: 'getTickLiquidity',
+        inputs: [
+            { name: 'poolId', type: 'bytes32' },
+            { name: 'tick', type: 'int24' },
+        ],
+        outputs: [
+            { name: 'liquidityGross', type: 'uint128' },
+            { name: 'liquidityNet', type: 'int128' },
+        ],
+        stateMutability: 'view',
+    },
+];
+const MULTICALL3_ABI = [
+    {
+        type: 'function',
+        name: 'aggregate',
+        inputs: [
+            {
+                name: 'calls',
+                type: 'tuple[]',
+                components: [
+                    { name: 'target', type: 'address' },
+                    { name: 'callData', type: 'bytes' },
+                ],
+            },
+        ],
+        outputs: [
+            { name: 'blockNumber', type: 'uint256' },
+            { name: 'returnData', type: 'bytes[]' },
+        ],
+        stateMutability: 'nonpayable',
+    },
+];
+function getInitializedTicksFromBitmap(bitmapIndex, bitmap, tickSpacing) {
+    const ticks = [];
+    for (let bit = 0; bit < 256; bit++) {
+        if ((bitmap >> BigInt(bit)) & BigInt(1)) {
+            const tickIndex = (bitmapIndex * 256 + bit) * tickSpacing;
+            ticks.push(tickIndex);
+        }
+    }
+    return ticks;
+}
+class StateViewTickLensLoader {
+    constructor(params) {
+        this.tickSpacingMap = new Map();
+        this.ethersLib = params.ethersLib;
+        this.provider = params.provider;
+        this.stateViewAddress = params.stateViewAddress;
+        const InterfaceClass = params.ethersLib.Interface || params.ethersLib.utils?.Interface;
+        if (!InterfaceClass) {
+            throw new Error('ethersLib.Interface not found');
+        }
+        this.stateViewIface = new InterfaceClass(STATE_VIEW_ABI);
+        this.multicallContract = new params.ethersLib.Contract(params.multicallAddress || tick_lens_loaders_1.MULTICALL3_ADDRESS, MULTICALL3_ABI, this.provider);
+    }
+    setTickSpacing(poolAddress, tickSpacing) {
+        this.tickSpacingMap.set(poolAddress.toLowerCase(), tickSpacing);
+    }
+    async loadBitmapWords(poolAddress, bitmapIndexes) {
+        const result = new Map();
+        if (bitmapIndexes.length === 0)
+            return result;
+        const tickSpacing = this.tickSpacingMap.get(poolAddress.toLowerCase());
+        if (!tickSpacing) {
+            (0, ttd_core_1.log_warn)(`[StateViewLoader] tickSpacing not set for ${poolAddress}, defaulting to 1`);
+        }
+        const spacing = tickSpacing || 1;
+        try {
+            const bitmapCalls = bitmapIndexes.map(bitmapIndex => ({
+                target: this.stateViewAddress,
+                callData: this.stateViewIface.encodeFunctionData('getTickBitmap', [poolAddress, bitmapIndex]),
+            }));
+            const callMethod = this.multicallContract.aggregate.staticCall || this.multicallContract.callStatic?.aggregate;
+            const [, bitmapReturnData] = await callMethod(bitmapCalls);
+            const initializedTicks = [];
+            for (let i = 0; i < bitmapReturnData.length; i++) {
+                try {
+                    const decoded = this.stateViewIface.decodeFunctionResult('getTickBitmap', bitmapReturnData[i]);
+                    const bitmap = typeof decoded[0] === 'bigint' ? decoded[0] : BigInt(decoded[0].toString());
+                    const ticks = getInitializedTicksFromBitmap(bitmapIndexes[i], bitmap, spacing);
+                    initializedTicks.push(...ticks);
+                }
+                catch (e) {
+                    (0, ttd_core_1.log_warn)(`[StateViewLoader] Failed to decode bitmap ${bitmapIndexes[i]}: ${e.message}`);
+                }
+            }
+            if (initializedTicks.length === 0) {
+                (0, ttd_core_1.log_debug)(`[StateViewLoader] No initialized ticks in ${bitmapIndexes.length} bitmap words`);
+                return result;
+            }
+            const liquidityCalls = initializedTicks.map(tick => ({
+                target: this.stateViewAddress,
+                callData: this.stateViewIface.encodeFunctionData('getTickLiquidity', [poolAddress, tick]),
+            }));
+            const [, liquidityReturnData] = await callMethod(liquidityCalls);
+            for (let i = 0; i < liquidityReturnData.length; i++) {
+                try {
+                    const decoded = this.stateViewIface.decodeFunctionResult('getTickLiquidity', liquidityReturnData[i]);
+                    const liquidityGross = typeof decoded[0] === 'bigint' ? decoded[0] : BigInt(decoded[0].toString());
+                    const liquidityNet = typeof decoded[1] === 'bigint' ? decoded[1] : BigInt(decoded[1].toString());
+                    result.set(initializedTicks[i], { liquidityNet, liquidityGross });
+                }
+                catch (e) {
+                    (0, ttd_core_1.log_warn)(`[StateViewLoader] Failed to decode tick ${initializedTicks[i]}: ${e.message}`);
+                }
+            }
+            (0, ttd_core_1.log_debug)(`[StateViewLoader] Loaded ${result.size} ticks from ${bitmapIndexes.length} bitmap words (2 Multicall3 calls)`);
+        }
+        catch (error) {
+            (0, ttd_core_1.log_warn)(`[StateViewLoader] Multicall failed: ${error.message}`);
+        }
+        return result;
+    }
+}
+exports.StateViewTickLensLoader = StateViewTickLensLoader;

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

@@ -0,0 +1,24 @@
+import { TickInfo, TickLensLoader } from "./clmm_tick_cache";
+export declare const MULTICALL3_ADDRESS = "0xcA11bde05977b3631167028862bE2a173976CA11";
+export declare const BASE_TICK_LENS_ADDRESSES: {
+    readonly UNISWAP_V3: "0x0CdeE061c75D43c82520eD998C23ac2991c9ac6d";
+    readonly UNISWAP_V4: "0xA3c0c9b65baD0b08107Aa264b0f3dB444b867A71";
+};
+export declare class MulticallTickLensLoader implements TickLensLoader {
+    private ethersLib;
+    private provider;
+    private tickLensAddress;
+    private tickLensAbi;
+    private multicallAddress;
+    private tickLensIface;
+    private multicallContract;
+    constructor(params: {
+        ethersLib: any;
+        provider: any;
+        tickLensAddress: string;
+        version: 'V3' | 'V4';
+        multicallAddress?: string;
+    });
+    loadBitmapWords(poolAddress: string, bitmapIndexes: number[]): Promise<Map<number, TickInfo>>;
+    private loadBitmapWordsIndividually;
+}

package/dist/quote/tick/tick_lens_loaders.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MulticallTickLensLoader = exports.BASE_TICK_LENS_ADDRESSES = exports.MULTICALL3_ADDRESS = void 0;
+const ttd_core_1 = require("@clonegod/ttd-core");
+exports.MULTICALL3_ADDRESS = '0xcA11bde05977b3631167028862bE2a173976CA11';
+exports.BASE_TICK_LENS_ADDRESSES = {
+    UNISWAP_V3: '0x0CdeE061c75D43c82520eD998C23ac2991c9ac6d',
+    UNISWAP_V4: '0xA3c0c9b65baD0b08107Aa264b0f3dB444b867A71',
+};
+const V3_TICK_LENS_ABI = [
+    {
+        type: 'function',
+        name: 'getPopulatedTicksInWord',
+        inputs: [
+            { name: 'pool', type: 'address' },
+            { name: 'tickBitmapIndex', type: 'int16' },
+        ],
+        outputs: [
+            {
+                name: 'populatedTicks',
+                type: 'tuple[]',
+                components: [
+                    { name: 'tick', type: 'int24' },
+                    { name: 'liquidityNet', type: 'int128' },
+                    { name: 'liquidityGross', type: 'uint128' },
+                ],
+            },
+        ],
+        stateMutability: 'view',
+    },
+];
+const V4_TICK_LENS_ABI = [
+    {
+        type: 'function',
+        name: 'getPopulatedTicksInWord',
+        inputs: [
+            { name: 'id', type: 'bytes32' },
+            { name: 'tickBitmapIndex', type: 'int16' },
+        ],
+        outputs: [
+            {
+                name: 'populatedTicks',
+                type: 'tuple[]',
+                components: [
+                    { name: 'tick', type: 'int24' },
+                    { name: 'liquidityNet', type: 'int128' },
+                    { name: 'liquidityGross', type: 'uint128' },
+                ],
+            },
+        ],
+        stateMutability: 'view',
+    },
+];
+const MULTICALL3_ABI = [
+    {
+        type: 'function',
+        name: 'aggregate',
+        inputs: [
+            {
+                name: 'calls',
+                type: 'tuple[]',
+                components: [
+                    { name: 'target', type: 'address' },
+                    { name: 'callData', type: 'bytes' },
+                ],
+            },
+        ],
+        outputs: [
+            { name: 'blockNumber', type: 'uint256' },
+            { name: 'returnData', type: 'bytes[]' },
+        ],
+        stateMutability: 'nonpayable',
+    },
+];
+class MulticallTickLensLoader {
+    constructor(params) {
+        this.ethersLib = params.ethersLib;
+        this.provider = params.provider;
+        this.tickLensAddress = params.tickLensAddress;
+        this.tickLensAbi = params.version === 'V4' ? V4_TICK_LENS_ABI : V3_TICK_LENS_ABI;
+        this.multicallAddress = params.multicallAddress || exports.MULTICALL3_ADDRESS;
+        const InterfaceClass = params.ethersLib.Interface || params.ethersLib.utils?.Interface;
+        if (!InterfaceClass) {
+            throw new Error('ethersLib.Interface not found, ensure ethers v5 or v6 is passed');
+        }
+        this.tickLensIface = new InterfaceClass(this.tickLensAbi);
+        this.multicallContract = new params.ethersLib.Contract(this.multicallAddress, MULTICALL3_ABI, this.provider);
+    }
+    async loadBitmapWords(poolAddress, bitmapIndexes) {
+        const result = new Map();
+        if (bitmapIndexes.length === 0)
+            return result;
+        try {
+            const calls = bitmapIndexes.map(bitmapIndex => {
+                const callData = this.tickLensIface.encodeFunctionData('getPopulatedTicksInWord', [
+                    poolAddress,
+                    bitmapIndex,
+                ]);
+                return {
+                    target: this.tickLensAddress,
+                    callData,
+                };
+            });
+            const callMethod = this.multicallContract.aggregate.staticCall || this.multicallContract.callStatic?.aggregate;
+            const [, returnData] = await callMethod(calls);
+            for (let i = 0; i < returnData.length; i++) {
+                try {
+                    const decoded = this.tickLensIface.decodeFunctionResult('getPopulatedTicksInWord', returnData[i]);
+                    const populatedTicks = decoded[0];
+                    if (!populatedTicks || populatedTicks.length === 0)
+                        continue;
+                    for (const tick of populatedTicks) {
+                        const tickIndex = typeof tick.tick === 'bigint' ? Number(tick.tick) : tick.tick;
+                        result.set(tickIndex, {
+                            liquidityNet: typeof tick.liquidityNet === 'bigint'
+                                ? tick.liquidityNet
+                                : BigInt(String(tick.liquidityNet)),
+                            liquidityGross: typeof tick.liquidityGross === 'bigint'
+                                ? tick.liquidityGross
+                                : BigInt(String(tick.liquidityGross)),
+                        });
+                    }
+                }
+                catch (e) {
+                    (0, ttd_core_1.log_warn)(`[TickLensLoader] Failed to decode bitmap index ${bitmapIndexes[i]}: ${e.message}`);
+                }
+            }
+            (0, ttd_core_1.log_debug)(`[TickLensLoader] Loaded ${result.size} ticks from ${bitmapIndexes.length} bitmap words (1 RPC call)`);
+        }
+        catch (error) {
+            (0, ttd_core_1.log_warn)(`[TickLensLoader] Multicall failed, falling back to individual queries: ${error.message}`);
+            await this.loadBitmapWordsIndividually(poolAddress, bitmapIndexes, result);
+        }
+        return result;
+    }
+    async loadBitmapWordsIndividually(poolAddress, bitmapIndexes, result) {
+        const tickLensContract = new this.ethersLib.Contract(this.tickLensAddress, this.tickLensAbi, this.provider);
+        const promises = bitmapIndexes.map(async (bitmapIndex) => {
+            try {
+                const callMethod = tickLensContract.getPopulatedTicksInWord.staticCall
+                    || tickLensContract.callStatic?.getPopulatedTicksInWord;
+                const populatedTicks = await callMethod(poolAddress, bitmapIndex);
+                for (const tick of populatedTicks) {
+                    const tickIndex = Number(tick.tick);
+                    result.set(tickIndex, {
+                        liquidityNet: BigInt(tick.liquidityNet.toString()),
+                        liquidityGross: BigInt(tick.liquidityGross.toString()),
+                    });
+                }
+            }
+            catch (e) {
+                (0, ttd_core_1.log_warn)(`[TickLensLoader] Bitmap index ${bitmapIndex} query failed for ${poolAddress}`);
+            }
+        });
+        await Promise.all(promises);
+    }
+}
+exports.MulticallTickLensLoader = MulticallTickLensLoader;

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

@@ -0,0 +1,2 @@
+export { QuotePriceVerify } from './quote_price_verify';
+export type { CheckSwapParams } from './quote_price_verify';

package/dist/quote/verify/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuotePriceVerify = void 0;
+var quote_price_verify_1 = require("./quote_price_verify");
+Object.defineProperty(exports, "QuotePriceVerify", { enumerable: true, get: function () { return quote_price_verify_1.QuotePriceVerify; } });

package/dist/quote/verify/quote_price_verify.d.ts

@@ -0,0 +1,30 @@
+import { QuoteTier } from '@clonegod/ttd-core';
+export interface CheckSwapParams {
+    poolAddress: string;
+    poolName: string;
+    blockNumber: number;
+    txHash: string;
+    amount0: string;
+    amount1: string;
+    token0Address: string;
+    token1Address: string;
+    token0Decimals: number;
+    token1Decimals: number;
+    poolInfo: {
+        tokenA: any;
+        tokenB: any;
+        quote_token: string;
+    };
+    swapperDeltaConvention?: boolean;
+}
+export declare class QuotePriceVerify {
+    private quoteCache;
+    private get enabled();
+    cacheQuote(poolAddress: string, priceId: string, source: string, askPrice: number, bidPrice: number, blockNumber: number, quoteAmountUsd: number, token0PriceUsd?: number, token1PriceUsd?: number, tiers?: {
+        askTiers?: QuoteTier[];
+        bidTiers?: QuoteTier[];
+    }): void;
+    checkSwap(params: CheckSwapParams): void;
+    private deriveSwapDirection;
+    private compareAndLog;
+}