@n1xyz/nord-ts 0.1.10 → 0.1.12

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, AccountPnlPage, 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<AccountPnlPage>;
     /**
      * 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

@@ -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;
@@ -82,25 +83,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,5 +1,5 @@
 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";
@@ -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;
@@ -30,24 +31,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 +49,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 +82,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 ed.sign(xs, wallet.secretKey);
+                },
+                signSessionFn: async (xs) => {
+                    return ed.sign(xs, sessionKey.secretKey);
+                },
             });
         }
         catch (error) {
@@ -171,7 +185,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 +207,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);
@@ -261,7 +275,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 +289,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 +613,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/openapi.d.ts

@@ -770,7 +770,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 +1320,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 +2433,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 +2633,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
@@ -2570,45 +2674,22 @@ export interface components {
             /** Format: double */
             pnl: number;
         };
-        AccountTriggersQuery: {
-            /**
-             * @description start with this timestamp (RFC3339); defaults to UNIX epoch start
-             * @default null
-             */
-            since: string;
-            /**
-             * @description end with this timestamp (RFC3339); defaults to current date-time
-             * @default null
-             */
-            until: string;
-            /**
-             * Format: uint64
-             * @description fetch results starting with this page; query starts with first entry if page isn't specified
-             */
-            startInclusive?: number | null;
-            /**
-             * Format: uint8
-             * @description Query returns up to 50 trades in one go.
-             * @default null
-             */
-            pageSize: number | null;
-        };
-        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 +2700,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 +2726,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 +2886,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 PagedQuery = components["schemas"]["PagedQuery"];
 export type AccountPnl = components["schemas"]["AccountPnl"];
 export type AccountPnlPage = components["schemas"]["PageResult_for_uint64_and_AccountPnl"];
 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
  */

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

@@ -1,6 +1,6 @@
 {
   "name": "@n1xyz/nord-ts",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "Typescript for Nord",
   "keywords": [],
   "author": "",