@n1xyz/nord-ts 0.0.1 → 0.0.4

package/dist/utils.d.ts

@@ -1,8 +1,9 @@
-import { Decimal } from "decimal.js";
-import { KeyType, type Market, type Token } from "./types";
-import * as proto from "./gen/nord";
-import { ethers } from "ethers";
-import { RequestInfo, RequestInit, Response } from "node-fetch";
+import { Decimal } from 'decimal.js';
+import { KeyType, type Market, type Token } from './types';
+import * as proto from './gen/nord';
+import { ethers } from 'ethers';
+import { RequestInfo, RequestInit, Response } from 'node-fetch';
+import { BN } from '@coral-xyz/anchor';
 export declare const SESSION_TTL: bigint;
 export declare const ZERO_DECIMAL: Decimal;
 export declare const MAX_BUFFER_LEN = 10000;
@@ -112,3 +113,11 @@ export declare function decodeLengthDelimited<T, M extends proto.MessageFns<T>>(
 export declare function checkPubKeyLength(keyType: KeyType, len: number): void;
 export declare function findMarket(markets: Market[], marketId: number): Market;
 export declare function findToken(tokens: Token[], tokenId: number): Token;
+/**
+ * Convert a number to a BN with the specified number of decimals
+ *
+ * @param amount Amount as a number
+ * @param decimals Number of decimal places
+ * @returns Amount as a BN
+ */
+export declare function toBN(amount: number, decimals: number): BN;

package/dist/utils.js

@@ -18,6 +18,7 @@ exports.decodeLengthDelimited = decodeLengthDelimited;
 exports.checkPubKeyLength = checkPubKeyLength;
 exports.findMarket = findMarket;
 exports.findToken = findToken;
+exports.toBN = toBN;
 const decimal_js_1 = require("decimal.js");
 const ed25519_1 = require("@noble/curves/ed25519");
 const bls12_381_1 = require("@noble/curves/bls12-381");
@@ -27,7 +28,8 @@ const types_1 = require("./types");
 const wire_1 = require("@bufbuild/protobuf/wire");
 const ethers_1 = require("ethers");
 const node_fetch_1 = __importDefault(require("node-fetch"));
-exports.SESSION_TTL = 10n * 60n * 1000n * 10000n;
+const anchor_1 = require("@coral-xyz/anchor");
+exports.SESSION_TTL = 60n * 60n * 24n * 30n;
 exports.ZERO_DECIMAL = new decimal_js_1.Decimal(0);
 exports.MAX_BUFFER_LEN = 10000;
 const MAX_PAYLOAD_SIZE = 100 * 1024; // 100 kB
@@ -36,7 +38,7 @@ function panic(message) {
 }
 function assert(predicate, message) {
     if (!predicate)
-        panic(message ?? "Assertion violated");
+        panic(message ?? 'Assertion violated');
 }
 /**
  * Extracts value out of optional if it's defined, or throws error if it's not
@@ -55,7 +57,7 @@ function optExpect(value, message) {
  * @returns
  */
 function optUnwrap(value) {
-    return optExpect(value, "Optional contains no value");
+    return optExpect(value, 'Optional contains no value');
 }
 /**
  * Applies function to value if it's defined, or passes `undefined` through
@@ -97,7 +99,7 @@ function signAction(action, sk, keyType) {
         sig = secp256k1_1.secp256k1.sign((0, sha256_1.sha256)(action), sk).toCompactRawBytes();
     }
     else {
-        throw new Error("Invalid key type");
+        throw new Error('Invalid key type');
     }
     return new Uint8Array([...action, ...sig]);
 }
@@ -234,13 +236,13 @@ function decodeLengthDelimited(bytes, coder) {
 }
 function checkPubKeyLength(keyType, len) {
     if (keyType === types_1.KeyType.Bls12_381) {
-        throw new Error("Cannot create a user using Bls12_381, use Ed25119 or Secp256k1 instead.");
+        throw new Error('Cannot create a user using Bls12_381, use Ed25119 or Secp256k1 instead.');
     }
     if (len !== 32 && keyType === types_1.KeyType.Ed25519) {
-        throw new Error("Ed25519 pubkeys must be 32 length.");
+        throw new Error('Ed25519 pubkeys must be 32 length.');
     }
     if (len !== 33 && keyType === types_1.KeyType.Secp256k1) {
-        throw new Error("Secp256k1 pubkeys must be 33 length.");
+        throw new Error('Secp256k1 pubkeys must be 33 length.');
     }
 }
 function findMarket(markets, marketId) {
@@ -255,3 +257,20 @@ function findToken(tokens, tokenId) {
     }
     return tokens[tokenId];
 }
+/**
+ * Convert a number to a BN with the specified number of decimals
+ *
+ * @param amount Amount as a number
+ * @param decimals Number of decimal places
+ * @returns Amount as a BN
+ */
+function toBN(amount, decimals) {
+    const amountString = amount.toFixed(decimals);
+    const [whole, fraction] = amountString.split('.');
+    // Convert to smallest units (no decimals)
+    const wholeBN = new anchor_1.BN(whole).mul(new anchor_1.BN(10).pow(new anchor_1.BN(decimals)));
+    const fractionBN = fraction
+        ? new anchor_1.BN(fraction.padEnd(decimals, '0').slice(0, decimals))
+        : new anchor_1.BN(0);
+    return wholeBN.add(fractionBN);
+}

package/dist/websocket/NordWebSocketClient.d.ts

@@ -0,0 +1,71 @@
+import { EventEmitter } from 'events';
+import { NordWebSocketClientEvents } from './events';
+/**
+ * WebSocket client for Nord exchange
+ *
+ * This client connects to one of the specific Nord WebSocket endpoints:
+ * - /ws/trades - For trade updates
+ * - /ws/deltas - For orderbook delta updates
+ * - /ws/user - For user-specific updates
+ *
+ * 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 declare class NordWebSocketClient extends EventEmitter implements NordWebSocketClientEvents {
+    private ws;
+    private url;
+    private subscriptions;
+    private reconnectAttempts;
+    private maxReconnectAttempts;
+    private reconnectDelay;
+    private pingInterval;
+    private pingTimeout;
+    private isBrowser;
+    /**
+     * Create a new NordWebSocketClient
+     * @param url WebSocket server URL
+     */
+    constructor(url: string);
+    /**
+     * Validate stream format
+     * @param stream Stream identifier to validate
+     * @throws Error if stream format is invalid
+     */
+    private validateStream;
+    /**
+     * Setup WebSocket ping/pong heartbeat
+     */
+    private setupHeartbeat;
+    /**
+     * Get the appropriate WebSocket class based on environment
+     */
+    private getWebSocketClass;
+    /**
+     * Connect to the Nord WebSocket server
+     */
+    connect(): void;
+    /**
+     * Subscribe to one or more streams
+     * @param streams Array of streams to subscribe to (e.g. ["trades@BTCUSDC", "deltas@BTCUSDC"])
+     */
+    subscribe(streams: string[]): void;
+    /**
+     * Unsubscribe from one or more streams
+     * @param streams Array of streams to unsubscribe from
+     */
+    unsubscribe(streams: string[]): void;
+    /**
+     * Close the WebSocket connection
+     */
+    close(): void;
+    /**
+     * Handle incoming WebSocket messages
+     * @param message WebSocket message
+     */
+    private handleMessage;
+    /**
+     * Attempt to reconnect to the WebSocket server
+     */
+    private reconnect;
+}

package/dist/websocket/NordWebSocketClient.js

@@ -0,0 +1,343 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NordWebSocketClient = void 0;
+const ws_1 = __importDefault(require("ws"));
+const events_1 = require("events");
+const types_1 = require("../types");
+const VALID_STREAM_TYPES = ['trades', 'deltas', 'user'];
+// Constants for WebSocket readyState
+const WS_OPEN = 1;
+/**
+ * WebSocket client for Nord exchange
+ *
+ * This client connects to one of the specific Nord WebSocket endpoints:
+ * - /ws/trades - For trade updates
+ * - /ws/deltas - For orderbook delta updates
+ * - /ws/user - For user-specific updates
+ *
+ * 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).
+ */
+class NordWebSocketClient extends events_1.EventEmitter {
+    /**
+     * Create a new NordWebSocketClient
+     * @param url WebSocket server URL
+     */
+    constructor(url) {
+        super();
+        this.ws = null;
+        this.subscriptions = new Set();
+        this.reconnectAttempts = 0;
+        this.maxReconnectAttempts = 5;
+        this.reconnectDelay = 1000;
+        this.pingInterval = null;
+        this.pingTimeout = null;
+        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 === 'user' && !/^\d+$/.test(params)) {
+            throw new Error(`Invalid user 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
+            // @ts-ignore - Check for WebSocket in globalThis
+            if (typeof globalThis !== 'undefined' && globalThis.WebSocket) {
+                // @ts-ignore - Return WebSocket from globalThis
+                return globalThis.WebSocket;
+            }
+            throw new Error('WebSocket is not available in this environment');
+        }
+        else {
+            // In Node.js
+            return ws_1.default;
+        }
+    }
+    /**
+     * 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;
+                    // Resubscribe to previous subscriptions
+                    if (this.subscriptions.size > 0) {
+                        this.subscribe([...this.subscriptions]);
+                    }
+                };
+                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) => {
+                    const reason = event && event.reason ? ` Reason: ${event.reason}` : '';
+                    const code = event && event.code ? ` Code: ${event.code}` : '';
+                    this.emit('disconnected');
+                    console.log(`WebSocket closed.${code}${reason}`);
+                    this.reconnect();
+                };
+                this.ws.onerror = (event) => {
+                    const errorMsg = `WebSocket error: ${event && event.type ? event.type : 'unknown'}`;
+                    console.error(errorMsg, event);
+                    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();
+                    // Resubscribe to previous subscriptions
+                    if (this.subscriptions.size > 0) {
+                        this.subscribe([...this.subscriptions]);
+                    }
+                });
+                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');
+                    console.log(`WebSocket closed. Code: ${code} Reason: ${reason}`);
+                    if (this.pingInterval) {
+                        clearInterval(this.pingInterval);
+                    }
+                    if (this.pingTimeout) {
+                        clearTimeout(this.pingTimeout);
+                    }
+                    this.reconnect();
+                });
+                nodeWs.on('error', (error) => {
+                    console.error('WebSocket 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)}`;
+            console.error(errorMsg);
+            this.emit('error', new Error(errorMsg));
+        }
+    }
+    /**
+     * Subscribe to one or more streams
+     * @param streams Array of streams to subscribe to (e.g. ["trades@BTCUSDC", "deltas@BTCUSDC"])
+     */
+    subscribe(streams) {
+        // Validate all streams first
+        try {
+            streams.forEach((stream) => this.validateStream(stream));
+        }
+        catch (error) {
+            this.emit('error', error instanceof Error ? error : new Error(String(error)));
+            return;
+        }
+        if (!this.ws ||
+            (this.isBrowser
+                ? this.ws.readyState !== WS_OPEN
+                : this.ws.readyState !== ws_1.default.OPEN)) {
+            streams.forEach((stream) => this.subscriptions.add(stream));
+            return;
+        }
+        const message = {
+            type: types_1.WebSocketMessageType.Subscribe,
+            streams,
+        };
+        try {
+            const messageStr = JSON.stringify(message);
+            if (this.isBrowser) {
+                this.ws.send(messageStr);
+            }
+            else {
+                this.ws.send(messageStr);
+            }
+            streams.forEach((stream) => this.subscriptions.add(stream));
+        }
+        catch (error) {
+            this.emit('error', error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    /**
+     * Unsubscribe from one or more streams
+     * @param streams Array of streams to unsubscribe from
+     */
+    unsubscribe(streams) {
+        // Validate all streams first
+        try {
+            streams.forEach((stream) => this.validateStream(stream));
+        }
+        catch (error) {
+            this.emit('error', error instanceof Error ? error : new Error(String(error)));
+            return;
+        }
+        if (!this.ws ||
+            (this.isBrowser
+                ? this.ws.readyState !== WS_OPEN
+                : this.ws.readyState !== ws_1.default.OPEN)) {
+            streams.forEach((stream) => this.subscriptions.delete(stream));
+            return;
+        }
+        const message = {
+            type: types_1.WebSocketMessageType.Unsubscribe,
+            streams,
+        };
+        try {
+            const messageStr = JSON.stringify(message);
+            if (this.isBrowser) {
+                this.ws.send(messageStr);
+            }
+            else {
+                this.ws.send(messageStr);
+            }
+            streams.forEach((stream) => this.subscriptions.delete(stream));
+        }
+        catch (error) {
+            this.emit('error', error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    /**
+     * 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;
+        }
+        this.subscriptions.clear();
+    }
+    /**
+     * Handle incoming WebSocket messages
+     * @param message WebSocket message
+     */
+    handleMessage(message) {
+        switch (message.type) {
+            case types_1.WebSocketMessageType.TradeUpdate:
+                this.emit('trade', message);
+                break;
+            case types_1.WebSocketMessageType.DeltaUpdate:
+                this.emit('delta', message);
+                break;
+            case types_1.WebSocketMessageType.UserUpdate:
+                this.emit('user', message);
+                break;
+            default:
+                this.emit('error', new Error(`Unknown message type: ${message.type}`));
+        }
+    }
+    /**
+     * 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);
+    }
+}
+exports.NordWebSocketClient = NordWebSocketClient;

package/dist/websocket/client.d.ts

@@ -0,0 +1,93 @@
+/**
+ * WebSocket client for real-time data
+ * @module websocket/client
+ */
+import { OrderbookData, Trade } from '../models';
+/**
+ * WebSocket client for real-time data
+ */
+export declare class WebSocketClient {
+    /**
+     * WebSocket connection
+     */
+    private ws;
+    /**
+     * Base URL for the WebSocket server
+     */
+    private readonly baseUrl;
+    /**
+     * Map of subscription IDs to callbacks
+     */
+    private subscriptions;
+    /**
+     * Whether the WebSocket is connected
+     */
+    private connected;
+    /**
+     * Whether the WebSocket is connecting
+     */
+    private connecting;
+    /**
+     * Queue of messages to send when connected
+     */
+    private messageQueue;
+    /**
+     * Create a new WebSocket client
+     *
+     * @param baseUrl - Base URL for the WebSocket server
+     */
+    constructor(baseUrl: string);
+    /**
+     * Connect to the WebSocket server
+     *
+     * @returns Promise that resolves when connected
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the WebSocket server
+     */
+    disconnect(): void;
+    /**
+     * Send a message to the WebSocket server
+     *
+     * @param message - Message to send
+     */
+    private sendMessage;
+    /**
+     * Generate a unique subscription ID
+     *
+     * @returns Unique subscription ID
+     */
+    private generateSubscriptionId;
+    /**
+     * Subscribe to orderbook updates for a specific market
+     *
+     * @param market - Market symbol (e.g., "BTCUSDC")
+     * @param callback - Callback function to handle updates
+     * @returns Subscription ID
+     */
+    subscribeToOrderbook(market: string, callback: (data: OrderbookData) => void): string;
+    /**
+     * Subscribe to trade updates for a specific market
+     *
+     * @param market - Market symbol (e.g., "BTCUSDC")
+     * @param callback - Callback function to handle updates
+     * @returns Subscription ID
+     */
+    subscribeToTrades(market: string, callback: (data: Trade[]) => void): string;
+    /**
+     * Subscribe to user updates for a specific account
+     *
+     * @param accountId - Account ID
+     * @param callback - Callback function to handle updates
+     * @returns Subscription ID
+     */
+    subscribeToUserUpdates(accountId: number, callback: (data: any) => void): string;
+    /**
+     * Unsubscribe from a subscription
+     *
+     * @param subscriptionId - Subscription ID to unsubscribe from
+     * @returns Whether the unsubscription was successful
+     */
+    unsubscribe(subscriptionId: string): boolean;
+}