@clonegod/ttd-bsc-common 1.0.30 → 1.0.31

package/dist/types/pool_state.d.ts

@@ -0,0 +1,29 @@
+export interface OnchainPoolData {
+    address: string;
+    token0: string;
+    token1: string;
+    fee: number;
+    tickSpacing: number;
+    reserve0: string;
+    reserve1: string;
+    tick: number;
+    sqrtPriceX96: string;
+    liquidity: string;
+}
+export interface OnchainPoolChangeEvent {
+    pool_address: string;
+    type: string;
+    event_time: number;
+    data: {
+        blockNumber: number;
+        transactionIndex: number;
+        transactionHash: string;
+        amount0: string;
+        amount1: string;
+        reserve0: BigInt;
+        reserve1: BigInt;
+        tick: number;
+        sqrtPriceX96: BigInt;
+        liquidity: BigInt;
+    };
+}

package/dist/types/pool_state.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/ws/event_filter.d.ts

@@ -0,0 +1,8 @@
+export declare class EventFilter {
+    private static poolEventMap;
+    private static readonly CLEANUP_INTERVAL_MS;
+    private static readonly EVENT_EXPIRE_MS;
+    private static cleanupInitialized;
+    private static initializeCleanup;
+    static filterEvent<T>(poolAddress: string, blockNumber: number, eventType: string, callback: (data: T) => void, eventData: T): boolean;
+}

package/dist/ws/event_filter.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventFilter = void 0;
+const dist_1 = require("@clonegod/ttd-core/dist");
+class EventFilter {
+    static initializeCleanup() {
+        if (this.cleanupInitialized) {
+            return;
+        }
+        setInterval(() => {
+            const now = Date.now();
+            this.poolEventMap.forEach((timestamp, key) => {
+                if (now - timestamp > this.EVENT_EXPIRE_MS) {
+                    this.poolEventMap.delete(key);
+                }
+            });
+        }, this.CLEANUP_INTERVAL_MS);
+        this.cleanupInitialized = true;
+    }
+    static filterEvent(poolAddress, blockNumber, eventType, callback, eventData) {
+        this.initializeCleanup();
+        const key = `${poolAddress}-${blockNumber}-${eventType.toUpperCase()}`;
+        if (this.poolEventMap.has(key)) {
+            (0, dist_1.log_warn)(`Event ${eventType} already occurred on pool: ${poolAddress}, block: ${blockNumber}`);
+            return false;
+        }
+        this.poolEventMap.set(key, Date.now());
+        callback(eventData);
+        return true;
+    }
+}
+exports.EventFilter = EventFilter;
+EventFilter.poolEventMap = new Map();
+EventFilter.CLEANUP_INTERVAL_MS = 10 * 1000;
+EventFilter.EVENT_EXPIRE_MS = 10 * 60 * 1000;
+EventFilter.cleanupInitialized = false;

package/dist/ws/index.d.ts

@@ -0,0 +1,2 @@
+export * from './subscribe_v2_events';
+export * from './subscribe_v3_events';

package/dist/ws/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("./subscribe_v2_events"), exports);
+__exportStar(require("./subscribe_v3_events"), exports);

package/dist/ws/subscribe_v2_events.d.ts

@@ -0,0 +1,14 @@
+export declare class UniswapV2AmmPoolEventsSubscriber {
+    private wsUrl;
+    private poolAddress;
+    private provider;
+    private poolContract;
+    private eventCallbacks;
+    private isConnected;
+    constructor(wsUrl: string, poolAddress: string);
+    initialize(): Promise<void>;
+    subscribe(eventType: string, callback: any): void;
+    unsubscribe(eventType: string): Promise<void>;
+    disconnect(): Promise<void>;
+    _reconnect(): void;
+}

package/dist/ws/subscribe_v2_events.js

@@ -0,0 +1,174 @@
+"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.UniswapV2AmmPoolEventsSubscriber = void 0;
+const ethers_1 = require("ethers");
+const event_filter_1 = require("./event_filter");
+const UNISWAP_V2_POOL_ABI = [
+    'event Sync(uint112 reserve0, uint112 reserve1)',
+    'event Mint(address indexed sender, uint amount0, uint amount1)',
+    'event Burn(address indexed sender, uint amount0, uint amount1, address indexed to)'
+];
+class UniswapV2AmmPoolEventsSubscriber {
+    constructor(wsUrl, poolAddress) {
+        this.wsUrl = wsUrl;
+        this.poolAddress = poolAddress;
+        this.provider = null;
+        this.poolContract = null;
+        this.eventCallbacks = {
+            sync: null,
+            mint: null,
+            burn: null
+        };
+        this.isConnected = false;
+    }
+    initialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!this.wsUrl || !this.poolAddress) {
+                    throw new Error(`wsUrl and poolAddress are required! wsUrl=${this.wsUrl} poolAddress=${this.poolAddress}`);
+                }
+                this.provider = new ethers_1.ethers.providers.WebSocketProvider(this.wsUrl);
+                this.poolContract = new ethers_1.ethers.Contract(this.poolAddress, UNISWAP_V2_POOL_ABI, this.provider);
+                this.isConnected = true;
+                console.log(`Connected to WebSocket: ${this.wsUrl} for pool: ${this.poolAddress}`);
+                this.provider._websocket.on('error', (error) => {
+                    console.error('WebSocket Error:', error);
+                    this.isConnected = false;
+                    this._reconnect();
+                });
+                this.provider._websocket.on('close', (code, reason) => {
+                    console.error('WebSocket Closed:', code, reason);
+                    this.isConnected = false;
+                    this._reconnect();
+                });
+            }
+            catch (error) {
+                console.error('Initialization Error:', error);
+                this.isConnected = false;
+                this._reconnect();
+            }
+        });
+    }
+    subscribe(eventType, callback) {
+        if (!this.poolContract) {
+            throw new Error('Contract not initialized. Call initialize() first.');
+        }
+        if (!['sync', 'mint', 'burn'].includes(eventType.toLowerCase())) {
+            throw new Error('Invalid event type. Use "sync", "mint", or "burn".');
+        }
+        this.eventCallbacks[eventType.toLowerCase()] = callback;
+        if (eventType.toLowerCase() === 'sync') {
+            this.poolContract.on('Sync', (reserve0, reserve1, event) => {
+                const data = {
+                    pool_address: this.poolAddress,
+                    type: 'sync',
+                    event_time: Date.now(),
+                    data: {
+                        blockNumber: event.blockNumber,
+                        transactionIndex: event.transactionIndex,
+                        transactionHash: event.transactionHash,
+                        amount0: '0',
+                        amount1: '0',
+                        reserve0: BigInt(reserve0.toString()),
+                        reserve1: BigInt(reserve1.toString()),
+                        tick: 0,
+                        sqrtPriceX96: BigInt(0),
+                        liquidity: BigInt(0),
+                    }
+                };
+                callback(data);
+            });
+        }
+        else if (eventType.toLowerCase() === 'mint') {
+            this.poolContract.on('Mint', (sender, amount0, amount1, event) => {
+                const data = {
+                    pool_address: this.poolAddress,
+                    type: 'mint',
+                    event_time: Date.now(),
+                    data: {
+                        blockNumber: event.blockNumber,
+                        transactionIndex: event.transactionIndex,
+                        transactionHash: event.transactionHash,
+                        amount0: amount0.toString(),
+                        amount1: amount1.toString(),
+                        reserve0: BigInt(0),
+                        reserve1: BigInt(0),
+                        tick: 0,
+                        sqrtPriceX96: BigInt(0),
+                        liquidity: BigInt(0),
+                    }
+                };
+                event_filter_1.EventFilter.filterEvent(this.poolAddress, event.blockNumber, 'mint', callback, data);
+            });
+        }
+        else if (eventType.toLowerCase() === 'burn') {
+            this.poolContract.on('Burn', (sender, amount0, amount1, to, event) => {
+                const data = {
+                    pool_address: this.poolAddress,
+                    type: 'burn',
+                    event_time: Date.now(),
+                    data: {
+                        blockNumber: event.blockNumber,
+                        transactionIndex: event.transactionIndex,
+                        transactionHash: event.transactionHash,
+                        amount0: amount0.toString(),
+                        amount1: amount1.toString(),
+                        reserve0: BigInt(0),
+                        reserve1: BigInt(0),
+                        tick: 0,
+                        sqrtPriceX96: BigInt(0),
+                        liquidity: BigInt(0),
+                    }
+                };
+                event_filter_1.EventFilter.filterEvent(this.poolAddress, event.blockNumber, 'burn', callback, data);
+            });
+        }
+    }
+    unsubscribe(eventType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.poolContract) {
+                throw new Error('Contract not initialized.');
+            }
+            if (!['sync', 'mint', 'burn'].includes(eventType.toLowerCase())) {
+                throw new Error('Invalid event type. Use "sync", "mint", or "burn".');
+            }
+            this.poolContract.removeAllListeners(eventType);
+            this.eventCallbacks[eventType.toLowerCase()] = null;
+            console.log(`Unsubscribed from ${eventType} events`);
+        });
+    }
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.provider) {
+                yield this.provider.destroy();
+                this.provider = null;
+                this.poolContract = null;
+                this.isConnected = false;
+                console.log('Disconnected from WebSocket');
+            }
+        });
+    }
+    _reconnect() {
+        if (!this.isConnected) {
+            console.log('Attempting to reconnect...');
+            setTimeout(() => __awaiter(this, void 0, void 0, function* () {
+                yield this.initialize();
+                for (const [eventType, callback] of Object.entries(this.eventCallbacks)) {
+                    if (callback) {
+                        this.subscribe(eventType, callback);
+                    }
+                }
+            }), 2000);
+        }
+    }
+}
+exports.UniswapV2AmmPoolEventsSubscriber = UniswapV2AmmPoolEventsSubscriber;

package/dist/ws/subscribe_v3_events.d.ts

@@ -0,0 +1,14 @@
+export declare class UniswapV3PoolEventsSubscriber {
+    private wsUrl;
+    private poolAddress;
+    private provider;
+    private poolContract;
+    private eventCallbacks;
+    private isConnected;
+    constructor(wsUrl: string, poolAddress: string);
+    initialize(): Promise<void>;
+    subscribe(eventType: string, callback: any): void;
+    unsubscribe(eventType: string): Promise<void>;
+    disconnect(): Promise<void>;
+    _reconnect(): void;
+}

package/dist/ws/subscribe_v3_events.js

@@ -0,0 +1,174 @@
+"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.UniswapV3PoolEventsSubscriber = void 0;
+const ethers_1 = require("ethers");
+const event_filter_1 = require("./event_filter");
+const UNISWAP_V3_POOL_ABI = [
+    'event Swap(address indexed sender, address indexed recipient, int256 amount0, int256 amount1, uint160 sqrtPriceX96, uint128 liquidity, int24 tick)',
+    '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)'
+];
+class UniswapV3PoolEventsSubscriber {
+    constructor(wsUrl, poolAddress) {
+        this.wsUrl = wsUrl;
+        this.poolAddress = poolAddress;
+        this.provider = null;
+        this.poolContract = null;
+        this.eventCallbacks = {
+            swap: null,
+            mint: null,
+            burn: null
+        };
+        this.isConnected = false;
+    }
+    initialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!this.wsUrl || !this.poolAddress) {
+                    throw new Error(`wsUrl and poolAddress are required! wsUrl=${this.wsUrl} poolAddress=${this.poolAddress}`);
+                }
+                this.provider = new ethers_1.ethers.providers.WebSocketProvider(this.wsUrl);
+                this.poolContract = new ethers_1.ethers.Contract(this.poolAddress, UNISWAP_V3_POOL_ABI, this.provider);
+                this.isConnected = true;
+                console.log(`Connected to WebSocket: ${this.wsUrl} for pool: ${this.poolAddress}`);
+                this.provider._websocket.on('error', (error) => {
+                    console.error('WebSocket Error:', error);
+                    this.isConnected = false;
+                    this._reconnect();
+                });
+                this.provider._websocket.on('close', (code, reason) => {
+                    console.error('WebSocket Closed:', code, reason);
+                    this.isConnected = false;
+                    this._reconnect();
+                });
+            }
+            catch (error) {
+                console.error('Initialization Error:', error);
+                this.isConnected = false;
+                this._reconnect();
+            }
+        });
+    }
+    subscribe(eventType, callback) {
+        if (!this.poolContract) {
+            throw new Error('Contract not initialized. Call initialize() first.');
+        }
+        if (!['swap', 'mint', 'burn'].includes(eventType.toLowerCase())) {
+            throw new Error('Invalid event type. Use "swap", "mint", or "burn".');
+        }
+        this.eventCallbacks[eventType.toLowerCase()] = callback;
+        if (eventType.toLowerCase() === 'swap') {
+            this.poolContract.on('Swap', (sender, recipient, amount0, amount1, sqrtPriceX96, liquidity, tick, event) => {
+                const data = {
+                    pool_address: this.poolAddress,
+                    type: 'swap',
+                    event_time: Date.now(),
+                    data: {
+                        blockNumber: event.blockNumber,
+                        transactionIndex: event.transactionIndex,
+                        transactionHash: event.transactionHash,
+                        amount0: amount0.toString(),
+                        amount1: amount1.toString(),
+                        reserve0: BigInt(0),
+                        reserve1: BigInt(0),
+                        tick,
+                        sqrtPriceX96: sqrtPriceX96.toString(),
+                        liquidity: liquidity.toString(),
+                    }
+                };
+                callback(data);
+            });
+        }
+        else if (eventType.toLowerCase() === 'mint') {
+            this.poolContract.on('Mint', (sender, owner, tickLower, tickUpper, amount, amount0, amount1, event) => {
+                const data = {
+                    pool_address: this.poolAddress,
+                    type: 'mint',
+                    event_time: Date.now(),
+                    data: {
+                        blockNumber: event.blockNumber,
+                        transactionIndex: event.transactionIndex,
+                        transactionHash: event.transactionHash,
+                        amount0: amount0.toString(),
+                        amount1: amount1.toString(),
+                        reserve0: BigInt(0),
+                        reserve1: BigInt(0),
+                        tick: 0,
+                        sqrtPriceX96: BigInt(0),
+                        liquidity: BigInt(0),
+                    }
+                };
+                event_filter_1.EventFilter.filterEvent(this.poolAddress, event.blockNumber, 'mint', callback, data);
+            });
+        }
+        else if (eventType.toLowerCase() === 'burn') {
+            this.poolContract.on('Burn', (owner, tickLower, tickUpper, amount, amount0, amount1, event) => {
+                const data = {
+                    pool_address: this.poolAddress,
+                    type: 'burn',
+                    event_time: Date.now(),
+                    data: {
+                        blockNumber: event.blockNumber,
+                        transactionIndex: event.transactionIndex,
+                        transactionHash: event.transactionHash,
+                        amount0: amount0.toString(),
+                        amount1: amount1.toString(),
+                        reserve0: BigInt(0),
+                        reserve1: BigInt(0),
+                        tick: 0,
+                        sqrtPriceX96: BigInt(0),
+                        liquidity: BigInt(0),
+                    }
+                };
+                event_filter_1.EventFilter.filterEvent(this.poolAddress, event.blockNumber, 'burn', callback, data);
+            });
+        }
+    }
+    unsubscribe(eventType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.poolContract) {
+                throw new Error('Contract not initialized.');
+            }
+            if (!['swap', 'mint', 'burn'].includes(eventType.toLowerCase())) {
+                throw new Error('Invalid event type. Use "swap", "mint", or "burn".');
+            }
+            this.poolContract.removeAllListeners(eventType);
+            this.eventCallbacks[eventType.toLowerCase()] = null;
+            console.log(`Unsubscribed from ${eventType} events`);
+        });
+    }
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.provider) {
+                yield this.provider.destroy();
+                this.provider = null;
+                this.poolContract = null;
+                this.isConnected = false;
+                console.log('Disconnected from WebSocket');
+            }
+        });
+    }
+    _reconnect() {
+        if (!this.isConnected) {
+            console.log('Attempting to reconnect...');
+            setTimeout(() => __awaiter(this, void 0, void 0, function* () {
+                yield this.initialize();
+                for (const [eventType, callback] of Object.entries(this.eventCallbacks)) {
+                    if (callback) {
+                        this.subscribe(eventType, callback);
+                    }
+                }
+            }), 2000);
+        }
+    }
+}
+exports.UniswapV3PoolEventsSubscriber = UniswapV3PoolEventsSubscriber;

package/package.json

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