@n1xyz/nord-ts 0.0.12 → 0.0.15

package/dist/nord/client/Nord.js

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Nord = void 0;
 const events_1 = require("events");
+const web3_js_1 = require("@solana/web3.js");
 const types_1 = require("../../types");
 const core = __importStar(require("../api/core"));
 const market = __importStar(require("../api/market"));
@@ -50,74 +51,80 @@ class Nord {
      *
      * @param config - Configuration options for the Nord client
      * @param config.webServerUrl - Base URL for the Nord web server
-     * @param config.solanaProgramId - Solana program ID
+     * @param config.bridgeVk - Bridge verification key
      * @param config.solanaUrl - Solana cluster URL
-     * @param config.initWebSockets - Whether to initialize WebSockets on creation, defaults to true
-     * @param config.tradesSubscriptions - Optional array of trades subscriptions to initialize with (e.g., ["trades@BTCUSDC"])
-     * @param config.deltasSubscriptions - Optional array of deltas subscriptions to initialize with (e.g., ["deltas@BTCUSDC"])
      * @throws {Error} If required configuration is missing
      */
-    constructor({ webServerUrl, solanaProgramId, solanaUrl, initWebSockets = true, tradesSubscriptions, deltasSubscriptions, }) {
+    constructor(config) {
         /** Available markets */
         this.markets = [];
         /** Available tokens */
         this.tokens = [];
         /** Map of symbol to market_id */
         this.symbolToMarketId = new Map();
-        /**
-         * WebSocket client for trades
-         * @private
-         */
-        this.tradesWs = null;
-        /**
-         * WebSocket client for orderbook deltas
-         * @private
-         */
-        this.deltasWs = null;
-        /**
-         * WebSocket client for user updates
-         * @private
-         */
-        this.userWs = null;
-        if (!webServerUrl) {
+        if (!config.webServerUrl) {
             throw new NordError_1.NordError("webServerUrl is required");
         }
-        if (!solanaProgramId) {
-            throw new NordError_1.NordError("solanaProgramId is required");
+        if (!config.bridgeVk) {
+            throw new NordError_1.NordError("bridgeVk is required");
         }
-        if (!solanaUrl) {
+        if (!config.solanaUrl) {
             throw new NordError_1.NordError("solanaUrl is required");
         }
-        this.webServerUrl = webServerUrl;
-        this.solanaProgramId = solanaProgramId;
-        this.solanaUrl = solanaUrl;
-        // Store subscription parameters
-        this.tradesSubscriptions = tradesSubscriptions;
-        this.deltasSubscriptions = deltasSubscriptions;
-        // Initialize WebSocket clients only if initWebSockets is true
-        if (initWebSockets) {
-            this.initializeWebSockets();
-        }
+        this.webServerUrl = config.webServerUrl;
+        this.bridgeVk = config.bridgeVk;
+        this.solanaUrl = config.solanaUrl;
     }
     /**
-     * Initialize WebSocket clients for trades and deltas
-     *
-     * This method can be called manually if websockets were not initialized during construction
-     * (i.e., if initWebSockets was set to false in the constructor).
-     *
-     * It initializes the trades and deltas WebSocket clients. The user WebSocket client
-     * is initialized on demand when needed.
-     *
-     * @param tradesSubscriptions - Optional array of trades subscriptions to initialize with
-     * @param deltasSubscriptions - Optional array of deltas subscriptions to initialize with
+     * Create a WebSocket client with specific subscriptions
+     *
+     * @param options - Subscription options that specify which data streams to subscribe to
+     * @returns A new WebSocket client with the requested subscriptions
+     * @throws {NordError} If invalid subscription options are provided
+     *
+     * @example
+     * // Create a client for trades and deltas from one market and an account
+     * const wsClient = nord.createWebSocketClient({
+     *   trades: ["BTCUSDC"],
+     *   deltas: ["BTCUSDC"],
+     *   accounts: [123]
+     * });
+     *
+     * @example
+     * // Create a client for trades from multiple markets
+     * const tradesClient = nord.createWebSocketClient({
+     *   trades: ["BTCUSDC", "ETHUSDC"]
+     * });
      */
-    initializeWebSockets(tradesSubscriptions, deltasSubscriptions) {
-        // Use provided subscriptions or fall back to stored ones
-        const trades = tradesSubscriptions || this.tradesSubscriptions;
-        const deltas = deltasSubscriptions || this.deltasSubscriptions;
-        // Initialize WebSocket clients for each endpoint with subscriptions
-        this.tradesWs = core.initWebSocketClient(this.webServerUrl, "trades", trades);
-        this.deltasWs = core.initWebSocketClient(this.webServerUrl, "deltas", deltas);
+    createWebSocketClient(options) {
+        const subscriptions = [];
+        // Add trade subscriptions
+        if (options.trades && options.trades.length > 0) {
+            options.trades.forEach((symbol) => {
+                subscriptions.push(`trades@${symbol}`);
+            });
+        }
+        // Add delta subscriptions
+        if (options.deltas && options.deltas.length > 0) {
+            options.deltas.forEach((symbol) => {
+                subscriptions.push(`deltas@${symbol}`);
+            });
+        }
+        // Add account subscriptions
+        if (options.accounts && options.accounts.length > 0) {
+            options.accounts.forEach((accountId) => {
+                if (isNaN(accountId) || accountId <= 0) {
+                    throw new NordError_1.NordError(`Invalid account ID: ${accountId}. Must be a positive number.`);
+                }
+                subscriptions.push(`account@${accountId}`);
+            });
+        }
+        // Validate that at least one subscription was provided
+        if (subscriptions.length === 0) {
+            throw new NordError_1.NordError("At least one subscription must be provided");
+        }
+        // Create and return a new WebSocket client
+        return core.initWebSocketClient(this.webServerUrl, subscriptions);
     }
     /**
      * Get the current timestamp from the Nord server
@@ -162,19 +169,42 @@ class Nord {
      *
      * @param nordConfig - Configuration options for the Nord client
      * @param nordConfig.webServerUrl - Base URL for the Nord web server
-     * @param nordConfig.solanaProgramId - Solana program ID
+     * @param nordConfig.bridgeVk - Bridge verification key
      * @param nordConfig.solanaUrl - Solana cluster URL
-     * @param nordConfig.initWebSockets - Whether to initialize WebSockets on creation, defaults to true
-     * @param nordConfig.tradesSubscriptions - Optional array of trades subscriptions (e.g., ["trades@BTCUSDC"])
-     * @param nordConfig.deltasSubscriptions - Optional array of deltas subscriptions (e.g., ["deltas@BTCUSDC"])
      * @returns Initialized Nord client
      * @throws {NordError} If initialization fails
      */
     static async initNord(nordConfig) {
         const nord = new Nord(nordConfig);
-        await nord.fetchNordInfo();
+        await nord.init();
         return nord;
     }
+    /**
+     * Initialize the Nord client by deriving program ID and fetching info
+     * @private
+     */
+    async init() {
+        const connection = new web3_js_1.Connection(this.solanaUrl);
+        const bridgeVkPubkey = new web3_js_1.PublicKey(this.bridgeVk);
+        const bridgeAccount = await connection.getAccountInfo(bridgeVkPubkey);
+        if (!bridgeAccount) {
+            throw new NordError_1.NordError(`Bridge account ${this.bridgeVk} not found`);
+        }
+        this._solanaProgramId = bridgeAccount.owner.toString();
+        await this.fetchNordInfo();
+    }
+    /**
+     * Get the Solana program ID derived from bridge VK
+     *
+     * @returns Program ID string
+     * @throws {NordError} If program ID hasn't been initialized
+     */
+    getSolanaProgramId() {
+        if (!this._solanaProgramId) {
+            throw new NordError_1.NordError("Solana program ID not initialized. Have you called Nord.initNord()?");
+        }
+        return this._solanaProgramId;
+    }
     /**
      * Get market statistics
      *
@@ -294,79 +324,31 @@ class Nord {
     async queryPrometheus(params) {
         return metrics.queryPrometheus(this.webServerUrl, params);
     }
-    /**
-     * Get the trades WebSocket client (default)
-     * If not already initialized, it will be created
-     *
-     * @returns WebSocket client for trades
-     */
-    getWebSocketClient() {
-        if (!this.tradesWs) {
-            this.initializeWebSockets();
-        }
-        return this.tradesWs;
-    }
-    /**
-     * Get the trades WebSocket client
-     * If not already initialized, it will be created
-     *
-     * @returns WebSocket client for trades
-     */
-    getTradesWebSocketClient() {
-        if (!this.tradesWs) {
-            this.initializeWebSockets();
-        }
-        return this.tradesWs;
-    }
-    /**
-     * Get the deltas WebSocket client
-     * If not already initialized, it will be created
-     *
-     * @returns WebSocket client for orderbook deltas
-     */
-    getDeltasWebSocketClient() {
-        if (!this.deltasWs) {
-            this.initializeWebSockets();
-        }
-        return this.deltasWs;
-    }
-    /**
-     * Get the user WebSocket client
-     * If not already initialized, it will be created
-     *
-     * @returns WebSocket client for user updates
-     */
-    getUserWebSocketClient() {
-        if (!this.userWs) {
-            // Initialize user WebSocket client on demand
-            this.userWs = core.initWebSocketClient(this.webServerUrl, "user");
-            return this.userWs;
-        }
-        return this.userWs;
-    }
     /**
      * Subscribe to orderbook updates for a market
      *
      * @param symbol - Market symbol
      * @returns Orderbook subscription
+     * @throws {NordError} If symbol is invalid
      */
     subscribeOrderbook(symbol) {
+        if (!symbol || typeof symbol !== "string") {
+            throw new NordError_1.NordError("Invalid market symbol");
+        }
         const subscription = new events_1.EventEmitter();
+        const wsClient = this.createWebSocketClient({
+            deltas: [symbol],
+        });
         const handleDelta = (update) => {
             if (update.symbol !== symbol) {
                 return;
             }
             subscription.emit("message", update);
         };
-        // Initialize deltas websocket if it doesn't exist
-        if (!this.deltasWs) {
-            this.initializeWebSockets();
-        }
-        this.deltasWs.on("delta", handleDelta);
-        this.deltasWs.subscribe([`deltas@${symbol}`]);
+        wsClient.on("delta", handleDelta);
         subscription.close = () => {
-            this.deltasWs.unsubscribe([`deltas@${symbol}`]);
-            this.deltasWs.removeListener("delta", handleDelta);
+            wsClient.unsubscribe([`deltas@${symbol}`]);
+            wsClient.removeListener("delta", handleDelta);
             subscription.removeAllListeners();
         };
         return subscription;
@@ -376,24 +358,55 @@ class Nord {
      *
      * @param symbol - Market symbol
      * @returns Trade subscription
+     * @throws {NordError} If symbol is invalid
      */
     subscribeTrades(symbol) {
+        if (!symbol || typeof symbol !== "string") {
+            throw new NordError_1.NordError("Invalid market symbol");
+        }
         const subscription = new events_1.EventEmitter();
+        const wsClient = this.createWebSocketClient({
+            trades: [symbol],
+        });
         const handleTrade = (update) => {
             if (update.symbol !== symbol) {
                 return;
             }
             subscription.emit("message", update);
         };
-        // Initialize trades websocket if it doesn't exist
-        if (!this.tradesWs) {
-            this.initializeWebSockets();
+        wsClient.on("trades", handleTrade);
+        subscription.close = () => {
+            wsClient.unsubscribe([`trades@${symbol}`]);
+            wsClient.removeListener("trades", handleTrade);
+            subscription.removeAllListeners();
+        };
+        return subscription;
+    }
+    /**
+     * Subscribe to account updates
+     *
+     * @param accountId - Account ID to subscribe to
+     * @returns User subscription
+     * @throws {NordError} If accountId is invalid
+     */
+    subscribeAccount(accountId) {
+        if (isNaN(accountId) || accountId <= 0) {
+            throw new NordError_1.NordError("Invalid account ID");
         }
-        this.tradesWs.on("trade", handleTrade);
-        this.tradesWs.subscribe([`trades@${symbol}`]);
+        const subscription = new events_1.EventEmitter();
+        const wsClient = this.createWebSocketClient({
+            accounts: [accountId],
+        });
+        const handleAccountUpdate = (update) => {
+            if (update.account_id !== accountId) {
+                return;
+            }
+            subscription.emit("message", update);
+        };
+        wsClient.on("account", handleAccountUpdate);
         subscription.close = () => {
-            this.tradesWs.unsubscribe([`trades@${symbol}`]);
-            this.tradesWs.removeListener("trade", handleTrade);
+            wsClient.unsubscribe([`account@${accountId}`]);
+            wsClient.removeListener("account", handleAccountUpdate);
             subscription.removeAllListeners();
         };
         return subscription;
@@ -440,10 +453,6 @@ class Nord {
             }
             query = { market_id: marketId };
         }
-        // Ensure market_id is provided
-        if (query.market_id === undefined) {
-            throw new NordError_1.NordError("market_id is required for orderbook query");
-        }
         return market.getOrderbook(this.webServerUrl, query);
     }
     /**

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

@@ -64,15 +64,6 @@ export interface TransferParams {
     /** Destination account ID */
     toAccountId: number;
 }
-/**
- * Parameters for creating a new account
- */
-export interface CreateAccountParams {
-    /** Token ID for initial funding */
-    tokenId: number;
-    /** Initial funding amount */
-    amount: Decimal.Value;
-}
 /**
  * User class for interacting with the Nord protocol
  */
@@ -270,14 +261,6 @@ export declare class NordUser {
      * @throws {NordError} If the operation fails
      */
     transferToAccount(params: TransferParams): Promise<void>;
-    /**
-     * Create a new account
-     *
-     * @param params - Account creation parameters
-     * @returns New NordUser instance
-     * @throws {NordError} If the operation fails
-     */
-    createAccount(params: CreateAccountParams): Promise<NordUser>;
     /**
      * Helper function to retry a promise with exponential backoff
      *

package/dist/nord/client/NordUser.js

@@ -153,7 +153,7 @@ class NordUser {
     initBridgeClient() {
         if (!this.getSolanaPublicKey() ||
             !this.connection ||
-            !this.nord.solanaProgramId) {
+            !this.nord.getSolanaProgramId()) {
             throw new NordError_1.NordError("Solana public key, connection, and program ID are required to initialize bridge client");
         }
         // Create an Anchor wallet that uses walletSignFn for signing
@@ -176,9 +176,10 @@ class NordUser {
         // Initialize the bridge client
         this.bridgeClient = new client_1.SolanaBridgeClient({
             rpcUrl: this.connection.rpcEndpoint,
-            programId: this.nord.solanaProgramId,
+            programId: this.nord.getSolanaProgramId(),
             commitment: "confirmed",
             tokenInfos: this.splTokenInfos,
+            bridgeVk: this.nord.bridgeVk,
         }, wallet);
     }
     /**
@@ -276,9 +277,6 @@ class NordUser {
             const mint = new web3_js_1.PublicKey(tokenInfo.mint);
             // Get the user's token account
             const fromAccount = await this.getAssociatedTokenAccount(mint);
-            // Get the bridge's token account
-            const [authority] = await this.bridgeClient.findAuthorityPda();
-            const toAccount = await (0, spl_token_1.getAssociatedTokenAddress)(mint, authority, true, spl_token_1.TOKEN_2022_PROGRAM_ID);
             // Convert amount to BN with proper decimals
             const amountBN = (0, utils_2.toBN)(amount, tokenInfo.precision);
             // Deposit tokens
@@ -286,7 +284,6 @@ class NordUser {
                 amount: amountBN,
                 mint,
                 fromAccount,
-                toAccount,
             });
         }
         catch (error) {
@@ -372,7 +369,7 @@ class NordUser {
     async fetchInfo() {
         if (this.accountIds !== undefined) {
             const accountsData = await Promise.all(this.accountIds.map(async (accountId) => {
-                const response = await (0, utils_2.checkedFetch)(`${this.nord.webServerUrl}/account?account_id=${accountId}`);
+                const response = await (0, utils_2.checkedFetch)(`${this.nord.webServerUrl}/account/${accountId}`);
                 const accountData = (await response.json());
                 // Ensure we have the correct accountId
                 return {
@@ -547,34 +544,6 @@ class NordUser {
             throw new NordError_1.NordError("Failed to transfer tokens", { cause: error });
         }
     }
-    /**
-     * Create a new account
-     *
-     * @param params - Account creation parameters
-     * @returns New NordUser instance
-     * @throws {NordError} If the operation fails
-     */
-    async createAccount(params) {
-        try {
-            this.checkSessionValidity();
-            // Create a new keypair for the account
-            const keypair = web3_js_1.Keypair.generate();
-            // Create a new NordUser
-            const newUser = NordUser.fromPrivateKey(this.nord, keypair.secretKey, this.connection);
-            // Transfer initial funds
-            await this.transferToAccount({
-                to: newUser,
-                tokenId: params.tokenId,
-                amount: params.amount,
-                fromAccountId: (0, utils_2.optExpect)(this.accountIds?.[0], "No account ID"),
-                toAccountId: (0, utils_2.optExpect)(newUser.accountIds?.[0], "No account ID for new user"),
-            });
-            return newUser;
-        }
-        catch (error) {
-            throw new NordError_1.NordError("Failed to create account", { cause: error });
-        }
-    }
     /**
      * Helper function to retry a promise with exponential backoff
      *

package/dist/types.d.ts

@@ -15,23 +15,46 @@ export declare enum PeakTpsPeriodUnit {
     Month = "m",
     Year = "y"
 }
+/**
+ * Nord subscription type for trades or deltas
+ */
+export type SubscriptionType = "trades" | "deltas" | "account";
+/**
+ * Pattern for a valid Nord subscription
+ * Format should be: "<type>@<parameter>"
+ * Examples: "trades@BTCUSDC", "deltas@ETHUSDC", "account@42"
+ */
+export type SubscriptionPattern = `${SubscriptionType}@${string}` | string;
 /**
  * Configuration options for the Nord client
  */
 export interface NordConfig {
     /** Base URL for the Nord web server */
     webServerUrl: string;
-    /** Solana program ID */
-    solanaProgramId: string;
+    /** Bridge verification key */
+    bridgeVk: string;
     /** Solana cluster URL */
     solanaUrl: string;
     /** Whether to initialize WebSockets on creation, defaults to true */
     initWebSockets?: boolean;
-    /** Initial subscriptions for the trades WebSocket (e.g., ["trades@BTCUSDC"]) */
-    tradesSubscriptions?: string[];
-    /** Initial subscriptions for the deltas WebSocket (e.g., ["deltas@BTCUSDC"]) */
-    deltasSubscriptions?: string[];
+    /**
+     * Initial subscriptions for the trades WebSocket
+     * Supports both formats:
+     * - Legacy format: ["BTCUSDC", "ETHUSDC"]
+     * - New format: ["trades@BTCUSDC", "trades@ETHUSDC"]
+     */
+    tradesSubscriptions?: SubscriptionPattern[];
+    /**
+     * Initial subscriptions for the deltas WebSocket
+     * Supports both formats:
+     * - Legacy format: ["BTCUSDC", "ETHUSDC"]
+     * - New format: ["deltas@BTCUSDC", "deltas@ETHUSDC"]
+     */
+    deltasSubscriptions?: SubscriptionPattern[];
 }
+/**
+ * Configuration options for the Nord client
+ */
 export interface TokenInfo {
     address: string;
     precision: number;
@@ -355,22 +378,22 @@ export interface ActionNonceResponse {
 export declare enum WebSocketMessageType {
     Subscribe = "subscribe",
     Unsubscribe = "unsubscribe",
-    TradeUpdate = "trade",
+    TradeUpdate = "trades",
     DeltaUpdate = "delta",
-    UserUpdate = "user"
+    AccountUpdate = "account"
 }
 /**
  * WebSocket subscription request
  */
 export interface WebSocketSubscription {
-    type: WebSocketMessageType;
+    e: WebSocketMessageType;
     streams: string[];
 }
 /**
  * WebSocket trade update message
  */
 export interface WebSocketTradeUpdate {
-    type: WebSocketMessageType.TradeUpdate;
+    e: WebSocketMessageType.TradeUpdate;
     symbol: string;
     trades: Trade[];
     timestamp: number;
@@ -379,7 +402,7 @@ export interface WebSocketTradeUpdate {
  * WebSocket delta update message
  */
 export interface WebSocketDeltaUpdate {
-    type: WebSocketMessageType.DeltaUpdate;
+    e: WebSocketMessageType.DeltaUpdate;
     last_update_id: number;
     update_id: number;
     market_symbol: string;
@@ -390,11 +413,11 @@ export interface WebSocketDeltaUpdate {
 /**
  * WebSocket user update message
  */
-export interface WebSocketUserUpdate {
-    type: WebSocketMessageType.UserUpdate;
-    userId: number;
+export interface WebSocketAccountUpdate {
+    e: WebSocketMessageType.AccountUpdate;
+    accountId: number;
     account: Account;
     timestamp: number;
 }
-export type WebSocketMessage = WebSocketSubscription | WebSocketTradeUpdate | WebSocketDeltaUpdate | WebSocketUserUpdate;
+export type WebSocketMessage = WebSocketSubscription | WebSocketTradeUpdate | WebSocketDeltaUpdate | WebSocketAccountUpdate;
 export {};

package/dist/types.js

@@ -97,7 +97,7 @@ var WebSocketMessageType;
 (function (WebSocketMessageType) {
     WebSocketMessageType["Subscribe"] = "subscribe";
     WebSocketMessageType["Unsubscribe"] = "unsubscribe";
-    WebSocketMessageType["TradeUpdate"] = "trade";
+    WebSocketMessageType["TradeUpdate"] = "trades";
     WebSocketMessageType["DeltaUpdate"] = "delta";
-    WebSocketMessageType["UserUpdate"] = "user";
+    WebSocketMessageType["AccountUpdate"] = "account";
 })(WebSocketMessageType || (exports.WebSocketMessageType = WebSocketMessageType = {}));

package/dist/websocket/NordWebSocketClient.d.ts

@@ -4,9 +4,6 @@ import { NordWebSocketClientEvents } from "./events";
  * WebSocket client for Nord exchange
  *
  * This client connects to one of the specific Nord WebSocket endpoints:
- * - /ws/trades - For trade updates
- * - /ws/deltas - For orderbook delta updates
- * - /ws/user - For user-specific updates
  *
  * Each endpoint handles a specific type of data and subscriptions must match
  * the endpoint type (e.g., only 'trades@BTCUSDC' subscriptions are valid on

package/dist/websocket/NordWebSocketClient.js

@@ -7,16 +7,13 @@ exports.NordWebSocketClient = void 0;
 const ws_1 = __importDefault(require("ws"));
 const events_1 = require("events");
 const types_1 = require("../types");
-const VALID_STREAM_TYPES = ["trades", "deltas", "user"];
+const VALID_STREAM_TYPES = ["trades", "delta", "account"];
 // Constants for WebSocket readyState
 const WS_OPEN = 1;
 /**
  * WebSocket client for Nord exchange
  *
  * This client connects to one of the specific Nord WebSocket endpoints:
- * - /ws/trades - For trade updates
- * - /ws/deltas - For orderbook delta updates
- * - /ws/user - For user-specific updates
  *
  * Each endpoint handles a specific type of data and subscriptions must match
  * the endpoint type (e.g., only 'trades@BTCUSDC' subscriptions are valid on
@@ -64,8 +61,8 @@ class NordWebSocketClient extends events_1.EventEmitter {
         if (!VALID_STREAM_TYPES.includes(type)) {
             throw new Error(`Invalid stream type: ${type}. Valid types are: ${VALID_STREAM_TYPES.join(", ")}`);
         }
-        if (type === "user" && !/^\d+$/.test(params)) {
-            throw new Error(`Invalid user ID in stream: ${params}. Expected numeric ID`);
+        if (type === "account" && !/^\d+$/.test(params)) {
+            throw new Error(`Invalid account ID in stream: ${params}. Expected numeric ID`);
         }
     }
     /**
@@ -228,7 +225,7 @@ class NordWebSocketClient extends events_1.EventEmitter {
             return;
         }
         const message = {
-            type: types_1.WebSocketMessageType.Subscribe,
+            e: types_1.WebSocketMessageType.Subscribe,
             streams,
         };
         try {
@@ -266,7 +263,7 @@ class NordWebSocketClient extends events_1.EventEmitter {
             return;
         }
         const message = {
-            type: types_1.WebSocketMessageType.Unsubscribe,
+            e: types_1.WebSocketMessageType.Unsubscribe,
             streams,
         };
         try {
@@ -311,18 +308,18 @@ class NordWebSocketClient extends events_1.EventEmitter {
      * @param message WebSocket message
      */
     handleMessage(message) {
-        switch (message.type) {
+        switch (message.e) {
             case types_1.WebSocketMessageType.TradeUpdate:
-                this.emit("trade", message);
+                this.emit("trades", message);
                 break;
             case types_1.WebSocketMessageType.DeltaUpdate:
                 this.emit("delta", message);
                 break;
-            case types_1.WebSocketMessageType.UserUpdate:
-                this.emit("user", message);
+            case types_1.WebSocketMessageType.AccountUpdate:
+                this.emit("account", message);
                 break;
             default:
-                this.emit("error", new Error(`Unknown message type: ${message.type}`));
+                this.emit("error", new Error(`Unknown message type: ${message.e}`));
         }
     }
     /**

package/dist/websocket/events.d.ts

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