@n1xyz/nord-ts 0.2.0 → 0.3.2

package/dist/types.d.ts

@@ -61,10 +61,10 @@ export type PlacementOrigin = components["schemas"]["PlacementOrigin"];
 export type FinalizationReason = components["schemas"]["FinalizationReason"];
 export type PagedQuery = components["schemas"]["PagedQuery"];
 export type AccountPnlInfo = components["schemas"]["AccountPnlInfo"];
-export type AccountPnlInfoPage = components["schemas"]["PageResult_for_uint64_and_AccountPnlInfo"];
-export type AccountTriggerInfo = components["schemas"]["AccountTriggerInfo"];
-export type TriggerHistoryPage = components["schemas"]["PageResult_for_uint64_and_Trigger"];
-export type WithdrawalHistoryPage = components["schemas"]["PageResult_for_uint64_and_Withdrawal"];
+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 FeeTierConfig = components["schemas"]["FeeTierConfig"];
 export type FeeTierId = components["schemas"]["FeeTierId"];
 export type TokenStats = components["schemas"]["TokenStats"];
@@ -127,7 +127,7 @@ export interface StreamTrade {
     side: Side;
     price: number;
     size: number;
-    order_id: number;
+    order_id: string;
 }
 export interface Trades {
     last_update_id: number;
@@ -199,12 +199,7 @@ export declare enum WebSocketMessageType {
 /**
  * WebSocket trade update message
  */
-export interface WebSocketTradeUpdate {
-    e: WebSocketMessageType.TradeUpdate;
-    symbol: string;
-    trades: StreamTrade[];
-    timestamp: number;
-}
+export type WebSocketTradeUpdate = Trades;
 /**
  * WebSocket delta update message
  */
@@ -217,19 +212,35 @@ export interface WebSocketDeltaUpdate {
     bids: OrderbookEntry[];
     timestamp: number;
 }
+export type OrderId = string;
 export interface WebSocketAccountUpdate {
     last_update_id: number;
     update_id: number;
     account_id: number;
-    fills: Record<string, unknown>;
-    places: Record<string, unknown>;
-    cancels: Record<string, {
+    fills: Record<OrderId, {
+        side: "bid" | "ask";
+        quantity: number;
+        remaining: number;
+        price: number;
+        order_id: string;
+        market_id: number;
+        maker_id: number;
+        taker_id: number;
+        sender_tracking_id: number | null;
+    }>;
+    places: Record<OrderId, {
+        side: "bid" | "ask";
+        current_size: number;
+        price: number;
+        market_id: number;
+    }>;
+    cancels: Record<OrderId, {
         side: "bid" | "ask";
         current_size: number;
         price: number;
         market_id: number;
     }>;
-    balances: Record<string, unknown>;
+    balances: Record<string, number>;
 }
 export type WebSocketMessage = {
     trades: WebSocketTradeUpdate;

package/dist/websocket/Subscriber.d.ts

@@ -1,5 +1,5 @@
 import { EventEmitter } from "events";
-import { Account, DeltaEvent, WebSocketDeltaUpdate, SubscriberConfig, StreamTrade, Trades } from "../types";
+import { Account, DeltaEvent, WebSocketDeltaUpdate, SubscriberConfig, Trades, WebSocketTradeUpdate } from "../types";
 /**
  * Subscriber class for handling WebSocket subscriptions
  */
@@ -30,7 +30,7 @@ export interface OrderbookSubscription extends EventEmitter {
  * Interface for trade subscription
  */
 export interface TradeSubscription extends EventEmitter {
-    on(event: "message", listener: (data: StreamTrade[]) => void): this;
+    on(event: "message", listener: (data: WebSocketTradeUpdate) => void): this;
     on(event: "error", listener: (error: Error) => void): this;
     close(): void;
     removeAllListeners(event?: string): this;

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@n1xyz/nord-ts",
-  "version": "0.2.0",
+  "version": "0.3.2",
   "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": {
@@ -44,7 +47,7 @@
   },
   "dependencies": {
     "@bufbuild/protobuf": "^2.6.3",
-    "@n1xyz/proton": "0.1.0",
+    "@n1xyz/proton": "0.1.1",
     "@noble/curves": "^1.9.6",
     "@noble/ed25519": "^2.3.0",
     "@noble/hashes": "^1.8.0",

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}`);
-}