@3rd-eye-labs/openmm 0.0.1 → 0.1.1

package/dist/exchanges/kraken/kraken-websocket.js

@@ -0,0 +1,667 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KrakenWebSocket = void 0;
+const ws_1 = __importDefault(require("ws"));
+const kraken_data_mapper_1 = require("./kraken-data-mapper");
+const kraken_utils_1 = require("./kraken-utils");
+const kraken_auth_1 = require("./kraken-auth");
+const utils_1 = require("../../utils");
+class KrakenWebSocket {
+    constructor(publicWsUrl = 'wss://ws.kraken.com/v2', privateWsUrl = 'wss://ws-auth.kraken.com/v2') {
+        this.subscriptions = new Map();
+        this.status = 'disconnected';
+        this.privateStatus = 'disconnected';
+        this.logger = (0, utils_1.createLogger)('kraken-websocket');
+        this.reconnectAttempts = 0;
+        this.maxReconnectAttempts = 5;
+        this.reconnectDelay = 5000;
+        this.autoReconnect = true;
+        this.pingInterval = 30000;
+        this.dataMapper = new kraken_data_mapper_1.KrakenDataMapper();
+        this.nextReqId = 1;
+        this.pendingCancelRequests = new Map();
+        this.publicWsUrl = publicWsUrl;
+        this.privateWsUrl = privateWsUrl;
+    }
+    setCredentials(apiKey, apiSecret) {
+        this.auth = new kraken_auth_1.KrakenAuth({ apiKey, secret: apiSecret });
+    }
+    async connectWebSocket() {
+        return new Promise((resolve, reject) => {
+            try {
+                this.autoReconnect = true;
+                this.ws = new ws_1.default(this.publicWsUrl);
+                this.status = 'connecting';
+                this.ws.on('open', () => this.onOpen(resolve));
+                this.ws.on('message', (data) => this.onMessage(data));
+                this.ws.on('close', () => this.onClose());
+                this.ws.on('error', error => this.onError(error, reject));
+                this.ws.on('pong', () => { });
+            }
+            catch (error) {
+                this.status = 'error';
+                reject(error);
+            }
+        });
+    }
+    onOpen(resolve) {
+        this.status = 'connected';
+        this.reconnectAttempts = 0;
+        this.startPing();
+        this.logger.info('✅ Kraken public WebSocket connected successfully');
+        this.resubscribeAll();
+        resolve();
+    }
+    onClose() {
+        this.status = 'disconnected';
+        this.stopPing();
+        this.logger.warn('🔌 Kraken public WebSocket connection closed');
+        if (this.autoReconnect && this.reconnectAttempts < this.maxReconnectAttempts) {
+            this.scheduleReconnect();
+        }
+        else if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+            this.logger.error('❌ Max reconnection attempts reached, giving up');
+        }
+    }
+    onError(error, reject) {
+        this.status = 'error';
+        this.logger.error('❌ Kraken public WebSocket error:', { error: error.message });
+        if (this.reconnectAttempts === 0 && reject) {
+            reject(error);
+        }
+    }
+    onMessage(data) {
+        try {
+            const message = data.toString();
+            const parsedMessage = JSON.parse(message);
+            if (parsedMessage.channel === 'heartbeat') {
+                return;
+            }
+            if (parsedMessage.channel === 'status' && parsedMessage.type === 'update') {
+                return;
+            }
+            if (parsedMessage.type === 'subscribe' || parsedMessage.type === 'unsubscribe') {
+                this.handleSubscriptionResponse(parsedMessage);
+                return;
+            }
+            if (parsedMessage.type === 'update' || parsedMessage.type === 'snapshot') {
+                this.processMarketData(parsedMessage);
+            }
+        }
+        catch (error) {
+            this.logger.error('❌ Error processing Kraken message:', {
+                error,
+                message: data.toString().substring(0, 200),
+            });
+        }
+    }
+    handleSubscriptionResponse(message) {
+        const subscription = Array.from(this.subscriptions.values()).find(sub => sub.reqId === message.req_id);
+        if (message.success === false || message.error) {
+            this.logger.error('❌ Subscription failed:', {
+                error: message.error,
+                reqId: message.req_id,
+            });
+            if (subscription && subscription.type === 'orders' && subscription.reject) {
+                subscription.reject(new Error(message.error || 'Subscription failed'));
+            }
+            return;
+        }
+        if (message.req_id && message.type === 'subscribe') {
+            this.logger.info('✅ Subscription successful:', {
+                reqId: message.req_id,
+                subscription: message.subscription,
+            });
+            if (subscription && subscription.type === 'orders' && subscription.resolve) {
+                subscription.resolve();
+            }
+        }
+    }
+    processMarketData(message) {
+        try {
+            const { channel, data, symbol } = message;
+            if (!channel || !data || !Array.isArray(data)) {
+                return;
+            }
+            // Map Kraken channels to subscription types
+            let subscriptionType;
+            switch (channel) {
+                case 'ticker':
+                    subscriptionType = 'ticker';
+                    break;
+                case 'book':
+                    subscriptionType = 'orderbook';
+                    break;
+                case 'trade':
+                    subscriptionType = 'trades';
+                    break;
+                default:
+                    return;
+            }
+            const subscriptions = Array.from(this.subscriptions.values()).filter(sub => sub.type === subscriptionType && (!symbol || sub.symbol === symbol));
+            if (subscriptions.length === 0) {
+                return;
+            }
+            switch (subscriptionType) {
+                case 'ticker':
+                    this.handleTickerData(data, subscriptions);
+                    break;
+                case 'orderbook':
+                    this.handleOrderBookData(data, subscriptions);
+                    break;
+                case 'trades':
+                    this.handleTradeData(data, subscriptions);
+                    break;
+            }
+        }
+        catch (error) {
+            this.logger.error('Error processing market data:', {
+                error: error instanceof Error ? error.message : error,
+            });
+        }
+    }
+    handleTickerData(data, subscriptions) {
+        for (const rawData of data) {
+            const tickerData = rawData;
+            const ticker = this.dataMapper.mapWebSocketTicker(tickerData);
+            for (const sub of subscriptions) {
+                if (sub.symbol &&
+                    tickerData.symbol === kraken_utils_1.KrakenUtils.toKrakenSymbol(sub.symbol) &&
+                    sub.type === 'ticker') {
+                    ticker.symbol = sub.symbol;
+                    sub.callback(ticker);
+                }
+            }
+        }
+    }
+    handleOrderBookData(data, subscriptions) {
+        for (const rawData of data) {
+            const bookData = rawData;
+            const orderBook = this.dataMapper.mapWebSocketOrderBook(bookData);
+            for (const sub of subscriptions) {
+                if (sub.symbol &&
+                    bookData.symbol === kraken_utils_1.KrakenUtils.toKrakenSymbol(sub.symbol) &&
+                    sub.type === 'orderbook') {
+                    orderBook.symbol = sub.symbol;
+                    sub.callback(orderBook);
+                }
+            }
+        }
+    }
+    handleTradeData(data, subscriptions) {
+        for (const rawData of data) {
+            const tradeData = rawData;
+            const trade = this.dataMapper.mapWebSocketTrade(tradeData);
+            for (const sub of subscriptions) {
+                if (sub.symbol &&
+                    tradeData.symbol === kraken_utils_1.KrakenUtils.toKrakenSymbol(sub.symbol) &&
+                    sub.type === 'trades') {
+                    trade.symbol = sub.symbol;
+                    sub.callback(trade);
+                }
+            }
+        }
+    }
+    async subscribeTicker(symbol, callback) {
+        const subscriptionId = `ticker_${symbol}_${Date.now()}`;
+        const krakenSymbol = kraken_utils_1.KrakenUtils.toKrakenSymbol(symbol);
+        const reqId = this.getNextReqId();
+        this.subscriptions.set(subscriptionId, {
+            id: subscriptionId,
+            type: 'ticker',
+            symbol,
+            callback,
+            reqId,
+        });
+        const subscribeMessage = {
+            method: 'subscribe',
+            params: {
+                channel: 'ticker',
+                symbol: [krakenSymbol],
+                snapshot: true,
+            },
+            req_id: reqId,
+        };
+        if (this.ws?.readyState === ws_1.default.OPEN) {
+            this.ws.send(JSON.stringify(subscribeMessage));
+            this.logger.info('📊 Subscribed to ticker:', { symbol, reqId });
+        }
+        return subscriptionId;
+    }
+    async subscribeOrderBook(symbol, callback) {
+        const subscriptionId = `orderbook_${symbol}_${Date.now()}`;
+        const krakenSymbol = kraken_utils_1.KrakenUtils.toKrakenSymbol(symbol);
+        const reqId = this.getNextReqId();
+        this.subscriptions.set(subscriptionId, {
+            id: subscriptionId,
+            type: 'orderbook',
+            symbol,
+            callback,
+            reqId,
+        });
+        const subscribeMessage = {
+            method: 'subscribe',
+            params: {
+                channel: 'book',
+                symbol: [krakenSymbol],
+                depth: 100,
+                snapshot: true,
+            },
+            req_id: reqId,
+        };
+        if (this.ws?.readyState === ws_1.default.OPEN) {
+            this.ws.send(JSON.stringify(subscribeMessage));
+            this.logger.info('📚 Subscribed to order book:', { symbol, reqId });
+        }
+        return subscriptionId;
+    }
+    async subscribeTrades(symbol, callback) {
+        const subscriptionId = `trades_${symbol}_${Date.now()}`;
+        const krakenSymbol = kraken_utils_1.KrakenUtils.toKrakenSymbol(symbol);
+        const reqId = this.getNextReqId();
+        this.subscriptions.set(subscriptionId, {
+            id: subscriptionId,
+            type: 'trades',
+            symbol,
+            callback,
+            reqId,
+        });
+        const subscribeMessage = {
+            method: 'subscribe',
+            params: {
+                channel: 'trade',
+                symbol: [krakenSymbol],
+                snapshot: false,
+            },
+            req_id: reqId,
+        };
+        if (this.ws?.readyState === ws_1.default.OPEN) {
+            this.ws.send(JSON.stringify(subscribeMessage));
+            this.logger.info('💹 Subscribed to trades:', { symbol, reqId });
+        }
+        return subscriptionId;
+    }
+    async unsubscribe(subscriptionId) {
+        const subscription = this.subscriptions.get(subscriptionId);
+        if (!subscription) {
+            this.logger.warn('Subscription not found:', { subscriptionId });
+            return;
+        }
+        // Map subscription type to Kraken channel
+        let channel;
+        switch (subscription.type) {
+            case 'ticker':
+                channel = 'ticker';
+                break;
+            case 'orderbook':
+                channel = 'book';
+                break;
+            case 'trades':
+                channel = 'trade';
+                break;
+            default:
+                channel = 'executions'; // for orders and user_trades
+        }
+        const krakenSymbol = kraken_utils_1.KrakenUtils.toKrakenSymbol(subscription.symbol || '');
+        const reqId = this.getNextReqId();
+        const unsubscribeMessage = {
+            method: 'unsubscribe',
+            params: {
+                channel,
+                symbol: [krakenSymbol],
+            },
+            req_id: reqId,
+        };
+        if (this.ws?.readyState === ws_1.default.OPEN) {
+            this.ws.send(JSON.stringify(unsubscribeMessage));
+            this.logger.info('🔕 Unsubscribed:', { subscriptionId, type: subscription.type });
+        }
+        this.subscriptions.delete(subscriptionId);
+    }
+    async connectPrivateWebSocket() {
+        if (!this.auth) {
+            throw new Error('API credentials not set');
+        }
+        return new Promise((resolve, reject) => {
+            try {
+                this.privateWs = new ws_1.default(this.privateWsUrl);
+                this.privateStatus = 'connecting';
+                this.privateWs.on('open', () => this.onPrivateOpen(resolve));
+                this.privateWs.on('message', (data) => this.onPrivateMessage(data));
+                this.privateWs.on('close', () => this.onPrivateClose());
+                this.privateWs.on('error', error => this.onPrivateError(error, reject));
+                this.privateWs.on('pong', () => { });
+            }
+            catch (error) {
+                this.privateStatus = 'error';
+                reject(error);
+            }
+        });
+    }
+    async onPrivateOpen(resolve) {
+        this.privateStatus = 'connected';
+        this.startPrivatePing();
+        this.logger.info('✅ Kraken private WebSocket connected successfully');
+        await this.authenticatePrivateWebSocket();
+        resolve();
+    }
+    async authenticatePrivateWebSocket() {
+        if (!this.auth) {
+            throw new Error('API credentials not set');
+        }
+        try {
+            const data = (await this.auth.makeRequest('https://api.kraken.com/0/private/GetWebSocketsToken', '/0/private/GetWebSocketsToken'));
+            this.authToken = data.token;
+            this.logger.info('✅ Obtained WebSocket auth token');
+        }
+        catch (error) {
+            this.logger.error('Failed to authenticate private WebSocket:', {
+                error: error instanceof Error ? error.message : error,
+            });
+            throw error;
+        }
+    }
+    onPrivateClose() {
+        this.privateStatus = 'disconnected';
+        this.stopPrivatePing();
+        this.logger.warn('🔌 Kraken private WebSocket connection closed');
+    }
+    onPrivateError(error, reject) {
+        this.privateStatus = 'error';
+        this.logger.error('❌ Kraken private WebSocket error:', { error: error.message });
+        if (reject) {
+            reject(error);
+        }
+    }
+    onPrivateMessage(data) {
+        try {
+            const message = data.toString();
+            const parsedMessage = JSON.parse(message);
+            if (parsedMessage.channel === 'executions') {
+                this.handleUserOrderUpdate(parsedMessage);
+            }
+            else if (parsedMessage.type === 'update' && parsedMessage.channel === 'executions') {
+                this.handleUserOrderUpdate(parsedMessage);
+            }
+            else if (parsedMessage.method === 'subscribe' && parsedMessage.success) {
+            }
+            else if (parsedMessage.type === 'snapshot' && parsedMessage.channel === 'executions') {
+                this.handleUserOrderUpdate(parsedMessage);
+            }
+            else if (parsedMessage.method === 'cancel_all') {
+                this.handleCancelAllResponse(parsedMessage);
+            }
+        }
+        catch (error) {
+            this.logger.error('❌ Error processing Kraken private message:', {
+                error,
+                message: data.toString().substring(0, 200),
+            });
+        }
+    }
+    handleUserOrderUpdate(message) {
+        const orderSubscriptions = Array.from(this.subscriptions.values()).filter(sub => sub.type === 'orders');
+        const tradeSubscriptions = Array.from(this.subscriptions.values()).filter(sub => sub.type === 'user_trades');
+        if (!message.data || !Array.isArray(message.data)) {
+            return;
+        }
+        // Handle order updates
+        for (const sub of orderSubscriptions) {
+            const orders = message.data.map((orderData) => {
+                return this.dataMapper.mapWebSocketOrder(orderData);
+            });
+            orders.forEach((order) => {
+                if (sub.type === 'orders') {
+                    sub.callback(order);
+                }
+            });
+        }
+        // Handle trade updates
+        for (const sub of tradeSubscriptions) {
+            const trades = message.data
+                .filter((data) => data.exec_type === 'trade')
+                .map((tradeData) => this.dataMapper.mapWebSocketTrade(tradeData));
+            trades.forEach((trade) => {
+                if (sub.type === 'user_trades') {
+                    sub.callback(trade);
+                }
+            });
+        }
+    }
+    handleCancelAllResponse(message) {
+        const reqId = message.req_id;
+        const pending = this.pendingCancelRequests.get(reqId);
+        if (!pending) {
+            return;
+        }
+        this.pendingCancelRequests.delete(reqId);
+        if (message.success === false || message.error) {
+            this.logger.error('❌ cancel_all failed:', {
+                error: message.error,
+                reqId,
+            });
+            pending.reject(new Error(message.error || 'cancel_all failed'));
+        }
+        else {
+            this.logger.info(`✅ Cancelled ${message.result?.count || 0} orders via WebSocket`);
+            pending.resolve();
+        }
+        const now = Date.now();
+        for (const [id, req] of this.pendingCancelRequests.entries()) {
+            if (now - req.timestamp > 30000) {
+                this.pendingCancelRequests.delete(id);
+                req.reject(new Error('cancel_all request timed out'));
+            }
+        }
+    }
+    async subscribeUserOrders(callback) {
+        if (!this.authToken) {
+            throw new Error('Not authenticated to private WebSocket');
+        }
+        let attempts = 0;
+        while (this.privateWs?.readyState !== ws_1.default.OPEN && attempts < 50) {
+            await new Promise(resolve => setTimeout(resolve, 100));
+            attempts++;
+        }
+        if (this.privateWs?.readyState !== ws_1.default.OPEN) {
+            throw new Error('Private WebSocket not ready after 5 seconds');
+        }
+        const subscriptionId = `user_orders_${Date.now()}`;
+        const reqId = this.getNextReqId();
+        this.subscriptions.set(subscriptionId, {
+            id: subscriptionId,
+            type: 'orders',
+            symbol: '',
+            callback,
+            reqId,
+        });
+        const subscribeMessage = {
+            method: 'subscribe',
+            params: {
+                channel: 'executions',
+                token: this.authToken,
+                snapshot: true,
+            },
+            req_id: reqId,
+        };
+        this.privateWs.send(JSON.stringify(subscribeMessage));
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        return subscriptionId;
+    }
+    async subscribeUserTrades(callback) {
+        if (!this.authToken) {
+            throw new Error('Not authenticated to private WebSocket');
+        }
+        const subscriptionId = `user_trades_${Date.now()}`;
+        const reqId = this.getNextReqId();
+        this.subscriptions.set(subscriptionId, {
+            id: subscriptionId,
+            type: 'user_trades',
+            symbol: '',
+            callback,
+            reqId,
+        });
+        const subscribeMessage = {
+            method: 'subscribe',
+            params: {
+                channel: 'executions',
+                snapshot_trades: true,
+                token: this.authToken,
+            },
+            req_id: reqId,
+        };
+        if (this.privateWs?.readyState === ws_1.default.OPEN) {
+            this.privateWs.send(JSON.stringify(subscribeMessage));
+            this.logger.info('👤 Subscribed to user trades');
+        }
+        return subscriptionId;
+    }
+    async cancelAllOrders(symbol) {
+        if (!this.authToken) {
+            throw new Error('Not authenticated to private WebSocket');
+        }
+        if (this.privateWs?.readyState !== ws_1.default.OPEN) {
+            throw new Error('Private WebSocket not connected');
+        }
+        const reqId = this.getNextReqId();
+        const responsePromise = new Promise((resolve, reject) => {
+            this.pendingCancelRequests.set(reqId, {
+                resolve,
+                reject,
+                timestamp: Date.now(),
+            });
+            // Set timeout for response
+            setTimeout(() => {
+                if (this.pendingCancelRequests.has(reqId)) {
+                    this.pendingCancelRequests.delete(reqId);
+                    reject(new Error('cancel_all request timed out after 10 seconds'));
+                }
+            }, 10000);
+        });
+        const cancelMessage = {
+            method: 'cancel_all',
+            params: {
+                token: this.authToken,
+            },
+            req_id: reqId,
+        };
+        if (symbol) {
+            this.logger.warn('⚠️ Kraken WebSocket v2 cancel_all does not support filtering by symbol - cancelling ALL orders');
+        }
+        this.privateWs.send(JSON.stringify(cancelMessage));
+        try {
+            await responsePromise;
+        }
+        catch (error) {
+            this.logger.error('❌ Failed to cancel orders via WebSocket:', {
+                error: error instanceof Error ? error.message : error,
+            });
+            throw error;
+        }
+    }
+    startPing() {
+        this.pingTimer = setInterval(() => {
+            if (this.ws?.readyState === ws_1.default.OPEN) {
+                const pingMessage = {
+                    method: 'ping',
+                    req_id: this.getNextReqId(),
+                };
+                this.ws.send(JSON.stringify(pingMessage));
+            }
+        }, this.pingInterval);
+    }
+    stopPing() {
+        if (this.pingTimer) {
+            clearInterval(this.pingTimer);
+            this.pingTimer = undefined;
+        }
+    }
+    startPrivatePing() {
+        this.privatePingTimer = setInterval(() => {
+            if (this.privateWs?.readyState === ws_1.default.OPEN) {
+                const pingMessage = {
+                    method: 'ping',
+                    req_id: this.getNextReqId(),
+                };
+                this.privateWs.send(JSON.stringify(pingMessage));
+            }
+        }, this.pingInterval);
+    }
+    stopPrivatePing() {
+        if (this.privatePingTimer) {
+            clearInterval(this.privatePingTimer);
+            this.privatePingTimer = undefined;
+        }
+    }
+    scheduleReconnect() {
+        if (this.reconnectTimer) {
+            return;
+        }
+        this.reconnectAttempts++;
+        const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1);
+        this.logger.info(`⏳ Scheduling reconnect attempt ${this.reconnectAttempts} in ${delay}ms`);
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = undefined;
+            this.connectWebSocket().catch(error => {
+                this.logger.error('Reconnection failed:', {
+                    error: error instanceof Error ? error.message : error,
+                });
+            });
+        }, delay);
+    }
+    resubscribeAll() {
+        for (const [, subscription] of this.subscriptions) {
+            if (subscription.type === 'ticker') {
+                this.subscribeTicker(subscription.symbol, subscription.callback);
+            }
+            else if (subscription.type === 'orderbook') {
+                this.subscribeOrderBook(subscription.symbol, subscription.callback);
+            }
+            else if (subscription.type === 'trades') {
+                this.subscribeTrades(subscription.symbol, subscription.callback);
+            }
+        }
+    }
+    getNextReqId() {
+        return this.nextReqId++;
+    }
+    async disconnectWebSocket() {
+        this.autoReconnect = false;
+        this.stopPing();
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = undefined;
+        }
+        if (this.ws) {
+            this.ws.close();
+            this.ws = undefined;
+        }
+        this.status = 'disconnected';
+        this.subscriptions.clear();
+        this.logger.info('🔌 Kraken public WebSocket disconnected');
+    }
+    async disconnectPrivateWebSocket() {
+        this.stopPrivatePing();
+        if (this.privateWs) {
+            this.privateWs.close();
+            this.privateWs = undefined;
+        }
+        this.privateStatus = 'disconnected';
+        this.authToken = undefined;
+        this.logger.info('🔌 Kraken private WebSocket disconnected');
+    }
+    isConnected() {
+        return this.ws?.readyState === ws_1.default.OPEN;
+    }
+    isPrivateConnected() {
+        return this.privateWs?.readyState === ws_1.default.OPEN;
+    }
+    getStatus() {
+        return this.status;
+    }
+}
+exports.KrakenWebSocket = KrakenWebSocket;
+//# sourceMappingURL=kraken-websocket.js.map