@n1xyz/nord-ts 0.0.18-8121ed05.0 → 0.0.18

package/src/utils.ts

@@ -25,6 +25,12 @@ export function panic(message: string): never {
   throw new Error(message);
 }
 
+export function isRfc3339(s: string): boolean {
+  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);
+}
+
 export function assert(predicate: boolean, message?: string): void {
   if (!predicate) panic(message ?? "Assertion violated");
 }
@@ -38,26 +44,6 @@ export function optExpect<T>(value: T | undefined, message: string): T {
   if (value === undefined) throw new Error(message);
   return value as T;
 }
-/**
- * Unwraps optional value with default error message
- * @param value
- * @returns
- */
-export function optUnwrap<T>(value: T | undefined): T {
-  return optExpect(value, "Optional contains no value");
-}
-/**
- * Applies function to value if it's defined, or passes `undefined` through
- * @param value Optional value to map
- * @param mapFn Mapper function
- * @returns     Either mapped value or undefined
- */
-export function optMap<T, U>(
-  value: T | undefined,
-  mapFn: (arg: T) => U,
-): U | undefined {
-  return value !== undefined ? mapFn(value) : undefined;
-}
 /** Behaves same as `node-fetch/fetch` but throws if response is a failure
  *
  * @param url   Request HTTP URL
@@ -190,28 +176,6 @@ export const toScaledU128 = makeToScaledBigUint({
   exponent: 56,
 });
 
-const U64_MAX = (1n << 64n) - 1n;
-const U128_MAX = (1n << 128n) - 1n;
-/**
- * Converts U128 into pair of U64 numbers, to pass it through protobuf
- * @param value integer, must fit U128 limits
- * @returns     Pair of U64 integers which represent original number split in two
- */
-export function bigIntToProtoU128(value: bigint): proto.U128 {
-  if (value < 0n) {
-    throw new Error(`Negative number (${value})`);
-  }
-
-  if (value > U128_MAX) {
-    throw new Error(`U128 overflow (${value})`);
-  }
-
-  return {
-    lo: value & U64_MAX,
-    hi: (value >> 64n) & U64_MAX,
-  };
-}
-
 /**
  * Encodes any protobuf message into a length-delimited format,
  * i.e. prefixed with its length encoded as varint

package/src/websocket/NordWebSocketClient.ts

@@ -1,12 +1,12 @@
-import WebSocket from "ws";
 import { EventEmitter } from "events";
+import WebSocket from "ws";
 import {
+  WebSocketAccountUpdate,
+  WebSocketDeltaUpdate,
   WebSocketMessage,
   WebSocketMessageType,
   WebSocketSubscription,
   WebSocketTradeUpdate,
-  WebSocketDeltaUpdate,
-  WebSocketAccountUpdate,
 } from "../types";
 import { NordWebSocketClientEvents } from "./events";
 
@@ -394,19 +394,27 @@ export class NordWebSocketClient
    * @param message WebSocket message
    */
   private handleMessage(message: WebSocketMessage): void {
-    switch (message.e) {
-      case WebSocketMessageType.TradeUpdate:
-        this.emit("trades", message as WebSocketTradeUpdate);
-        break;
-      case WebSocketMessageType.DeltaUpdate:
-        this.emit("delta", message as WebSocketDeltaUpdate);
-        break;
-      case WebSocketMessageType.AccountUpdate:
-        this.emit("account", message as WebSocketAccountUpdate);
-        break;
-      default:
-        this.emit("error", new Error(`Unknown message type: ${message.e}`));
+    if (!message || typeof message !== "object") {
+      this.emit("error", new Error(`Unexpected message type: ${message}`));
+      return;
     }
+
+    const hasOwn = (k: string) =>
+      Object.prototype.hasOwnProperty.call(message, k);
+    if (hasOwn("trades")) {
+      this.emit("trades", message as WebSocketTradeUpdate);
+      return;
+    }
+    if (hasOwn("delta")) {
+      this.emit("delta", message as WebSocketDeltaUpdate);
+      return;
+    }
+    if (hasOwn("account")) {
+      this.emit("account", message as WebSocketAccountUpdate);
+      return;
+    }
+
+    this.emit("error", new Error(`Unexpected message type: ${message}`));
   }
 
   /**

package/src/websocket/index.ts

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

package/tests/utils.spec.ts

@@ -1,6 +1,5 @@
 import { describe, it, expect } from "@jest/globals";
 import {
-  bigIntToProtoU128,
   toScaledU64,
   toScaledU128,
   encodeLengthDelimited,
@@ -91,38 +90,6 @@ describe("toScaledU128", () => {
   });
 });
 
-const U64_MAX = (1n << 64n) - 1n;
-const U128_MAX = (1n << 128n) - 1n;
-
-describe("bigIntToProtoU128", () => {
-  const success: Array<[bigint, { lo: bigint; hi: bigint }]> = [
-    [0n, { lo: 0n, hi: 0n }],
-    [1n, { lo: 1n, hi: 0n }],
-    [U64_MAX - 1n, { lo: U64_MAX - 1n, hi: 0n }],
-    [U64_MAX, { lo: U64_MAX, hi: 0n }],
-    [U64_MAX + 1n, { lo: 0n, hi: 1n }],
-    [U128_MAX - 1n, { lo: U64_MAX - 1n, hi: U64_MAX }],
-    [U128_MAX, { lo: U64_MAX, hi: U64_MAX }],
-  ];
-
-  success.forEach((sample, index) => {
-    it(`Conversion to Protobuf's U128 should succeed: case ${index}`, () => {
-      expect(bigIntToProtoU128(sample[0])).toEqual(sample[1]);
-    });
-  });
-
-  const failure: Array<[bigint, string]> = [
-    [-1n, "Negative number"],
-    [U128_MAX + 1n, "U128 overflow"],
-  ];
-
-  failure.forEach((sample, index) => {
-    it(`Conversion to Protobuf's U128 should fail: case ${index}`, () => {
-      expect(() => bigIntToProtoU128(sample[0])).toThrow(sample[1]);
-    });
-  });
-});
-
 describe("proto.Action encode-decode loop", () => {
   const action: proto.Action = {
     currentTimestamp: 0n,
@@ -137,7 +104,7 @@ describe("proto.Action encode-decode loop", () => {
         isReduceOnly: false,
         price: 12n,
         size: 39n,
-        quoteSize: { lo: 54n, hi: 55n },
+        quoteSize: { size: 54n, price: 55n },
         senderAccountId: undefined,
         delegatorAccountId: undefined,
         clientOrderId: 350n,