@n1xyz/nord-ts 0.3.1 → 0.3.3

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>"
@@ -196,6 +196,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 +243,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/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
      */

package/dist/websocket/Subscriber.d.ts

@@ -1,5 +1,5 @@
 import { EventEmitter } from "events";
-import { Account, DeltaEvent, WebSocketDeltaUpdate, SubscriberConfig, Trades, WebSocketTradeUpdate } from "../types";
+import { Account, DeltaEvent, WebSocketDeltaUpdate, SubscriberConfig, Trades, WebSocketTradeUpdate, WebSocketCandleUpdate } from "../types";
 /**
  * Subscriber class for handling WebSocket subscriptions
  */
@@ -35,3 +35,9 @@ export interface TradeSubscription extends EventEmitter {
     close(): void;
     removeAllListeners(event?: string): this;
 }
+export interface CandleSubscription extends EventEmitter {
+    on(event: "message", listener: (data: WebSocketCandleUpdate) => void): this;
+    on(event: "error", listener: (error: Error) => void): this;
+    close(): void;
+    removeAllListeners(event?: string): this;
+}

package/dist/websocket/events.d.ts

@@ -1,4 +1,4 @@
-import { WebSocketTradeUpdate, WebSocketDeltaUpdate, WebSocketAccountUpdate } from "../types";
+import { WebSocketTradeUpdate, WebSocketDeltaUpdate, WebSocketAccountUpdate, WebSocketCandleUpdate } from "../types";
 /**
  * Event type definitions for the NordWebSocketClient
  */
@@ -9,6 +9,7 @@ export interface NordWebSocketEvents {
     trade: (update: WebSocketTradeUpdate) => void;
     delta: (update: WebSocketDeltaUpdate) => void;
     account: (update: WebSocketAccountUpdate) => void;
+    candle: (update: WebSocketCandleUpdate) => void;
 }
 /**
  * Type declaration for NordWebSocketClient event methods

package/dist/websocket/index.d.ts

@@ -16,4 +16,4 @@ export { NordWebSocketClient, NordWebSocketEvents, NordWebSocketClientEvents, Su
  * @returns WebSocket client
  * @throws {NordError} If initialization fails or invalid subscription is provided
  */
-export declare function initWebSocketClient(webServerUrl: string, subscriptions?: SubscriptionPattern[] | "trades" | "delta" | "account"): NordWebSocketClient;
+export declare function initWebSocketClient(webServerUrl: string, subscriptions?: SubscriptionPattern[] | "trades" | "delta" | "account" | "candle"): NordWebSocketClient;

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@n1xyz/nord-ts",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "Typescript for Nord",
   "keywords": [],
   "author": "",
   "license": "ISC",
   "type": "module",
-  "main": "dist/index.js",
+  "main": "dist/index.common.js",
+  "browser": "dist/index.browser.js",
   "types": "dist/index.d.ts",
   "files": [
     "dist/",
@@ -17,12 +18,14 @@
     "gen:proto": "bunx @bufbuild/buf generate ../engine",
     "gen:api": "nix run ..#openapi | bunx openapi-typescript > src/gen/openapi.ts",
     "gen": "bun run gen:proto && bun run gen:api",
-    "build": "bun run gen && bunx tsc && bun run docs",
+    "build:node": "bun build ./src/index.ts --target=node --format=esm --outfile=dist/index.common.js",
+    "build:browser": "bun build ./src/index.ts --target=browser --format=esm --outfile=dist/index.browser.js",
+    "build": "bun run gen && bunx tsc && bun run build:node && bun run build:browser && bun run docs",
     "docs": "bunx typedoc --out ./docs ./src",
     "compile": "tsc",
     "clean": "rm -rf ./src/gen ./dist ./docs",
     "fmt": "prettier --write src tests",
-    "ci": "bunx eslint && prettier --check src tests",
+    "ci": "bunx eslint && bunx tsc && prettier --check src tests",
     "all": "bun install && bun run build && bun run ci && bun fmt"
   },
   "devDependencies": {

package/dist/actions.js

@@ -1,184 +0,0 @@
-import * as proto from "./gen/nord_pb";
-import { create } from "@bufbuild/protobuf";
-import { fillModeToProtoFillMode, Side } from "./types";
-import { assert, decodeLengthDelimited, SESSION_TTL, toScaledU64, signUserPayload, } from "./utils";
-import { sizeDelimitedEncode } from "@bufbuild/protobuf/wire";
-import { NordError } from "./error";
-export function formatReceiptError(receipt) {
-    if (receipt.kind?.case === "err") {
-        const err = receipt.kind.value;
-        return proto.Error[err] ?? err.toString();
-    }
-    return receipt.kind?.case ?? "unknown";
-}
-export function expectReceiptKind(receipt, expected, action) {
-    if (receipt.kind?.case !== expected) {
-        const label = formatReceiptError(receipt);
-        throw new NordError(`Failed to ${action}: ${label}`);
-    }
-}
-async function sessionSign(signFn, message) {
-    const signature = await signFn(message);
-    return new Uint8Array([...message, ...signature]);
-}
-// Helper to create an action with common fields
-export function createAction(currentTimestamp, nonce, kind) {
-    return create(proto.ActionSchema, {
-        currentTimestamp,
-        nonce,
-        kind,
-    });
-}
-export async function sendAction(client, makeSignedMessage, action) {
-    const body = await prepareAction(action, makeSignedMessage);
-    const response = await client.POST("/action", {
-        params: {
-            header: {
-                "content-type": "application/octet-stream",
-            },
-        },
-        body: body,
-        // NOTE: openapi-fetch ignores headers and types/const headers in schema, and always assume all things are JSON
-        // to handle multi type bodies, need these overrides and later adhoc parsing
-        bodySerializer: (body) => body,
-        parseAs: "stream",
-    });
-    if (response.error) {
-        throw new Error(`Failed to ${action.kind.case}, HTTP status ${JSON.stringify(response.error)}`);
-    }
-    const rawResp = new Uint8Array(await response.response.arrayBuffer());
-    const resp = decodeLengthDelimited(rawResp, proto.ReceiptSchema);
-    if (resp.kind?.case === "err") {
-        throw new Error(`Could not execute ${action.kind.case}, reason: ${proto.Error[resp.kind.value]}`);
-    }
-    return resp;
-}
-// Given action and signature function, prepare the signed message to send to server as `body`.
-// `makeSignedMessage` must include the original message and signature.
-export async function prepareAction(action, makeSignedMessage) {
-    const encoded = sizeDelimitedEncode(proto.ActionSchema, action);
-    // NOTE(agent): keep in sync with MAX_ENCODED_ACTION_SIZE in Rust code
-    const MAX_ENCODED_ACTION_SIZE = 1024;
-    if (encoded.byteLength > MAX_ENCODED_ACTION_SIZE) {
-        console.warn("Encoded message:", encoded);
-        throw new Error(`Encoded message size (${encoded.byteLength} bytes) is greater than max payload size (${MAX_ENCODED_ACTION_SIZE} bytes).`);
-    }
-    const body = await makeSignedMessage(encoded);
-    if (body.byteLength > MAX_ENCODED_ACTION_SIZE) {
-        console.warn("Encoded length:", encoded.byteLength);
-        throw new Error(`Signed message size (${body.byteLength} bytes) is greater than max payload size (${MAX_ENCODED_ACTION_SIZE} bytes).`);
-    }
-    return body;
-}
-export async function createSession(client, signMessage, currentTimestamp, nonce, params) {
-    let expiry = 0n;
-    if (params.expiryTimestamp !== undefined) {
-        expiry = params.expiryTimestamp;
-        assert(expiry > currentTimestamp, "Cannot set expiry timestamp in the past");
-    }
-    else {
-        expiry = currentTimestamp + SESSION_TTL;
-    }
-    const action = createAction(currentTimestamp, nonce, {
-        case: "createSession",
-        value: create(proto.Action_CreateSessionSchema, {
-            userPubkey: params.userPubkey.toBytes(),
-            blstPubkey: params.sessionPubkey.toBytes(),
-            expiryTimestamp: expiry,
-        }),
-    });
-    const resp = await sendAction(client, async (payload) => {
-        return new Uint8Array([
-            ...payload,
-            ...(await signUserPayload({
-                payload,
-                signMessage,
-            })),
-        ]);
-    }, action);
-    if (resp.kind?.case === "createSessionResult") {
-        return {
-            actionId: resp.actionId,
-            sessionId: resp.kind.value.sessionId,
-        };
-    }
-    else {
-        throw new Error(`Unexpected receipt kind ${resp.kind?.case}`);
-    }
-}
-export async function revokeSession(client, signMessage, currentTimestamp, nonce, params) {
-    const action = createAction(currentTimestamp, nonce, {
-        case: "revokeSession",
-        value: create(proto.Action_RevokeSessionSchema, {
-            sessionId: BigInt(params.sessionId),
-        }),
-    });
-    const resp = await sendAction(client, async (payload) => {
-        return new Uint8Array([
-            ...payload,
-            ...(await signUserPayload({
-                payload,
-                signMessage,
-            })),
-        ]);
-    }, action);
-    return { actionId: resp.actionId };
-}
-export async function atomic(client, signFn, currentTimestamp, nonce, params) {
-    assert(params.actions.length > 0 && params.actions.length <= 4, "Atomic action must contain between 1 and 4 sub-actions");
-    const subactions = params.actions.map((a) => {
-        if (a.kind === "place") {
-            const price = toScaledU64(a.price ?? 0, a.priceDecimals);
-            const size = toScaledU64(a.size ?? 0, a.sizeDecimals);
-            const scaledQuote = a.quoteSize
-                ? a.quoteSize.toWire(a.priceDecimals, a.sizeDecimals)
-                : undefined;
-            // Require at least one limit to be set (non-zero size, non-zero price, or quoteSize)
-            assert(price > 0n || size > 0n || scaledQuote !== undefined, "OrderLimit must include at least one of: size, price, or quoteSize");
-            const tradeOrPlace = create(proto.TradeOrPlaceSchema, {
-                marketId: a.marketId,
-                orderType: create(proto.OrderTypeSchema, {
-                    side: a.side === Side.Bid ? proto.Side.BID : proto.Side.ASK,
-                    fillMode: fillModeToProtoFillMode(a.fillMode),
-                    isReduceOnly: a.isReduceOnly,
-                }),
-                limit: create(proto.OrderLimitSchema, {
-                    price,
-                    size,
-                    quoteSize: scaledQuote === undefined
-                        ? undefined
-                        : create(proto.QuoteSizeSchema, {
-                            size: scaledQuote.size,
-                            price: scaledQuote.price,
-                        }),
-                }),
-                clientOrderId: a.clientOrderId === undefined ? undefined : BigInt(a.clientOrderId),
-            });
-            return create(proto.AtomicSubactionKindSchema, {
-                inner: { case: "tradeOrPlace", value: tradeOrPlace },
-            });
-        }
-        return create(proto.AtomicSubactionKindSchema, {
-            inner: {
-                case: "cancelOrder",
-                value: create(proto.CancelOrderSchema, { orderId: BigInt(a.orderId) }),
-            },
-        });
-    });
-    const action = createAction(currentTimestamp, nonce, {
-        case: "atomic",
-        value: create(proto.AtomicSchema, {
-            sessionId: BigInt(params.sessionId),
-            accountId: params.accountId, // optional
-            actions: subactions,
-        }),
-    });
-    const resp = await sendAction(client, (m) => sessionSign(signFn, m), action);
-    if (resp.kind?.case === "atomic") {
-        return {
-            actionId: resp.actionId,
-            results: resp.kind.value.results,
-        };
-    }
-    throw new Error(`Unexpected receipt kind ${resp.kind?.case}`);
-}