@n1xyz/nord-ts 0.3.2 → 0.3.4

package/dist/websocket/NordWebSocketClient.js

@@ -0,0 +1,242 @@
+import { EventEmitter } from "events";
+import WebSocket from "ws";
+const VALID_STREAM_TYPES = ["trades", "delta", "account"];
+/**
+ * WebSocket client for Nord exchange
+ *
+ * This client connects to one of the specific Nord WebSocket endpoints:
+ *
+ * Each endpoint handles a specific type of data and subscriptions must match
+ * the endpoint type (e.g., only 'trades@BTCUSDC' subscriptions are valid on
+ * the /ws/trades endpoint).
+ */
+export class NordWebSocketClient extends EventEmitter {
+    ws = null;
+    url;
+    reconnectAttempts = 0;
+    maxReconnectAttempts = 5;
+    reconnectDelay = 1000;
+    pingInterval = null;
+    pingTimeout = null;
+    isBrowser;
+    /**
+     * Create a new NordWebSocketClient
+     * @param url WebSocket server URL
+     */
+    constructor(url) {
+        super();
+        this.url = url;
+        // Check if we're in a browser environment
+        // The most reliable way is to check for Node.js process
+        this.isBrowser =
+            typeof process === "undefined" ||
+                !process.versions ||
+                !process.versions.node;
+    }
+    /**
+     * Validate stream format
+     * @param stream Stream identifier to validate
+     * @throws Error if stream format is invalid
+     */
+    validateStream(stream) {
+        const [type, params] = stream.split("@");
+        if (!type || !params) {
+            throw new Error(`Invalid stream format: ${stream}. Expected format: <type>@<params>`);
+        }
+        // Extract the endpoint from the URL
+        const urlPath = new URL(this.url).pathname;
+        const endpoint = urlPath.split("/").pop();
+        // Ensure the stream type matches the endpoint we're connected to
+        if (endpoint && type !== endpoint) {
+            throw new Error(`Stream type '${type}' doesn't match the connected endpoint '${endpoint}'`);
+        }
+        if (!VALID_STREAM_TYPES.includes(type)) {
+            throw new Error(`Invalid stream type: ${type}. Valid types are: ${VALID_STREAM_TYPES.join(", ")}`);
+        }
+        if (type === "account" && !/^\d+$/.test(params)) {
+            throw new Error(`Invalid account ID in stream: ${params}. Expected numeric ID`);
+        }
+    }
+    /**
+     * Setup WebSocket ping/pong heartbeat
+     */
+    setupHeartbeat() {
+        if (this.pingInterval) {
+            clearInterval(this.pingInterval);
+        }
+        if (this.pingTimeout) {
+            clearTimeout(this.pingTimeout);
+        }
+        // In browser, we rely on the browser's WebSocket implementation to handle ping/pong
+        if (this.isBrowser) {
+            return;
+        }
+        this.pingInterval = setInterval(() => {
+            if (this.ws && !this.isBrowser) {
+                // Only use ping() method in Node.js environment
+                this.ws.ping();
+                // Set timeout for pong response
+                this.pingTimeout = setTimeout(() => {
+                    this.emit("error", new Error("WebSocket ping timeout"));
+                    this.close();
+                    this.reconnect();
+                }, 5000); // 5 second timeout
+            }
+        }, 30000); // Send ping every 30 seconds
+    }
+    /**
+     * Get the appropriate WebSocket class based on environment
+     */
+    getWebSocketClass() {
+        if (this.isBrowser) {
+            // In browser environments
+            if (typeof globalThis !== "undefined" && globalThis.WebSocket) {
+                return globalThis.WebSocket;
+            }
+            throw new Error("WebSocket is not available in this environment");
+        }
+        else {
+            // In Node.js
+            return WebSocket;
+        }
+    }
+    /**
+     * Connect to the Nord WebSocket server
+     */
+    connect() {
+        if (this.ws) {
+            return;
+        }
+        try {
+            const WebSocketClass = this.getWebSocketClass();
+            if (this.isBrowser) {
+                // Browser WebSocket setup
+                this.ws = new WebSocketClass(this.url);
+                this.ws.onopen = () => {
+                    this.emit("connected");
+                    this.reconnectAttempts = 0;
+                    this.reconnectDelay = 1000;
+                };
+                this.ws.onmessage = (event) => {
+                    try {
+                        const message = JSON.parse(event.data);
+                        this.handleMessage(message);
+                    }
+                    catch (error) {
+                        this.emit("error", new Error(`Failed to parse message: ${error instanceof Error ? error.message : String(error)}`));
+                    }
+                };
+                this.ws.onclose = (_event) => {
+                    this.emit("disconnected");
+                    this.reconnect();
+                };
+                this.ws.onerror = (event) => {
+                    const errorMsg = `WebSocket error: ${event && event.type ? event.type : "unknown"}`;
+                    this.emit("error", new Error(errorMsg));
+                };
+            }
+            else {
+                // Node.js WebSocket setup
+                const nodeWs = new WebSocketClass(this.url);
+                this.ws = nodeWs;
+                nodeWs.on("open", () => {
+                    this.emit("connected");
+                    this.reconnectAttempts = 0;
+                    this.reconnectDelay = 1000;
+                    this.setupHeartbeat();
+                });
+                nodeWs.on("message", (data) => {
+                    try {
+                        const message = JSON.parse(data.toString());
+                        this.handleMessage(message);
+                    }
+                    catch (error) {
+                        this.emit("error", new Error(`Failed to parse message: ${error instanceof Error ? error.message : String(error)}`));
+                    }
+                });
+                nodeWs.on("close", (_code, _reason) => {
+                    this.emit("disconnected");
+                    if (this.pingInterval) {
+                        clearInterval(this.pingInterval);
+                    }
+                    if (this.pingTimeout) {
+                        clearTimeout(this.pingTimeout);
+                    }
+                    this.reconnect();
+                });
+                nodeWs.on("error", (error) => {
+                    this.emit("error", error);
+                });
+                nodeWs.on("pong", () => {
+                    if (this.pingTimeout) {
+                        clearTimeout(this.pingTimeout);
+                    }
+                });
+            }
+        }
+        catch (error) {
+            const errorMsg = `Failed to initialize WebSocket: ${error instanceof Error ? error.message : String(error)}`;
+            this.emit("error", new Error(errorMsg));
+        }
+    }
+    /**
+     * Close the WebSocket connection
+     */
+    close() {
+        if (this.ws) {
+            if (this.isBrowser) {
+                this.ws.close();
+            }
+            else {
+                this.ws.close();
+            }
+            this.ws = null;
+        }
+        if (this.pingInterval) {
+            clearInterval(this.pingInterval);
+            this.pingInterval = null;
+        }
+        if (this.pingTimeout) {
+            clearTimeout(this.pingTimeout);
+            this.pingTimeout = null;
+        }
+    }
+    /**
+     * Handle incoming WebSocket messages
+     * @param message WebSocket message
+     */
+    handleMessage(message) {
+        if (!message || typeof message !== "object") {
+            this.emit("error", new Error(`Unexpected message type: ${message}`));
+            return;
+        }
+        const hasOwn = (k) => Object.prototype.hasOwnProperty.call(message, k);
+        if (hasOwn("trades")) {
+            this.emit("trades", message.trades);
+            return;
+        }
+        if (hasOwn("delta")) {
+            this.emit("delta", message.delta);
+            return;
+        }
+        if (hasOwn("account")) {
+            this.emit("account", message.account);
+            return;
+        }
+        this.emit("error", new Error(`Unexpected message type: ${message}`));
+    }
+    /**
+     * Attempt to reconnect to the WebSocket server
+     */
+    reconnect() {
+        if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+            this.emit("error", new Error("Max reconnection attempts reached"));
+            return;
+        }
+        setTimeout(() => {
+            this.reconnectAttempts++;
+            this.reconnectDelay *= 2; // Exponential backoff
+            this.connect();
+        }, this.reconnectDelay);
+    }
+}

package/dist/websocket/Subscriber.d.ts

@@ -1,5 +1,5 @@
 import { EventEmitter } from "events";
-import { Account, DeltaEvent, WebSocketDeltaUpdate, SubscriberConfig, Trades, WebSocketTradeUpdate } from "../types";
+import { Account, DeltaEvent, WebSocketDeltaUpdate, SubscriberConfig, Trades, WebSocketTradeUpdate, WebSocketCandleUpdate } from "../types";
 /**
  * Subscriber class for handling WebSocket subscriptions
  */
@@ -35,3 +35,9 @@ export interface TradeSubscription extends EventEmitter {
     close(): void;
     removeAllListeners(event?: string): this;
 }
+export interface CandleSubscription extends EventEmitter {
+    on(event: "message", listener: (data: WebSocketCandleUpdate) => void): this;
+    on(event: "error", listener: (error: Error) => void): this;
+    close(): void;
+    removeAllListeners(event?: string): this;
+}

package/dist/websocket/Subscriber.js

@@ -0,0 +1,24 @@
+import { MAX_BUFFER_LEN } from "../utils";
+/**
+ * Subscriber class for handling WebSocket subscriptions
+ */
+export class Subscriber {
+    streamURL;
+    buffer;
+    maxBufferLen;
+    /**
+     * Create a new Subscriber instance
+     * @param config Subscriber configuration
+     */
+    constructor(config) {
+        this.streamURL = config.streamURL;
+        this.buffer = [];
+        this.maxBufferLen = config.maxBufferLen ?? MAX_BUFFER_LEN;
+    }
+    /**
+     * Subscribe to WebSocket events
+     */
+    subscribe() {
+        // TODO: Implement subscription logic
+    }
+}

package/dist/websocket/events.d.ts

@@ -1,4 +1,4 @@
-import { WebSocketTradeUpdate, WebSocketDeltaUpdate, WebSocketAccountUpdate } from "../types";
+import { WebSocketTradeUpdate, WebSocketDeltaUpdate, WebSocketAccountUpdate, WebSocketCandleUpdate } from "../types";
 /**
  * Event type definitions for the NordWebSocketClient
  */
@@ -9,6 +9,7 @@ export interface NordWebSocketEvents {
     trade: (update: WebSocketTradeUpdate) => void;
     delta: (update: WebSocketDeltaUpdate) => void;
     account: (update: WebSocketAccountUpdate) => void;
+    candle: (update: WebSocketCandleUpdate) => void;
 }
 /**
  * Type declaration for NordWebSocketClient event methods

package/dist/websocket/events.js

@@ -0,0 +1 @@
+export {};

package/dist/websocket/index.d.ts

@@ -16,4 +16,4 @@ export { NordWebSocketClient, NordWebSocketEvents, NordWebSocketClientEvents, Su
  * @returns WebSocket client
  * @throws {NordError} If initialization fails or invalid subscription is provided
  */
-export declare function initWebSocketClient(webServerUrl: string, subscriptions?: SubscriptionPattern[] | "trades" | "delta" | "account"): NordWebSocketClient;
+export declare function initWebSocketClient(webServerUrl: string, subscriptions?: SubscriptionPattern[] | "trades" | "delta" | "account" | "candle"): NordWebSocketClient;

package/dist/websocket/index.js

@@ -0,0 +1,80 @@
+import { NordWebSocketClient } from "./NordWebSocketClient";
+import { NordError } from "../error";
+import { Subscriber } from "./Subscriber";
+export { NordWebSocketClient, Subscriber, };
+/**
+ * Initialize a WebSocket client for Nord
+ *
+ * Connects to the Nord WebSocket endpoint with support for multiple subscription types:
+ * - trades@SYMBOL - For trade updates
+ * - deltas@SYMBOL - For orderbook delta updates
+ * - account@ACCOUNT_ID - For user-specific updates
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param subscriptions - Array of subscriptions (e.g., ["trades@BTCUSDC", "deltas@BTCUSDC", "account@42"])
+ * @returns WebSocket client
+ * @throws {NordError} If initialization fails or invalid subscription is provided
+ */
+export function initWebSocketClient(webServerUrl, subscriptions) {
+    try {
+        // Determine URL and subscriptions based on parameters
+        let wsUrl = webServerUrl.replace(/^http/, "ws") + `/ws`;
+        // Validate subscriptions parameter
+        if (typeof subscriptions === "string") {
+            // Legacy mode - handle endpoint string
+            if (subscriptions === "trades" ||
+                subscriptions === "delta" ||
+                subscriptions === "account") {
+                wsUrl += `/${subscriptions}`;
+            }
+            else {
+                throw new NordError(`Invalid endpoint: ${subscriptions}. Must be "trades", "deltas", or "account".`);
+            }
+        }
+        else if (Array.isArray(subscriptions) && subscriptions.length > 0) {
+            // New mode - validate and combine subscriptions in URL
+            subscriptions.forEach(validateSubscription);
+            wsUrl += `/${subscriptions.join("&")}`;
+        }
+        else {
+            // Default to trades endpoint if no subscriptions specified
+            wsUrl += `/trades`;
+        }
+        console.log(`Initializing WebSocket client with URL: ${wsUrl}`);
+        // Create and connect the WebSocket client
+        const ws = new NordWebSocketClient(wsUrl);
+        // Add error handler
+        ws.on("error", (error) => {
+            console.error("Nord WebSocket error:", error);
+        });
+        // Add connected handler for debugging
+        ws.on("connected", () => {
+            console.log("Nord WebSocket connected successfully");
+        });
+        // Connect the WebSocket
+        ws.connect();
+        return ws;
+    }
+    catch (error) {
+        console.error("Failed to initialize WebSocket client:", error);
+        throw new NordError("Failed to initialize WebSocket client", {
+            cause: error,
+        });
+    }
+}
+/**
+ * Validates a subscription string follows the correct format
+ *
+ * @param subscription - The subscription to validate
+ * @throws {NordError} If the subscription format is invalid
+ */
+function validateSubscription(subscription) {
+    const [type, param] = subscription.split("@");
+    if (!type || !param || !["trades", "deltas", "account"].includes(type)) {
+        throw new NordError(`Invalid subscription format: ${subscription}. Expected format: "trades@SYMBOL", "deltas@SYMBOL", or "account@ID"`);
+    }
+    // Additional validation for account subscriptions
+    if (type === "account" && isNaN(Number(param))) {
+        throw new NordError(`Invalid account ID in subscription: ${subscription}. Account ID must be a number.`);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@n1xyz/nord-ts",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "description": "Typescript for Nord",
   "keywords": [],
   "author": "",
@@ -47,7 +47,7 @@
   },
   "dependencies": {
     "@bufbuild/protobuf": "^2.6.3",
-    "@n1xyz/proton": "0.1.1",
+    "@n1xyz/proton": "0.1.0",
     "@noble/curves": "^1.9.6",
     "@noble/ed25519": "^2.3.0",
     "@noble/hashes": "^1.8.0",