@n1xyz/nord-ts 0.3.2 → 0.3.4

package/dist/nord/index.d.ts

@@ -0,0 +1,8 @@
+export { Nord } from "./client/Nord";
+export { NordUser } from "./client/NordUser";
+export { NordAdmin, AclRole } from "./client/NordAdmin";
+export { NordError } from "./utils/NordError";
+export * from "./api/core";
+export * from "./api/metrics";
+export * from "./api/actions";
+export * from "./models/Subscriber";

package/dist/nord/index.js

@@ -0,0 +1,34 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NordError = exports.AclRole = exports.NordAdmin = exports.NordUser = exports.Nord = void 0;
+// Export main client classes
+var Nord_1 = require("./client/Nord");
+Object.defineProperty(exports, "Nord", { enumerable: true, get: function () { return Nord_1.Nord; } });
+var NordUser_1 = require("./client/NordUser");
+Object.defineProperty(exports, "NordUser", { enumerable: true, get: function () { return NordUser_1.NordUser; } });
+var NordAdmin_1 = require("./client/NordAdmin");
+Object.defineProperty(exports, "NordAdmin", { enumerable: true, get: function () { return NordAdmin_1.NordAdmin; } });
+Object.defineProperty(exports, "AclRole", { enumerable: true, get: function () { return NordAdmin_1.AclRole; } });
+// Export utility classes
+var NordError_1 = require("./utils/NordError");
+Object.defineProperty(exports, "NordError", { enumerable: true, get: function () { return NordError_1.NordError; } });
+// Export API modules
+__exportStar(require("./api/core"), exports);
+__exportStar(require("./api/metrics"), exports);
+__exportStar(require("./api/actions"), exports);
+// Export models
+__exportStar(require("./models/Subscriber"), exports);

package/dist/nord/models/Subscriber.d.ts

@@ -0,0 +1,37 @@
+import { EventEmitter } from "events";
+import { Account, DeltaEvent, OrderbookResponse, SubscriberConfig, StreamTrade, Trades } from "../../types";
+/**
+ * Subscriber class for handling WebSocket subscriptions
+ */
+export declare class Subscriber {
+    streamURL: string;
+    buffer: (DeltaEvent | Trades | Account)[];
+    maxBufferLen: number;
+    /**
+     * Create a new Subscriber instance
+     * @param config Subscriber configuration
+     */
+    constructor(config: SubscriberConfig);
+    /**
+     * Subscribe to WebSocket events
+     */
+    subscribe(): void;
+}
+/**
+ * Interface for orderbook subscription
+ */
+export interface OrderbookSubscription extends EventEmitter {
+    on(event: "message", listener: (data: OrderbookResponse) => void): this;
+    on(event: "error", listener: (error: Error) => void): this;
+    close(): void;
+    removeAllListeners(event?: string): this;
+}
+/**
+ * Interface for trade subscription
+ */
+export interface TradeSubscription extends EventEmitter {
+    on(event: "message", listener: (data: StreamTrade[]) => void): this;
+    on(event: "error", listener: (error: Error) => void): this;
+    close(): void;
+    removeAllListeners(event?: string): this;
+}

package/dist/nord/models/Subscriber.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Subscriber = void 0;
+const utils_1 = require("../../utils");
+/**
+ * Subscriber class for handling WebSocket subscriptions
+ */
+class Subscriber {
+    /**
+     * Create a new Subscriber instance
+     * @param config Subscriber configuration
+     */
+    constructor(config) {
+        this.streamURL = config.streamURL;
+        this.buffer = [];
+        this.maxBufferLen = config.maxBufferLen ?? utils_1.MAX_BUFFER_LEN;
+    }
+    /**
+     * Subscribe to WebSocket events
+     */
+    subscribe() {
+        // TODO: Implement subscription logic
+    }
+}
+exports.Subscriber = Subscriber;

package/dist/nord/utils/NordError.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Options for creating a NordError
+ */
+export interface NordErrorOptions {
+    /** The original error that caused this error */
+    cause?: unknown;
+    /** HTTP status code (if applicable) */
+    statusCode?: number;
+    /** Additional error details */
+    details?: Record<string, unknown>;
+}
+/**
+ * Custom error class for Nord-related errors
+ */
+export declare class NordError extends Error {
+    /** The original error that caused this error */
+    readonly cause?: unknown;
+    /** HTTP status code (if applicable) */
+    readonly statusCode?: number;
+    /** Additional error details */
+    readonly details?: Record<string, unknown>;
+    /**
+     * Create a new NordError
+     *
+     * @param message - Error message
+     * @param options - Error options
+     */
+    constructor(message: string, options?: NordErrorOptions);
+    /**
+     * Convert the error to a string representation
+     *
+     * @returns String representation of the error
+     */
+    toString(): string;
+}

package/dist/nord/utils/NordError.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NordError = void 0;
+/**
+ * Custom error class for Nord-related errors
+ */
+class NordError extends Error {
+    /**
+     * Create a new NordError
+     *
+     * @param message - Error message
+     * @param options - Error options
+     */
+    constructor(message, options = {}) {
+        super(message);
+        this.name = "NordError";
+        this.cause = options.cause;
+        this.statusCode = options.statusCode;
+        this.details = options.details;
+        // Capture stack trace
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, NordError);
+        }
+        // Handle nested errors
+        if (this.cause instanceof Error) {
+            this.stack =
+                this.stack + "\nCaused by: " + (this.cause.stack || this.cause.message);
+        }
+    }
+    /**
+     * Convert the error to a string representation
+     *
+     * @returns String representation of the error
+     */
+    toString() {
+        let result = `${this.name}: ${this.message}`;
+        if (this.statusCode) {
+            result += `  \nstatus: ${this.statusCode}`;
+        }
+        if (this.details && Object.keys(this.details).length > 0) {
+            result += `  \ndetails: ${JSON.stringify(this.details, null, 2)}`;
+        }
+        if (this.cause) {
+            result += `  \ncause: ${this.cause.toString()}`;
+        }
+        return result;
+    }
+}
+exports.NordError = NordError;

package/dist/types.d.ts

@@ -5,7 +5,7 @@ import { Connection } from "@solana/web3.js";
 /**
  * Nord subscription type for trades or deltas
  */
-export type SubscriptionType = "trades" | "deltas" | "account";
+export type SubscriptionType = "trades" | "deltas" | "account" | "candle";
 /**
  * Pattern for a valid Nord subscription
  * Format should be: "<type>@<parameter>"
@@ -64,7 +64,7 @@ export type AccountPnlInfo = components["schemas"]["AccountPnlInfo"];
 export type AccountPnlInfoPage = components["schemas"]["PageResult_for_String_and_AccountPnlInfo"];
 export type AccountTriggerInfo = components["schemas"]["TriggerInfo"];
 export type TriggerHistoryPage = components["schemas"]["PageResult_for_String_and_Trigger"];
-export type WithdrawalHistoryPage = components["schemas"]["PageResult_for_String_and_Withdrawal"];
+export type WithdrawalHistoryPage = components["schemas"]["PageResult_for_String_and_WithdrawalInfo"];
 export type FeeTierConfig = components["schemas"]["FeeTierConfig"];
 export type FeeTierId = components["schemas"]["FeeTierId"];
 export type TokenStats = components["schemas"]["TokenStats"];
@@ -73,9 +73,7 @@ export type AccountFeeTierPage = components["schemas"]["PageResult_for_uint32_an
 export type AdminInfo = components["schemas"]["AdminInfo"];
 export type GetAccountVolumeQuery = components["schemas"]["GetAccountVolumeQuery"];
 export type AccountVolumeInfo = components["schemas"]["AccountVolumeInfo"];
-export type GetPrevMarketPriceQuery = components["schemas"]["GetPrevMarketPriceQuery"];
-export type PreviousMarketPrice = components["schemas"]["PreviousMarketPrice"];
-export type WithdrawalInfo = components["schemas"]["Withdrawal"];
+export type WithdrawalInfo = components["schemas"]["WithdrawalInfo"];
 /**
  * Configuration options for the Nord client
  */
@@ -196,6 +194,7 @@ export declare enum WebSocketMessageType {
     DeltaUpdate = "delta",
     AccountUpdate = "account"
 }
+export type CandleResolution = "1" | "5" | "15" | "30" | "60" | "1D" | "1W" | "1M";
 /**
  * WebSocket trade update message
  */
@@ -242,13 +241,23 @@ export interface WebSocketAccountUpdate {
     }>;
     balances: Record<string, number>;
 }
+export interface WebSocketCandleUpdate {
+    res: CandleResolution;
+    mid: number;
+    t: number;
+    o: number;
+    h: number;
+    l: number;
+    c: number;
+    v: number;
+}
 export type WebSocketMessage = {
     trades: WebSocketTradeUpdate;
 } | {
     delta: WebSocketDeltaUpdate;
 } | {
     account: WebSocketAccountUpdate;
-};
+} | WebSocketCandleUpdate;
 export interface SPLTokenInfo {
     mint: string;
     precision: number;

package/dist/types.js

@@ -0,0 +1,92 @@
+import * as proto from "./gen/nord_pb";
+import Decimal from "decimal.js";
+import { toScaledU64 } from "./utils";
+export var Side;
+(function (Side) {
+    Side["Ask"] = "ask";
+    Side["Bid"] = "bid";
+})(Side || (Side = {}));
+export var FillMode;
+(function (FillMode) {
+    FillMode[FillMode["Limit"] = 0] = "Limit";
+    FillMode[FillMode["PostOnly"] = 1] = "PostOnly";
+    FillMode[FillMode["ImmediateOrCancel"] = 2] = "ImmediateOrCancel";
+    FillMode[FillMode["FillOrKill"] = 3] = "FillOrKill";
+})(FillMode || (FillMode = {}));
+export var TriggerKind;
+(function (TriggerKind) {
+    TriggerKind[TriggerKind["StopLoss"] = 0] = "StopLoss";
+    TriggerKind[TriggerKind["TakeProfit"] = 1] = "TakeProfit";
+})(TriggerKind || (TriggerKind = {}));
+export var TriggerStatus;
+(function (TriggerStatus) {
+    TriggerStatus[TriggerStatus["Active"] = 0] = "Active";
+    TriggerStatus[TriggerStatus["Success"] = 1] = "Success";
+    TriggerStatus[TriggerStatus["Cancel"] = 2] = "Cancel";
+    TriggerStatus[TriggerStatus["Remove"] = 4] = "Remove";
+})(TriggerStatus || (TriggerStatus = {}));
+/**
+ * Converts a `FillMode` enum to its corresponding protobuf representation.
+ *
+ * @param x - The fill mode to convert.
+ * @returns The corresponding protobuf fill mode.
+ * @throws Will throw an error if provided with an invalid fill mode.
+ */
+export function fillModeToProtoFillMode(x) {
+    if (x === FillMode.Limit)
+        return proto.FillMode.LIMIT;
+    if (x === FillMode.PostOnly)
+        return proto.FillMode.POST_ONLY;
+    if (x === FillMode.ImmediateOrCancel) {
+        return proto.FillMode.IMMEDIATE_OR_CANCEL;
+    }
+    if (x === FillMode.FillOrKill)
+        return proto.FillMode.FILL_OR_KILL;
+    throw new Error("Invalid fill mode");
+}
+/**
+ * WebSocket message types
+ */
+export var WebSocketMessageType;
+(function (WebSocketMessageType) {
+    WebSocketMessageType["TradeUpdate"] = "trades";
+    WebSocketMessageType["DeltaUpdate"] = "delta";
+    WebSocketMessageType["AccountUpdate"] = "account";
+})(WebSocketMessageType || (WebSocketMessageType = {}));
+// Positive decimal price and size.
+// Example:
+// ```
+// const limit = new QuoteSize(new Decimal(114000), new Decimal(0.00035)),
+//```
+// Gives 40$ USD limit.
+//
+// Given price is same(or very close) to the market price,
+// limit gives size tick as close as possible to settlemnt size tick.
+// If you want to get smaller tick on client (on server it will not change),
+// do `new QuoteSize(new Decimal(114000/2), new Decimal(0.00070))`.
+// It will be 40$ limit, but may help if BTC suddently moves fast.
+export class QuoteSize {
+    price;
+    size;
+    /// Input can be only positive values.
+    constructor(quotePrice, quoteSize) {
+        const p = new Decimal(quotePrice);
+        const s = new Decimal(quoteSize);
+        if (!p.isPositive() || !s.isPositive()) {
+            throw new Error("quotePrice and quoteSize must be positive");
+        }
+        this.price = p;
+        this.size = s;
+    }
+    // USD value of limit, use for debug
+    value() {
+        return this.price.mul(this.size);
+    }
+    // Converts to wire format to be send to server, scaling price and size according to market decimals.
+    toWire(marketPriceDecimals, marketSizeDecimals) {
+        return {
+            price: toScaledU64(this.price, marketPriceDecimals),
+            size: toScaledU64(this.size, marketSizeDecimals),
+        };
+    }
+}

package/dist/utils.js

@@ -0,0 +1,193 @@
+import { Decimal } from "decimal.js";
+import { sizeDelimitedPeek } from "@bufbuild/protobuf/wire";
+import { fromBinary } from "@bufbuild/protobuf";
+import { ethers } from "ethers";
+import fetch from "node-fetch";
+import { Keypair } from "@solana/web3.js";
+import bs58 from "bs58";
+import * as solana from "@solana/web3.js";
+import { Buffer } from "buffer";
+export const SESSION_TTL = 60n * 60n * 24n * 30n;
+export const ZERO_DECIMAL = new Decimal(0);
+export const MAX_BUFFER_LEN = 10_000;
+// Max size of data returned from Nord endpoints
+const MAX_PAYLOAD_SIZE = 100 * 1024; // 100 kB
+export function panic(message) {
+    throw new Error(message);
+}
+export 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);
+}
+export 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
+ */
+export 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
+ */
+export async function checkedFetch(url, init) {
+    const resp = await fetch(url, init);
+    assert(resp.ok, `Request failed with ${resp.status}: ${resp.statusText}`);
+    return resp;
+}
+/**
+ * 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 function makeWalletSignFn(walletKey) {
+    const signingKey = new ethers.SigningKey(walletKey);
+    return async (message) => signingKey.sign(ethers.hashMessage(message)).serialized;
+}
+// Returned numbers do fit into specified bits range, or error is thrown.
+function makeToScaledBigUint(params) {
+    const Dec = 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
+ */
+export const 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
+ */
+export const toScaledU128 = makeToScaledBigUint({
+    bits: 128,
+    precision: 40,
+    exponent: 56,
+});
+/**
+ * Decodes any protobuf message from a length-delimited format,
+ * i.e. prefixed with its length encoded as varint
+ *
+ * @param   bytes  Byte array with encoded message
+ * @param   schema Message schema for decoding
+ * @returns        Decoded message
+ */
+export function decodeLengthDelimited(bytes, schema) {
+    // use sizeDelimitedPeek to extract the message length and offset
+    const peekResult = sizeDelimitedPeek(bytes);
+    if (peekResult.size === null || peekResult.offset === null) {
+        throw new Error("Failed to parse size-delimited message");
+    }
+    if (peekResult.size > MAX_PAYLOAD_SIZE) {
+        throw new Error(`Encoded message size (${peekResult.size} bytes) is greater than max payload size (${MAX_PAYLOAD_SIZE} bytes).`);
+    }
+    if (peekResult.offset + peekResult.size > bytes.length) {
+        throw new Error(`Encoded message size (${peekResult.size} bytes) is greater than remaining buffer size (${bytes.length - peekResult.offset} bytes).`);
+    }
+    // decode the message using the offset and size from peek
+    return fromBinary(schema, bytes.slice(peekResult.offset, peekResult.offset + peekResult.size));
+}
+export function decodeHex(value) {
+    const hex = value.startsWith("0x") ? value.slice(2) : value;
+    return Uint8Array.from(Buffer.from(hex, "hex"));
+}
+export function findMarket(markets, marketId) {
+    if (marketId < 0 || markets.length - 1 < marketId) {
+        throw new Error(`The market with marketId=${marketId} not found`);
+    }
+    return markets[marketId];
+}
+export function findToken(tokens, tokenId) {
+    if (tokenId < 0 || tokens.length - 1 < tokenId) {
+        throw new Error(`The token with tokenId=${tokenId} not found`);
+    }
+    return tokens[tokenId];
+}
+export function keypairFromPrivateKey(privateKey) {
+    if (typeof privateKey === "string") {
+        if (!privateKey.startsWith("0x")) {
+            return Keypair.fromSecretKey(bs58.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 Keypair.fromSecretKey(bytes);
+    }
+    return Keypair.fromSecretKey(privateKey);
+}
+export async function signAdminPayload({ payload, user, signTransaction, }) {
+    const tx = new solana.Transaction({
+        blockhash: bs58.encode(new Uint8Array(32)),
+        lastValidBlockHeight: 0,
+        feePayer: user,
+    });
+    tx.add(new solana.TransactionInstruction({
+        keys: [],
+        programId: user,
+        data: Buffer.from(payload),
+    }));
+    const signedTx = await signTransaction(tx);
+    const sig = signedTx.signatures[0];
+    assert(sig !== undefined, //.
+    "signed transaction must have a signature");
+    assert(sig.signature !== null, "signature must be non-null; check your signTransaction function");
+    assert(sig.signature.length === 64, //.
+    "signature must be 64 bytes");
+    assert(sig.publicKey.equals(user), `signature is for ${sig.publicKey}, expected ${user}`);
+    return sig.signature;
+}
+export async function signUserPayload({ payload, signMessage, }) {
+    return await signMessage(new TextEncoder().encode(payload.toHex()));
+}

package/dist/websocket/NordWebSocketClient.d.ts

@@ -50,6 +50,7 @@ export declare class NordWebSocketClient extends EventEmitter implements NordWeb
      * @param message WebSocket message
      */
     private handleMessage;
+    private isCandleUpdate;
     /**
      * Attempt to reconnect to the WebSocket server
      */