@n1xyz/nord-ts 0.0.19 → 0.0.21

package/dist/utils.js

@@ -0,0 +1,237 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toScaledU128 = exports.toScaledU64 = exports.MAX_BUFFER_LEN = exports.ZERO_DECIMAL = exports.SESSION_TTL = void 0;
+exports.panic = panic;
+exports.isRfc3339 = isRfc3339;
+exports.assert = assert;
+exports.optExpect = optExpect;
+exports.checkedFetch = checkedFetch;
+exports.signAction = signAction;
+exports.makeWalletSignFn = makeWalletSignFn;
+exports.encodeLengthDelimited = encodeLengthDelimited;
+exports.decodeLengthDelimited = decodeLengthDelimited;
+exports.checkPubKeyLength = checkPubKeyLength;
+exports.findMarket = findMarket;
+exports.findToken = findToken;
+exports.keypairFromPrivateKey = keypairFromPrivateKey;
+const decimal_js_1 = require("decimal.js");
+const ed25519_1 = require("@noble/curves/ed25519");
+const bls12_381_1 = require("@noble/curves/bls12-381");
+const secp256k1_1 = require("@noble/curves/secp256k1");
+const sha256_1 = require("@noble/hashes/sha256");
+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"));
+const web3_js_1 = require("@solana/web3.js");
+const bs58_1 = __importDefault(require("bs58"));
+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
+function panic(message) {
+    throw new Error(message);
+}
+function isRfc3339(s) {
+    const REGEX = /^((?:(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2}:\d{2}(?:\.\d+)?))(Z|[\+-]\d{2}:\d{2})?)$/;
+    return REGEX.test(s);
+}
+function assert(predicate, message) {
+    if (!predicate)
+        panic(message ?? "Assertion violated");
+}
+/**
+ * Extracts value out of optional if it's defined, or throws error if it's not
+ * @param value   Optional value to unwrap
+ * @param message Error message
+ * @returns       Unwrapped value
+ */
+function optExpect(value, message) {
+    if (value === undefined)
+        throw new Error(message);
+    return value;
+}
+/** Behaves same as `node-fetch/fetch` but throws if response is a failure
+ *
+ * @param url   Request HTTP URL
+ * @param init  Request parameters
+ * @returns     Raw response if fetch succeeded
+ * @throws      If response wasn't Ok
+ */
+async function checkedFetch(url, init) {
+    const resp = await (0, node_fetch_1.default)(url, init);
+    assert(resp.ok, `Request failed with ${resp.status}: ${resp.statusText}`);
+    return resp;
+}
+/**
+ * Signs an action using the specified secret key and key type.
+ * @param action - The action data to be signed.
+ * @param sk - Secret key used for signing the action.
+ * @param keyType - Type of the key used for signing.
+ * @returns A new Uint8Array containing the action followed by its signature.
+ */
+function signAction(action, sk, keyType) {
+    let sig;
+    if (keyType === types_1.KeyType.Ed25519) {
+        sig = ed25519_1.ed25519.sign(action, sk);
+    }
+    else if (keyType === types_1.KeyType.Bls12_381) {
+        sig = bls12_381_1.bls12_381.sign(action, sk);
+    }
+    else if (keyType === types_1.KeyType.Secp256k1) {
+        sig = secp256k1_1.secp256k1.sign((0, sha256_1.sha256)(action), sk).toCompactRawBytes();
+    }
+    else {
+        throw new Error("Invalid key type");
+    }
+    return new Uint8Array([...action, ...sig]);
+}
+/**
+ * Constructs wallet signing function, usable with `NordUser` type
+ *
+ * @param walletKey   Either raw signing key as bytes array or hex string prefixed with `"0x"`
+ * @returns           Async function which accepts arbitrary message, generates its digets,
+ *                    then signs it with provided user wallet key and returns signature
+ *                    as hex string prefixed with `"0x"`
+ */
+function makeWalletSignFn(walletKey) {
+    const signingKey = new ethers_1.ethers.SigningKey(walletKey);
+    return async (message) => signingKey.sign(ethers_1.ethers.hashMessage(message)).serialized;
+}
+function makeToScaledBigUint(params) {
+    const Dec = decimal_js_1.Decimal.clone({
+        precision: params.precision,
+        toExpPos: params.exponent,
+        toExpNeg: -params.exponent,
+    });
+    const Ten = new Dec(10);
+    const Max = new Dec(((1n << BigInt(params.bits)) - 1n).toString());
+    return (x, decimals) => {
+        const dec = new Dec(x);
+        if (dec.isZero()) {
+            return 0n;
+        }
+        if (dec.isNeg()) {
+            throw new Error(`Number is negative`);
+        }
+        const scaled = Ten.pow(decimals).mul(dec).truncated();
+        if (scaled.isZero()) {
+            throw new Error(`Precision loss when converting ${dec} to scaled integer`);
+        }
+        if (scaled.greaterThan(Max)) {
+            throw new Error(`Integer is out of range: ${scaled} exceeds limit ${Max}`);
+        }
+        return BigInt(scaled.toString());
+    };
+}
+/**
+ * Converts decimal value into rescaled 64-bit unsigned integer
+ * by scaling it up by specified number of decimal digits.
+ *
+ * Ensures that number won't accidentally become zero
+ * or exceed U64's value range
+ *
+ * @param x         Decimal value to rescale
+ * @param decimals  Number of decimal digits
+ * @returns         Rescaled unsigned integer
+ */
+exports.toScaledU64 = makeToScaledBigUint({
+    bits: 64,
+    precision: 20,
+    exponent: 28,
+});
+/**
+ * Converts decimal value into rescaled 128-bit unsigned integer
+ * by scaling it up by specified number of decimal digits.
+ *
+ * Ensures that number won't accidentally become zero
+ * or exceed U128's value range
+ *
+ * @param x         Decimal value to rescale
+ * @param decimals  Number of decimal digits
+ * @returns         Rescaled unsigned integer
+ */
+exports.toScaledU128 = makeToScaledBigUint({
+    bits: 128,
+    precision: 40,
+    exponent: 56,
+});
+/**
+ * Encodes any protobuf message into a length-delimited format,
+ * i.e. prefixed with its length encoded as varint
+ * @param   message message object
+ * @param   coder   associated coder object which implements `MessageFns` interface
+ * @returns         Encoded message as Uint8Array, prefixed with its length
+ */
+function encodeLengthDelimited(message, coder) {
+    const encoded = coder.encode(message).finish();
+    if (encoded.byteLength > MAX_PAYLOAD_SIZE) {
+        throw new Error(`Encoded message size (${encoded.byteLength} bytes) is greater than max payload size (${MAX_PAYLOAD_SIZE} bytes).`);
+    }
+    const encodedLength = new wire_1.BinaryWriter().uint32(encoded.byteLength).finish();
+    return new Uint8Array([...encodedLength, ...encoded]);
+}
+/**
+ * Decodes any protobuf message from a length-delimited format,
+ * i.e. prefixed with its length encoded as varint
+ *
+ * NB: Please note that due to limitations of Typescript type inference
+ * it requires to specify variable type explicitly:
+ *
+ * ```
+ * const foo: proto.Bar = decodeLengthDelimited(bytes, proto.Bar);
+ * ```
+ *
+ * @param   bytes Byte array with encoded message
+ * @param   coder associated coder object which implements `MessageFns` interface
+ * @returns       Decoded Action as Uint8Array.
+ */
+function decodeLengthDelimited(bytes, coder) {
+    const lengthReader = new wire_1.BinaryReader(bytes);
+    const msgLength = lengthReader.uint32();
+    const startsAt = lengthReader.pos;
+    if (msgLength > MAX_PAYLOAD_SIZE) {
+        throw new Error(`Encoded message size (${msgLength} bytes) is greater than max payload size (${MAX_PAYLOAD_SIZE} bytes).`);
+    }
+    if (startsAt + msgLength > bytes.byteLength) {
+        throw new Error(`Encoded message size (${msgLength} bytes) is greater than remaining buffer size (${bytes.byteLength - startsAt} bytes).`);
+    }
+    return coder.decode(bytes.slice(startsAt, startsAt + msgLength));
+}
+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.");
+    }
+    if (len !== 32 && keyType === types_1.KeyType.Ed25519) {
+        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.");
+    }
+}
+function findMarket(markets, marketId) {
+    if (marketId < 0 || markets.length - 1 < marketId) {
+        throw new Error(`The market with marketId=${marketId} not found`);
+    }
+    return markets[marketId];
+}
+function findToken(tokens, tokenId) {
+    if (tokenId < 0 || tokens.length - 1 < tokenId) {
+        throw new Error(`The token with tokenId=${tokenId} not found`);
+    }
+    return tokens[tokenId];
+}
+function keypairFromPrivateKey(privateKey) {
+    if (typeof privateKey === "string") {
+        if (!privateKey.startsWith("0x")) {
+            return web3_js_1.Keypair.fromSecretKey(bs58_1.default.decode(privateKey));
+        }
+        const hex = privateKey.startsWith("0x") ? privateKey.slice(2) : privateKey;
+        const bytes = new Uint8Array(hex.match(/.{1,2}/g).map((byte) => parseInt(byte, 16)));
+        return web3_js_1.Keypair.fromSecretKey(bytes);
+    }
+    return web3_js_1.Keypair.fromSecretKey(privateKey);
+}

package/dist/websocket/NordWebSocketClient.d.ts

@@ -0,0 +1,57 @@
+import { EventEmitter } from "events";
+import { NordWebSocketClientEvents } from "./events";
+/**
+ * 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 declare class NordWebSocketClient extends EventEmitter implements NordWebSocketClientEvents {
+    private ws;
+    private url;
+    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;
+    /**
+     * 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,251 @@
+"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 events_1 = require("events");
+const ws_1 = __importDefault(require("ws"));
+const VALID_STREAM_TYPES = ["trades", "delta", "account"];
+// Constants for WebSocket readyState
+const WS_OPEN = 1;
+/**
+ * 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).
+ */
+class NordWebSocketClient extends events_1.EventEmitter {
+    /**
+     * Create a new NordWebSocketClient
+     * @param url WebSocket server URL
+     */
+    constructor(url) {
+        super();
+        this.ws = null;
+        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 === "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 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;
+                };
+                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");
+                    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);
+            return;
+        }
+        if (hasOwn("delta")) {
+            this.emit("delta", message);
+            return;
+        }
+        if (hasOwn("account")) {
+            this.emit("account", message);
+            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);
+    }
+}
+exports.NordWebSocketClient = NordWebSocketClient;

package/dist/websocket/events.d.ts

@@ -0,0 +1,19 @@
+import { WebSocketTradeUpdate, WebSocketDeltaUpdate, WebSocketAccountUpdate } from "../types";
+/**
+ * Event type definitions for the NordWebSocketClient
+ */
+export interface NordWebSocketEvents {
+    connected: () => void;
+    disconnected: () => void;
+    error: (error: Error) => void;
+    trade: (update: WebSocketTradeUpdate) => void;
+    delta: (update: WebSocketDeltaUpdate) => void;
+    account: (update: WebSocketAccountUpdate) => void;
+}
+/**
+ * Type declaration for NordWebSocketClient event methods
+ */
+export declare interface NordWebSocketClientEvents {
+    on<E extends keyof NordWebSocketEvents>(event: E, listener: NordWebSocketEvents[E]): this;
+    emit<E extends keyof NordWebSocketEvents>(event: E, ...args: Parameters<NordWebSocketEvents[E]>): boolean;
+}

package/dist/websocket/events.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/websocket/index.d.ts

@@ -0,0 +1,2 @@
+export { NordWebSocketClient } from "./NordWebSocketClient";
+export type { NordWebSocketEvents, NordWebSocketClientEvents } from "./events";

package/dist/websocket/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NordWebSocketClient = void 0;
+var NordWebSocketClient_1 = require("./NordWebSocketClient");
+Object.defineProperty(exports, "NordWebSocketClient", { enumerable: true, get: function () { return NordWebSocketClient_1.NordWebSocketClient; } });

package/package.json

@@ -1,12 +1,18 @@
 {
   "name": "@n1xyz/nord-ts",
-  "version": "0.0.19",
+  "version": "0.0.21",
   "description": "Typescript for Nord",
   "keywords": [],
   "author": "",
   "license": "ISC",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "files": [
+    "dist/",
+    "src/",
+    "package.json",
+    "README.md"
+  ],
   "scripts": {
     "gen:proto": "nix run ..#nord-ts-proto ../engine/nord.proto src/gen/",
     "gen:api": "nix run ..#nord-openapi | bunx openapi-typescript > src/gen/openapi.ts",
@@ -36,7 +42,7 @@
   },
   "dependencies": {
     "@bufbuild/protobuf": "^2.0.0",
-    "@n1xyz/proton": "0.0.0",
+    "@n1xyz/proton": "0.0.2",
     "@noble/curves": "^1.3.0",
     "@noble/ed25519": "^2.2.3",
     "@noble/hashes": "^1.3.2",