@clonegod/ttd-core 2.0.67 → 2.0.69

package/dist/index.d.ts

@@ -10,6 +10,7 @@ export * from './quote';
 export * from './token';
 export * from './trade';
 export * from './chains';
+export * from './ws';
 export declare const FAILED = "FAILED";
 export declare const SUCCESS = "SUCCESS";
 export declare const NOT_FOUND = "NOT_FOUND";

package/dist/index.js

@@ -90,6 +90,7 @@ __exportStar(require("./quote"), exports);
 __exportStar(require("./token"), exports);
 __exportStar(require("./trade"), exports);
 __exportStar(require("./chains"), exports);
+__exportStar(require("./ws"), exports);
 const short = require('short-uuid');
 const exec = require('util').promisify(require('child_process').exec);
 exports.FAILED = 'FAILED';

package/dist/ws/index.d.ts

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

package/dist/ws/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("./ws_client"), exports);

package/dist/ws/ws_client.d.ts

@@ -0,0 +1,42 @@
+export interface WebSocketClientOptions {
+    reconnectInterval?: number;
+    maxReconnectAttempts?: number;
+    headers?: {
+        [key: string]: string;
+    };
+    protocols?: string | string[];
+    handshakeTimeout?: number;
+    perMessageDeflate?: boolean | object;
+    timeout?: number;
+    keepAlive?: boolean;
+    keepAliveInterval?: number;
+}
+export declare class WebSocketClient {
+    private url;
+    private options;
+    private ws;
+    private reconnectInterval;
+    private onMessageCallback;
+    private onOpenCallback;
+    private onCloseCallback;
+    private onErrorCallback;
+    private reconnectAttempts;
+    private maxReconnectAttempts;
+    private isReconnecting;
+    private keepAliveTimer;
+    constructor(url: string, options?: WebSocketClientOptions);
+    private setDefaultOptions;
+    connect(): void;
+    onMessage(callback: (data: any) => void): void;
+    onOpen(callback: () => void): void;
+    onClose(callback: () => void): void;
+    onError(callback: (error: Error) => void): void;
+    send(data: any): boolean;
+    disconnect(): void;
+    private handleReconnect;
+    isConnected(): boolean;
+    getConnectionState(): string;
+    resetReconnectAttempts(): void;
+    private startKeepAlive;
+    private stopKeepAlive;
+}

package/dist/ws/ws_client.js

@@ -0,0 +1,170 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketClient = void 0;
+const ws_1 = __importDefault(require("ws"));
+const __1 = require("..");
+class WebSocketClient {
+    constructor(url, options = {}) {
+        this.ws = null;
+        this.onMessageCallback = null;
+        this.onOpenCallback = null;
+        this.onCloseCallback = null;
+        this.onErrorCallback = null;
+        this.reconnectAttempts = 0;
+        this.maxReconnectAttempts = 10;
+        this.isReconnecting = false;
+        this.keepAliveTimer = null;
+        this.url = url;
+        this.options = this.setDefaultOptions(options);
+        this.reconnectInterval = this.options.reconnectInterval;
+        this.maxReconnectAttempts = this.options.maxReconnectAttempts;
+        (0, __1.log_info)(`WebSocketClient constructor, url: ${this.url}`, this.options);
+    }
+    setDefaultOptions(options) {
+        const defaults = {
+            reconnectInterval: 3000,
+            maxReconnectAttempts: 10,
+            keepAlive: true,
+            keepAliveInterval: 30000,
+            handshakeTimeout: 10000,
+            perMessageDeflate: true,
+            timeout: 5000,
+        };
+        return Object.assign(Object.assign({}, defaults), options);
+    }
+    connect() {
+        if (this.isReconnecting) {
+            return;
+        }
+        const wsOptions = {
+            headers: this.options.headers,
+            protocols: this.options.protocols,
+            handshakeTimeout: this.options.handshakeTimeout,
+            perMessageDeflate: this.options.perMessageDeflate
+        };
+        (0, __1.log_info)(`Connecting to ${this.url} with options:`, wsOptions);
+        this.ws = new ws_1.default(this.url, wsOptions);
+        this.ws.on('open', () => {
+            console.log(`Connected to ${this.url}`);
+            this.reconnectAttempts = 0;
+            this.isReconnecting = false;
+            this.startKeepAlive();
+            if (this.onOpenCallback)
+                this.onOpenCallback();
+        });
+        this.ws.on('message', (message) => {
+            try {
+                const data = JSON.parse(message.toString());
+                if (this.onMessageCallback)
+                    this.onMessageCallback(data);
+            }
+            catch (err) {
+                console.error('Invalid message format:', err);
+            }
+        });
+        this.ws.on('close', (code, reason) => {
+            console.log(`Disconnected from server: ${code} - ${reason.toString()}`);
+            if (this.onCloseCallback)
+                this.onCloseCallback();
+            this.handleReconnect();
+        });
+        this.ws.on('error', (err) => {
+            console.error('WebSocket error:', err);
+            if (this.onErrorCallback)
+                this.onErrorCallback(err);
+        });
+    }
+    onMessage(callback) {
+        this.onMessageCallback = callback;
+    }
+    onOpen(callback) {
+        this.onOpenCallback = callback;
+    }
+    onClose(callback) {
+        this.onCloseCallback = callback;
+    }
+    onError(callback) {
+        this.onErrorCallback = callback;
+    }
+    send(data) {
+        if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
+            this.ws.send(JSON.stringify(data));
+            return true;
+        }
+        else {
+            console.error('WebSocket is not connected');
+            return false;
+        }
+    }
+    disconnect() {
+        this.isReconnecting = false;
+        this.stopKeepAlive();
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+    }
+    handleReconnect() {
+        if (this.isReconnecting) {
+            return;
+        }
+        if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+            (0, __1.log_info)(`Max reconnection attempts (${this.maxReconnectAttempts}) reached`);
+            return;
+        }
+        this.isReconnecting = true;
+        this.reconnectAttempts++;
+        (0, __1.log_info)(`Scheduling reconnect in ${this.reconnectInterval}ms (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})`);
+        setTimeout(() => {
+            (0, __1.log_info)(`Attempting to reconnect to ${this.url}... (${this.reconnectAttempts}/${this.maxReconnectAttempts})`);
+            this.connect();
+        }, this.reconnectInterval);
+    }
+    isConnected() {
+        return this.ws !== null && this.ws.readyState === ws_1.default.OPEN;
+    }
+    getConnectionState() {
+        if (!this.ws)
+            return 'DISCONNECTED';
+        switch (this.ws.readyState) {
+            case ws_1.default.CONNECTING:
+                return 'CONNECTING';
+            case ws_1.default.OPEN:
+                return 'OPEN';
+            case ws_1.default.CLOSING:
+                return 'CLOSING';
+            case ws_1.default.CLOSED:
+                return 'CLOSED';
+            default:
+                return 'UNKNOWN';
+        }
+    }
+    resetReconnectAttempts() {
+        this.reconnectAttempts = 0;
+        this.isReconnecting = false;
+    }
+    startKeepAlive() {
+        if (!this.options.keepAlive) {
+            (0, __1.log_info)('KeepAlive disabled');
+            return;
+        }
+        const interval = this.options.keepAliveInterval;
+        (0, __1.log_info)(`Starting keepAlive with interval: ${interval}ms`);
+        this.keepAliveTimer = setInterval(() => {
+            if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
+                this.ws.ping();
+                (0, __1.log_info)('KeepAlive ping sent');
+            }
+        }, interval);
+    }
+    stopKeepAlive() {
+        if (this.keepAliveTimer) {
+            clearInterval(this.keepAliveTimer);
+            this.keepAliveTimer = null;
+        }
+    }
+}
+exports.WebSocketClient = WebSocketClient;

package/dist/ws/ws_client_example.d.ts

@@ -0,0 +1,5 @@
+import { WebSocketClient } from './index';
+declare const basicClient: WebSocketClient;
+declare const fullClient: WebSocketClient;
+declare const bscClient: WebSocketClient;
+export { basicClient, fullClient, bscClient };

package/dist/ws/ws_client_example.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bscClient = exports.fullClient = exports.basicClient = void 0;
+const index_1 = require("./index");
+const basicClient = new index_1.WebSocketClient('wss://api.blxrbdn.com/ws', {
+    headers: {
+        "Authorization": "YOUR_AUTHORIZATION_HEADER"
+    }
+});
+exports.basicClient = basicClient;
+const fullClient = new index_1.WebSocketClient('wss://api.blxrbdn.com/ws', {
+    reconnectInterval: 2000,
+    maxReconnectAttempts: 15,
+    headers: {
+        "Authorization": "YOUR_AUTHORIZATION_HEADER",
+        "User-Agent": "MyApp/1.0"
+    },
+    protocols: ["echo-protocol"],
+    handshakeTimeout: 15000,
+    keepAlive: true,
+    keepAliveInterval: 20000,
+    timeout: 8000
+});
+exports.fullClient = fullClient;
+const bscOptions = {
+    reconnectInterval: 2000,
+    maxReconnectAttempts: 15,
+    headers: {
+        "Authorization": "YOUR_BSC_AUTHORIZATION_HEADER"
+    },
+    keepAlive: true,
+    keepAliveInterval: 20000,
+    handshakeTimeout: 15000
+};
+const bscClient = new index_1.WebSocketClient('wss://singapore.bsc.blxrbdn.com/ws', bscOptions);
+exports.bscClient = bscClient;
+bscClient.onOpen(() => {
+    console.log('BSC WebSocket 连接成功');
+    bscClient.send({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "subscribe",
+        params: ["newTxs", { "include": [], "blockchain_network": "BSC-Mainnet" }]
+    });
+});
+bscClient.onMessage((data) => {
+    console.log('收到 BSC 数据:', data);
+});
+bscClient.onError((error) => {
+    console.error('BSC WebSocket 错误:', error);
+});
+bscClient.onClose(() => {
+    console.log('BSC WebSocket 连接关闭');
+});
+bscClient.connect();
+console.log('连接状态:', bscClient.getConnectionState());
+console.log('是否连接:', bscClient.isConnected());
+const success = bscClient.send({
+    jsonrpc: "2.0",
+    id: 2,
+    method: "subscribe",
+    params: ["traceBlocks", { "include": [], "blockchain_network": "BSC-Mainnet" }]
+});
+if (success) {
+    console.log('消息发送成功');
+}
+else {
+    console.log('消息发送失败');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@clonegod/ttd-core",
-    "version": "2.0.67",
+    "version": "2.0.69",
     "description": "Common types and utilities for trading systems - use `npm run push` to publish",
     "main": "dist/index.js",
     "types": "types/index.d.ts",