@clonegod/ttd-bsc-common 1.0.10 → 1.0.12

package/dist/common/constants.d.ts

@@ -12,6 +12,7 @@ export declare const EVENT_NAMES: {
     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;

package/dist/common/constants.js

@@ -15,6 +15,7 @@ exports.EVENT_NAMES = {
     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)",

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

@@ -1,6 +1,5 @@
-import { ethers } from 'ethers';
-import { StandardPoolInfoType } from "@clonegod/ttd-core";
-import { AppConfig } from "@clonegod/ttd-core/dist";
+import { StandardPoolInfoType } from '@clonegod/ttd-core';
+import { AppConfig } from '@clonegod/ttd-core/dist';
 export interface BlockUpdateEvent {
     blockNumber: number;
     previousBlockNumber: number;
@@ -10,31 +9,25 @@ export declare class PoolEventListener {
     private appConfig;
     private wsProvider;
     private poolList;
+    private ws_endpoint;
     private isConnected;
+    private isReconnecting;
     private isStarted;
     private reconnectAttempts;
     private maxReconnectAttempts;
     private baseReconnectDelay;
     private maxReconnectDelay;
-    private heartbeatInterval;
-    private connectionTimeout;
-    private connectionTimeoutMs;
     private lastProcessedBlockNumber;
     private isBlockListenerActive;
-    private metrics;
-    constructor(appConfig: AppConfig, wsProvider: ethers.providers.WebSocketProvider);
+    constructor(appConfig: AppConfig, ws_endpoint: string);
     init(poolList: StandardPoolInfoType[]): Promise<void>;
     start(): Promise<void>;
     stop(): Promise<void>;
-    private initProvider;
-    private setConnectionTimeout;
-    private clearConnectionTimeout;
+    private connect;
     private handleConnectionIssue;
-    private startHeartbeat;
-    private stopHeartbeat;
-    private cleanupProvider;
     private startBlockListener;
     private stopBlockListener;
+    private cleanup;
     isWSConnected(): boolean;
     getConnectionDiagnostics(): object;
 }

package/dist/quote/event/pool_event_listener.js

@@ -12,28 +12,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PoolEventListener = void 0;
 const ethers_1 = require("ethers");
 const dist_1 = require("@clonegod/ttd-core/dist");
-const constants_1 = require("../../common/constants");
+const common_1 = require("../../common");
 class PoolEventListener {
-    constructor(appConfig, wsProvider) {
+    constructor(appConfig, ws_endpoint) {
+        this.wsProvider = null;
         this.poolList = [];
         this.isConnected = false;
+        this.isReconnecting = false;
         this.isStarted = false;
         this.reconnectAttempts = 0;
         this.maxReconnectAttempts = 10;
-        this.baseReconnectDelay = 1000;
+        this.baseReconnectDelay = 500;
         this.maxReconnectDelay = 30000;
-        this.heartbeatInterval = null;
-        this.connectionTimeout = null;
-        this.connectionTimeoutMs = 15000;
         this.lastProcessedBlockNumber = 0;
         this.isBlockListenerActive = false;
-        this.metrics = {
-            lastBlockTime: 0,
-            blockInterval: 0,
-            missedBlocks: 0
-        };
         this.appConfig = appConfig;
-        this.wsProvider = wsProvider;
+        this.ws_endpoint = ws_endpoint;
     }
     init(poolList) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -41,13 +35,13 @@ class PoolEventListener {
             if (this.poolList.length !== poolList.length) {
                 (0, dist_1.log_warn)(`发现 ${poolList.length - this.poolList.length} 个无效池地址，已过滤`, '');
             }
-            yield this.initProvider();
+            yield this.connect();
         });
     }
     start() {
         return __awaiter(this, void 0, void 0, function* () {
             (0, dist_1.log_info)(`开始启动区块监听...`);
-            if (!this.isConnected) {
+            if (!this.isConnected || !this.wsProvider) {
                 (0, dist_1.log_warn)('WebSocket 尚未连接，无法启动监听', '');
                 return;
             }
@@ -60,125 +54,76 @@ class PoolEventListener {
         return __awaiter(this, void 0, void 0, function* () {
             (0, dist_1.log_info)(`停止区块监听...`);
             this.stopBlockListener();
-            this.cleanupProvider();
+            this.cleanup();
             this.isStarted = false;
             (0, dist_1.log_info)(`区块监听已停止`);
         });
     }
-    initProvider() {
+    connect() {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                (0, dist_1.log_info)(`正在连接WebSocket: ${this.appConfig.env_args.ws_endpoint}`);
+                (0, dist_1.log_info)(`正在连接 WebSocket: ${this.ws_endpoint}`);
+                this.wsProvider = new ethers_1.ethers.providers.WebSocketProvider(this.ws_endpoint);
                 yield this.wsProvider.ready;
-                this.setConnectionTimeout();
-                this.clearConnectionTimeout();
                 this.isConnected = true;
                 this.reconnectAttempts = 0;
-                (0, dist_1.log_info)(`WebSocket Provider 已连接`);
+                (0, dist_1.log_info)(`WebSocket 已连接: ${this.ws_endpoint}`);
                 this.wsProvider.on('error', (err) => {
-                    (0, dist_1.log_error)(`WebSocket Provider 错误:`, err, '');
+                    (0, dist_1.log_error)(`WebSocket 错误:`, err, '');
                     this.handleConnectionIssue();
                 });
-                this.wsProvider._websocket.on('close', (code) => __awaiter(this, void 0, void 0, function* () {
-                    (0, dist_1.log_warn)(`WebSocket 连接关闭, 代码: ${code}. 尝试重新连接...`, '');
+                this.wsProvider._websocket.on('close', (code, reason) => {
+                    (0, dist_1.log_warn)(`WebSocket 连接关闭, 代码: ${code}, 原因: ${reason || '未知'}`);
                     this.handleConnectionIssue();
-                }));
-                this.startHeartbeat();
+                });
+                if (this.isStarted) {
+                    yield this.startBlockListener();
+                }
             }
             catch (error) {
-                (0, dist_1.log_error)('初始化 WebSocket 提供者失败:', error, '');
-                this.clearConnectionTimeout();
-                this.handleConnectionIssue();
+                (0, dist_1.log_error)(`首次连接 WebSocket 失败: ${this.ws_endpoint}`, error, '');
+                if (this.reconnectAttempts > 0) {
+                    this.handleConnectionIssue();
+                }
+                else {
+                    this.isReconnecting = true;
+                    this.isConnected = false;
+                    this.cleanup();
+                    yield (0, dist_1.sleep)(this.baseReconnectDelay);
+                    yield this.connect();
+                    this.isReconnecting = false;
+                }
             }
         });
     }
-    setConnectionTimeout() {
-        this.clearConnectionTimeout();
-        this.connectionTimeout = setTimeout(() => {
-            (0, dist_1.log_error)(`WebSocket 连接超时`, new Error('Connection timeout'), '');
-            this.handleConnectionIssue();
-        }, this.connectionTimeoutMs);
-    }
-    clearConnectionTimeout() {
-        if (this.connectionTimeout) {
-            clearTimeout(this.connectionTimeout);
-            this.connectionTimeout = null;
-        }
-    }
     handleConnectionIssue() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.isConnected)
+            if (this.isReconnecting)
                 return;
+            this.isReconnecting = true;
             this.isConnected = false;
-            this.stopHeartbeat();
-            const delay = Math.min(this.baseReconnectDelay * Math.pow(2, this.reconnectAttempts), this.maxReconnectDelay);
+            this.stopBlockListener();
+            this.cleanup();
             this.reconnectAttempts++;
-            (0, dist_1.log_warn)(`WebSocket 断开连接. 重连尝试 ${this.reconnectAttempts}/${this.maxReconnectAttempts}, 延迟 ${delay}ms`, '');
+            const delay = Math.min(this.baseReconnectDelay * Math.pow(2, this.reconnectAttempts), this.maxReconnectDelay);
+            (0, dist_1.log_info)(`尝试重连 ${this.reconnectAttempts}/${this.maxReconnectAttempts}, 延迟 ${delay}ms, 节点: ${this.ws_endpoint}`);
             if (this.reconnectAttempts > this.maxReconnectAttempts) {
-                (0, dist_1.log_error)(`超过最大重连尝试次数 (${this.maxReconnectAttempts})，停止重连`, new Error('Max reconnect attempts exceeded'), '');
-                return;
+                (0, dist_1.log_error)(`重连失败，尝试次数达到 ${this.maxReconnectAttempts} 次，程序退出`, new Error('Max reconnect attempts failed'), '');
+                this.appConfig.emit(common_1.EVENT_NAMES.WS_CONNECTION_FAILED, {
+                    endpoint: this.ws_endpoint,
+                    attempts: this.maxReconnectAttempts,
+                });
+                process.exit(1);
             }
             yield (0, dist_1.sleep)(delay);
-            try {
-                yield this.initProvider();
-                if (this.isStarted) {
-                    (0, dist_1.log_info)('重连成功，正在重新启动区块监听...');
-                    yield this.startBlockListener();
-                }
-            }
-            catch (err) {
-                (0, dist_1.log_error)('重新连接失败:', err, '');
-                this.handleConnectionIssue();
-            }
+            yield this.connect();
+            this.isReconnecting = false;
         });
     }
-    startHeartbeat() {
-        this.stopHeartbeat();
-        this.heartbeatInterval = setInterval(() => __awaiter(this, void 0, void 0, function* () {
-            try {
-                if (!this.wsProvider)
-                    return;
-                const blockNumber = yield this.wsProvider.getBlockNumber();
-                (0, dist_1.log_debug)(`心跳检测成功，当前区块: ${blockNumber}`);
-            }
-            catch (error) {
-                (0, dist_1.log_warn)(`心跳检测失败，正在重连...`);
-                this.handleConnectionIssue();
-            }
-        }), 15000);
-    }
-    stopHeartbeat() {
-        if (this.heartbeatInterval) {
-            clearInterval(this.heartbeatInterval);
-            this.heartbeatInterval = null;
-        }
-    }
-    cleanupProvider() {
-        this.stopHeartbeat();
-        this.clearConnectionTimeout();
-        this.stopBlockListener();
-        if (this.wsProvider) {
-            try {
-                this.wsProvider.removeAllListeners();
-                if (this.wsProvider._websocket) {
-                    this.wsProvider._websocket.removeAllListeners();
-                    if (this.wsProvider._websocket.readyState === 1) {
-                        this.wsProvider._websocket.close(1000, "Normal closure");
-                    }
-                }
-            }
-            catch (error) {
-                (0, dist_1.log_error)(`清理 Provider 资源时出错:`, error, '');
-            }
-            this.wsProvider = undefined;
-        }
-    }
     startBlockListener() {
         return __awaiter(this, void 0, void 0, function* () {
-            (0, dist_1.log_info)(`开始启动区块监听...`);
-            this.stopBlockListener();
-            if (!this.isConnected || !this.wsProvider) {
-                (0, dist_1.log_warn)(`无法启动区块监听: WebSocket未连接`);
+            if (!this.wsProvider || !this.isConnected) {
+                (0, dist_1.log_warn)(`无法启动区块监听: WebSocket 未连接`);
                 return;
             }
             try {
@@ -189,28 +134,22 @@ class PoolEventListener {
                     try {
                         if (!this.isConnected || !this.isBlockListenerActive)
                             return;
-                        this.metrics.blockInterval = Date.now() - this.metrics.lastBlockTime;
-                        this.metrics.lastBlockTime = Date.now();
-                        if (this.metrics.blockInterval > 30000) {
-                            (0, dist_1.log_warn)(`区块间隔异常: ${this.metrics.blockInterval}ms`);
-                            this.metrics.missedBlocks++;
-                        }
                         (0, dist_1.log_info)(`------- Block: ${blockNumber} -------`);
                         const previousBlockNumber = this.lastProcessedBlockNumber;
                         this.lastProcessedBlockNumber = blockNumber;
                         const blockUpdateEvent = {
-                            blockNumber: blockNumber,
-                            previousBlockNumber: previousBlockNumber,
-                            timestamp: Date.now()
+                            blockNumber,
+                            previousBlockNumber,
+                            timestamp: Date.now(),
                         };
-                        this.appConfig.emit(constants_1.EVENT_NAMES.BLOCK_UPDATE, blockUpdateEvent);
+                        this.appConfig.emit(common_1.EVENT_NAMES.BLOCK_UPDATE, blockUpdateEvent);
                     }
                     catch (error) {
                         (0, dist_1.log_error)(`处理区块事件出错:`, error, '');
                     }
                 }));
                 this.isBlockListenerActive = true;
-                (0, dist_1.log_info)(`区块监听已启动，使用WebSocket事件订阅方式`);
+                (0, dist_1.log_info)(`区块监听已启动，使用 WebSocket 事件订阅方式`);
             }
             catch (error) {
                 (0, dist_1.log_error)(`启动区块监听失败:`, error, '');
@@ -225,22 +164,38 @@ class PoolEventListener {
             (0, dist_1.log_info)(`区块监听已停止`);
         }
     }
+    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)(`清理 WebSocket 资源失败:`, error, '');
+            }
+            this.wsProvider = null;
+        }
+        this.isConnected = false;
+        this.isReconnecting = false;
+    }
     isWSConnected() {
-        return this.isConnected;
+        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,
-            hasActiveHeartbeat: this.heartbeatInterval !== null,
-            wsEndpoint: this.appConfig.env_args.ws_endpoint,
+            ws_endpoint: this.ws_endpoint,
             wsReadyState: this.wsProvider && this.wsProvider._websocket
                 ? this.wsProvider._websocket.readyState
                 : null,
             trackingPools: this.poolList.length,
             lastProcessedBlock: this.lastProcessedBlockNumber,
-            metrics: Object.assign(Object.assign({}, this.metrics), { lastBlockTime: new Date(this.metrics.lastBlockTime).toISOString() })
         };
     }
 }

package/package.json

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

package/dist/config/env_args.d.ts

@@ -1,13 +0,0 @@
-import { EnvArgs } from "@clonegod/ttd-core/dist";
-export declare class BSCEnvArgs extends EnvArgs {
-    trade_mgt_http_port: number;
-    subscribe_dex_pool_txns: boolean;
-    subscribe_dex_pool_txns_startup: boolean;
-    subscribe_dex_pool_txns_interval: number;
-    onchain_data_save_file: boolean;
-    load_dex_pools_min_tvl: number;
-    load_dex_pools_min_vol: number;
-    load_dex_pools_all: boolean;
-    load_dex_pools_on_startup: boolean;
-    constructor();
-}

package/dist/config/env_args.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BSCEnvArgs = void 0;
-const dist_1 = require("@clonegod/ttd-core/dist");
-const dist_2 = require("@clonegod/ttd-core/dist");
-class BSCEnvArgs extends dist_1.EnvArgs {
-    constructor() {
-        super();
-        // BSC特定配置初始化
-        this.trade_mgt_http_port = parseInt(process.env.TRADE_MGT_HTTP_PORT || '8003');
-        this.subscribe_dex_pool_txns = process.env.SUBSCRIBE_DEX_POOL_TXNS === 'true';
-        this.subscribe_dex_pool_txns_startup = process.env.SUBSCRIBE_DEX_POOL_TXNS_STARTUP === 'true';
-        this.subscribe_dex_pool_txns_interval = parseInt(process.env.SUBSCRIBE_DEX_POOL_TXNS_INTERVAL || '3600');
-        this.onchain_data_save_file = process.env.ONCHAIN_DATA_SAVE_FILE === 'true';
-        // BSC链特定的池子配置初始化
-        this.load_dex_pools_min_tvl = parseInt(process.env.LOAD_DEX_POOLS_MIN_TVL || '50000');
-        this.load_dex_pools_min_vol = parseInt(process.env.LOAD_DEX_POOLS_MIN_VOL || '100000');
-        this.load_dex_pools_all = process.env.LOAD_DEX_POOLS_ALL === 'true';
-        this.load_dex_pools_on_startup = process.env.LOAD_DEX_POOLS_ON_STARTUP === 'true';
-        (0, dist_2.log_info)('BSC env args init finish', this);
-    }
-}
-exports.BSCEnvArgs = BSCEnvArgs;

package/dist/constants/networks.d.ts

@@ -1,10 +0,0 @@
-import { BSCNetworkConfig } from '../types';
-/**
- * BSC网络配置
- */
-export declare const BSC_MAINNET: BSCNetworkConfig;
-export declare const BSC_TESTNET: BSCNetworkConfig;
-/**
- * 根据环境变量获取当前使用的网络
- */
-export declare const getCurrentNetwork: () => BSCNetworkConfig;

package/dist/constants/networks.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCurrentNetwork = exports.BSC_TESTNET = exports.BSC_MAINNET = void 0;
-/**
- * BSC网络配置
- */
-exports.BSC_MAINNET = {
-    chainId: 56,
-    name: 'BSC Mainnet',
-    rpcUrl: 'https://bsc-dataseed.binance.org/',
-    explorerUrl: 'https://bscscan.com',
-    blockTime: 3, // 3秒
-};
-exports.BSC_TESTNET = {
-    chainId: 97,
-    name: 'BSC Testnet',
-    rpcUrl: 'https://data-seed-prebsc-1-s1.binance.org:8545/',
-    explorerUrl: 'https://testnet.bscscan.com',
-    blockTime: 3, // 3秒
-};
-/**
- * 根据环境变量获取当前使用的网络
- */
-const getCurrentNetwork = () => {
-    const network = process.env.BSC_NETWORK || 'mainnet';
-    return network.toLowerCase() === 'testnet' ? exports.BSC_TESTNET : exports.BSC_MAINNET;
-};
-exports.getCurrentNetwork = getCurrentNetwork;

package/dist/providers/index.d.ts

@@ -1,9 +0,0 @@
-import { ethers } from 'ethers';
-/**
- * 创建BSC网络的Provider
- */
-export declare const createBSCProvider: () => ethers.providers.JsonRpcProvider;
-/**
- * 使用私钥创建Signer
- */
-export declare const createSigner: (privateKey: string, provider?: ethers.providers.Provider) => ethers.Wallet;

package/dist/providers/index.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSigner = exports.createBSCProvider = void 0;
-const ethers_1 = require("ethers");
-const networks_1 = require("../constants/networks");
-/**
- * 创建BSC网络的Provider
- */
-const createBSCProvider = () => {
-    const network = (0, networks_1.getCurrentNetwork)();
-    return new ethers_1.ethers.providers.JsonRpcProvider(network.rpcUrl);
-};
-exports.createBSCProvider = createBSCProvider;
-/**
- * 使用私钥创建Signer
- */
-const createSigner = (privateKey, provider) => {
-    const bscProvider = provider || (0, exports.createBSCProvider)();
-    return new ethers_1.ethers.Wallet(privateKey, bscProvider);
-};
-exports.createSigner = createSigner;

package/dist/utils/redis_lock.d.ts

@@ -1,14 +0,0 @@
-import { RedisClientType } from "redis";
-export declare class RedisLock {
-    private lock_prefix;
-    private redisClient;
-    private lockMaxRetries;
-    private lockRetryDelayMs;
-    private lockExpireSeconds;
-    constructor(lock_prefix: string);
-    getRedisClient(): Promise<RedisClientType>;
-    private getLockKey;
-    private acquireLock;
-    private releaseLock;
-    withLock<T>(lock_identifier: string, callback: () => Promise<T>): Promise<T>;
-}

package/dist/utils/redis_lock.js

@@ -1,100 +0,0 @@
-"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.RedisLock = void 0;
-const dist_1 = require("@clonegod/ttd-core/dist");
-class RedisLock {
-    constructor(lock_prefix) {
-        this.lock_prefix = lock_prefix;
-        this.redisClient = null;
-        this.lockMaxRetries = 10;
-        this.lockRetryDelayMs = 300;
-        this.lockExpireSeconds = 10;
-    }
-    getRedisClient() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.redisClient) {
-                this.redisClient = yield (0, dist_1.getRedisCache)();
-            }
-            return this.redisClient;
-        });
-    }
-    getLockKey(lock_identifier) {
-        return `${this.lock_prefix}:lock:${lock_identifier}`;
-    }
-    acquireLock(lock_key_1, lock_value_1) {
-        return __awaiter(this, arguments, void 0, function* (lock_key, lock_value, expireSeconds = this.lockExpireSeconds) {
-            const redisClient = yield this.getRedisClient();
-            const result = yield redisClient.set(lock_key, lock_value, {
-                NX: true,
-                EX: expireSeconds
-            });
-            (0, dist_1.log_info)(`try acquireLock: lock_key=${lock_key}, lock_value=${lock_value}, expireSeconds=${expireSeconds}, result=${result}`);
-            const success = result === 'OK';
-            if (success) {
-                (0, dist_1.log_info)(`acquire lock success: lock_key=${lock_key}, lock_value=${lock_value}`);
-            }
-            return success;
-        });
-    }
-    releaseLock(lock_key, lock_value) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const redisClient = yield this.getRedisClient();
-            const script = `
-            if redis.call('get', KEYS[1]) == ARGV[1] then
-                return redis.call('del', KEYS[1])
-            else
-                return 0
-            end
-        `;
-            const result = yield redisClient.eval(script, {
-                keys: [lock_key],
-                arguments: [lock_value]
-            });
-            const success = Number(result) === 1;
-            if (success) {
-                (0, dist_1.log_info)(`release lock success: lock_key=${lock_key}, lock_value=${lock_value}`);
-            }
-            else {
-                (0, dist_1.log_info)(`release lock failed: lock_key=${lock_key}, lock_value=${lock_value}, maybe expired or locked by other process`);
-            }
-            return success;
-        });
-    }
-    withLock(lock_identifier, callback) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const lock_key = this.getLockKey(lock_identifier);
-            const lock_value = `${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
-            let retries = 0;
-            let acquired = false;
-            try {
-                while (retries < this.lockMaxRetries) {
-                    acquired = yield this.acquireLock(lock_key, lock_value);
-                    if (acquired)
-                        break;
-                    yield new Promise(resolve => setTimeout(resolve, this.lockRetryDelayMs));
-                    retries++;
-                }
-                if (!acquired) {
-                    throw new Error(`acquire lock failed: lock_key=${lock_key}, lock_value=${lock_value}, after ${this.lockMaxRetries} retries, maybe locked by other process`);
-                }
-                return yield callback();
-            }
-            finally {
-                if (acquired) {
-                    yield (0, dist_1.sleep)(parseInt(process.env.NONCE_LOCK_RELEASE_DELAY_MS || '2000'));
-                    yield this.releaseLock(lock_key, lock_value);
-                }
-            }
-        });
-    }
-}
-exports.RedisLock = RedisLock;