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

package/.local/qa.ts

@@ -0,0 +1,77 @@
+// quick script i use to qa sdk against deployed instance. this
+// will no longer be needed once we have proper integration tests.
+
+import { Nord, NordUser } from "../src";
+
+const nord = await Nord.initNord({
+  bridgeVk: "rbrpQMMPaVLSG3hTPZj2GLKxGLbPM2q7gDxc7BTync6",
+  initWebSockets: false,
+  solanaUrl: "https://api.devnet.solana.com",
+  webServerUrl: "https://zo-devnet-rc.n1.xyz",
+});
+
+const poky = await nord.getUser({
+  pubkey: "GSPX6qX4bs8oTU3n5A1Xx8q9MPiGFyxWhMtuVvpZNK52",
+});
+
+console.log("user", poky);
+
+if (!poky) {
+  throw new Error("No user found");
+}
+
+console.log("account", await nord.getAccount(poky.accountIds[0]));
+console.log("timestamp", await nord.getTimestamp());
+console.log("actionNonce", await nord.getActionNonce());
+console.log("lastActionId", await nord.getLastActionId());
+console.log("info", await nord.getInfo());
+
+console.log(
+  "marketStats",
+  await nord.getMarketStats({
+    marketId: 1,
+  }),
+);
+
+console.log(
+  "orderbook",
+  await nord.getOrderbook({
+    market_id: 1,
+  }),
+);
+
+const since = new Date();
+since.setMinutes(0);
+
+console.log(
+  "trades",
+  await nord.getTrades({
+    takerId: poky.accountIds[0],
+    sinceRcf3339: since.toISOString(),
+    untilRfc3339: new Date().toISOString(),
+    pageId: "0",
+  }),
+);
+
+console.log(
+  "recentActions",
+  await nord.queryRecentActions({
+    from: 6,
+    to: 6,
+  }),
+);
+
+console.log("action", await nord.queryAction({ action_id: 0 }));
+console.log("action", await nord.queryAction({ action_id: 1 }));
+console.log("action", await nord.queryAction({ action_id: 2 }));
+console.log("action", await nord.queryAction({ action_id: 5 }));
+console.log("action", await nord.queryAction({ action_id: 100 }));
+
+const user = NordUser.fromPrivateKey(
+  nord,
+  new Uint8Array(JSON.parse(process.env.PRIVATE_KEY!)),
+);
+
+console.log("deposit", await user.deposit({ amount: 2.0, tokenId: 0 }));
+await user.refreshSession();
+console.log("withdraw", await user.withdraw({ amount: 2.0, tokenId: 0 }));

package/.local/test-atomic.ts

@@ -0,0 +1,112 @@
+import { NordWebSocketClient } from "../src/websocket/NordWebSocketClient";
+
+/**
+ * All event types that we track in the counters object. Keeping this
+ * union type explicit lets TypeScript validate that we use the same
+ * keys everywhere and prevents typos.
+ */
+export type CounterKeys =
+  | "trade"
+  | "delta"
+  | "account"
+  | "error"
+  | "disconnected";
+
+interface Endpoint {
+  /** WebSocket endpoint URL */
+  url: string;
+  /** Streams we want to subscribe to once connected (can be empty) */
+  streams: string[];
+}
+
+/**
+ * Web‑socket endpoints to test.  Keep this list short & focused so the smoke
+ * test finishes quickly inside CI.
+ */
+const endpoints: Endpoint[] = [
+  //   {
+  //     url: "wss://staging.n1.xyz/ws/",
+  //     streams: [], // no runtime subscribe call needed
+  //   },
+
+  // {
+  //   url: `wss://staging.n1.xyz/ws/account@${process.env.NORD_ACCOUNT_ID ?? "3"}`,
+  //   streams: [],
+  // },
+
+  {
+    url: `wss://zo-devnet-rc.n1.xyz/ws/trades@ETHPERP`,
+    streams: ["trades@ETHPERP"],
+  },
+];
+
+/** How long each endpoint should be observed for (default: 15 s) */
+// const TEST_DURATION_MS = Number(process.env.TEST_DURATION_MS ?? 15_000);
+const TEST_DURATION_MS = 15_000;
+
+/**
+ * Simple message counters for every event type the client can emit.
+ * This is mutated by the event handlers during the test run.
+ */
+const counters: Record<CounterKeys, number> = {
+  trade: 0,
+  delta: 0,
+  account: 0,
+  error: 0,
+  disconnected: 0,
+};
+
+/**
+ * Connect to a single endpoint, wait for activity, then verify we received the
+ * expected events.
+ */
+async function smokeTest(endpoint: Endpoint): Promise<void> {
+  console.log(`🛰️  Connecting to ${endpoint.url} …`);
+  const client = new NordWebSocketClient(endpoint.url);
+  client.connect();
+
+  client.on("connected", () => {
+    console.log("✅ connected");
+  });
+
+  client.on("disconnected", () => {
+    console.log("⚠️  disconnected");
+    counters.disconnected++;
+  });
+
+  client.on("error", (err: unknown) => {
+    console.error("❌ error:", err);
+    counters.error++;
+  });
+
+  client.on("trades", (m) => {
+    console.log({ m });
+    counters.trade++;
+  });
+  client.on("deltas", (m) => {
+    console.log({ m });
+    counters.delta++;
+  });
+  client.on("accounts", (m) => {
+    console.log({ m });
+    counters.account++;
+  });
+
+  // Wait a bit, then close and report
+  await new Promise((resolve) => setTimeout(resolve, TEST_DURATION_MS));
+  client.close();
+}
+
+(async () => {
+  try {
+    for (const ep of endpoints) {
+      await smokeTest(ep);
+    }
+    console.log("\n🎉 All websocket endpoints responded as expected:");
+    console.table(counters);
+  } catch (e) {
+    console.error("\n🔴 Smoke test failed:", (e as Error).message);
+    console.table(counters);
+    process.exitCode = 1;
+  }
+})();

package/check.sh

@@ -0,0 +1,4 @@
+npm install
+npm build
+npm run test
+npm run ci

package/default.nix

@@ -0,0 +1,47 @@
+{ inputs, ... }:
+{
+  perSystem =
+    {
+      pkgs,
+      self',
+      system,
+      ...
+    }:
+    {
+      packages = {
+        nord-ts-proto =
+          let
+            ts-proto = inputs.n1.packages.${system}.ts-proto;
+          in
+          pkgs.writeShellApplication {
+            name = "nord-ts-proto";
+            runtimeInputs = [ pkgs.protobuf ];
+            text = ''
+              if [ $# -ne 2 ]; then
+                echo >&2 "usage: $(basename "$0") <proto-file> <out-dir>"
+                exit 1
+              fi
+              readonly PROTO_FILE="$1"
+              readonly OUT_DIR="$2"
+              protoc \
+                --plugin="${ts-proto}/bin/protoc-gen-ts_proto" \
+                --ts_proto_opt=forceLong=bigint \
+                --ts_proto_opt=esModuleInterop=true \
+                --ts_proto_opt=oneof=unions-value \
+                --ts_proto_opt=unrecognizedEnum=false \
+                --ts_proto_out="$OUT_DIR" \
+                --proto_path="$(dirname "$PROTO_FILE")" \
+                "$PROTO_FILE"
+            '';
+          };
+        nord-ts-check = pkgs.writeShellApplication {
+          name = "ts-check";
+          runtimeInputs = [
+            pkgs.protobuf
+            pkgs.pnpm
+          ];
+          text = builtins.readFile ./check.sh;
+        };
+      };
+    };
+}

package/dist/api/client.d.ts

@@ -0,0 +1,14 @@
+import type { paths } from "../gen/openapi";
+export interface ClientConfig {
+    baseUrl: string;
+}
+export declare function createApiClient(config: ClientConfig): import("openapi-fetch").Client<paths, `${string}/${string}`>;
+export declare function handleApiResponse<T>(response: Promise<{
+    data: T;
+    error?: unknown;
+    response: Response;
+} | {
+    data?: never;
+    error?: unknown;
+    response: Response;
+}>): Promise<T>;

package/dist/api/client.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createApiClient = createApiClient;
+exports.handleApiResponse = handleApiResponse;
+const openapi_fetch_1 = __importDefault(require("openapi-fetch"));
+const NordError_1 = require("../nord/utils/NordError");
+function createApiClient(config) {
+    const client = (0, openapi_fetch_1.default)({
+        baseUrl: config.baseUrl,
+    });
+    client.use({
+        onResponse({ response }) {
+            if (!response.ok) {
+                throw new NordError_1.NordError(`HTTP ${response.status}: ${response.statusText}`, {
+                    statusCode: response.status,
+                    details: { url: response.url }
+                });
+            }
+            return response;
+        },
+    });
+    return client;
+}
+async function handleApiResponse(response) {
+    const result = await response;
+    if (result.error || !result.response.ok) {
+        const errorMessage = result.error
+            ? `HTTP ${result.response.status}: ${result.response.statusText}`
+            : `Request failed: ${result.response.statusText}`;
+        throw new NordError_1.NordError(errorMessage, {
+            statusCode: result.response.status,
+            details: { url: result.response.url }
+        });
+    }
+    if (!('data' in result)) {
+        throw new NordError_1.NordError("No data in response", {
+            statusCode: 500,
+            details: { url: result.response.url }
+        });
+    }
+    return result.data;
+}

package/dist/gen/nord.d.ts

@@ -181,6 +181,7 @@ export declare enum Error {
     POSITION_STATE_ORDER_PRICE = 203,
     POSITION_STATE_ORDER_SIZE = 204,
     POSITION_STATE_ORDER_SIDE = 205,
+    /** POSITION_SIZE_LIMIT - 1100_1110 */
     POSITION_SIZE_LIMIT = 206,
     PRICE = 209,
     SIGNATURE_VERIFICATION = 217,
@@ -194,11 +195,22 @@ export declare enum Error {
     ORDER_EXECUTION_MISSING_LIMITS = 243,
     ORDER_EXECUTION_MISSING_PRICE = 244,
     ORDER_EXECUTION_SIZE_LIMIT = 245,
+    /** ORDER_EXECUTION_LIMIT_PRICE - 111_0110 */
     ORDER_EXECUTION_LIMIT_PRICE = 246,
-    /** ORDER_REDUCE_IS_POST_ONLY - Reduce orders can only be post only. */
+    /**
+     * ORDER_REDUCE_IS_POST_ONLY - Reduce orders can only be post only.
+     * 01111_0111 = 247
+     */
     ORDER_REDUCE_IS_POST_ONLY = 247,
-    /** ORDER_EXECUTION_SELL_PRICE - Order was rejected, because it planned under proposed price */
+    /**
+     * ORDER_EXECUTION_SELL_PRICE - Order was rejected, because it planned under proposed price
+     * 01111_1000 = 248
+     */
     ORDER_EXECUTION_SELL_PRICE = 248,
+    /** ATOMICS_TRADES_CANNOT_FOLLOW_PLACES - 10000_0000 */
+    ATOMICS_TRADES_CANNOT_FOLLOW_PLACES = 256,
+    /** ATOMICS_CANCELS_CANNOT_FOLLOW_TRADES_PLACES - 10000_0001 */
+    ATOMICS_CANCELS_CANNOT_FOLLOW_TRADES_PLACES = 257,
     NOT_IMPLEMENTED = 500,
     Dropped = 999
 }
@@ -209,13 +221,6 @@ export declare enum SpecialAccount {
 }
 export declare function specialAccountFromJSON(object: any): SpecialAccount;
 export declare function specialAccountToJSON(object: SpecialAccount): string;
-/** Emulation of 128-bit integers since Protobuf doesn't have native support */
-export interface U128 {
-    /** Low 64-bit word */
-    lo: bigint;
-    /** High 64-bit word */
-    hi: bigint;
-}
 export interface Market {
     marketId: number;
     priceDecimals: number;
@@ -328,8 +333,8 @@ export interface Action {
         $case: "takePosition";
         value: Action_TakePosition;
     } | {
-        $case: "transaction";
-        value: Transaction;
+        $case: "atomic";
+        value: Atomic;
     } | undefined;
 }
 export interface Action_CreateSession {
@@ -445,12 +450,8 @@ export interface Action_PlaceOrder {
      * `1` here equals to market's `10^-(size_decimals + price_decimals)`
      * When used in token balances and reward computations, shifted by market's
      * `size_decimals + price_decimals`. Optional, treated as not set if 0.
-     *
-     * NB: Requires 128-bit value because it can be seen as sum
-     * of order sizes multiplied by respective prices. Since size is up to 48
-     * bits and price is up to 64 bits, their product can easily exceed 64 bits.
      */
-    quoteSize: U128 | undefined;
+    quoteSize: QuoteSize | undefined;
     /**
      * Optional account on behalf of whom the order should be placed.
      * Executed only if sender has delegated authority to do so,
@@ -471,6 +472,11 @@ export interface Action_PlaceOrder {
      * if not specified, first account of session's owner user is picked
      */
     senderAccountId?: number | undefined;
+    /**
+     * Opaque identifier chosen by the sender to be able to correlate this
+     * place order requests with the corresponding fill and place order events.
+     */
+    senderTrackingId?: bigint | undefined;
 }
 export interface Action_CancelOrderById {
     sessionId: bigint;
@@ -584,7 +590,7 @@ export interface Action_TakePosition {
      */
     price?: bigint | undefined;
 }
-export interface TransactionKind {
+export interface AtomicSubactionKind {
     inner?: {
         $case: "tradeOrPlace";
         value: TradeOrPlace;
@@ -593,10 +599,10 @@ export interface TransactionKind {
         value: CancelOrder;
     } | undefined;
 }
-export interface Transaction {
+export interface Atomic {
     sessionId: bigint;
-    accountId?: bigint | undefined;
-    actions: TransactionKind[];
+    accountId?: number | undefined;
+    actions: AtomicSubactionKind[];
 }
 export interface Receipt {
     /**
@@ -662,6 +668,9 @@ export interface Receipt {
     } | {
         $case: "positionTakenOrTraded";
         value: Receipt_PositionTakenOrTradedResult;
+    } | {
+        $case: "atomic";
+        value: Receipt_AtomicResult;
     } | undefined;
 }
 export interface Receipt_Posted {
@@ -686,6 +695,7 @@ export interface Receipt_PlaceOrderResult {
     posted?: Receipt_Posted | undefined;
     fills: Receipt_Trade[];
     clientOrderId?: bigint | undefined;
+    senderTrackingId?: bigint | undefined;
 }
 export interface Receipt_TakenResult {
     pnl: bigint;
@@ -774,7 +784,24 @@ export interface Receipt_TriggerAdded {
 }
 export interface Receipt_TriggerRemoved {
 }
-export declare const U128: MessageFns<U128>;
+export interface Receipt_AtomicSubactionResultKind {
+    inner?: //
+    /**
+     * reusing existing messages -> way less code to change in nord, with some
+     * duplication of data unlike input, which is required to be very specific
+     * to be correct, receipts can be same to easy ingested into view and hist
+     */
+    {
+        $case: "placeOrderResult";
+        value: Receipt_PlaceOrderResult;
+    } | {
+        $case: "cancelOrder";
+        value: Receipt_CancelOrderResult;
+    } | undefined;
+}
+export interface Receipt_AtomicResult {
+    results: Receipt_AtomicSubactionResultKind[];
+}
 export declare const Market: MessageFns<Market>;
 export declare const Token: MessageFns<Token>;
 export declare const QuoteSize: MessageFns<QuoteSize>;
@@ -801,8 +828,8 @@ export declare const Action_Transfer: MessageFns<Action_Transfer>;
 export declare const Action_AddTrigger: MessageFns<Action_AddTrigger>;
 export declare const Action_RemoveTrigger: MessageFns<Action_RemoveTrigger>;
 export declare const Action_TakePosition: MessageFns<Action_TakePosition>;
-export declare const TransactionKind: MessageFns<TransactionKind>;
-export declare const Transaction: MessageFns<Transaction>;
+export declare const AtomicSubactionKind: MessageFns<AtomicSubactionKind>;
+export declare const Atomic: MessageFns<Atomic>;
 export declare const Receipt: MessageFns<Receipt>;
 export declare const Receipt_Posted: MessageFns<Receipt_Posted>;
 export declare const Receipt_Trade: MessageFns<Receipt_Trade>;
@@ -826,6 +853,8 @@ export declare const Receipt_Unpaused: MessageFns<Receipt_Unpaused>;
 export declare const Receipt_Transferred: MessageFns<Receipt_Transferred>;
 export declare const Receipt_TriggerAdded: MessageFns<Receipt_TriggerAdded>;
 export declare const Receipt_TriggerRemoved: MessageFns<Receipt_TriggerRemoved>;
+export declare const Receipt_AtomicSubactionResultKind: MessageFns<Receipt_AtomicSubactionResultKind>;
+export declare const Receipt_AtomicResult: MessageFns<Receipt_AtomicResult>;
 type Builtin = Date | Function | Uint8Array | string | number | boolean | bigint | undefined;
 export type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {
     $case: string;