@n1xyz/nord-ts 0.0.1

package/dist/types.d.ts

@@ -0,0 +1,343 @@
+import * as proto from "./gen/nord";
+/**
+ * The peak TPS rate is queried over the specified period.
+ * The period is specified in units of: {hour, day, week, month, year}.
+ * Example inputs:
+ *  1. AggregateMetrics.txPeakTpsPeriod = 3,
+ *     AggregateMetrics.txPeakTpsPeriodUnit = "d" => Peak TPS over last 3 days.
+ *  1. AggregateMetrics.txPeakTpsPeriod = 1,
+ *     AggregateMetrics.txPeakTpsPeriodUnit = "w" => Peak TPS over last week.
+ */
+export declare enum PeakTpsPeriodUnit {
+    Hour = "h",
+    Day = "d",
+    Week = "w",
+    Month = "m",
+    Year = "y"
+}
+export interface NordConfig {
+    evmUrl: string;
+    webServerUrl: string;
+    contractAddress: string;
+    tokenInfos: ERC20TokenInfo[];
+}
+export interface ERC20TokenInfo {
+    address: string;
+    precision: number;
+    tokenId: number;
+    name: string;
+}
+export interface Order {
+    orderId: number;
+    isLong: boolean;
+    size: number;
+    price: number;
+    marketId: number;
+}
+export declare enum KeyType {
+    Ed25519 = 0,
+    Secp256k1 = 1,
+    Bls12_381 = 2
+}
+export declare enum Side {
+    Ask = 0,
+    Bid = 1
+}
+export declare enum FillMode {
+    Limit = 0,
+    PostOnly = 1,
+    ImmediateOrCancel = 2,
+    FillOrKill = 3
+}
+export interface SubscriberConfig {
+    streamURL: string;
+    maxBufferLen?: number;
+}
+export interface Market {
+    symbol: string;
+    baseTokenId: number;
+    quoteTokenId: number;
+    priceDecimals: number;
+    sizeDecimals: number;
+}
+export interface Token {
+    symbol: string;
+    ethAddr: string;
+    decimals: number;
+    tokenId: number;
+}
+export interface Info {
+    markets: Market[];
+    tokens: Token[];
+}
+export interface DeltaEvent {
+    last_update_id: number;
+    update_id: number;
+    market_symbol: string;
+    asks: [number, number];
+    bids: [number, number];
+}
+export interface Trade {
+    side: Side;
+    price: number;
+    size: number;
+    order_id: number;
+}
+export interface Trades {
+    last_update_id: number;
+    update_id: number;
+    market_symbol: string;
+    trades: Trade[];
+}
+export interface OrderInfo {
+    id: number;
+    reduce_only: boolean;
+    imit_price: number;
+    size: number;
+    account_id: number;
+}
+interface HashMap<T> {
+    [key: number]: T;
+}
+export interface Account {
+    last_update_id: number;
+    update_id: number;
+    account_id: number;
+    fills: HashMap<FillMode>;
+    places: HashMap<OrderInfo>;
+    cancels: HashMap<OrderInfo>;
+    balances: HashMap<number>;
+}
+/**
+ * Query the transactions in the specified L2 block.
+ * @field {number} block_number specifies the block number to query.
+ *                 If not specified, transactions from latest block
+ *                 are returned.
+ */
+export interface BlockQuery {
+    block_number?: number;
+}
+/**
+ * Response for BlockQuery.
+ * @field {number} block_number specifies the block number being returned.
+ * @field {BlockActions} actions are the list of transactions from the block.
+ */
+export interface BlockResponse {
+    block_number: number;
+    actions: ActionInfo[];
+}
+/**
+ * Response for BlockSummaryQuery.
+ * @field {BlockSummary} block_summary is the summary of upto the last N blocks.
+ *                       The server can return fewer than last_n block summary if
+ *                       fewer blocks are available or if it exceeds a max cap.
+ */
+export interface BlockSummaryResponse {
+    block_summary: BlockSummary[];
+}
+/**
+ * Query the action for the specified action id.
+ * @field {number} action_id specifies the action to query.
+ */
+export interface ActionQuery {
+    action_id: number;
+}
+/**
+ * Response for ActionQuery.
+ * @field {number} block_number the block the action is part of.
+ *                 If the action is not yet included in any block,
+ *                 null is returned.
+ * @field {Action} the transaction.
+ */
+export interface ActionResponse {
+    block_number?: number;
+    action: proto.Action;
+}
+/**
+ * Query the recent actions
+ * @field {number} last_n requests last N actions.
+ * @field {number} action_id specifies the action to query.
+ */
+export interface ActionsQuery {
+    last_n: number;
+}
+/**
+ * Response for ActionsQuery.
+ * @field {ActionsExtendedInfo} actions returns upto the last N actions.
+ *                       The server can return fewer than last_n actions if
+ *                       fewer actions are available or if it exceeds a max cap.
+ */
+export interface ActionsResponse {
+    actions: ActionsExtendedInfo[];
+}
+/**
+ * Block summary.
+ * @field {number} block_number Block number.
+ * @field {Action} from First action_id in the block.
+ * @field {Action} to Last action_id in the block.
+ */
+export interface BlockSummary {
+    block_number: number;
+    from_action_id: number;
+    to_action_id: number;
+}
+/**
+ * Info about the block transaction.
+ * @field {number} action_id is the action identifier.
+ * @field {Action} action in protobuf format.
+ * @field {number} exec_timestamp is the execution timestamp.
+ */
+export interface ActionInfo {
+    action_id: number;
+    action: proto.Action;
+    exec_timestamp: number;
+}
+/**
+ * Extended info about the block transaction.
+ * @field {number} block_number the block the action is part of.
+ *                 If the action is not yet included in any block,
+ *                 null is returned.
+ * @field {number} action_id of the action.
+ * @field {Action} action the transaction.
+ */
+export interface ActionsExtendedInfo {
+    block_number?: number;
+    action_id: number;
+    action: proto.Action;
+}
+/**
+ * Aggregate metrics
+ * @field {number} blocks_total: Total number of L2 blocks.
+ * @field {number} tx_total: Total number of transactions.
+ * @field {number} tx_tps: Transaction throughput.
+ * @field {number} tx_tps_peak: Peak transaction throughput.
+ * @field {number} request_latency_average: Average request latency.
+ */
+export interface AggregateMetrics {
+    blocks_total: number;
+    tx_total: number;
+    tx_tps: number;
+    tx_tps_peak: number;
+    request_latency_average: number;
+}
+/**
+ * Parameters for querying trades
+ * @field {number} accountId - ID of target account
+ * @field {string} [since] - Start with this timestamp (RFC3339); defaults to UNIX epoch start
+ * @field {string} [until] - End with this timestamp (RFC3339); defaults to current date-time
+ * @field {string} [pageId] - Fetch results starting with this page
+ */
+export interface TradesQueryParams {
+    accountId: number;
+    since?: string;
+    until?: string;
+    pageId?: string;
+}
+/**
+ * Trade information
+ * @field {string} id - Trade ID
+ * @field {string} timestamp - Trade timestamp (RFC3339)
+ * @field {string} symbol - Market symbol
+ * @field {string} side - Trade side (buy/sell)
+ * @field {number} price - Trade price
+ * @field {number} size - Trade size
+ * @field {number} fee - Trade fee
+ * @field {string} feeCurrency - Fee currency
+ * @field {number} orderId - Order ID
+ */
+export interface TradeInfo {
+    id: string;
+    timestamp: string;
+    symbol: string;
+    side: string;
+    price: number;
+    size: number;
+    fee: number;
+    feeCurrency: string;
+    orderId: number;
+}
+/**
+ * Response for trades query
+ * @field {number} accountId - Account ID
+ * @field {string} since - Start timestamp (RFC3339)
+ * @field {string} until - End timestamp (RFC3339)
+ * @field {string} [nextPageId] - ID for the next page of results
+ * @field {TradeInfo[]} trades - Array of trades
+ */
+export interface TradesResponse {
+    accountId: number;
+    since: string;
+    until: string;
+    nextPageId?: string;
+    trades: TradeInfo[];
+}
+/**
+ * Order in the orderbook
+ * @field {number} price - Order price
+ * @field {number} size - Order size
+ */
+export interface OrderbookOrder {
+    price: number;
+    size: number;
+}
+/**
+ * Response for orderbook query
+ * @field {string} symbol - Market symbol
+ * @field {number} timestamp - Orderbook timestamp
+ * @field {OrderbookOrder[]} bids - Array of bid orders
+ * @field {OrderbookOrder[]} asks - Array of ask orders
+ */
+export interface OrderbookResponse {
+    symbol: string;
+    timestamp: number;
+    bids: OrderbookOrder[];
+    asks: OrderbookOrder[];
+}
+export interface RollmanBlockResponse {
+    block_number: number;
+    actions: RollmanActionInfo[];
+}
+export interface RollmanActionResponse {
+    block_number?: number;
+    action_pb: Uint8Array;
+    exec_timestamp: number;
+}
+export interface RollmanActionsResponse {
+    actions: RollmanActionExtendedInfo[];
+}
+export interface RollmanActionInfo {
+    action_id: number;
+    action_pb: Uint8Array;
+    exec_timestamp: number;
+}
+export interface RollmanActionExtendedInfo {
+    block_number?: number;
+    action_id: number;
+    action_pb: Uint8Array;
+}
+export interface MarketsStatsResponse {
+    markets: MarketStats[];
+}
+export interface MarketStats {
+    market_id: number;
+    index_price: [number, number];
+    volume_24h: number;
+    high_24h: number;
+    low_24h: number;
+    perp_stats?: PerpMarketStats;
+}
+export interface PerpMarketStats {
+    mark_price?: number;
+    funding_rate?: number;
+    next_funding_time?: Date;
+    open_interest?: number;
+}
+/**
+ * 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 declare function fillModeToProtoFillMode(x: FillMode): proto.FillMode;
+export {};

package/dist/types.js

@@ -0,0 +1,92 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FillMode = exports.Side = exports.KeyType = exports.PeakTpsPeriodUnit = void 0;
+exports.fillModeToProtoFillMode = fillModeToProtoFillMode;
+const proto = __importStar(require("./gen/nord"));
+/**
+ * The peak TPS rate is queried over the specified period.
+ * The period is specified in units of: {hour, day, week, month, year}.
+ * Example inputs:
+ *  1. AggregateMetrics.txPeakTpsPeriod = 3,
+ *     AggregateMetrics.txPeakTpsPeriodUnit = "d" => Peak TPS over last 3 days.
+ *  1. AggregateMetrics.txPeakTpsPeriod = 1,
+ *     AggregateMetrics.txPeakTpsPeriodUnit = "w" => Peak TPS over last week.
+ */
+var PeakTpsPeriodUnit;
+(function (PeakTpsPeriodUnit) {
+    PeakTpsPeriodUnit["Hour"] = "h";
+    PeakTpsPeriodUnit["Day"] = "d";
+    PeakTpsPeriodUnit["Week"] = "w";
+    PeakTpsPeriodUnit["Month"] = "m";
+    PeakTpsPeriodUnit["Year"] = "y";
+})(PeakTpsPeriodUnit || (exports.PeakTpsPeriodUnit = PeakTpsPeriodUnit = {}));
+var KeyType;
+(function (KeyType) {
+    KeyType[KeyType["Ed25519"] = 0] = "Ed25519";
+    KeyType[KeyType["Secp256k1"] = 1] = "Secp256k1";
+    KeyType[KeyType["Bls12_381"] = 2] = "Bls12_381";
+})(KeyType || (exports.KeyType = KeyType = {}));
+var Side;
+(function (Side) {
+    Side[Side["Ask"] = 0] = "Ask";
+    Side[Side["Bid"] = 1] = "Bid";
+})(Side || (exports.Side = Side = {}));
+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 || (exports.FillMode = FillMode = {}));
+/**
+ * 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.
+ */
+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");
+}

package/dist/utils.d.ts

@@ -0,0 +1,114 @@
+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";
+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;