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

package/.claude/settings.local.json

@@ -0,0 +1,11 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(rg:*)",
+      "Bash(grep:*)",
+      "Bash(npm run build:*)",
+      "Bash(bun run:*)"
+    ],
+    "deny": []
+  }
+}

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/package.json

@@ -1,21 +1,26 @@
 {
   "name": "@n1xyz/nord-ts",
-  "version": "0.0.18-8121ed05.0",
+  "version": "0.0.19",
   "description": "Typescript for Nord",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/n1xyz/nord.git"
-  },
   "keywords": [],
   "author": "",
   "license": "ISC",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "gen:proto": "nix run ..#nord-ts-proto ../engine/nord.proto src/gen/",
+    "gen:api": "nix run ..#nord-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",
+    "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"
+  },
   "devDependencies": {
-    "@jest/globals": "^29.7.0",
-    "@jest/types": "^29.6.3",
+    "@types/bun": "latest",
     "@types/google-protobuf": "^3.15.10",
-    "@types/jest": "^29.5.12",
     "@types/node": "^22.15.29",
     "@types/node-fetch": "^2.6.9",
     "@types/ws": "^8.5.10",
@@ -23,16 +28,15 @@
     "@typescript-eslint/parser": "^8.26.1",
     "eslint": "^9.22.0",
     "globals": "^16.0.0",
-    "jest": "^29.7.0",
+    "openapi-typescript": "^7.8.0",
     "prettier": "^3.5.3",
-    "ts-jest": "^29.1.4",
     "ts-node": "^10.9.2",
-    "ts-proto": "^2.7.0",
     "typedoc": "^0.27.9",
     "typescript": "*"
   },
   "dependencies": {
     "@bufbuild/protobuf": "^2.0.0",
+    "@n1xyz/proton": "0.0.0",
     "@noble/curves": "^1.3.0",
     "@noble/ed25519": "^2.2.3",
     "@noble/hashes": "^1.3.2",
@@ -42,19 +46,8 @@
     "decimal.js": "^10.4.3",
     "ethers": "^6.11.1",
     "node-fetch": "2.6.13",
+    "openapi-fetch": "^0.14.0",
     "tweetnacl": "^1.0.3",
-    "ws": "^8.16.0",
-    "@n1xyz/proton": "0.0.1-8121ed05.0"
-  },
-  "scripts": {
-    "dev": "nodemon --exec npx tsc",
-    "build:proto": "./protoc-generate.sh",
-    "build": "pnpm run build:proto && pnpm exec tsc && pnpm run docs",
-    "test": "pnpm exec jest",
-    "docs": "pnpm exec typedoc --out ./docs ./src",
-    "compile": "tsc",
-    "clean": "rm -rf ./src/gen ./dist ./docs",
-    "fmt": "prettier --write src tests",
-    "ci": "eslint && prettier --check src tests"
+    "ws": "^8.16.0"
   }
-}
+}

package/src/index.ts

@@ -1,21 +1,5 @@
-// Export types
 export * from "./types";
 export * from "./utils";
 export * from "./const";
-
-// Export Nord modules
 export * from "./nord";
-
-// Export WebSocket modules
 export * from "./websocket/index";
-
-// Re-export proton bridge functionality for backward compatibility
-export {
-  ProtonClient,
-  buildDepositTx,
-  createTokenAccountIfNeeded,
-  type DepositSplParams,
-  type WithdrawalParams,
-  type WithdrawalClaim,
-  type SPLTokenInfo,
-} from "@n1xyz/proton";

package/src/nord/api/actions.ts

@@ -3,15 +3,12 @@ import * as proto from "../../gen/nord";
 import { FillMode, fillModeToProtoFillMode, KeyType, Side } from "../../types";
 import {
   assert,
-  bigIntToProtoU128,
   BigIntValue,
   checkedFetch,
   checkPubKeyLength,
   decodeLengthDelimited,
   encodeLengthDelimited,
-  optMap,
   SESSION_TTL,
-  toScaledU128,
   toScaledU64,
 } from "../../utils";
 
@@ -35,6 +32,7 @@ function makeSendHttp(
   serverUrl: string,
 ): (encoded: Uint8Array) => Promise<Uint8Array> {
   return async (body) => {
+    // TODO: this should be changed to use openapi
     const response = await checkedFetch(`${serverUrl}/action`, {
       method: "POST",
       headers: {
@@ -271,15 +269,17 @@ async function placeOrderImpl(
     // NOTE: if `size` equals 1.0, it will sell whole unit, for example 1.0 BTC
     size?: Decimal.Value;
     price?: Decimal.Value;
-    quoteSize?: Decimal.Value;
+    quoteSizeSize?: Decimal.Value;
+    quoteSizePrice?: Decimal.Value;
     clientOrderId?: BigIntValue;
   },
 ): Promise<bigint | undefined> {
   const price = toScaledU64(params.price ?? 0, params.priceDecimals);
   const size = toScaledU64(params.size ?? 0, params.sizeDecimals);
-  const quoteSize = toScaledU128(
-    params.quoteSize ?? 0,
-    params.priceDecimals + params.sizeDecimals,
+  const quoteSize = toScaledU64(params.quoteSizeSize ?? 0, params.sizeDecimals);
+  const quotePrice = toScaledU64(
+    params.quoteSizePrice ?? 0,
+    params.priceDecimals,
   );
 
   // Compose action object
@@ -297,8 +297,11 @@ async function placeOrderImpl(
         isReduceOnly: params.isReduceOnly,
         price,
         size,
-        quoteSize: bigIntToProtoU128(quoteSize),
-        clientOrderId: optMap(params.clientOrderId, (x) => BigInt(x)),
+        quoteSize: { size: quoteSize, price: quotePrice },
+        clientOrderId:
+          params.clientOrderId === undefined
+            ? undefined
+            : BigInt(params.clientOrderId),
         delegatorAccountId: params.liquidateeId,
       },
     },
@@ -478,6 +481,124 @@ export async function transfer(
     params,
   );
 }
+
+export type AtomicSubaction =
+  | {
+      kind: "place";
+      // Market and order parameters – identical semantics to placeOrder()
+      marketId: number;
+      side: Side;
+      fillMode: FillMode;
+      isReduceOnly: boolean;
+      // decimals for scaling
+      sizeDecimals: number;
+      priceDecimals: number;
+      // at least one of the three has to be specified; 0 treated as "not set"
+      size?: Decimal.Value;
+      price?: Decimal.Value;
+      quoteSizeSize?: Decimal.Value;
+      quoteSizePrice?: Decimal.Value;
+      clientOrderId?: BigIntValue;
+    }
+  | {
+      kind: "cancel";
+      orderId: BigIntValue;
+    };
+
+async function atomicImpl(
+  sendFn: (encoded: Uint8Array) => Promise<Uint8Array>,
+  signFn: (message: Uint8Array) => Promise<Uint8Array>,
+  currentTimestamp: bigint,
+  nonce: number,
+  params: {
+    sessionId: BigIntValue;
+    accountId?: number;
+    actions: AtomicSubaction[];
+  },
+): Promise<proto.Receipt_AtomicResult> {
+  assert(
+    params.actions.length > 0 && params.actions.length <= 4,
+    "Atomic action must contain between 1 and 4 sub-actions",
+  );
+
+  const subactions: proto.AtomicSubactionKind[] = 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 quoteSizeSize = toScaledU64(a.quoteSizeSize ?? 0, a.sizeDecimals);
+      const quoteSizePrice = toScaledU64(
+        a.quoteSizePrice ?? 0,
+        a.priceDecimals,
+      );
+      const tradeOrPlace: proto.TradeOrPlace = {
+        marketId: a.marketId,
+        orderType: {
+          side: a.side === Side.Bid ? proto.Side.BID : proto.Side.ASK,
+          fillMode: fillModeToProtoFillMode(a.fillMode),
+          isReduceOnly: a.isReduceOnly,
+        },
+        limit: {
+          price,
+          size,
+          quoteSize: { size: quoteSizeSize, price: quoteSizePrice },
+        },
+        clientOrderId:
+          a.clientOrderId === undefined ? undefined : BigInt(a.clientOrderId),
+      };
+      return {
+        inner: { $case: "tradeOrPlace", value: tradeOrPlace },
+      } as proto.AtomicSubactionKind;
+    }
+    return {
+      inner: { $case: "cancelOrder", value: { orderId: BigInt(a.orderId) } },
+    } as proto.AtomicSubactionKind;
+  });
+
+  const action: proto.Action = {
+    currentTimestamp,
+    nonce,
+    kind: {
+      $case: "atomic",
+      value: {
+        sessionId: BigInt(params.sessionId),
+        accountId: params.accountId, // optional
+        actions: subactions,
+      },
+    },
+  };
+
+  const resp = await sendAction(
+    sendFn,
+    (m) => sessionSign(signFn, m),
+    action,
+    "execute atomic action",
+  );
+  if (resp.kind?.$case === "atomic") {
+    return resp.kind.value;
+  }
+  throw new Error(`Unexpected receipt kind ${resp.kind?.$case}`);
+}
+
+export async function atomic(
+  serverUrl: string,
+  signFn: (message: Uint8Array) => Promise<Uint8Array>,
+  currentTimestamp: bigint,
+  nonce: number,
+  params: {
+    sessionId: BigIntValue;
+    accountId?: number;
+    actions: AtomicSubaction[];
+  },
+): Promise<proto.Receipt_AtomicResult> {
+  return atomicImpl(
+    makeSendHttp(serverUrl),
+    signFn,
+    currentTimestamp,
+    nonce,
+    params,
+  );
+}
+
 /**
  * For testing purposes
  */
@@ -488,4 +609,5 @@ export const _private = {
   placeOrderImpl,
   cancelOrderImpl,
   transferImpl,
+  atomicImpl,
 };

package/src/nord/api/core.ts

@@ -3,77 +3,6 @@ import { checkedFetch } from "../../utils";
 import { NordWebSocketClient } from "../../websocket/index";
 import { NordError } from "../utils/NordError";
 
-/**
- * Get the current timestamp from the Nord server
- *
- * @param webServerUrl - Base URL for the Nord web server
- * @returns Current timestamp as a bigint
- * @throws {NordError} If the request fails
- */
-export async function getTimestamp(webServerUrl: string): Promise<bigint> {
-  try {
-    const response = await checkedFetch(`${webServerUrl}/timestamp`);
-    return BigInt(await response.json());
-  } catch (error) {
-    throw new NordError("Failed to get timestamp", { cause: error });
-  }
-}
-
-/**
- * Get the next action nonce from the Nord server
- *
- * @param webServerUrl - Base URL for the Nord web server
- * @returns Next action nonce
- * @throws {NordError} If the request fails
- */
-export async function getLastEventNonce(webServerUrl: string): Promise<number> {
-  try {
-    const response = await checkedFetch(
-      `${webServerUrl}/event/last-acked-nonce`,
-    );
-    const data = await response.json();
-    return data.nonce;
-  } catch (error) {
-    throw new NordError("Failed to get action nonce", { cause: error });
-  }
-}
-
-/**
- * Get information about the Nord server
- *
- * @param webServerUrl - Base URL for the Nord web server
- * @returns Information about markets and tokens
- * @throws {NordError} If the request fails
- */
-export async function getInfo(webServerUrl: string): Promise<Info> {
-  try {
-    const response = await checkedFetch(`${webServerUrl}/info`);
-    return await response.json();
-  } catch (error) {
-    throw new NordError("Failed to get info", { cause: error });
-  }
-}
-
-/**
- * Get account information
- *
- * @param webServerUrl - Base URL for the Nord web server
- * @param accountId - Account ID to get information for
- * @returns Account information
- * @throws {NordError} If the request fails
- */
-export async function getAccount(
-  webServerUrl: string,
-  accountId: number,
-): Promise<Account> {
-  try {
-    const response = await checkedFetch(`${webServerUrl}/account/${accountId}`);
-    return await response.json();
-  } catch (error) {
-    throw new NordError(`Failed to get account ${accountId}`, { cause: error });
-  }
-}
-
 /**
  * Initialize a WebSocket client for Nord
  *