@n1xyz/nord-ts 0.0.20 → 0.0.22

package/dist/nord/api/actions.js

@@ -33,7 +33,6 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._private = void 0;
 exports.createSession = createSession;
 exports.revokeSession = revokeSession;
 exports.withdraw = withdraw;
@@ -41,9 +40,11 @@ exports.placeOrder = placeOrder;
 exports.cancelOrder = cancelOrder;
 exports.transfer = transfer;
 exports.atomic = atomic;
-const proto = __importStar(require("../../gen/nord"));
+const proto = __importStar(require("../../gen/nord_pb"));
+const protobuf_1 = require("@bufbuild/protobuf");
 const types_1 = require("../../types");
 const utils_1 = require("../../utils");
+const wire_1 = require("@bufbuild/protobuf/wire");
 async function sessionSign(signFn, message) {
     const signature = await signFn(message);
     return new Uint8Array([...message, ...signature]);
@@ -52,30 +53,38 @@ async function walletSign(walletSignFn, message) {
     const signature = await walletSignFn(message);
     return new Uint8Array([...message, ...signature]);
 }
-function makeSendHttp(serverUrl) {
-    return async (body) => {
-        // TODO: this should be changed to use openapi
-        const response = await (0, utils_1.checkedFetch)(`${serverUrl}/action`, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-            },
-            body,
-        });
-        return new Uint8Array(await response.arrayBuffer());
-    };
+// Helper to create an action with common fields
+function createAction(currentTimestamp, nonce, kind) {
+    return (0, protobuf_1.create)(proto.ActionSchema, {
+        currentTimestamp,
+        nonce,
+        kind,
+    });
 }
-async function sendAction(sendFn, makeSignedMessage, action, actionErrorDesc) {
-    const encoded = (0, utils_1.encodeLengthDelimited)(action, proto.Action);
+async function sendAction(serverUrl, makeSignedMessage, action, actionErrorDesc) {
+    const encoded = (0, wire_1.sizeDelimitedEncode)(proto.ActionSchema, action);
+    // validate the payload size
+    const MAX_PAYLOAD_SIZE = 100 * 1024; // 100 kB
+    if (encoded.byteLength > MAX_PAYLOAD_SIZE) {
+        throw new Error(`Encoded message size (${encoded.byteLength} bytes) is greater than max payload size (${MAX_PAYLOAD_SIZE} bytes).`);
+    }
     const body = await makeSignedMessage(encoded);
-    const rawResp = await sendFn(body);
-    const resp = (0, utils_1.decodeLengthDelimited)(rawResp, proto.Receipt);
-    if (resp.kind?.$case === "err") {
-        throw new Error(`Could not ${actionErrorDesc}, reason: ${proto.errorToJSON(resp.kind.value)}`);
+    // TODO: this should be changed to use openapi
+    const response = await (0, utils_1.checkedFetch)(`${serverUrl}/action`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body,
+    });
+    const rawResp = new Uint8Array(await response.arrayBuffer());
+    const resp = (0, utils_1.decodeLengthDelimited)(rawResp, proto.ReceiptSchema);
+    if (resp.kind?.case === "err") {
+        throw new Error(`Could not ${actionErrorDesc}, reason: ${proto.Error[resp.kind.value]}`);
     }
     return resp;
 }
-async function createSessionImpl(sendFn, walletSignFn, currentTimestamp, nonce, params) {
+async function createSession(serverUrl, walletSignFn, currentTimestamp, nonce, params) {
     (0, utils_1.checkPubKeyLength)(types_1.KeyType.Ed25519, params.userPubkey.length);
     (0, utils_1.checkPubKeyLength)(types_1.KeyType.Ed25519, params.sessionPubkey.length);
     let expiry = 0n;
@@ -86,228 +95,198 @@ async function createSessionImpl(sendFn, walletSignFn, currentTimestamp, nonce,
     else {
         expiry = currentTimestamp + utils_1.SESSION_TTL;
     }
-    const action = {
-        currentTimestamp,
-        nonce,
-        kind: {
-            $case: "createSession",
-            value: {
-                userPubkey: params.userPubkey,
-                blstPubkey: params.sessionPubkey,
-                expiryTimestamp: expiry,
-            },
-        },
-    };
-    const resp = await sendAction(sendFn, (m) => walletSign(walletSignFn, m), action, "create a new session");
-    if (resp.kind?.$case === "createSessionResult") {
-        return resp.kind.value.sessionId;
+    const action = createAction(currentTimestamp, nonce, {
+        case: "createSession",
+        value: (0, protobuf_1.create)(proto.Action_CreateSessionSchema, {
+            userPubkey: params.userPubkey,
+            blstPubkey: params.sessionPubkey,
+            expiryTimestamp: expiry,
+        }),
+    });
+    const resp = await sendAction(serverUrl, (m) => walletSign(walletSignFn, m), action, "create a new session");
+    if (resp.kind?.case === "createSessionResult") {
+        return {
+            actionId: resp.actionId,
+            sessionId: resp.kind.value.sessionId,
+        };
     }
     else {
-        throw new Error(`Unexpected receipt kind ${resp.kind?.$case}`);
+        throw new Error(`Unexpected receipt kind ${resp.kind?.case}`);
     }
 }
-async function createSession(serverUrl, walletSignFn, currentTimestamp, nonce, params) {
-    return createSessionImpl(makeSendHttp(serverUrl), walletSignFn, currentTimestamp, nonce, params);
-}
-async function revokeSessionImpl(sendFn, walletSignFn, currentTimestamp, nonce, params) {
-    const action = {
-        currentTimestamp,
-        nonce,
-        kind: {
-            $case: "revokeSession",
-            value: {
-                sessionId: BigInt(params.sessionId),
-            },
-        },
-    };
-    await sendAction(sendFn, (m) => walletSign(walletSignFn, m), action, "create a new session");
-}
 async function revokeSession(serverUrl, walletSignFn, currentTimestamp, nonce, params) {
-    return revokeSessionImpl(makeSendHttp(serverUrl), walletSignFn, currentTimestamp, nonce, params);
+    const action = createAction(currentTimestamp, nonce, {
+        case: "revokeSession",
+        value: (0, protobuf_1.create)(proto.Action_RevokeSessionSchema, {
+            sessionId: BigInt(params.sessionId),
+        }),
+    });
+    const resp = await sendAction(serverUrl, (m) => walletSign(walletSignFn, m), action, "revoke session");
+    return { actionId: resp.actionId };
 }
-async function withdrawImpl(sendFn, signFn, currentTimestamp, nonce, params) {
+async function withdraw(serverUrl, signFn, currentTimestamp, nonce, params) {
     const amount = (0, utils_1.toScaledU64)(params.amount, params.sizeDecimals);
     if (amount <= 0) {
         throw new Error("Withdraw amount must be positive");
     }
-    const action = {
-        currentTimestamp,
-        nonce,
-        kind: {
-            $case: "withdraw",
-            value: {
-                sessionId: BigInt(params.sessionId),
-                tokenId: params.tokenId,
-                amount,
-            },
-        },
-    };
-    const resp = await sendAction(sendFn, (m) => sessionSign(signFn, m), action, "withdraw");
-    if (resp.kind?.$case === "withdrawResult") {
+    const action = createAction(currentTimestamp, nonce, {
+        case: "withdraw",
+        value: (0, protobuf_1.create)(proto.Action_WithdrawSchema, {
+            sessionId: BigInt(params.sessionId),
+            tokenId: params.tokenId,
+            amount,
+        }),
+    });
+    const resp = await sendAction(serverUrl, (m) => sessionSign(signFn, m), action, "withdraw");
+    if (resp.kind?.case === "withdrawResult") {
         return { actionId: resp.actionId, ...resp.kind.value };
     }
     else {
-        throw new Error(`Unexpected receipt kind ${resp.kind?.$case}`);
+        throw new Error(`Unexpected receipt kind ${resp.kind?.case}`);
     }
 }
-async function withdraw(serverUrl, signFn, currentTimestamp, nonce, params) {
-    return withdrawImpl(makeSendHttp(serverUrl), signFn, currentTimestamp, nonce, params);
-}
-async function placeOrderImpl(sendFn, signFn, currentTimestamp, nonce, params) {
+async function placeOrder(serverUrl, signFn, currentTimestamp, nonce, params) {
     const price = (0, utils_1.toScaledU64)(params.price ?? 0, params.priceDecimals);
     const size = (0, utils_1.toScaledU64)(params.size ?? 0, params.sizeDecimals);
-    const quoteSize = (0, utils_1.toScaledU64)(params.quoteSizeSize ?? 0, params.sizeDecimals);
-    const quotePrice = (0, utils_1.toScaledU64)(params.quoteSizePrice ?? 0, params.priceDecimals);
-    // Compose action object
-    const action = {
-        currentTimestamp,
-        nonce,
-        kind: {
-            $case: "placeOrder",
-            value: {
-                sessionId: BigInt(params.sessionId),
-                senderAccountId: params.senderId,
-                marketId: params.marketId,
-                side: params.side === types_1.Side.Bid ? proto.Side.BID : proto.Side.ASK,
-                fillMode: (0, types_1.fillModeToProtoFillMode)(params.fillMode),
-                isReduceOnly: params.isReduceOnly,
-                price,
-                size,
-                quoteSize: { size: quoteSize, price: quotePrice },
-                clientOrderId: params.clientOrderId === undefined
-                    ? undefined
-                    : BigInt(params.clientOrderId),
-                delegatorAccountId: params.liquidateeId,
-            },
-        },
-    };
-    const resp = await sendAction(sendFn, (m) => sessionSign(signFn, m), action, "place the order");
-    if (resp.kind?.$case === "placeOrderResult") {
-        return resp.kind.value.posted?.orderId;
+    const scaledQuote = params.quoteSize
+        ? params.quoteSize.toScaledU64(params.priceDecimals, params.sizeDecimals)
+        : undefined;
+    const action = createAction(currentTimestamp, nonce, {
+        case: "placeOrder",
+        value: (0, protobuf_1.create)(proto.Action_PlaceOrderSchema, {
+            sessionId: BigInt(params.sessionId),
+            senderAccountId: params.senderId,
+            marketId: params.marketId,
+            side: params.side === types_1.Side.Bid ? proto.Side.BID : proto.Side.ASK,
+            fillMode: (0, types_1.fillModeToProtoFillMode)(params.fillMode),
+            isReduceOnly: params.isReduceOnly,
+            price,
+            size,
+            quoteSize: scaledQuote === undefined
+                ? undefined
+                : (0, protobuf_1.create)(proto.QuoteSizeSchema, {
+                    size: scaledQuote.size,
+                    price: scaledQuote.price,
+                }),
+            clientOrderId: params.clientOrderId === undefined
+                ? undefined
+                : BigInt(params.clientOrderId),
+            delegatorAccountId: params.liquidateeId,
+        }),
+    });
+    const resp = await sendAction(serverUrl, (m) => sessionSign(signFn, m), action, "place order");
+    if (resp.kind?.case === "placeOrderResult") {
+        return {
+            actionId: resp.actionId,
+            orderId: resp.kind.value.posted?.orderId,
+            fills: resp.kind.value.fills,
+        };
     }
     else {
-        throw new Error(`Unexpected receipt kind ${resp.kind?.$case}`);
+        throw new Error(`Unexpected receipt kind ${resp.kind?.case}`);
     }
 }
-async function placeOrder(serverUrl, signFn, currentTimestamp, nonce, params) {
-    return placeOrderImpl(makeSendHttp(serverUrl), signFn, currentTimestamp, nonce, params);
-}
-async function cancelOrderImpl(sendFn, signFn, currentTimestamp, nonce, params) {
-    const action = {
-        currentTimestamp,
-        nonce: nonce,
-        kind: {
-            $case: "cancelOrderById",
-            value: {
-                orderId: BigInt(params.orderId),
-                sessionId: BigInt(params.sessionId),
-                senderAccountId: params.senderId,
-                delegatorAccountId: params.liquidateeId,
-            },
-        },
-    };
-    const resp = await sendAction(sendFn, (m) => sessionSign(signFn, m), action, "cancel the order");
-    if (resp.kind?.$case === "cancelOrderResult") {
-        return resp.kind.value.orderId;
+async function cancelOrder(serverUrl, signFn, currentTimestamp, nonce, params) {
+    const action = createAction(currentTimestamp, nonce, {
+        case: "cancelOrderById",
+        value: (0, protobuf_1.create)(proto.Action_CancelOrderByIdSchema, {
+            orderId: BigInt(params.orderId),
+            sessionId: BigInt(params.sessionId),
+            senderAccountId: params.senderId,
+            delegatorAccountId: params.liquidateeId,
+        }),
+    });
+    const resp = await sendAction(serverUrl, (m) => sessionSign(signFn, m), action, "cancel order");
+    if (resp.kind?.case === "cancelOrderResult") {
+        return {
+            actionId: resp.actionId,
+            orderId: resp.kind.value.orderId,
+            accountId: resp.kind.value.accountId,
+        };
     }
     else {
-        throw new Error(`Unexpected receipt kind ${resp.kind?.$case}`);
+        throw new Error(`Unexpected receipt kind ${resp.kind?.case}`);
     }
 }
-async function cancelOrder(serverUrl, signFn, currentTimestamp, nonce, params) {
-    return cancelOrderImpl(makeSendHttp(serverUrl), signFn, currentTimestamp, nonce, params);
-}
-async function transferImpl(sendFn, signFn, currentTimestamp, nonce, params) {
-    const action = {
-        currentTimestamp,
-        nonce: nonce,
-        kind: {
-            $case: "transfer",
-            value: {
-                sessionId: BigInt(params.sessionId),
-                fromAccountId: params.fromAccountId,
-                toAccountId: params.toAccountId,
-                tokenId: params.tokenId,
-                amount: (0, utils_1.toScaledU64)(params.amount ?? 0, params.tokenDecimals),
-            },
-        },
-    };
-    const resp = await sendAction(sendFn, (m) => sessionSign(signFn, m), action, "transfer asset to other account");
-    if (resp.kind?.$case === "transferred") {
-        if (resp.kind.value.accountCreated) {
-            return resp.kind.value.toUserAccount;
-        }
-        else {
-            return undefined;
-        }
+async function transfer(serverUrl, signFn, currentTimestamp, nonce, params) {
+    const action = createAction(currentTimestamp, nonce, {
+        case: "transfer",
+        value: (0, protobuf_1.create)(proto.Action_TransferSchema, {
+            sessionId: BigInt(params.sessionId),
+            fromAccountId: params.fromAccountId,
+            toAccountId: params.toAccountId,
+            tokenId: params.tokenId,
+            amount: (0, utils_1.toScaledU64)(params.amount ?? 0, params.tokenDecimals),
+        }),
+    });
+    const resp = await sendAction(serverUrl, (m) => sessionSign(signFn, m), action, "transfer");
+    if (resp.kind?.case === "transferred") {
+        return {
+            actionId: resp.actionId,
+            fromAccountId: resp.kind.value.fromAccountId,
+            toAccountId: resp.kind.value.toUserAccount,
+            tokenId: resp.kind.value.tokenId,
+            amount: resp.kind.value.amount,
+            accountCreated: resp.kind.value.accountCreated,
+        };
     }
     else {
-        throw new Error(`Unexpected receipt kind ${resp.kind?.$case}`);
+        throw new Error(`Unexpected receipt kind ${resp.kind?.case}`);
     }
 }
-async function transfer(serverUrl, signFn, currentTimestamp, nonce, params) {
-    return transferImpl(makeSendHttp(serverUrl), signFn, currentTimestamp, nonce, params);
-}
-async function atomicImpl(sendFn, signFn, currentTimestamp, nonce, params) {
+async function atomic(serverUrl, signFn, currentTimestamp, nonce, params) {
     (0, utils_1.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 = (0, utils_1.toScaledU64)(a.price ?? 0, a.priceDecimals);
             const size = (0, utils_1.toScaledU64)(a.size ?? 0, a.sizeDecimals);
-            const quoteSizeSize = (0, utils_1.toScaledU64)(a.quoteSizeSize ?? 0, a.sizeDecimals);
-            const quoteSizePrice = (0, utils_1.toScaledU64)(a.quoteSizePrice ?? 0, a.priceDecimals);
-            const tradeOrPlace = {
+            const scaledQuote = a.quoteSize
+                ? a.quoteSize.toScaledU64(a.priceDecimals, a.sizeDecimals)
+                : undefined;
+            const tradeOrPlace = (0, protobuf_1.create)(proto.TradeOrPlaceSchema, {
                 marketId: a.marketId,
-                orderType: {
+                orderType: (0, protobuf_1.create)(proto.OrderTypeSchema, {
                     side: a.side === types_1.Side.Bid ? proto.Side.BID : proto.Side.ASK,
                     fillMode: (0, types_1.fillModeToProtoFillMode)(a.fillMode),
                     isReduceOnly: a.isReduceOnly,
-                },
-                limit: {
+                }),
+                limit: (0, protobuf_1.create)(proto.OrderLimitSchema, {
                     price,
                     size,
-                    quoteSize: { size: quoteSizeSize, price: quoteSizePrice },
-                },
+                    quoteSize: scaledQuote === undefined
+                        ? undefined
+                        : (0, protobuf_1.create)(proto.QuoteSizeSchema, {
+                            size: scaledQuote.size,
+                            price: scaledQuote.price,
+                        }),
+                }),
                 clientOrderId: a.clientOrderId === undefined ? undefined : BigInt(a.clientOrderId),
-            };
-            return {
-                inner: { $case: "tradeOrPlace", value: tradeOrPlace },
-            };
+            });
+            return (0, protobuf_1.create)(proto.AtomicSubactionKindSchema, {
+                inner: { case: "tradeOrPlace", value: tradeOrPlace },
+            });
         }
+        return (0, protobuf_1.create)(proto.AtomicSubactionKindSchema, {
+            inner: {
+                case: "cancelOrder",
+                value: (0, protobuf_1.create)(proto.CancelOrderSchema, { orderId: BigInt(a.orderId) }),
+            },
+        });
+    });
+    const action = createAction(currentTimestamp, nonce, {
+        case: "atomic",
+        value: (0, protobuf_1.create)(proto.AtomicSchema, {
+            sessionId: BigInt(params.sessionId),
+            accountId: params.accountId, // optional
+            actions: subactions,
+        }),
+    });
+    const resp = await sendAction(serverUrl, (m) => sessionSign(signFn, m), action, "execute atomic action");
+    if (resp.kind?.case === "atomic") {
         return {
-            inner: { $case: "cancelOrder", value: { orderId: BigInt(a.orderId) } },
+            actionId: resp.actionId,
+            results: resp.kind.value.results,
         };
-    });
-    const 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}`);
-}
-async function atomic(serverUrl, signFn, currentTimestamp, nonce, params) {
-    return atomicImpl(makeSendHttp(serverUrl), signFn, currentTimestamp, nonce, params);
+    throw new Error(`Unexpected receipt kind ${resp.kind?.case}`);
 }
-/**
- * For testing purposes
- */
-exports._private = {
-    createSessionImpl,
-    revokeSessionImpl,
-    withdrawImpl,
-    placeOrderImpl,
-    cancelOrderImpl,
-    transferImpl,
-    atomicImpl,
-};

package/dist/nord/api/core.d.ts

@@ -13,4 +13,4 @@ import { NordWebSocketClient } from "../../websocket/index";
  * @returns WebSocket client
  * @throws {NordError} If initialization fails or invalid subscription is provided
  */
-export declare function initWebSocketClient(webServerUrl: string, subscriptions?: SubscriptionPattern[] | "trades" | "delta" | "account", initialSubscriptions?: SubscriptionPattern[]): NordWebSocketClient;
+export declare function initWebSocketClient(webServerUrl: string, subscriptions?: SubscriptionPattern[] | "trades" | "delta" | "account"): NordWebSocketClient;

package/dist/nord/api/core.js

@@ -16,11 +16,10 @@ const NordError_1 = require("../utils/NordError");
  * @returns WebSocket client
  * @throws {NordError} If initialization fails or invalid subscription is provided
  */
-function initWebSocketClient(webServerUrl, subscriptions, initialSubscriptions) {
+function initWebSocketClient(webServerUrl, subscriptions) {
     try {
         // Determine URL and subscriptions based on parameters
         let wsUrl = webServerUrl.replace(/^http/, "ws") + `/ws`;
-        let wsSubscriptions = [];
         // Validate subscriptions parameter
         if (typeof subscriptions === "string") {
             // Legacy mode - handle endpoint string
@@ -28,12 +27,6 @@ function initWebSocketClient(webServerUrl, subscriptions, initialSubscriptions)
                 subscriptions === "delta" ||
                 subscriptions === "account") {
                 wsUrl += `/${subscriptions}`;
-                // If initialSubscriptions provided, use them
-                if (initialSubscriptions && initialSubscriptions.length > 0) {
-                    // Validate initialSubscriptions
-                    initialSubscriptions.forEach(validateSubscription);
-                    wsSubscriptions = initialSubscriptions;
-                }
             }
             else {
                 throw new NordError_1.NordError(`Invalid endpoint: ${subscriptions}. Must be "trades", "deltas", or "account".`);
@@ -58,11 +51,6 @@ function initWebSocketClient(webServerUrl, subscriptions, initialSubscriptions)
         // Add connected handler for debugging
         ws.on("connected", () => {
             console.log("Nord WebSocket connected successfully");
-            // Subscribe to additional subscriptions if provided
-            // For new format, these are already part of the URL
-            if (wsSubscriptions.length > 0) {
-                ws.subscribe(wsSubscriptions);
-            }
         });
         // Connect the WebSocket
         ws.connect();

package/dist/nord/client/Nord.d.ts

@@ -1,7 +1,7 @@
-import { EventEmitter } from "events";
-import { PublicKey } from "@solana/web3.js";
-import { Info, Account, ActionResponse, AggregateMetrics, Market, NordConfig, OrderbookQuery, OrderbookResponse, PeakTpsPeriodUnit, Token, TradesResponse, User, MarketStats } from "../../types";
 import { ProtonClient } from "@n1xyz/proton";
+import { PublicKey } from "@solana/web3.js";
+import { EventEmitter } from "events";
+import { Account, ActionResponse, AggregateMetrics, Info, Market, MarketStats, NordConfig, OrderbookQuery, OrderbookResponse, PeakTpsPeriodUnit, Token, TradesResponse, User } from "../../types";
 import { NordWebSocketClient } from "../../websocket/index";
 import { OrderbookSubscription, TradeSubscription } from "../models/Subscriber";
 /**

package/dist/nord/client/Nord.js

@@ -37,15 +37,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Nord = void 0;
-const events_1 = require("events");
+const proton_1 = require("@n1xyz/proton");
 const web3_js_1 = require("@solana/web3.js");
+const events_1 = require("events");
 const openapi_fetch_1 = __importDefault(require("openapi-fetch"));
+const proto = __importStar(require("../../gen/nord_pb"));
 const types_1 = require("../../types");
-const proton_1 = require("@n1xyz/proton");
-const proto = __importStar(require("../../gen/nord"));
+const utils = __importStar(require("../../utils"));
 const core = __importStar(require("../api/core"));
 const metrics = __importStar(require("../api/metrics"));
-const utils = __importStar(require("../../utils"));
 const NordError_1 = require("../utils/NordError");
 /**
  * Main Nord client class for interacting with the Nord API
@@ -240,8 +240,8 @@ class Nord {
         });
         return xs.map((x) => ({
             actionId: x.actionId,
-            action: utils.decodeLengthDelimited(Buffer.from(x.payload, "base64"), proto.Action),
-            physicalExecTime: new Date(x.physicalTime * 1000),
+            action: utils.decodeLengthDelimited(Buffer.from(x.payload, "base64"), proto.ActionSchema),
+            physicalExecTime: new Date(x.physicalTime),
         }));
     }
     /**
@@ -336,7 +336,6 @@ class Nord {
         };
         wsClient.on("delta", handleDelta);
         subscription.close = () => {
-            wsClient.unsubscribe([`deltas@${symbol}`]);
             wsClient.removeListener("delta", handleDelta);
             subscription.removeAllListeners();
         };
@@ -365,7 +364,6 @@ class Nord {
         };
         wsClient.on("trades", handleTrade);
         subscription.close = () => {
-            wsClient.unsubscribe([`trades@${symbol}`]);
             wsClient.removeListener("trades", handleTrade);
             subscription.removeAllListeners();
         };
@@ -394,7 +392,6 @@ class Nord {
         };
         wsClient.on("account", handleAccountUpdate);
         subscription.close = () => {
-            wsClient.unsubscribe([`account@${accountId}`]);
             wsClient.removeListener("account", handleAccountUpdate);
             subscription.removeAllListeners();
         };