@n1xyz/nord-ts 0.1.10 → 0.2.0

package/dist/actions.d.ts

@@ -4,7 +4,7 @@ import { paths } from "./gen/openapi";
 import { Client } from "openapi-fetch";
 import { FillMode, Side, QuoteSize } from "./types";
 import { BigIntValue } from "./utils";
-import { PublicKey, Transaction } from "@solana/web3.js";
+import { PublicKey } from "@solana/web3.js";
 type ReceiptKind = NonNullable<proto.Receipt["kind"]>;
 type ExtractReceiptKind<K extends ReceiptKind["case"]> = Extract<ReceiptKind, {
     case: K;
@@ -16,7 +16,7 @@ export declare function expectReceiptKind<K extends ReceiptKind["case"]>(receipt
 export declare function createAction(currentTimestamp: bigint, nonce: number, kind: proto.Action["kind"]): proto.Action;
 export declare function sendAction(client: Client<paths>, makeSignedMessage: (message: Uint8Array) => Promise<Uint8Array>, action: proto.Action): Promise<proto.Receipt>;
 export declare function prepareAction(action: proto.Action, makeSignedMessage: (message: Uint8Array) => Promise<Uint8Array>): Promise<Uint8Array<ArrayBufferLike>>;
-export declare function createSession(client: Client<paths>, signTransaction: (tx: Transaction) => Promise<Transaction>, currentTimestamp: bigint, nonce: number, params: {
+export declare function createSession(client: Client<paths>, signMessage: (_: Uint8Array) => Promise<Uint8Array>, currentTimestamp: bigint, nonce: number, params: {
     userPubkey: PublicKey;
     sessionPubkey: PublicKey;
     expiryTimestamp?: bigint;
@@ -24,9 +24,8 @@ export declare function createSession(client: Client<paths>, signTransaction: (t
     actionId: bigint;
     sessionId: bigint;
 }>;
-export declare function revokeSession(client: Client<paths>, signTransaction: (tx: Transaction) => Promise<Transaction>, currentTimestamp: bigint, nonce: number, params: {
+export declare function revokeSession(client: Client<paths>, signMessage: (_: Uint8Array) => Promise<Uint8Array>, currentTimestamp: bigint, nonce: number, params: {
     sessionId: BigIntValue;
-    userPubkey: PublicKey;
 }): Promise<{
     actionId: bigint;
 }>;

package/dist/actions.js

@@ -70,7 +70,7 @@ export async function prepareAction(action, makeSignedMessage) {
     }
     return body;
 }
-export async function createSession(client, signTransaction, currentTimestamp, nonce, params) {
+export async function createSession(client, signMessage, currentTimestamp, nonce, params) {
     let expiry = 0n;
     if (params.expiryTimestamp !== undefined) {
         expiry = params.expiryTimestamp;
@@ -92,8 +92,7 @@ export async function createSession(client, signTransaction, currentTimestamp, n
             ...payload,
             ...(await signUserPayload({
                 payload,
-                user: params.userPubkey,
-                signTransaction,
+                signMessage,
             })),
         ]);
     }, action);
@@ -107,7 +106,7 @@ export async function createSession(client, signTransaction, currentTimestamp, n
         throw new Error(`Unexpected receipt kind ${resp.kind?.case}`);
     }
 }
-export async function revokeSession(client, signTransaction, currentTimestamp, nonce, params) {
+export async function revokeSession(client, signMessage, currentTimestamp, nonce, params) {
     const action = createAction(currentTimestamp, nonce, {
         case: "revokeSession",
         value: create(proto.Action_RevokeSessionSchema, {
@@ -119,8 +118,7 @@ export async function revokeSession(client, signTransaction, currentTimestamp, n
             ...payload,
             ...(await signUserPayload({
                 payload,
-                user: params.userPubkey,
-                signTransaction,
+                signMessage,
             })),
         ]);
     }, action);

package/dist/client/Nord.d.ts

@@ -3,7 +3,7 @@ import { Connection, PublicKey } from "@solana/web3.js";
 import { EventEmitter } from "events";
 import { Client } from "openapi-fetch";
 import type { paths } from "../gen/openapi.ts";
-import { Account, AccountPnlPage, AccountPnlQuery, ActionResponse, MarketsInfo, Market, MarketStats, NordConfig, OrderbookQuery, OrderbookResponse, FeeTierConfig, Token, TradesResponse, User, AccountTriggerInfo, HistoryTriggerQuery, TriggerHistoryPage, FeeTierId, AccountFeeTierPage, PageResultStringOrderInfo, PageResultStringTrade, OrderInfoFromApi, TokenStats, FillRole, AdminInfo, AccountVolumeInfo, GetAccountVolumeQuery } from "../types";
+import { Account, AccountPnlInfoPage, PagedQuery, ActionResponse, MarketsInfo, Market, MarketStats, NordConfig, OrderbookQuery, OrderbookResponse, FeeTierConfig, Token, TradesResponse, User, AccountTriggerInfo, TriggerHistoryPage, WithdrawalHistoryPage, FeeTierId, AccountFeeTierPage, PageResultStringOrderInfo, PageResultStringTrade, OrderInfoFromApi, TokenStats, FillRole, AdminInfo, AccountVolumeInfo, GetAccountVolumeQuery, PreviousMarketPrice } from "../types";
 import { NordWebSocketClient } from "../websocket/index";
 import { OrderbookSubscription, TradeSubscription } from "../websocket/Subscriber";
 /**
@@ -302,7 +302,7 @@ export declare class Nord {
      * @returns Page of PnL entries ordered from latest to oldest
      * @throws {NordError} If the request fails
      */
-    getAccountPnl(accountId: number, { since, until, startInclusive, pageSize, }?: Readonly<Partial<AccountPnlQuery>>): Promise<AccountPnlPage>;
+    getAccountPnl(accountId: number, { since, until, startInclusive, pageSize, }?: Readonly<Partial<PagedQuery>>): Promise<AccountPnlInfoPage>;
     /**
      * Get market statistics (alias for marketsStats for backward compatibility)
      *
@@ -328,6 +328,18 @@ export declare class Nord {
         feeKind: FillRole;
         accountId: number;
     }>): Promise<number>;
+    /**
+     * Fetch the latest available market price at or before the given timestamp.
+     *
+     * @param marketId - Market identifier
+     * @param atOrBefore - RFC3339 timestamp to look back from (returns the latest price at or before this time)
+     * @returns Previous market price record; price is `null` if no trades exist at or before `at`
+     * @throws {NordError} If the request fails
+     */
+    getPrevMarketPrice({ marketId, atOrBefore, }: Readonly<{
+        marketId: number;
+        atOrBefore: string;
+    }>): Promise<PreviousMarketPrice>;
     /**
      * Fetch token statistics such as index price and oracle metadata.
      *
@@ -384,7 +396,20 @@ export declare class Nord {
      * @param startInclusive - Pagination cursor to resume from
      * @throws {NordError} If no account can be resolved or the request fails.
      */
-    getAccountTriggerHistory({ accountId, since, until, pageSize, startInclusive, }: Readonly<HistoryTriggerQuery & {
+    getAccountTriggerHistory({ accountId, since, until, pageSize, startInclusive, }: Readonly<PagedQuery & {
         accountId?: number;
     }>): Promise<TriggerHistoryPage>;
+    /**
+     * Fetch withdrawal history for an account.
+     *
+     * @param accountId - Account identifier owning the withdrawals
+     * @param since - RFC3339 timestamp to start from (inclusive)
+     * @param until - RFC3339 timestamp to end at (exclusive)
+     * @param pageSize - Maximum number of entries to return
+     * @param startInclusive - Pagination cursor to resume from
+     * @throws {NordError} If no account can be resolved or the request fails.
+     */
+    getAccountWithdrawalHistory({ accountId, since, until, pageSize, startInclusive, }: Readonly<PagedQuery & {
+        accountId?: number;
+    }>): Promise<WithdrawalHistoryPage>;
 }

package/dist/client/Nord.js

@@ -265,7 +265,7 @@ export class Nord {
             deltas: [symbol],
         });
         const handleDelta = (update) => {
-            if (update.symbol !== symbol) {
+            if (update.market_symbol !== symbol) {
                 return;
             }
             subscription.emit("message", update);
@@ -592,6 +592,24 @@ export class Nord {
             },
         });
     }
+    /**
+     * Fetch the latest available market price at or before the given timestamp.
+     *
+     * @param marketId - Market identifier
+     * @param atOrBefore - RFC3339 timestamp to look back from (returns the latest price at or before this time)
+     * @returns Previous market price record; price is `null` if no trades exist at or before `at`
+     * @throws {NordError} If the request fails
+     */
+    async getPrevMarketPrice({ marketId, atOrBefore, }) {
+        return await this.GET("/market/{market_id}/price/prev", {
+            params: {
+                path: { market_id: marketId },
+                query: {
+                    atOrBefore,
+                },
+            },
+        });
+    }
     /**
      * Fetch token statistics such as index price and oracle metadata.
      *
@@ -705,4 +723,37 @@ export class Nord {
             });
         }
     }
+    /**
+     * Fetch withdrawal history for an account.
+     *
+     * @param accountId - Account identifier owning the withdrawals
+     * @param since - RFC3339 timestamp to start from (inclusive)
+     * @param until - RFC3339 timestamp to end at (exclusive)
+     * @param pageSize - Maximum number of entries to return
+     * @param startInclusive - Pagination cursor to resume from
+     * @throws {NordError} If no account can be resolved or the request fails.
+     */
+    async getAccountWithdrawalHistory({ accountId, since, until, pageSize, startInclusive, }) {
+        if (accountId == null) {
+            throw new NordError("Account ID is undefined. Make sure to call updateAccountId() before requesting withdrawal history.");
+        }
+        try {
+            return await this.GET("/account/{account_id}/history/withdrawal", {
+                params: {
+                    path: { account_id: accountId },
+                    query: {
+                        since,
+                        until,
+                        pageSize,
+                        startInclusive,
+                    },
+                },
+            });
+        }
+        catch (error) {
+            throw new NordError("Failed to fetch account withdrawal history", {
+                cause: error,
+            });
+        }
+    }
 }

package/dist/client/NordAdmin.js

@@ -1,6 +1,6 @@
 import { create } from "@bufbuild/protobuf";
 import * as proto from "../gen/nord_pb";
-import { decodeHex, signUserPayload } from "../utils";
+import { decodeHex, signAdminPayload } from "../utils";
 import { createAction, sendAction, expectReceiptKind } from "../actions";
 import { NordError } from "../error";
 // NOTE: keep in sync with `acl.rs`.
@@ -49,7 +49,7 @@ export class NordAdmin {
         const timestamp = await this.nord.getTimestamp();
         const action = createAction(timestamp, 0, kind);
         return sendAction(this.nord.httpClient, async (xs) => {
-            const signature = await signUserPayload({
+            const signature = await signAdminPayload({
                 payload: xs,
                 user: this.admin,
                 signTransaction: this.signFn,

package/dist/client/NordUser.d.ts

@@ -33,9 +33,10 @@ export interface UserAtomicSubaction {
  * User class for interacting with the Nord protocol
  */
 export declare class NordUser {
+    private readonly signSessionMessage;
+    private readonly signMessage;
+    private readonly signTransaction;
     readonly nord: Nord;
-    readonly sessionSignFn: (message: Uint8Array) => Promise<Uint8Array>;
-    readonly transactionSignFn: (tx: Transaction) => Promise<Transaction>;
     sessionId?: bigint;
     sessionPubKey: PublicKey;
     publicKey: PublicKey;
@@ -49,6 +50,17 @@ export declare class NordUser {
             symbol: string;
         }[];
     };
+    orders: {
+        [key: string]: {
+            orderId: string;
+            marketId: number;
+            side: "ask" | "bid";
+            size: number;
+            price: number;
+            originalOrderSize: number;
+            clientOrderId: number | null;
+        }[];
+    };
     /** User positions by account ID */
     positions: {
         [key: string]: {
@@ -82,25 +94,28 @@ export declare class NordUser {
     accountIds?: number[];
     /** SPL token information */
     splTokenInfos: SPLTokenInfo[];
+    private constructor();
     /**
      * Create a new NordUser instance
      *
      * @param nord - Nord client instance
-     * @param sessionSignFn - Function to sign messages with the user's session key
-     * @param transactionSignFn - Function to sign transactions with the user's wallet (optional)
-     * @param sessionId - Existing session identifier
+     * @param walletPubkey - Wallet public key
      * @param sessionPubKey - Session public key
-     * @param publicKey - Wallet public key
+     * @param sessionId - Existing session identifier, if known. Otherwise, pass nothing and call `refreshSession` to fetch a new session.
+     * @param signMessageFn - Function to sign the given UTF-8 string with the user's wallet. Typically just your wallet's `signMessage` method.
+     * @param signTransactionFn - Function to sign transactions with the user's wallet. Typically just your wallet's `signTransaction` method.
+     * @param signSessionFn - Function to sign messages with the provided `sessionPubKey`
      * @throws {NordError} If required parameters are missing
      */
-    constructor({ nord, sessionSignFn, transactionSignFn, sessionId, sessionPubKey, publicKey, }: Readonly<{
+    static new({ nord, walletPubkey, sessionPubkey, sessionId, signMessageFn, signTransactionFn, signSessionFn, }: Readonly<{
         nord: Nord;
-        sessionSignFn: (message: Uint8Array) => Promise<Uint8Array>;
-        transactionSignFn: (tx: Transaction) => Promise<Transaction>;
+        signSessionFn: (rawMessage: Uint8Array) => Promise<Uint8Array>;
+        signMessageFn: (utf8Message: Uint8Array) => Promise<Uint8Array>;
+        signTransactionFn: (tx: Transaction) => Promise<Transaction>;
         sessionId?: bigint;
-        sessionPubKey: Uint8Array;
-        publicKey: PublicKey;
-    }>);
+        sessionPubkey: Uint8Array;
+        walletPubkey: PublicKey;
+    }>): Promise<NordUser>;
     /**
      * Create a NordUser from a private key
      *

package/dist/client/NordUser.js

@@ -1,10 +1,10 @@
 import { ASSOCIATED_TOKEN_PROGRAM_ID, getAssociatedTokenAddress, TOKEN_PROGRAM_ID, TOKEN_2022_PROGRAM_ID, } from "@solana/spl-token";
-import { PublicKey, Transaction } from "@solana/web3.js";
+import { PublicKey, Keypair, Transaction } from "@solana/web3.js";
 import * as ed from "@noble/ed25519";
 import { floatToScaledBigIntLossy } from "@n1xyz/proton";
 import { Side, TriggerKind, fillModeToProtoFillMode, } from "../types";
 import * as proto from "../gen/nord_pb";
-import { checkedFetch, assert, findMarket, findToken, optExpect, keypairFromPrivateKey, toScaledU64, } from "../utils";
+import { assert, findMarket, findToken, optExpect, keypairFromPrivateKey, toScaledU64, } from "../utils";
 import { create } from "@bufbuild/protobuf";
 import { createSession, revokeSession, atomic, expectReceiptKind, createAction, sendAction, } from "../actions";
 import { NordError } from "../error";
@@ -12,9 +12,10 @@ import { NordError } from "../error";
  * User class for interacting with the Nord protocol
  */
 export class NordUser {
+    signSessionMessage;
+    signMessage;
+    signTransaction;
     nord;
-    sessionSignFn;
-    transactionSignFn;
     sessionId;
     sessionPubKey;
     publicKey;
@@ -22,6 +23,7 @@ export class NordUser {
     nonce = 0;
     /** User balances by token symbol */
     balances = {};
+    orders = {};
     /** User positions by account ID */
     positions = {};
     /** User margins by account ID */
@@ -30,24 +32,14 @@ export class NordUser {
     accountIds;
     /** SPL token information */
     splTokenInfos = [];
-    /**
-     * Create a new NordUser instance
-     *
-     * @param nord - Nord client instance
-     * @param sessionSignFn - Function to sign messages with the user's session key
-     * @param transactionSignFn - Function to sign transactions with the user's wallet (optional)
-     * @param sessionId - Existing session identifier
-     * @param sessionPubKey - Session public key
-     * @param publicKey - Wallet public key
-     * @throws {NordError} If required parameters are missing
-     */
-    constructor({ nord, sessionSignFn, transactionSignFn, sessionId, sessionPubKey, publicKey, }) {
+    constructor({ nord, walletPubkey, sessionPubkey, sessionId, signMessageFn, signTransactionFn, signSessionFn, }) {
         this.nord = nord;
-        this.sessionSignFn = sessionSignFn;
-        this.transactionSignFn = transactionSignFn;
+        this.signSessionMessage = signSessionFn;
+        this.signMessage = signMessageFn;
+        this.signTransaction = signTransactionFn;
         this.sessionId = sessionId;
-        this.sessionPubKey = new PublicKey(sessionPubKey);
-        this.publicKey = publicKey;
+        this.sessionPubKey = new PublicKey(sessionPubkey);
+        this.publicKey = walletPubkey;
         // Convert tokens from info endpoint to SPLTokenInfo
         if (this.nord.tokens && this.nord.tokens.length > 0) {
             this.splTokenInfos = this.nord.tokens.map((token) => ({
@@ -58,6 +50,29 @@ export class NordUser {
             }));
         }
     }
+    /**
+     * Create a new NordUser instance
+     *
+     * @param nord - Nord client instance
+     * @param walletPubkey - Wallet public key
+     * @param sessionPubKey - Session public key
+     * @param sessionId - Existing session identifier, if known. Otherwise, pass nothing and call `refreshSession` to fetch a new session.
+     * @param signMessageFn - Function to sign the given UTF-8 string with the user's wallet. Typically just your wallet's `signMessage` method.
+     * @param signTransactionFn - Function to sign transactions with the user's wallet. Typically just your wallet's `signTransaction` method.
+     * @param signSessionFn - Function to sign messages with the provided `sessionPubKey`
+     * @throws {NordError} If required parameters are missing
+     */
+    static async new({ nord, walletPubkey, sessionPubkey, sessionId, signMessageFn, signTransactionFn, signSessionFn, }) {
+        return new NordUser({
+            nord,
+            walletPubkey,
+            sessionPubkey,
+            sessionId,
+            signMessageFn,
+            signTransactionFn,
+            signSessionFn,
+        });
+    }
     /**
      * Create a NordUser from a private key
      *
@@ -68,22 +83,22 @@ export class NordUser {
      */
     static fromPrivateKey(nord, privateKey) {
         try {
-            const keypair = keypairFromPrivateKey(privateKey);
-            const publicKey = keypair.publicKey;
-            const sessionSignFn = async (message) => {
-                // Use ed25519 to sign the message
-                return ed.sign(message, keypair.secretKey.slice(0, 32));
-            };
-            const transactionSignFn = async (tx) => {
-                tx.sign(keypair);
-                return tx;
-            };
+            const wallet = keypairFromPrivateKey(privateKey);
+            const sessionKey = Keypair.generate();
             return new NordUser({
                 nord,
-                sessionSignFn,
-                transactionSignFn,
-                publicKey,
-                sessionPubKey: publicKey.toBytes(),
+                walletPubkey: wallet.publicKey,
+                sessionPubkey: sessionKey.publicKey.toBytes(),
+                signTransactionFn: async (tx) => {
+                    tx.sign(wallet);
+                    return tx;
+                },
+                signMessageFn: async (xs) => {
+                    return await ed.signAsync(xs, wallet.secretKey.slice(0, 32));
+                },
+                signSessionFn: async (xs) => {
+                    return await ed.signAsync(xs, sessionKey.secretKey.slice(0, 32));
+                },
             });
         }
         catch (error) {
@@ -171,7 +186,7 @@ export class NordUser {
             tx.add(ix);
             tx.recentBlockhash = blockhash;
             tx.feePayer = payer;
-            const signedTx = await this.transactionSignFn(tx);
+            const signedTx = await this.signTransaction(tx);
             signedTx.partialSign(extraSigner);
             const signature = await this.nord.solanaConnection.sendRawTransaction(signedTx.serialize(), sendOptions);
             return {
@@ -193,7 +208,7 @@ export class NordUser {
     }
     async submitSessionAction(kind) {
         return this.submitSignedAction(kind, async (message) => {
-            const signature = await this.sessionSignFn(message);
+            const signature = await this.signSessionMessage(message);
             const signed = new Uint8Array(message.length + signature.length);
             signed.set(message);
             signed.set(signature, message.length);
@@ -230,8 +245,7 @@ export class NordUser {
     async fetchInfo() {
         if (this.accountIds !== undefined) {
             const accountsData = await Promise.all(this.accountIds.map(async (accountId) => {
-                const response = await checkedFetch(`${this.nord.webServerUrl}/account/${accountId}`);
-                const accountData = (await response.json());
+                const accountData = await this.nord.getAccount(accountId);
                 // Ensure we have the correct accountId
                 return {
                     ...accountData,
@@ -239,6 +253,15 @@ export class NordUser {
                 };
             }));
             for (const accountData of accountsData) {
+                this.orders[accountData.accountId] = accountData.orders.map((o) => ({
+                    orderId: o.orderId,
+                    marketId: o.marketId,
+                    side: o.side,
+                    size: o.size,
+                    price: o.price,
+                    originalOrderSize: o.originalOrderSize,
+                    clientOrderId: o.clientOrderId ?? null,
+                }));
                 // Process balances
                 this.balances[accountData.accountId] = [];
                 for (const balance of accountData.balances) {
@@ -249,7 +272,12 @@ export class NordUser {
                     });
                 }
                 // Process positions
-                this.positions[accountData.accountId] = accountData.positions;
+                this.positions[accountData.accountId] = accountData.positions.map((p) => ({
+                    marketId: p.marketId,
+                    openOrders: p.openOrders,
+                    actionId: p.actionId,
+                    ...(p.perp != null ? { perp: p.perp } : {}),
+                }));
                 // Process margins
                 this.margins[accountData.accountId] = accountData.margins;
             }
@@ -261,7 +289,7 @@ export class NordUser {
      * @throws {NordError} If the operation fails
      */
     async refreshSession() {
-        const result = await createSession(this.nord.httpClient, this.transactionSignFn, await this.nord.getTimestamp(), this.getNonce(), {
+        const result = await createSession(this.nord.httpClient, this.signMessage, await this.nord.getTimestamp(), this.getNonce(), {
             userPubkey: this.publicKey,
             sessionPubkey: this.sessionPubKey,
         });
@@ -275,8 +303,7 @@ export class NordUser {
      */
     async revokeSession(sessionId) {
         try {
-            await revokeSession(this.nord.httpClient, this.transactionSignFn, await this.nord.getTimestamp(), this.getNonce(), {
-                userPubkey: this.publicKey,
+            await revokeSession(this.nord.httpClient, this.signMessage, await this.nord.getTimestamp(), this.getNonce(), {
                 sessionId,
             });
         }
@@ -600,7 +627,7 @@ export class NordUser {
                     orderId: act.orderId,
                 };
             });
-            const result = await atomic(this.nord.httpClient, this.sessionSignFn, await this.nord.getTimestamp(), this.getNonce(), {
+            const result = await atomic(this.nord.httpClient, this.signSessionMessage, await this.nord.getTimestamp(), this.getNonce(), {
                 sessionId: optExpect(this.sessionId, "No session"),
                 accountId: accountId,
                 actions: apiActions,

package/dist/gen/nord_pb.d.ts

@@ -4238,6 +4238,9 @@ export declare enum Error {
     POSITION_STATE_ORDER_SIDE = 205,
     /**
      * 1100_1110
+     * Maximuma size of single position exceeded.
+     * See `POSITION_SIZE_LIMIT` constant default limit for exacat value and
+     * details.
      *
      * @generated from enum value: POSITION_SIZE_LIMIT = 206;
      */
@@ -4270,6 +4273,9 @@ export declare enum Error {
     SIGNATURE_VERIFICATION_INVALID_LENGTH = 219,
     /**
      * 11011_000
+     * Error prefix which indicates that some actions cannot to be executed,
+     * if they move account into unhealthy(liquidatable) state
+     * or if liquidaiton handling action as parameterized cannot be executed
      *
      * @generated from enum value: RISK = 224;
      */
@@ -4287,6 +4293,8 @@ export declare enum Error {
      */
     RISK_OMF_LESS_THAN_OR_EQUAL_CMF = 227,
     /**
+     * See `OMF < CMF` rule in MARKETS.md.
+     *
      * @generated from enum value: RISK_TRADE_OMF_LESS_THAN_OR_EQUAL_CMF = 229;
      */
     RISK_TRADE_OMF_LESS_THAN_OR_EQUAL_CMF = 229,

package/dist/gen/nord_pb.js

@@ -873,6 +873,9 @@ export var Error;
     Error[Error["POSITION_STATE_ORDER_SIDE"] = 205] = "POSITION_STATE_ORDER_SIDE";
     /**
      * 1100_1110
+     * Maximuma size of single position exceeded.
+     * See `POSITION_SIZE_LIMIT` constant default limit for exacat value and
+     * details.
      *
      * @generated from enum value: POSITION_SIZE_LIMIT = 206;
      */
@@ -905,6 +908,9 @@ export var Error;
     Error[Error["SIGNATURE_VERIFICATION_INVALID_LENGTH"] = 219] = "SIGNATURE_VERIFICATION_INVALID_LENGTH";
     /**
      * 11011_000
+     * Error prefix which indicates that some actions cannot to be executed,
+     * if they move account into unhealthy(liquidatable) state
+     * or if liquidaiton handling action as parameterized cannot be executed
      *
      * @generated from enum value: RISK = 224;
      */
@@ -922,6 +928,8 @@ export var Error;
      */
     Error[Error["RISK_OMF_LESS_THAN_OR_EQUAL_CMF"] = 227] = "RISK_OMF_LESS_THAN_OR_EQUAL_CMF";
     /**
+     * See `OMF < CMF` rule in MARKETS.md.
+     *
      * @generated from enum value: RISK_TRADE_OMF_LESS_THAN_OR_EQUAL_CMF = 229;
      */
     Error[Error["RISK_TRADE_OMF_LESS_THAN_OR_EQUAL_CMF"] = 229] = "RISK_TRADE_OMF_LESS_THAN_OR_EQUAL_CMF";

package/dist/gen/openapi.d.ts

@@ -725,7 +725,44 @@ export interface paths {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["PageResult_for_uint64_and_AccountPnl"];
+                        "application/json": components["schemas"]["PageResult_for_uint64_and_AccountPnlInfo"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/account/{account_id}/pnl/history/PT1H": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description Account for which to retrieve PnL history */
+                    account_id: number;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["AccountPnlHistInfo"][];
                     };
                 };
             };
@@ -770,7 +807,7 @@ export interface paths {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["PageResult_for_uint64_and_HistoryTriggerInfo"];
+                        "application/json": components["schemas"]["PageResult_for_uint64_and_Trigger"];
                     };
                 };
             };
@@ -1320,6 +1357,108 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/market/{market_id}/price/prev": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** @description Fetch the latest price for a market at or before a timestamp. */
+        get: {
+            parameters: {
+                query: {
+                    atOrBefore: string;
+                };
+                header?: never;
+                path: {
+                    market_id: number;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["PreviousMarketPrice"];
+                    };
+                };
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["MarketNotFound"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/account/{account_id}/history/withdrawal": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** @description Fetch full history of withdrawals for an account. */
+        get: {
+            parameters: {
+                query?: {
+                    /** @description start with this timestamp (RFC3339); defaults to UNIX epoch start */
+                    since?: string;
+                    /** @description end with this timestamp (RFC3339); defaults to current date-time */
+                    until?: string;
+                    /** @description fetch results starting with this page; query starts with first entry if page isn't specified */
+                    startInclusive?: number | null;
+                    /** @description Query returns up to 50 trades in one go. */
+                    pageSize?: number | null;
+                };
+                header?: never;
+                path: {
+                    /** @description Account ID for which to fetch withdrawal history. */
+                    account_id: number;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["PageResult_for_uint64_and_Withdrawal"];
+                    };
+                };
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["UserNotFound"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/tv": {
         parameters: {
             query?: never;
@@ -2331,7 +2470,9 @@ export interface components {
             /** Format: double */
             low24h: number;
             /** Format: double */
-            closePrice24h: number;
+            close24h: number;
+            /** Format: double */
+            prevClose24h?: number | null;
             perpStats?: components["schemas"]["PerpMarketStats"] | null;
         };
         PerpMarketStats: {
@@ -2529,7 +2670,7 @@ export interface components {
             /** @description See `bankruptcy` in MARKETS.md. In general happens if account does not have enough weighted tokens to covert his debt and negative PnL. */
             bankruptcy: boolean;
         };
-        AccountPnlQuery: {
+        PagedQuery: {
             /**
              * @description start with this timestamp (RFC3339); defaults to UNIX epoch start
              * @default null
@@ -2552,63 +2693,78 @@ export interface components {
              */
             pageSize: number | null;
         };
-        PageResult_for_uint64_and_AccountPnl: {
+        PageResult_for_uint64_and_AccountPnlInfo: {
             /** @description Set of items for requested by query. */
-            items: components["schemas"]["AccountPnl"][];
+            items: components["schemas"]["AccountPnlInfo"][];
             /**
              * Format: uint64
              * @description If request contains more data, this is the id is set with which next request should be performed to get next page. If no more data, then it is undefined.
              */
             nextStartInclusive?: number | null;
         };
-        AccountPnl: {
+        AccountPnlInfo: {
             time: string;
             /** Format: uint64 */
             actionId: number;
             /** Format: uint32 */
             accountId: number;
             /** Format: double */
-            pnl: number;
-        };
-        AccountTriggersQuery: {
+            pricePnlDelta: number;
+            /** Format: double */
+            fundingPnlDelta: number;
             /**
-             * @description start with this timestamp (RFC3339); defaults to UNIX epoch start
-             * @default null
+             * Format: double
+             * @description Total PnL update
              */
-            since: string;
+            pnl: number;
+        };
+        AccountPnlHistInfo: {
+            /** @description Same time when funding is applied */
+            time: string;
+            /** Format: double */
+            fundingPnl: number;
             /**
-             * @description end with this timestamp (RFC3339); defaults to current date-time
-             * @default null
+             * Format: double
+             * @description in USDC, PnL from position price and price and trade price difference
              */
-            until: string;
+            tradedPnl: number;
             /**
-             * Format: uint64
-             * @description fetch results starting with this page; query starts with first entry if page isn't specified
+             * Format: double
+             * @description Funding rate used to calculate this funding payment
              */
-            startInclusive?: number | null;
+            fundingRate: number;
             /**
-             * Format: uint8
-             * @description Query returns up to 50 trades in one go.
-             * @default null
+             * Format: double
+             * @description Size used to calculated funding payment
              */
-            pageSize: number | null;
+            fundingSize: number;
+            /** @description Side on time of funding application. */
+            side?: components["schemas"]["Side"] | null;
+            /** Format: double */
+            positionSizeTraded: number;
+            market: components["schemas"]["MarketIdInfo"];
+        };
+        MarketIdInfo: {
+            /** Format: uint32 */
+            market_id: number;
+            market_symbol: string;
         };
-        PageResult_for_uint64_and_HistoryTriggerInfo: {
+        PageResult_for_uint64_and_Trigger: {
             /** @description Set of items for requested by query. */
-            items: components["schemas"]["HistoryTriggerInfo"][];
+            items: components["schemas"]["Trigger"][];
             /**
              * Format: uint64
              * @description If request contains more data, this is the id is set with which next request should be performed to get next page. If no more data, then it is undefined.
              */
             nextStartInclusive?: number | null;
         };
-        HistoryTriggerInfo: {
+        Trigger: {
             /** Format: uint32 */
             accountId: number;
             /** Format: uint32 */
             marketId: number;
-            /** Format: uint64 */
-            price: number;
+            triggerPrice: components["schemas"]["PositivePriceMantissa"];
+            limitPrice?: components["schemas"]["PositivePriceMantissa"] | null;
             side: components["schemas"]["Side"];
             kind: components["schemas"]["TriggerKind"];
             status: components["schemas"]["TriggerStatus"];
@@ -2619,6 +2775,11 @@ export interface components {
             createdAt: string;
             finalizedAt: string;
         };
+        /**
+         * Format: uint64
+         * @description 63 bit integer, which is always positive
+         */
+        PositivePriceMantissa: number;
         /** @enum {string} */
         TriggerKind: "stopLoss" | "takeProfit";
         /** @enum {string} */
@@ -2640,11 +2801,6 @@ export interface components {
             trigger: components["schemas"]["PositivePriceMantissa"];
             settlement?: components["schemas"]["PositivePriceMantissa"] | null;
         };
-        /**
-         * Format: uint64
-         * @description 63 bit integer, which is always positive
-         */
-        PositivePriceMantissa: number;
         OrderNotFound: null;
         PageResult_for_String_and_Trade: {
             /** @description Set of items for requested by query. */
@@ -2805,6 +2961,39 @@ export interface components {
             /** Format: double */
             volume: number;
         };
+        GetPrevMarketPriceQuery: {
+            atOrBefore: string;
+        };
+        PreviousMarketPrice: {
+            /** Format: uint32 */
+            marketId: number;
+            /** Format: double */
+            price?: number | null;
+        };
+        PageResult_for_uint64_and_Withdrawal: {
+            /** @description Set of items for requested by query. */
+            items: components["schemas"]["Withdrawal"][];
+            /**
+             * Format: uint64
+             * @description If request contains more data, this is the id is set with which next request should be performed to get next page. If no more data, then it is undefined.
+             */
+            nextStartInclusive?: number | null;
+        };
+        Withdrawal: {
+            time: string;
+            /** Format: uint64 */
+            actionId: number;
+            /** Format: uint32 */
+            accountId: number;
+            /** Format: uint32 */
+            tokenId: number;
+            /** Format: uint64 */
+            amount: number;
+            /** Format: int64 */
+            balance: number;
+            /** Format: int64 */
+            fee: number;
+        };
         /** @description TV config query response https://www.tradingview.com/charting-library-docs/latest/connecting_data/UDF/#data-feed-configuration-data */
         TvConfigResponse: {
             supported_resolutions: components["schemas"]["Resolution"][];

package/dist/types.d.ts

@@ -59,12 +59,12 @@ export type SideFromApi = components["schemas"]["Side"];
 export type FillModeFromApi = components["schemas"]["FillMode"];
 export type PlacementOrigin = components["schemas"]["PlacementOrigin"];
 export type FinalizationReason = components["schemas"]["FinalizationReason"];
-export type AccountPnlQuery = components["schemas"]["AccountPnlQuery"];
-export type AccountPnl = components["schemas"]["AccountPnl"];
-export type AccountPnlPage = components["schemas"]["PageResult_for_uint64_and_AccountPnl"];
+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_HistoryTriggerInfo"];
-export type HistoryTriggerQuery = components["schemas"]["AccountTriggersQuery"];
+export type TriggerHistoryPage = components["schemas"]["PageResult_for_uint64_and_Trigger"];
+export type WithdrawalHistoryPage = components["schemas"]["PageResult_for_uint64_and_Withdrawal"];
 export type FeeTierConfig = components["schemas"]["FeeTierConfig"];
 export type FeeTierId = components["schemas"]["FeeTierId"];
 export type TokenStats = components["schemas"]["TokenStats"];
@@ -73,6 +73,9 @@ export type AccountFeeTierPage = components["schemas"]["PageResult_for_uint32_an
 export type AdminInfo = components["schemas"]["AdminInfo"];
 export type GetAccountVolumeQuery = components["schemas"]["GetAccountVolumeQuery"];
 export type AccountVolumeInfo = components["schemas"]["AccountVolumeInfo"];
+export type GetPrevMarketPriceQuery = components["schemas"]["GetPrevMarketPriceQuery"];
+export type PreviousMarketPrice = components["schemas"]["PreviousMarketPrice"];
+export type WithdrawalInfo = components["schemas"]["Withdrawal"];
 /**
  * Configuration options for the Nord client
  */
@@ -214,16 +217,27 @@ export interface WebSocketDeltaUpdate {
     bids: OrderbookEntry[];
     timestamp: number;
 }
-/**
- * WebSocket user update message
- */
 export interface WebSocketAccountUpdate {
-    e: WebSocketMessageType.AccountUpdate;
-    accountId: number;
-    account: Account;
-    timestamp: number;
+    last_update_id: number;
+    update_id: number;
+    account_id: number;
+    fills: Record<string, unknown>;
+    places: Record<string, unknown>;
+    cancels: Record<string, {
+        side: "bid" | "ask";
+        current_size: number;
+        price: number;
+        market_id: number;
+    }>;
+    balances: Record<string, unknown>;
 }
-export type WebSocketMessage = WebSocketTradeUpdate | WebSocketDeltaUpdate | WebSocketAccountUpdate;
+export type WebSocketMessage = {
+    trades: WebSocketTradeUpdate;
+} | {
+    delta: WebSocketDeltaUpdate;
+} | {
+    account: WebSocketAccountUpdate;
+};
 export interface SPLTokenInfo {
     mint: string;
     precision: number;

package/dist/utils.d.ts

@@ -75,8 +75,12 @@ export declare function decodeHex(value: string): Uint8Array;
 export declare function findMarket(markets: Market[], marketId: number): Market;
 export declare function findToken(tokens: Token[], tokenId: number): Token;
 export declare function keypairFromPrivateKey(privateKey: string | Uint8Array): Keypair;
-export declare function signUserPayload({ payload, user, signTransaction, }: Readonly<{
+export declare function signAdminPayload({ payload, user, signTransaction, }: Readonly<{
     payload: Uint8Array;
     user: solana.PublicKey;
     signTransaction: (tx: solana.Transaction) => Promise<solana.Transaction>;
 }>): Promise<Uint8Array>;
+export declare function signUserPayload({ payload, signMessage, }: Readonly<{
+    payload: Uint8Array;
+    signMessage: (message: Uint8Array) => Promise<Uint8Array>;
+}>): Promise<Uint8Array>;

package/dist/utils.js

@@ -167,7 +167,7 @@ export function keypairFromPrivateKey(privateKey) {
     }
     return Keypair.fromSecretKey(privateKey);
 }
-export async function signUserPayload({ payload, user, signTransaction, }) {
+export async function signAdminPayload({ payload, user, signTransaction, }) {
     const tx = new solana.Transaction({
         blockhash: bs58.encode(new Uint8Array(32)),
         lastValidBlockHeight: 0,
@@ -188,3 +188,6 @@ export async function signUserPayload({ payload, user, signTransaction, }) {
     assert(sig.publicKey.equals(user), `signature is for ${sig.publicKey}, expected ${user}`);
     return sig.signature;
 }
+export async function signUserPayload({ payload, signMessage, }) {
+    return await signMessage(new TextEncoder().encode(payload.toHex()));
+}

package/dist/websocket/NordWebSocketClient.js

@@ -212,15 +212,15 @@ export class NordWebSocketClient extends EventEmitter {
         }
         const hasOwn = (k) => Object.prototype.hasOwnProperty.call(message, k);
         if (hasOwn("trades")) {
-            this.emit("trades", message);
+            this.emit("trades", message.trades);
             return;
         }
         if (hasOwn("delta")) {
-            this.emit("delta", message);
+            this.emit("delta", message.delta);
             return;
         }
         if (hasOwn("account")) {
-            this.emit("account", message);
+            this.emit("account", message.account);
             return;
         }
         this.emit("error", new Error(`Unexpected message type: ${message}`));

package/dist/websocket/Subscriber.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@n1xyz/nord-ts",
-  "version": "0.1.10",
+  "version": "0.2.0",
   "description": "Typescript for Nord",
   "keywords": [],
   "author": "",
@@ -44,7 +44,7 @@
   },
   "dependencies": {
     "@bufbuild/protobuf": "^2.6.3",
-    "@n1xyz/proton": "0.0.7",
+    "@n1xyz/proton": "0.1.0",
     "@noble/curves": "^1.9.6",
     "@noble/ed25519": "^2.3.0",
     "@noble/hashes": "^1.8.0",