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

package/dist/utils.d.ts

@@ -1,116 +0,0 @@
-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 { Keypair } from "@solana/web3.js";
-export declare const SESSION_TTL: bigint;
-export declare const ZERO_DECIMAL: Decimal;
-export declare const MAX_BUFFER_LEN = 10000;
-/** Any type convertible to bigint */
-export type BigIntValue = bigint | number | string;
-export declare function panic(message: string): never;
-export declare function assert(predicate: boolean, message?: string): void;
-/**
- * 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
- */
-export declare function optExpect<T>(value: T | undefined, message: string): T;
-/**
- * Unwraps optional value with default error message
- * @param value
- * @returns
- */
-export declare function optUnwrap<T>(value: T | undefined): T;
-/**
- * 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 declare function optMap<T, U>(value: T | undefined, mapFn: (arg: T) => U): U | undefined;
-/** 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
- */
-export declare function checkedFetch(url: RequestInfo, init?: RequestInit): Promise<Response>;
-/**
- * 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.
- */
-export declare function signAction(action: Uint8Array, sk: Uint8Array, keyType: KeyType): Uint8Array;
-/**
- * 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"`
- */
-export declare function makeWalletSignFn(walletKey: ethers.BytesLike): (message: Uint8Array | string) => Promise<string>;
-/**
- * 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
- */
-export declare const toScaledU64: (x: Decimal.Value, decimals: number) => bigint;
-/**
- * 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
- */
-export declare const toScaledU128: (x: Decimal.Value, decimals: number) => bigint;
-/**
- * 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 declare function bigIntToProtoU128(value: bigint): proto.U128;
-/**
- * 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
- */
-export declare function encodeLengthDelimited<T, M extends proto.MessageFns<T>>(message: T, coder: M): Uint8Array;
-/**
- * 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.
- */
-export declare function decodeLengthDelimited<T, M extends proto.MessageFns<T>>(bytes: Uint8Array, coder: M): 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;
-export declare function keypairFromPrivateKey(privateKey: string | Uint8Array): Keypair;

package/dist/utils.js

@@ -1,271 +0,0 @@
-"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.assert = assert;
-exports.optExpect = optExpect;
-exports.optUnwrap = optUnwrap;
-exports.optMap = optMap;
-exports.checkedFetch = checkedFetch;
-exports.signAction = signAction;
-exports.makeWalletSignFn = makeWalletSignFn;
-exports.bigIntToProtoU128 = bigIntToProtoU128;
-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 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;
-}
-/**
- * Unwraps optional value with default error message
- * @param value
- * @returns
- */
-function optUnwrap(value) {
-    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
- */
-function optMap(value, mapFn) {
-    return value !== undefined ? mapFn(value) : undefined;
-}
-/** 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,
-});
-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
- */
-function bigIntToProtoU128(value) {
-    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
- * @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

@@ -1,68 +0,0 @@
-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 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;
-}