@clonegod/ttd-base-common 1.0.25 → 1.1.1

package/dist/quote/depth/tick_liquidity_snapshot.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTickLiquiditySnapshot = buildTickLiquiditySnapshot;
+const clmm_depth_calculator_1 = require("./clmm_depth_calculator");
+const Q96 = 1n << 96n;
+const DEFAULT_RANGE_BPS = 200;
+function buildTickLiquiditySnapshot(input) {
+    const { poolAddress, pair, protocolId, tickCache, currentTick, tickSpacing, token0, token1, baseIsToken0, token0PriceUsd, token1PriceUsd, } = input;
+    const currentSqrtPriceX96 = BigInt(input.sqrtPriceX96);
+    const currentLiquidity = BigInt(input.liquidity);
+    const rangeBps = input.rangeBps ?? DEFAULT_RANGE_BPS;
+    if (currentLiquidity === 0n)
+        return undefined;
+    const allTickIndices = tickCache.getCachedTickIndices(poolAddress);
+    if (allTickIndices.length === 0)
+        return undefined;
+    const upperSqrtPrice = (0, clmm_depth_calculator_1.computeTargetSqrtPrice)(currentSqrtPriceX96, rangeBps, false);
+    const lowerSqrtPrice = (0, clmm_depth_calculator_1.computeTargetSqrtPrice)(currentSqrtPriceX96, rangeBps, true);
+    const upperTick = sqrtPriceToTick(upperSqrtPrice);
+    const lowerTick = sqrtPriceToTick(lowerSqrtPrice);
+    const ticksInRange = allTickIndices.filter(t => t >= lowerTick && t <= upperTick);
+    if (ticksInRange.length === 0)
+        return undefined;
+    const liquidityMap = computeLiquidityAtTicks(ticksInRange, currentTick, currentLiquidity, tickCache, poolAddress);
+    const tickDataPoints = [];
+    let totalTvlUsd = 0;
+    for (let i = 0; i < ticksInRange.length - 1; i++) {
+        const tickLower = ticksInRange[i];
+        const tickUpper = ticksInRange[i + 1];
+        const liq = liquidityMap.get(tickLower) ?? 0n;
+        if (liq <= 0n) {
+            const price0 = tickToPrice(tickLower, token0.decimals, token1.decimals);
+            const price1 = price0 > 0 ? 1 / price0 : 0;
+            tickDataPoints.push({
+                tick: tickLower,
+                price0, price1,
+                liquidity: '0',
+                amount0: 0, amount1: 0, tvlUsd: 0,
+                buyable: 0, sellable: 0,
+            });
+            continue;
+        }
+        const sqrtPriceLower = (0, clmm_depth_calculator_1.getSqrtRatioAtTick)(tickLower);
+        const sqrtPriceUpper = (0, clmm_depth_calculator_1.getSqrtRatioAtTick)(tickUpper);
+        const { amount0, amount1 } = computeTokenAmounts(sqrtPriceLower, sqrtPriceUpper, currentSqrtPriceX96, liq, token0.decimals, token1.decimals);
+        const tvlUsd = amount0 * token0PriceUsd + amount1 * token1PriceUsd;
+        totalTvlUsd += tvlUsd;
+        const { buyable, sellable } = computeBuySell(sqrtPriceLower, sqrtPriceUpper, liq, token0.decimals, token1.decimals, baseIsToken0);
+        const price0 = tickToPrice(tickLower, token0.decimals, token1.decimals);
+        const price1 = price0 > 0 ? 1 / price0 : 0;
+        tickDataPoints.push({
+            tick: tickLower,
+            price0, price1,
+            liquidity: liq.toString(),
+            amount0, amount1, tvlUsd,
+            buyable, sellable,
+        });
+    }
+    const currentPriceFloat = Number(currentSqrtPriceX96) / Number(Q96);
+    const currentPrice = (currentPriceFloat * currentPriceFloat) *
+        Math.pow(10, token0.decimals - token1.decimals);
+    return {
+        poolAddress,
+        pair,
+        protocolId,
+        currentTick,
+        tickSpacing,
+        currentPrice,
+        token0,
+        token1,
+        ticks: tickDataPoints,
+        totalTvlUsd,
+        timestamp: Date.now(),
+    };
+}
+function computeLiquidityAtTicks(sortedTicks, currentTick, currentLiquidity, tickCache, poolAddress) {
+    const result = new Map();
+    let splitIdx = sortedTicks.findIndex(t => t > currentTick);
+    if (splitIdx === -1)
+        splitIdx = sortedTicks.length;
+    let liq = currentLiquidity;
+    for (let i = splitIdx; i < sortedTicks.length; i++) {
+        const tick = sortedTicks[i];
+        const netLiq = tickCache.getTickLiquidityNet(poolAddress, tick) ?? 0n;
+        liq = liq + netLiq;
+        result.set(tick, liq > 0n ? liq : 0n);
+    }
+    liq = currentLiquidity;
+    for (let i = splitIdx - 1; i >= 0; i--) {
+        const tick = sortedTicks[i];
+        result.set(tick, liq > 0n ? liq : 0n);
+        const netLiq = tickCache.getTickLiquidityNet(poolAddress, tick) ?? 0n;
+        liq = liq - netLiq;
+    }
+    return result;
+}
+function computeTokenAmounts(sqrtPriceLower, sqrtPriceUpper, currentSqrtPrice, liquidity, decimals0, decimals1) {
+    let amount0Wei = 0n;
+    let amount1Wei = 0n;
+    if (currentSqrtPrice <= sqrtPriceLower) {
+        amount0Wei = calcToken0Amount(sqrtPriceLower, sqrtPriceUpper, liquidity);
+    }
+    else if (currentSqrtPrice >= sqrtPriceUpper) {
+        amount1Wei = calcToken1Amount(sqrtPriceLower, sqrtPriceUpper, liquidity);
+    }
+    else {
+        amount0Wei = calcToken0Amount(currentSqrtPrice, sqrtPriceUpper, liquidity);
+        amount1Wei = calcToken1Amount(sqrtPriceLower, currentSqrtPrice, liquidity);
+    }
+    return {
+        amount0: Number(amount0Wei) / Math.pow(10, decimals0),
+        amount1: Number(amount1Wei) / Math.pow(10, decimals1),
+    };
+}
+function computeBuySell(sqrtPriceLower, sqrtPriceUpper, liquidity, decimals0, decimals1, baseIsToken0) {
+    const token0Out = Number(calcToken0Amount(sqrtPriceLower, sqrtPriceUpper, liquidity)) / Math.pow(10, decimals0);
+    const token1Out = Number(calcToken1Amount(sqrtPriceLower, sqrtPriceUpper, liquidity)) / Math.pow(10, decimals1);
+    if (baseIsToken0) {
+        return { buyable: token0Out, sellable: token1Out };
+    }
+    else {
+        return { buyable: token1Out, sellable: token0Out };
+    }
+}
+function calcToken0Amount(sqrtPriceLower, sqrtPriceUpper, liquidity) {
+    if (sqrtPriceLower >= sqrtPriceUpper || liquidity === 0n)
+        return 0n;
+    const diff = sqrtPriceUpper - sqrtPriceLower;
+    return liquidity * diff * Q96 / (sqrtPriceLower * sqrtPriceUpper);
+}
+function calcToken1Amount(sqrtPriceLower, sqrtPriceUpper, liquidity) {
+    if (sqrtPriceLower >= sqrtPriceUpper || liquidity === 0n)
+        return 0n;
+    const diff = sqrtPriceUpper - sqrtPriceLower;
+    return liquidity * diff / Q96;
+}
+function sqrtPriceToTick(sqrtPriceX96) {
+    const sqrtPriceFloat = Number(sqrtPriceX96) / Number(Q96);
+    return Math.floor(Math.log(sqrtPriceFloat * sqrtPriceFloat) / Math.log(1.0001));
+}
+function tickToPrice(tick, decimals0, decimals1) {
+    return Math.pow(1.0001, tick) * Math.pow(10, decimals0 - decimals1);
+}

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

@@ -1 +1,2 @@
 export * from './pool_event_listener';
+export * from './swap_debouncer';

package/dist/quote/event/index.js

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./pool_event_listener"), exports);
+__exportStar(require("./swap_debouncer"), exports);

package/dist/quote/event/pool_event_listener.d.ts

@@ -1,9 +1,11 @@
 import { StandardPoolInfoType } from '@clonegod/ttd-core';
-import { AppConfig } from '@clonegod/ttd-core/dist';
+import { AppConfig } from '@clonegod/ttd-core';
 export interface BlockUpdateEvent {
     blockNumber: number;
-    previousBlockNumber: number;
-    timestamp: number;
+    previousBlockNumber?: number;
+    blockTimestamp?: number;
+    blockTimestampMs?: number;
+    recvBlockTime: number;
 }
 export interface ConnectionDiagnostics {
     isConnected: boolean;

package/dist/quote/event/pool_event_listener.js

@@ -1,17 +1,8 @@
 "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.PoolEventListener = void 0;
-const ethers_1 = require("ethers");
-const dist_1 = require("@clonegod/ttd-core/dist");
+const ethers_compat_1 = require("../../utils/ethers_compat");
+const ttd_core_1 = require("@clonegod/ttd-core");
 const common_1 = require("../../common");
 const CONFIG = {
     MAX_RETRIES: 3,
@@ -44,81 +35,73 @@ class PoolEventListener {
         this.appConfig = appConfig;
         this.ws_endpoint = ws_endpoint;
     }
-    init(poolList) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.poolList = poolList.filter(pool => ethers_1.ethers.utils.isAddress(pool.pool_address));
-            if (this.poolList.length !== poolList.length) {
-                (0, dist_1.log_warn)(`Found ${poolList.length - this.poolList.length} invalid pool addresses, filtered out`, '');
-            }
-            yield this.connect();
-        });
+    async init(poolList) {
+        this.poolList = poolList.filter(pool => ethers_compat_1.ethersCompat.isAddress(pool.pool_address));
+        if (this.poolList.length !== poolList.length) {
+            (0, ttd_core_1.log_warn)(`Found ${poolList.length - this.poolList.length} invalid pool addresses, filtered out`, '');
+        }
+        await this.connect();
     }
-    start() {
-        return __awaiter(this, void 0, void 0, function* () {
-            (0, dist_1.log_info)(`Starting block listener...`);
-            if (!this.isConnected || !this.wsProvider) {
-                (0, dist_1.log_warn)('WebSocket not connected, cannot start listener', '');
-                return;
-            }
-            yield this.startBlockListener();
-            this.isStarted = true;
-            (0, dist_1.log_info)('Block listener started successfully');
-        });
+    async start() {
+        (0, ttd_core_1.log_info)(`Starting block listener...`);
+        if (!this.isConnected || !this.wsProvider) {
+            (0, ttd_core_1.log_warn)('WebSocket not connected, cannot start listener', '');
+            return;
+        }
+        await this.startBlockListener();
+        this.isStarted = true;
+        (0, ttd_core_1.log_info)('Block listener started successfully');
     }
-    stop() {
-        return __awaiter(this, void 0, void 0, function* () {
-            (0, dist_1.log_info)(`Stopping block listener...`);
-            this.stopBlockListener();
-            this.cleanup();
-            this.isStarted = false;
-            (0, dist_1.log_info)(`Block listener stopped`);
-        });
+    async stop() {
+        (0, ttd_core_1.log_info)(`Stopping block listener...`);
+        this.stopBlockListener();
+        this.cleanup();
+        this.isStarted = false;
+        (0, ttd_core_1.log_info)(`Block listener stopped`);
     }
-    connect() {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (let i = 0; i < CONFIG.MAX_RETRIES; i++) {
-                try {
-                    (0, dist_1.log_info)(`Connecting to WebSocket: ${this.ws_endpoint} (Attempt ${i + 1}/${CONFIG.MAX_RETRIES})`);
-                    this.wsProvider = new ethers_1.ethers.providers.WebSocketProvider(this.ws_endpoint);
-                    const wsPromise = this.wsProvider.ready;
-                    const timeoutPromise = new Promise((_, reject) => {
-                        setTimeout(() => reject(new Error('WebSocket connection timeout')), CONFIG.CONNECTION_TIMEOUT);
-                    });
-                    yield Promise.race([wsPromise, timeoutPromise]);
-                    this.isConnected = true;
-                    this.reconnectAttempts = 0;
-                    (0, dist_1.log_info)(`WebSocket connected: ${this.ws_endpoint}`);
-                    this.setupWebSocketListeners();
-                    if (this.isStarted) {
-                        yield this.startBlockListener();
-                    }
-                    return;
+    async connect() {
+        for (let i = 0; i < CONFIG.MAX_RETRIES; i++) {
+            try {
+                (0, ttd_core_1.log_info)(`Connecting to WebSocket: ${this.ws_endpoint} (Attempt ${i + 1}/${CONFIG.MAX_RETRIES})`);
+                this.wsProvider = new ethers_compat_1.ethersCompat.WebSocketProvider(this.ws_endpoint);
+                const wsPromise = this.wsProvider.ready;
+                const timeoutPromise = new Promise((_, reject) => {
+                    setTimeout(() => reject(new Error('WebSocket connection timeout')), CONFIG.CONNECTION_TIMEOUT);
+                });
+                await Promise.race([wsPromise, timeoutPromise]);
+                this.isConnected = true;
+                this.reconnectAttempts = 0;
+                (0, ttd_core_1.log_info)(`WebSocket connected: ${this.ws_endpoint}`);
+                this.setupWebSocketListeners();
+                if (this.isStarted) {
+                    await this.startBlockListener();
                 }
-                catch (error) {
-                    (0, dist_1.log_error)(`WebSocket connection failed (Attempt ${i + 1}/${CONFIG.MAX_RETRIES}):`, error);
-                    if (i === CONFIG.MAX_RETRIES - 1) {
-                        throw error;
-                    }
-                    const delay = CONFIG.RETRY_DELAY_MULTIPLIER * (i + 1);
-                    (0, dist_1.log_info)(`Waiting ${delay / 1000} seconds before retry...`);
-                    yield new Promise(resolve => setTimeout(resolve, delay));
+                return;
+            }
+            catch (error) {
+                (0, ttd_core_1.log_error)(`WebSocket connection failed (Attempt ${i + 1}/${CONFIG.MAX_RETRIES}):`, error);
+                if (i === CONFIG.MAX_RETRIES - 1) {
+                    throw error;
                 }
+                const delay = CONFIG.RETRY_DELAY_MULTIPLIER * (i + 1);
+                (0, ttd_core_1.log_info)(`Waiting ${delay / 1000} seconds before retry...`);
+                await new Promise(resolve => setTimeout(resolve, delay));
             }
-        });
+        }
     }
     setupWebSocketListeners() {
         if (!this.wsProvider)
             return;
         this.wsProvider.on('error', (err) => {
-            (0, dist_1.log_error)(`WebSocket error:`, err, '');
+            (0, ttd_core_1.log_error)(`WebSocket error:`, err, '');
             this.handleConnectionIssue();
         });
         this.wsProvider._websocket.on('close', (code, reason) => {
-            (0, dist_1.log_warn)(`WebSocket connection closed, code: ${code}, reason: ${reason || 'unknown'}`);
+            (0, ttd_core_1.log_warn)(`WebSocket connection closed, code: ${code}, reason: ${reason || 'unknown'}`);
             this.handleConnectionIssue();
         });
         this.wsProvider._websocket.on('open', () => {
-            (0, dist_1.log_info)('WebSocket connection opened');
+            (0, ttd_core_1.log_info)('WebSocket connection opened');
             this.isConnected = true;
             this.reconnectAttempts = 0;
         });
@@ -128,7 +111,7 @@ class PoolEventListener {
         if (this.heartbeatInterval) {
             clearInterval(this.heartbeatInterval);
         }
-        this.heartbeatInterval = setInterval(() => __awaiter(this, void 0, void 0, function* () {
+        this.heartbeatInterval = setInterval(async () => {
             try {
                 if (!this.wsProvider || !this.isConnected) {
                     this.handleConnectionIssue();
@@ -138,89 +121,85 @@ class PoolEventListener {
                 this.lastHeartbeatResponse = Date.now();
                 const timeSinceLastHeartbeat = Date.now() - this.lastHeartbeatResponse;
                 if (timeSinceLastHeartbeat > CONFIG.HEARTBEAT_TIMEOUT) {
-                    (0, dist_1.log_warn)(`No heartbeat response for ${timeSinceLastHeartbeat / 1000} seconds`);
+                    (0, ttd_core_1.log_warn)(`No heartbeat response for ${timeSinceLastHeartbeat / 1000} seconds`);
                     this.handleConnectionIssue();
                 }
             }
             catch (error) {
-                (0, dist_1.log_error)('Heartbeat check failed:', error);
+                (0, ttd_core_1.log_error)('Heartbeat check failed:', error);
                 this.handleConnectionIssue();
             }
-        }), CONFIG.HEARTBEAT_INTERVAL);
+        }, CONFIG.HEARTBEAT_INTERVAL);
     }
-    handleConnectionIssue() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.isReconnecting) {
-                (0, dist_1.log_info)('Already attempting to reconnect, skipping...');
-                return;
-            }
-            this.isReconnecting = true;
-            this.isConnected = false;
-            try {
-                this.stopBlockListener();
-                this.cleanup();
-                this.reconnectAttempts++;
-                const delay = Math.min(CONFIG.BASE_RECONNECT_DELAY * Math.pow(2, this.reconnectAttempts), CONFIG.MAX_RECONNECT_DELAY);
-                (0, dist_1.log_info)(`Attempting to reconnect ${this.reconnectAttempts}/${CONFIG.MAX_RECONNECT_ATTEMPTS}, delay ${delay}ms, node: ${this.ws_endpoint}`);
-                if (this.reconnectAttempts > CONFIG.MAX_RECONNECT_ATTEMPTS) {
-                    (0, dist_1.log_error)(`Reconnection failed, reached maximum attempts (${CONFIG.MAX_RECONNECT_ATTEMPTS}), exiting`, new Error('Max reconnect attempts failed'), '');
-                    this.appConfig.emit(common_1.EVENT_NAMES.WS_CONNECTION_FAILED, {
-                        endpoint: this.ws_endpoint,
-                        attempts: CONFIG.MAX_RECONNECT_ATTEMPTS,
-                    });
-                    process.exit(1);
-                }
-                yield (0, dist_1.sleep)(delay);
-                yield this.connect();
-            }
-            catch (error) {
-                (0, dist_1.log_error)('Reconnection attempt failed:', error);
-                setTimeout(() => this.handleConnectionIssue(), CONFIG.BASE_RECONNECT_DELAY);
-            }
-            finally {
-                this.isReconnecting = false;
+    async handleConnectionIssue() {
+        if (this.isReconnecting) {
+            (0, ttd_core_1.log_info)('Already attempting to reconnect, skipping...');
+            return;
+        }
+        this.isReconnecting = true;
+        this.isConnected = false;
+        try {
+            this.stopBlockListener();
+            this.cleanup();
+            this.reconnectAttempts++;
+            const delay = Math.min(CONFIG.BASE_RECONNECT_DELAY * Math.pow(2, this.reconnectAttempts), CONFIG.MAX_RECONNECT_DELAY);
+            (0, ttd_core_1.log_info)(`Attempting to reconnect ${this.reconnectAttempts}/${CONFIG.MAX_RECONNECT_ATTEMPTS}, delay ${delay}ms, node: ${this.ws_endpoint}`);
+            if (this.reconnectAttempts > CONFIG.MAX_RECONNECT_ATTEMPTS) {
+                (0, ttd_core_1.log_error)(`Reconnection failed, reached maximum attempts (${CONFIG.MAX_RECONNECT_ATTEMPTS}), exiting`, new Error('Max reconnect attempts failed'), '');
+                this.appConfig.emit(common_1.EVENT_NAMES.WS_CONNECTION_FAILED, {
+                    endpoint: this.ws_endpoint,
+                    attempts: CONFIG.MAX_RECONNECT_ATTEMPTS,
+                });
+                process.exit(1);
             }
-        });
+            await (0, ttd_core_1.sleep)(delay);
+            await this.connect();
+        }
+        catch (error) {
+            (0, ttd_core_1.log_error)('Reconnection attempt failed:', error);
+            setTimeout(() => this.handleConnectionIssue(), CONFIG.BASE_RECONNECT_DELAY);
+        }
+        finally {
+            this.isReconnecting = false;
+        }
     }
-    startBlockListener() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.wsProvider || !this.isConnected) {
-                (0, dist_1.log_warn)(`Cannot start block listener: WebSocket not connected`);
-                return;
-            }
-            try {
-                const blockNumber = yield this.wsProvider.getBlockNumber();
-                this.lastProcessedBlockNumber = blockNumber;
-                (0, dist_1.log_info)(`Initializing block listener, current block: ${blockNumber}`);
-                this.wsProvider.on('block', (blockNumber) => __awaiter(this, void 0, void 0, function* () {
-                    try {
-                        if (!this.isConnected || !this.isBlockListenerActive)
-                            return;
-                        this.lastMessageTime = Date.now();
-                        (0, dist_1.log_info)(`------- Block: ${blockNumber} -------`);
-                        const previousBlockNumber = this.lastProcessedBlockNumber;
-                        this.lastProcessedBlockNumber = blockNumber;
-                        const blockUpdateEvent = {
-                            blockNumber,
-                            previousBlockNumber,
-                            timestamp: Date.now(),
-                        };
-                        this.appConfig.emit(common_1.EVENT_NAMES.BLOCK_UPDATE, blockUpdateEvent);
-                    }
-                    catch (error) {
-                        (0, dist_1.log_error)(`Error processing block event:`, error, '');
-                    }
-                }));
-                this.startMessageMonitor();
-                this.startDiagnosticMonitor();
-                this.isBlockListenerActive = true;
-                (0, dist_1.log_info)(`Block listener started using WebSocket event subscription`);
-            }
-            catch (error) {
-                (0, dist_1.log_error)(`Failed to start block listener:`, error, '');
-                this.isBlockListenerActive = false;
-            }
-        });
+    async startBlockListener() {
+        if (!this.wsProvider || !this.isConnected) {
+            (0, ttd_core_1.log_warn)(`Cannot start block listener: WebSocket not connected`);
+            return;
+        }
+        try {
+            const blockNumber = await this.wsProvider.getBlockNumber();
+            this.lastProcessedBlockNumber = blockNumber;
+            (0, ttd_core_1.log_info)(`Initializing block listener, current block: ${blockNumber}`);
+            this.wsProvider.on('block', async (blockNumber) => {
+                try {
+                    if (!this.isConnected || !this.isBlockListenerActive)
+                        return;
+                    this.lastMessageTime = Date.now();
+                    (0, ttd_core_1.log_info)(`------- Block: ${blockNumber} -------`);
+                    const previousBlockNumber = this.lastProcessedBlockNumber;
+                    this.lastProcessedBlockNumber = blockNumber;
+                    const blockUpdateEvent = {
+                        blockNumber,
+                        previousBlockNumber,
+                        recvBlockTime: Date.now(),
+                    };
+                    this.appConfig.emit(common_1.EVENT_NAMES.BLOCK_UPDATE, blockUpdateEvent);
+                }
+                catch (error) {
+                    (0, ttd_core_1.log_error)(`Error processing block event:`, error, '');
+                }
+            });
+            this.startMessageMonitor();
+            this.startDiagnosticMonitor();
+            this.isBlockListenerActive = true;
+            (0, ttd_core_1.log_info)(`Block listener started using WebSocket event subscription`);
+        }
+        catch (error) {
+            (0, ttd_core_1.log_error)(`Failed to start block listener:`, error, '');
+            this.isBlockListenerActive = false;
+        }
     }
     startMessageMonitor() {
         if (this.messageMonitorInterval) {
@@ -229,7 +208,7 @@ class PoolEventListener {
         this.messageMonitorInterval = setInterval(() => {
             const timeSinceLastMessage = Date.now() - this.lastMessageTime;
             if (timeSinceLastMessage > CONFIG.MESSAGE_TIMEOUT) {
-                (0, dist_1.log_warn)(`No messages received for ${CONFIG.MESSAGE_TIMEOUT / 1000} seconds, preparing to resubscribe`);
+                (0, ttd_core_1.log_warn)(`No messages received for ${CONFIG.MESSAGE_TIMEOUT / 1000} seconds, preparing to resubscribe`);
                 this.handleConnectionIssue();
             }
         }, CONFIG.MESSAGE_CHECK_INTERVAL);
@@ -244,7 +223,7 @@ class PoolEventListener {
         }, CONFIG.DIAGNOSTIC_INTERVAL);
     }
     logDiagnostics(diagnostics) {
-        (0, dist_1.log_info)(`WebSocket Connection Diagnostics:
+        (0, ttd_core_1.log_info)(`WebSocket Connection Diagnostics:
             Connection Status: ${diagnostics.isConnected ? 'Connected' : 'Disconnected'}
             Reconnection Status: ${diagnostics.isReconnecting ? 'Reconnecting' : 'Not Reconnecting'}
             Listener Status: ${diagnostics.isStarted ? 'Started' : 'Not Started'}
@@ -279,7 +258,7 @@ class PoolEventListener {
                 clearInterval(this.diagnosticInterval);
                 this.diagnosticInterval = null;
             }
-            (0, dist_1.log_info)(`Block listener stopped`);
+            (0, ttd_core_1.log_info)(`Block listener stopped`);
         }
     }
     cleanup() {
@@ -291,7 +270,7 @@ class PoolEventListener {
                 }
             }
             catch (error) {
-                (0, dist_1.log_error)(`Failed to cleanup WebSocket resources:`, error, '');
+                (0, ttd_core_1.log_error)(`Failed to cleanup WebSocket resources:`, error, '');
             }
             this.wsProvider = null;
         }
@@ -311,8 +290,7 @@ class PoolEventListener {
         this.isReconnecting = false;
     }
     isWSConnected() {
-        var _a, _b;
-        return this.isConnected && ((_b = (_a = this.wsProvider) === null || _a === void 0 ? void 0 : _a._websocket) === null || _b === void 0 ? void 0 : _b.readyState) === 1;
+        return this.isConnected && this.wsProvider?._websocket?.readyState === 1;
     }
     getConnectionDiagnostics() {
         return {

package/dist/quote/event/swap_debouncer.d.ts

@@ -0,0 +1,22 @@
+export declare class SwapDebouncer<TEvent extends {
+    pool_address: string;
+    type: string;
+    data: {
+        blockNumber: number;
+    };
+}, TResult = void> {
+    private debounceMs;
+    private onCalculate;
+    private onPublish;
+    private debouncedTypes;
+    private windows;
+    private latestBlock;
+    constructor(config: {
+        onCalculate: (event: TEvent) => TResult | Promise<TResult>;
+        onPublish: (event: TEvent, result: TResult) => void;
+        debouncedEventTypes?: string[];
+    });
+    onEvent(event: TEvent): Promise<void>;
+    flush(): void;
+    private startWindow;
+}

package/dist/quote/event/swap_debouncer.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwapDebouncer = void 0;
+const ttd_core_1 = require("@clonegod/ttd-core");
+class SwapDebouncer {
+    constructor(config) {
+        this.windows = new Map();
+        this.latestBlock = new Map();
+        this.debounceMs = parseInt(process.env.SWAP_DEBOUNCE_MS || '3', 10);
+        this.onCalculate = config.onCalculate;
+        this.onPublish = config.onPublish;
+        this.debouncedTypes = new Set((config.debouncedEventTypes || ['swap']).map(t => t.toLowerCase()));
+    }
+    async onEvent(event) {
+        const poolAddress = event.pool_address;
+        const blockNumber = event.data?.blockNumber || 0;
+        if (blockNumber > 0) {
+            const lastBlock = this.latestBlock.get(poolAddress) || 0;
+            if (blockNumber < lastBlock) {
+                (0, ttd_core_1.log_warn)(`SwapDebouncer: stale block dropped, pool=${poolAddress}, event block=${blockNumber}, latest=${lastBlock}`);
+                return;
+            }
+            this.latestBlock.set(poolAddress, blockNumber);
+        }
+        const eventType = event.type?.toLowerCase();
+        if (!this.debouncedTypes.has(eventType)) {
+            const result = await this.onCalculate(event);
+            this.onPublish(event, result);
+            return;
+        }
+        const window = this.windows.get(poolAddress);
+        const result = await this.onCalculate(event);
+        if (window) {
+            if (blockNumber > window.blockNumber) {
+                if (!window.expired) {
+                    clearTimeout(window.timer);
+                    this.onPublish(window.latestEvent, window.latestResult);
+                }
+                this.windows.delete(poolAddress);
+                this.startWindow(poolAddress, event, result, blockNumber);
+            }
+            else if (window.expired) {
+                this.onPublish(event, result);
+            }
+            else {
+                window.latestEvent = event;
+                window.latestResult = result;
+            }
+        }
+        else {
+            this.startWindow(poolAddress, event, result, blockNumber);
+        }
+    }
+    flush() {
+        for (const [_, window] of this.windows) {
+            if (!window.expired) {
+                clearTimeout(window.timer);
+                this.onPublish(window.latestEvent, window.latestResult);
+            }
+        }
+        this.windows.clear();
+    }
+    startWindow(poolAddress, event, result, blockNumber) {
+        const timer = setTimeout(() => {
+            const w = this.windows.get(poolAddress);
+            if (w) {
+                w.expired = true;
+                this.onPublish(w.latestEvent, w.latestResult);
+            }
+        }, this.debounceMs);
+        this.windows.set(poolAddress, {
+            blockNumber,
+            latestEvent: event,
+            latestResult: result,
+            timer,
+            expired: false,
+        });
+    }
+}
+exports.SwapDebouncer = SwapDebouncer;

package/dist/quote/get_base_token_price.d.ts

@@ -0,0 +1,6 @@
+import { FormattedTokenPrice } from '@clonegod/ttd-core';
+type PriceSource = 'force_fetch' | 'cache_only' | 'cache_first';
+export declare function get_base_token_price_info(addresses: string[], opts?: {
+    source?: PriceSource;
+}): Promise<Map<string, FormattedTokenPrice>>;
+export {};