@clonegod/ttd-base-common 1.0.0

package/dist/common/abi.d.ts

@@ -0,0 +1 @@
+export declare const ERC20_ABI: string[];

package/dist/common/abi.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERC20_ABI = void 0;
+exports.ERC20_ABI = [
+    'function decimals() view returns (uint8)',
+    'function symbol() view returns (string)',
+    'function name() view returns (string)',
+    'function totalSupply() view returns (uint256)',
+    'function balanceOf(address) view returns (uint256)',
+    'function transfer(address to, uint amount) returns (bool)',
+    'function allowance(address owner, address spender) view returns (uint256)',
+    'function approve(address spender, uint256 amount) returns (bool)',
+    'function transferFrom(address sender, address recipient, uint256 amount) returns (bool)'
+];

package/dist/common/constants.d.ts

@@ -0,0 +1,18 @@
+export declare const BASE_CHAIN_ID = 8453;
+export declare const WETH_ADDRESS = "0x4200000000000000000000000000000000000006";
+export declare const EVENT_NAMES: {
+    readonly BLOCK_UPDATE: "block_update";
+    readonly POOL_STATE_UPDATE: "pool_state_update";
+    readonly LIQUIDITY_UPDATE: "liquidity_update";
+    readonly POOL_SYNC: "POOL_SYNC";
+    readonly POOL_SWAP: "POOL_SWAP";
+    readonly QUOTE_RESULT: "quote_result";
+    readonly QUOTE_TRIGGER: "quote_trigger";
+    readonly WS_CONNECTION_FAILED: "ws_connection_failed";
+};
+export declare const EVENT_SIGNATURES: {
+    SWAP_RAW: string;
+    MINT: string;
+    BURN: string;
+};
+export declare const UniswapV3PoolABI: string[];

package/dist/common/constants.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniswapV3PoolABI = exports.EVENT_SIGNATURES = exports.EVENT_NAMES = exports.WETH_ADDRESS = exports.BASE_CHAIN_ID = void 0;
+exports.BASE_CHAIN_ID = 8453;
+exports.WETH_ADDRESS = '0x4200000000000000000000000000000000000006';
+exports.EVENT_NAMES = {
+    BLOCK_UPDATE: 'block_update',
+    POOL_STATE_UPDATE: 'pool_state_update',
+    LIQUIDITY_UPDATE: 'liquidity_update',
+    POOL_SYNC: 'POOL_SYNC',
+    POOL_SWAP: 'POOL_SWAP',
+    QUOTE_RESULT: 'quote_result',
+    QUOTE_TRIGGER: 'quote_trigger',
+    WS_CONNECTION_FAILED: 'ws_connection_failed',
+};
+exports.EVENT_SIGNATURES = {
+    SWAP_RAW: "Swap(address indexed sender, address indexed recipient, int256 amount0, int256 amount1, uint160 sqrtPriceX96, uint128 liquidity, int24 tick, uint128 protocolFeesToken0, uint128 protocolFeesToken1)",
+    MINT: "event Mint(address sender, address indexed owner, int24 indexed tickLower, int24 indexed tickUpper, uint128 amount, uint256 amount0, uint256 amount1)",
+    BURN: "event Burn(address indexed owner, int24 indexed tickLower, int24 indexed tickUpper, uint128 amount, uint256 amount0, uint256 amount1)"
+};
+exports.UniswapV3PoolABI = [
+    "function slot0() external view returns (uint160 sqrtPriceX96, int24 tick, uint16 observationIndex, uint16 observationCardinality, uint16 observationCardinalityNext, uint8 feeProtocol, bool unlocked)",
+    "function liquidity() external view returns (uint128)",
+    "function tickSpacing() external view returns (int24)",
+    "function factory() external view returns (address)",
+    "function token0() external view returns (address)",
+    "function token1() external view returns (address)",
+    "function fee() external view returns (uint24)",
+    "function ticks(int24 tick) external view returns (uint128 liquidityGross, int128 liquidityNet, int56 tickCumulativeOutside, uint160 secondsPerLiquidityOutsideX128, uint32 secondsOutside, bool initialized)",
+    "function tickBitmap(int16 wordPosition) external view returns (uint256)",
+    "event Swap(address indexed sender, address indexed recipient, int256 amount0, int256 amount1, uint160 sqrtPriceX96, uint128 liquidity, int24 tick, uint128 protocolFeesToken0, uint128 protocolFeesToken1)",
+    "event Mint(address sender, address indexed owner, int24 indexed tickLower, int24 indexed tickUpper, uint128 amount, uint256 amount0, uint256 amount1)",
+    "event Burn(address indexed owner, int24 indexed tickLower, int24 indexed tickUpper, uint128 amount, uint256 amount0, uint256 amount1)"
+];

package/dist/common/index.d.ts

@@ -0,0 +1,2 @@
+export * from './abi';
+export * from './constants';

package/dist/common/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./abi"), exports);
+__exportStar(require("./constants"), exports);

package/dist/config/base_env_args.d.ts

@@ -0,0 +1,11 @@
+import { EnvArgs } from "@clonegod/ttd-core/dist";
+export declare class BaseEnvArgs extends EnvArgs {
+    large_trade_threshold_usd: number;
+    gas_price_gwei: number;
+    gas_limit: number;
+    tip_amount_gwei: number;
+    tx_status_check_interval_mills: number;
+    tx_cancel_timeout_ms: number;
+    tx_cancel_gas_boost_factor: number;
+    constructor();
+}

package/dist/config/base_env_args.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseEnvArgs = void 0;
+const dist_1 = require("@clonegod/ttd-core/dist");
+const decimal_js_1 = require("decimal.js");
+class BaseEnvArgs extends dist_1.EnvArgs {
+    constructor() {
+        super();
+        this.large_trade_threshold_usd = parseInt(process.env.LARGE_TRADE_THRESHOLD_USD || '500');
+        this.gas_price_gwei = new decimal_js_1.Decimal(process.env.GAS_PRICE_GWEI || '1').toNumber();
+        this.gas_limit = parseInt(process.env.GAS_LIMIT || '300000');
+        this.tip_amount_gwei = parseInt(process.env.EOA_TIP_AMOUNT_GWEI || '10000');
+        this.tx_status_check_interval_mills = parseInt(process.env.TX_STATUS_CHECK_INTERVAL_MILLS || '3000');
+        this.tx_cancel_timeout_ms = parseInt(process.env.TX_CANCEL_TIMEOUT_MS || '15000');
+        this.tx_cancel_gas_boost_factor = new decimal_js_1.Decimal(process.env.TX_CANCEL_GAS_PRICE_BOOST_FACTOR || '1.5').toNumber();
+        this.print();
+    }
+}
+exports.BaseEnvArgs = BaseEnvArgs;

package/dist/config/bsc_env_args.d.ts

@@ -0,0 +1,11 @@
+import { EnvArgs } from "@clonegod/ttd-core/dist";
+export declare class BscEnvArgs extends EnvArgs {
+    large_trade_threshold_usd: number;
+    gas_price_gwei: number;
+    gas_limit: number;
+    tip_amount_gwei: number;
+    tx_status_check_interval_mills: number;
+    tx_cancel_timeout_ms: number;
+    tx_cancel_gas_boost_factor: number;
+    constructor();
+}

package/dist/config/bsc_env_args.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BscEnvArgs = void 0;
+const dist_1 = require("@clonegod/ttd-core/dist");
+const decimal_js_1 = require("decimal.js");
+class BscEnvArgs extends dist_1.EnvArgs {
+    constructor() {
+        super();
+        this.large_trade_threshold_usd = parseInt(process.env.LARGE_TRADE_THRESHOLD_USD || '500');
+        this.gas_price_gwei = new decimal_js_1.Decimal(process.env.GAS_PRICE_GWEI || '1').toNumber();
+        this.gas_limit = parseInt(process.env.GAS_LIMIT || '300000');
+        this.tip_amount_gwei = parseInt(process.env.EOA_TIP_AMOUNT_GWEI || '10000');
+        this.tx_status_check_interval_mills = parseInt(process.env.TX_STATUS_CHECK_INTERVAL_MILLS || '3000');
+        this.tx_cancel_timeout_ms = parseInt(process.env.TX_CANCEL_TIMEOUT_MS || '15000');
+        this.tx_cancel_gas_boost_factor = new decimal_js_1.Decimal(process.env.TX_CANCEL_GAS_PRICE_BOOST_FACTOR || '1.5').toNumber();
+        this.print();
+    }
+}
+exports.BscEnvArgs = BscEnvArgs;

package/dist/config/index.d.ts

@@ -0,0 +1 @@
+export * from './base_env_args';

package/dist/config/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./base_env_args"), exports);

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from './common';
+export * from './config';
+export * from './quote';
+export * from './trade';
+export * from './types';
+export * from './utils';
+export * from './redis';

package/dist/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./common"), exports);
+__exportStar(require("./config"), exports);
+__exportStar(require("./quote"), exports);
+__exportStar(require("./trade"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./redis"), exports);

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

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

package/dist/quote/event/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./pool_event_listener"), exports);

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

@@ -0,0 +1,53 @@
+import { StandardPoolInfoType } from '@clonegod/ttd-core';
+import { AppConfig } from '@clonegod/ttd-core/dist';
+export interface BlockUpdateEvent {
+    blockNumber: number;
+    previousBlockNumber: number;
+    timestamp: number;
+}
+export interface ConnectionDiagnostics {
+    isConnected: boolean;
+    isReconnecting: boolean;
+    isStarted: boolean;
+    reconnectAttempts: number;
+    ws_endpoint: string;
+    wsReadyState: number | null;
+    trackingPools: number;
+    lastProcessedBlock: number;
+    lastMessageTime: number;
+    timeSinceLastMessage: number;
+}
+export declare class PoolEventListener {
+    private appConfig;
+    private wsProvider;
+    private poolList;
+    private ws_endpoint;
+    private isConnected;
+    private isReconnecting;
+    private isStarted;
+    private reconnectAttempts;
+    private lastProcessedBlockNumber;
+    private isBlockListenerActive;
+    private lastMessageTime;
+    private messageMonitorInterval;
+    private diagnosticInterval;
+    private heartbeatInterval;
+    private lastHeartbeatResponse;
+    constructor(appConfig: AppConfig, ws_endpoint: string);
+    init(poolList: StandardPoolInfoType[]): Promise<void>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    connect(): Promise<void>;
+    private setupWebSocketListeners;
+    private startHeartbeat;
+    private handleConnectionIssue;
+    private startBlockListener;
+    private startMessageMonitor;
+    private startDiagnosticMonitor;
+    private logDiagnostics;
+    private getWebSocketState;
+    private stopBlockListener;
+    private cleanup;
+    isWSConnected(): boolean;
+    getConnectionDiagnostics(): ConnectionDiagnostics;
+}

package/dist/quote/event/pool_event_listener.js

@@ -0,0 +1,334 @@
+"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 common_1 = require("../../common");
+const CONFIG = {
+    MAX_RETRIES: 3,
+    CONNECTION_TIMEOUT: 10000,
+    MESSAGE_TIMEOUT: 2 * 60 * 1000,
+    DIAGNOSTIC_INTERVAL: 30000,
+    MESSAGE_CHECK_INTERVAL: 10000,
+    BASE_RECONNECT_DELAY: 500,
+    MAX_RECONNECT_DELAY: 30000,
+    MAX_RECONNECT_ATTEMPTS: 10,
+    RETRY_DELAY_MULTIPLIER: 1000,
+    HEARTBEAT_INTERVAL: 30000,
+    HEARTBEAT_TIMEOUT: 90000,
+};
+class PoolEventListener {
+    constructor(appConfig, ws_endpoint) {
+        this.wsProvider = null;
+        this.poolList = [];
+        this.isConnected = false;
+        this.isReconnecting = false;
+        this.isStarted = false;
+        this.reconnectAttempts = 0;
+        this.lastProcessedBlockNumber = 0;
+        this.isBlockListenerActive = false;
+        this.lastMessageTime = Date.now();
+        this.messageMonitorInterval = null;
+        this.diagnosticInterval = null;
+        this.heartbeatInterval = null;
+        this.lastHeartbeatResponse = Date.now();
+        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();
+        });
+    }
+    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');
+        });
+    }
+    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`);
+        });
+    }
+    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;
+                }
+                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));
+                }
+            }
+        });
+    }
+    setupWebSocketListeners() {
+        if (!this.wsProvider)
+            return;
+        this.wsProvider.on('error', (err) => {
+            (0, dist_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'}`);
+            this.handleConnectionIssue();
+        });
+        this.wsProvider._websocket.on('open', () => {
+            (0, dist_1.log_info)('WebSocket connection opened');
+            this.isConnected = true;
+            this.reconnectAttempts = 0;
+        });
+        this.startHeartbeat();
+    }
+    startHeartbeat() {
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+        }
+        this.heartbeatInterval = setInterval(() => __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!this.wsProvider || !this.isConnected) {
+                    this.handleConnectionIssue();
+                    return;
+                }
+                this.wsProvider._websocket.ping();
+                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`);
+                    this.handleConnectionIssue();
+                }
+            }
+            catch (error) {
+                (0, dist_1.log_error)('Heartbeat check failed:', error);
+                this.handleConnectionIssue();
+            }
+        }), 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;
+            }
+        });
+    }
+    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;
+            }
+        });
+    }
+    startMessageMonitor() {
+        if (this.messageMonitorInterval) {
+            clearInterval(this.messageMonitorInterval);
+        }
+        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`);
+                this.handleConnectionIssue();
+            }
+        }, CONFIG.MESSAGE_CHECK_INTERVAL);
+    }
+    startDiagnosticMonitor() {
+        if (this.diagnosticInterval) {
+            clearInterval(this.diagnosticInterval);
+        }
+        this.diagnosticInterval = setInterval(() => {
+            const diagnostics = this.getConnectionDiagnostics();
+            this.logDiagnostics(diagnostics);
+        }, CONFIG.DIAGNOSTIC_INTERVAL);
+    }
+    logDiagnostics(diagnostics) {
+        (0, dist_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'}
+            Reconnection Attempts: ${diagnostics.reconnectAttempts}
+            WebSocket State: ${this.getWebSocketState(diagnostics.wsReadyState)}
+            Tracking Pools: ${diagnostics.trackingPools}
+            Last Processed Block: ${diagnostics.lastProcessedBlock}
+            Last Message Time: ${new Date(diagnostics.lastMessageTime).toLocaleString()}
+            Time Since Last Message: ${Math.floor(diagnostics.timeSinceLastMessage / 1000)} seconds
+        `);
+    }
+    getWebSocketState(state) {
+        if (state === null)
+            return 'Not Initialized';
+        switch (state) {
+            case 0: return 'Connecting';
+            case 1: return 'Connected';
+            case 2: return 'Closing';
+            case 3: return 'Closed';
+            default: return 'Unknown State';
+        }
+    }
+    stopBlockListener() {
+        if (this.isBlockListenerActive && this.wsProvider) {
+            this.wsProvider.removeListener('block', () => { });
+            this.isBlockListenerActive = false;
+            if (this.messageMonitorInterval) {
+                clearInterval(this.messageMonitorInterval);
+                this.messageMonitorInterval = null;
+            }
+            if (this.diagnosticInterval) {
+                clearInterval(this.diagnosticInterval);
+                this.diagnosticInterval = null;
+            }
+            (0, dist_1.log_info)(`Block listener stopped`);
+        }
+    }
+    cleanup() {
+        if (this.wsProvider) {
+            try {
+                this.wsProvider.removeAllListeners();
+                if (this.wsProvider._websocket && this.wsProvider._websocket.readyState === 1) {
+                    this.wsProvider._websocket.close(1000, 'Normal closure');
+                }
+            }
+            catch (error) {
+                (0, dist_1.log_error)(`Failed to cleanup WebSocket resources:`, error, '');
+            }
+            this.wsProvider = null;
+        }
+        if (this.messageMonitorInterval) {
+            clearInterval(this.messageMonitorInterval);
+            this.messageMonitorInterval = null;
+        }
+        if (this.diagnosticInterval) {
+            clearInterval(this.diagnosticInterval);
+            this.diagnosticInterval = null;
+        }
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+            this.heartbeatInterval = null;
+        }
+        this.isConnected = false;
+        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;
+    }
+    getConnectionDiagnostics() {
+        return {
+            isConnected: this.isConnected,
+            isReconnecting: this.isReconnecting,
+            isStarted: this.isStarted,
+            reconnectAttempts: this.reconnectAttempts,
+            ws_endpoint: this.ws_endpoint,
+            wsReadyState: this.wsProvider && this.wsProvider._websocket
+                ? this.wsProvider._websocket.readyState
+                : null,
+            trackingPools: this.poolList.length,
+            lastProcessedBlock: this.lastProcessedBlockNumber,
+            lastMessageTime: this.lastMessageTime,
+            timeSinceLastMessage: Date.now() - this.lastMessageTime,
+        };
+    }
+}
+exports.PoolEventListener = PoolEventListener;

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

@@ -0,0 +1 @@
+export {};