@clonegod/ttd-bsc-common 3.0.11 → 3.0.12

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,58 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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;
+    }
+    getTick(tick) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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',
+            };
+        });
+    }
+    nextInitializedTickWithinOneWord(tick, lte, tickSpacing) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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;

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

@@ -35,6 +35,7 @@ export declare class ClmmTickCache {
     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

@@ -20,7 +20,7 @@ class ClmmTickCache {
         this.loader = loader;
         this.config = {
             neighboringWords: (_a = config.neighboringWords) !== null && _a !== void 0 ? _a : 2,
-            refreshInterval: (_b = config.refreshInterval) !== null && _b !== void 0 ? _b : 30000,
+            refreshInterval: (_b = config.refreshInterval) !== null && _b !== void 0 ? _b : 60000,
             minUpdateInterval: (_c = config.minUpdateInterval) !== null && _c !== void 0 ? _c : 3000,
         };
     }
@@ -201,6 +201,32 @@ class ClmmTickCache {
         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);

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

@@ -1,2 +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/quote/tick/index.js

@@ -16,3 +16,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __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,149 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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) {
+        var _a;
+        this.tickSpacingMap = new Map();
+        this.ethersLib = params.ethersLib;
+        this.provider = params.provider;
+        this.stateViewAddress = params.stateViewAddress;
+        const InterfaceClass = params.ethersLib.Interface || ((_a = params.ethersLib.utils) === null || _a === void 0 ? void 0 : _a.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);
+    }
+    loadBitmapWords(poolAddress, bitmapIndexes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            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 || ((_a = this.multicallContract.callStatic) === null || _a === void 0 ? void 0 : _a.aggregate);
+                const [, bitmapReturnData] = yield 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] = yield 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clonegod/ttd-bsc-common",
-  "version": "3.0.11",
+  "version": "3.0.12",
   "description": "BSC common library",
   "license": "UNLICENSED",
   "main": "dist/index.js",