@clonegod/ttd-bsc-common 3.1.83 → 3.1.88

package/dist/trade/send/send_tx.js

@@ -0,0 +1,91 @@
+"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.TransactionSender = void 0;
+const dist_1 = require("@clonegod/ttd-core/dist");
+const blockrazor_1 = require("./blockrazor");
+const bsc_rpc_1 = require("./bsc_rpc");
+const _48club_1 = require("./48club");
+const _1 = require(".");
+class TransactionSender {
+    constructor(appConfig) {
+        this.rpc = new bsc_rpc_1.BscRpc(appConfig.env_args.rpc_endpoint);
+        this.blockRazor = new blockrazor_1.BlockRazorTrade();
+        this._48Club = new _48club_1._48ClubTrade();
+    }
+    sendTransaction(signedMainTx, eoa_tip_transaction, order_trace_id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rpcProviders = [
+                {
+                    name: 'Default (QuickNode / Merkle)',
+                    enable: process.env.SEND_TX_DEFAULT_RPC_PRIVATE === 'true',
+                    send: () => __awaiter(this, void 0, void 0, function* () {
+                        return yield this.rpc.eth_sendRawTransaction(signedMainTx);
+                    })
+                },
+                {
+                    name: 'BlockRazor - Private Transaction',
+                    enable: process.env.SEND_TX_BLOCKRAZOR_PRIVATE === 'true',
+                    send: () => __awaiter(this, void 0, void 0, function* () {
+                        return yield this.blockRazor.sendPrivateTransaction(signedMainTx);
+                    })
+                },
+                {
+                    name: 'BlockRazor - sendBundle',
+                    enable: process.env.SEND_TX_BLOCKRAZOR_BUNDLE === 'true',
+                    send: () => __awaiter(this, void 0, void 0, function* () {
+                        let bundle = [signedMainTx, yield eoa_tip_transaction(_1.BSC_EOA_ADDRESS.BLOCKRAZOR)];
+                        return yield this.blockRazor.sendBundle(bundle);
+                    })
+                },
+                {
+                    name: '48Club - Private Transaction',
+                    enable: process.env.SEND_TX_48CLUB_PRIVATE === 'true',
+                    send: () => __awaiter(this, void 0, void 0, function* () {
+                        return yield this._48Club.sendPrivateTransaction(signedMainTx);
+                    })
+                },
+                {
+                    name: '48Club - sendBundle',
+                    enable: process.env.SEND_TX_48CLUB_BUNDLE === 'true',
+                    send: () => __awaiter(this, void 0, void 0, function* () {
+                        let bundle = [signedMainTx, yield eoa_tip_transaction(_1.BSC_EOA_ADDRESS._48CLUB)];
+                        return yield this._48Club.sendBundle({ txs: bundle });
+                    })
+                }
+            ];
+            const results = [];
+            const errors = [];
+            yield Promise.all(rpcProviders.filter(provider => provider.enable).map((provider) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const txHash = yield provider.send();
+                    results.push(txHash);
+                    (0, dist_1.log_info)(`Transaction sent successfully`, { provider: provider.name, order_trace_id, txHash });
+                }
+                catch (error) {
+                    errors.push(`${provider.name}: ${error.message}`);
+                    (0, dist_1.log_info)(`Transaction sending failed`, { provider: provider.name, order_trace_id, error: error.message });
+                }
+            })));
+            if (errors.some(error => error.includes('nonce'))) {
+                throw new Error(`!!!!!! Some RPC providers returned nonce error: ${JSON.stringify(errors)}`);
+            }
+            if (errors.some(error => error.includes('bundle already exist') || error.includes('already known'))) {
+                return results;
+            }
+            if (results.length === 0 || errors.length > 0) {
+                throw new Error(`!!!!!! Some RPC providers failed to send transactions: ${JSON.stringify(errors)}`);
+            }
+            return results;
+        });
+    }
+}
+exports.TransactionSender = TransactionSender;

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 PancakeV2AmmPoolEventsSubscriber {
+    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.PancakeV2AmmPoolEventsSubscriber = void 0;
+const ethers_1 = require("ethers");
+const event_filter_1 = require("./event_filter");
+const PANCAKE_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 PancakeV2AmmPoolEventsSubscriber {
+    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, PANCAKE_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.PancakeV2AmmPoolEventsSubscriber = PancakeV2AmmPoolEventsSubscriber;

package/dist/ws/subscribe_v3_events.d.ts

@@ -0,0 +1,16 @@
+export declare class PancakeV3PoolEventsSubscriber {
+    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;
+}
+export declare class UniswapV3PoolEventsSubscriber extends PancakeV3PoolEventsSubscriber {
+}

package/dist/ws/subscribe_v3_events.js

@@ -0,0 +1,177 @@
+"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 = exports.PancakeV3PoolEventsSubscriber = void 0;
+const ethers_1 = require("ethers");
+const event_filter_1 = require("./event_filter");
+const PANCAKE_V3_POOL_ABI = [
+    '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)'
+];
+class PancakeV3PoolEventsSubscriber {
+    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, PANCAKE_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, protocolFeesToken0, protocolFeesToken1, 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.PancakeV3PoolEventsSubscriber = PancakeV3PoolEventsSubscriber;
+class UniswapV3PoolEventsSubscriber extends PancakeV3PoolEventsSubscriber {
+}
+exports.UniswapV3PoolEventsSubscriber = UniswapV3PoolEventsSubscriber;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clonegod/ttd-bsc-common",
-  "version": "3.1.83",
+  "version": "3.1.88",
   "description": "BSC common library",
   "license": "UNLICENSED",
   "main": "dist/index.js",
@@ -14,7 +14,7 @@
     "push": "npm run build && npm publish"
   },
   "dependencies": {
-    "@clonegod/ttd-core": "3.1.87",
+    "@clonegod/ttd-core": "3.1.92",
     "axios": "1.17.0",
     "dotenv": "^16.4.7",
     "ethers": "^5.8.0",

package/dist/quote/hook_fee_monitor.d.ts

@@ -1,10 +0,0 @@
-export declare function reportHookFeeChangeIfChanged(opts: {
-    pool_address: string;
-    dex_id: string;
-    pool_name?: string;
-    block_number: number;
-    prevLpFee: number | undefined;
-    prevProtocolFee: number | undefined;
-    newLpFee: number;
-    newProtocolFee: number;
-}): void;

package/dist/quote/hook_fee_monitor.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.reportHookFeeChangeIfChanged = reportHookFeeChangeIfChanged;
-const ttd_core_1 = require("@clonegod/ttd-core");
-function reportHookFeeChangeIfChanged(opts) {
-    const { pool_address, dex_id, pool_name, block_number, prevLpFee, prevProtocolFee, newLpFee, newProtocolFee } = opts;
-    if (prevLpFee == null)
-        return;
-    const prevTotal = prevLpFee + (prevProtocolFee ?? 0);
-    const newTotal = newLpFee + newProtocolFee;
-    if (prevTotal === newTotal)
-        return;
-    const addr = pool_address.toLowerCase();
-    const prevBps = (prevTotal / 100).toFixed(2);
-    const newBps = (newTotal / 100).toFixed(2);
-    ttd_core_1.ALERT_TYPES.QUOTE_HOOK_FEE_CHANGE.reportIfChanged(addr, true, () => ({
-        identity: addr,
-        scope: { dex_id, pool_address: addr },
-        title: `${pool_name || addr.slice(0, 10)} hook fee ${prevBps}bps → ${newBps}bps`,
-        detail: {
-            pool_name: pool_name || '',
-            block_number,
-            prev_lp_fee_ppm: prevLpFee,
-            prev_protocol_fee_ppm: prevProtocolFee ?? 0,
-            prev_total_ppm: prevTotal,
-            new_lp_fee_ppm: newLpFee,
-            new_protocol_fee_ppm: newProtocolFee,
-            new_total_ppm: newTotal,
-            delta_ppm: newTotal - prevTotal,
-        },
-    }));
-}