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

package/dist/nord/client/Nord.js

@@ -32,17 +32,21 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Nord = void 0;
 const events_1 = require("events");
+const web3_js_1 = require("@solana/web3.js");
+const openapi_fetch_1 = __importDefault(require("openapi-fetch"));
 const types_1 = require("../../types");
 const proton_1 = require("@n1xyz/proton");
+const proto = __importStar(require("../../gen/nord"));
 const core = __importStar(require("../api/core"));
-const market = __importStar(require("../api/market"));
 const metrics = __importStar(require("../api/metrics"));
-const queries = __importStar(require("../api/queries"));
+const utils = __importStar(require("../../utils"));
 const NordError_1 = require("../utils/NordError");
-const web3_js_1 = require("@solana/web3.js");
 /**
  * Main Nord client class for interacting with the Nord API
  */
@@ -67,6 +71,7 @@ class Nord {
         this.bridgeVk = bridgeVk;
         this.solanaUrl = solanaUrl;
         this.protonClient = protonClient;
+        this.httpClient = (0, openapi_fetch_1.default)({ baseUrl: webServerUrl });
     }
     /**
      * Create a WebSocket client with specific subscriptions
@@ -119,6 +124,18 @@ class Nord {
         // Create and return a new WebSocket client
         return core.initWebSocketClient(this.webServerUrl, subscriptions);
     }
+    async GET(path, options) {
+        const r = await this.httpClient.GET(path, options);
+        if (r.error) {
+            throw new NordError_1.NordError(`failed to GET ${path}`, { cause: r.error });
+        }
+        if (r.data === undefined) {
+            // this should never happen, but the type checker seems unhappy.
+            // if we catch this we'll need to debug accordingly.
+            throw new NordError_1.NordError("internal assertion violation", { cause: r });
+        }
+        return r.data;
+    }
     /**
      * Get the current timestamp from the Nord server
      *
@@ -126,7 +143,7 @@ class Nord {
      * @throws {NordError} If the request fails
      */
     async getTimestamp() {
-        return core.getTimestamp(this.webServerUrl);
+        return BigInt(await this.GET("/timestamp", {}));
     }
     /**
      * Get the last event nonce from the Nord server
@@ -135,7 +152,7 @@ class Nord {
      * @throws {NordError} If the request fails
      */
     async getActionNonce() {
-        return core.getLastEventNonce(this.webServerUrl);
+        return await this.GET("/event/last-acked-nonce", {});
     }
     /**
      * Fetch information about Nord markets and tokens
@@ -144,7 +161,7 @@ class Nord {
      */
     async fetchNordInfo() {
         try {
-            const info = await core.getInfo(this.webServerUrl);
+            const info = await this.GET("/info", {});
             this.markets = info.markets;
             this.tokens = info.tokens;
             // Populate the symbolToMarketId map
@@ -194,15 +211,6 @@ class Nord {
     async init() {
         await this.fetchNordInfo();
     }
-    /**
-     * Get market statistics
-     *
-     * @returns Market statistics response
-     * @throws {NordError} If the request fails
-     */
-    async marketsStats() {
-        return market.marketsStats(this.webServerUrl);
-    }
     /**
      * Query a specific action
      *
@@ -210,8 +218,11 @@ class Nord {
      * @returns Action response
      * @throws {NordError} If the request fails
      */
-    async queryAction(query) {
-        return queries.queryAction(this.webServerUrl, query);
+    async queryAction({ action_id, }) {
+        return ((await this.queryRecentActions({
+            from: action_id,
+            to: action_id,
+        }))[0] ?? null);
     }
     /**
      * Query recent actions
@@ -221,8 +232,17 @@ class Nord {
      * @returns Actions response
      * @throws {NordError} If the request fails
      */
-    async queryRecentActions(from, to) {
-        return queries.queryRecentActions(this.webServerUrl, from, to);
+    async queryRecentActions(query) {
+        const xs = await this.GET("/action", {
+            params: {
+                query,
+            },
+        });
+        return xs.map((x) => ({
+            actionId: x.actionId,
+            action: utils.decodeLengthDelimited(Buffer.from(x.payload, "base64"), proto.Action),
+            physicalExecTime: new Date(x.physicalTime * 1000),
+        }));
     }
     /**
      * Get the last action ID
@@ -231,7 +251,7 @@ class Nord {
      * @throws {NordError} If the request fails
      */
     async getLastActionId() {
-        return queries.getLastActionId(this.webServerUrl);
+        return await this.GET("/action/last-executed-id", {});
     }
     /**
      * Fetch aggregate metrics from the Nord API
@@ -283,26 +303,6 @@ class Nord {
     async getTotalTransactions() {
         return metrics.getTotalTransactions(this.webServerUrl);
     }
-    /**
-     * Query an action from Rollman
-     *
-     * @param query - Action query parameters
-     * @returns Rollman action response
-     * @throws {NordError} If the request fails
-     */
-    async actionQueryRollman(query) {
-        return queries.actionQueryRollman(this.webServerUrl, query);
-    }
-    /**
-     * Query actions from Rollman
-     *
-     * @param last_n - Number of recent actions to query
-     * @returns Rollman actions response
-     * @throws {NordError} If the request fails
-     */
-    async actionsQueryRollman(last_n) {
-        return queries.actionsQueryRollman(this.webServerUrl, last_n);
-    }
     /**
      * Query Prometheus metrics
      *
@@ -408,7 +408,26 @@ class Nord {
      * @throws {NordError} If the request fails
      */
     async getTrades(query) {
-        return market.getTrades(this.webServerUrl, query);
+        if (query.sinceRcf3339 && !utils.isRfc3339(query.sinceRcf3339)) {
+            throw new NordError_1.NordError(`Invalid RFC3339 timestamp: ${query.sinceRcf3339}`);
+        }
+        if (query.untilRfc3339 && !utils.isRfc3339(query.untilRfc3339)) {
+            throw new NordError_1.NordError(`Invalid RFC3339 timestamp: ${query.untilRfc3339}`);
+        }
+        return await this.GET("/trades", {
+            params: {
+                query: {
+                    takerId: query.takerId,
+                    makerId: query.makerId,
+                    marketId: query.marketId,
+                    pageSize: query.pageSize,
+                    takerSide: query.takerSide,
+                    since: query.sinceRcf3339,
+                    until: query.untilRfc3339,
+                    startInclusive: query.pageId,
+                },
+            },
+        });
     }
     /**
      * Get user account IDs
@@ -417,8 +436,16 @@ class Nord {
      * @returns User account IDs response
      * @throws {NordError} If the request fails
      */
-    async getUserAccountIds(query) {
-        return market.getUserAccountIds(this.webServerUrl, query);
+    async getUser(query) {
+        const r = await this.httpClient.GET("/user/{pubkey}", {
+            params: {
+                path: { pubkey: query.pubkey.toString() },
+            },
+        });
+        if (r.response.status === 404) {
+            return null;
+        }
+        return r.data;
     }
     /**
      * Get orderbook for a market
@@ -431,18 +458,29 @@ class Nord {
      */
     async getOrderbook(query) {
         // If only symbol is provided, convert it to market_id
+        let marketId;
         if (query.symbol && query.market_id === undefined) {
             // If the map is empty, try to fetch market information first
             if (this.symbolToMarketId.size === 0) {
                 await this.fetchNordInfo();
             }
-            const marketId = this.symbolToMarketId.get(query.symbol);
-            if (marketId === undefined) {
+            const id = this.symbolToMarketId.get(query.symbol);
+            if (id === undefined) {
                 throw new NordError_1.NordError(`Unknown market symbol: ${query.symbol}`);
             }
-            query = { market_id: marketId };
+            marketId = id;
+        }
+        else if (query.market_id !== undefined) {
+            marketId = query.market_id;
+        }
+        else {
+            throw new NordError_1.NordError("Either symbol or market_id must be provided for orderbook query");
         }
-        return market.getOrderbook(this.webServerUrl, query);
+        return await this.GET("/market/{market_id}/orderbook", {
+            params: {
+                path: { market_id: marketId },
+            },
+        });
     }
     /**
      * Get information about the Nord server
@@ -451,7 +489,7 @@ class Nord {
      * @throws {NordError} If the request fails
      */
     async getInfo() {
-        return core.getInfo(this.webServerUrl);
+        return await this.GET("/info", {});
     }
     /**
      * Get account information
@@ -461,31 +499,33 @@ class Nord {
      * @throws {NordError} If the request fails
      */
     async getAccount(accountId) {
-        return core.getAccount(this.webServerUrl, accountId);
+        return await this.GET("/account/{account_id}", {
+            params: {
+                path: { account_id: accountId },
+            },
+        });
     }
     /**
      * Get market statistics (alias for marketsStats for backward compatibility)
      *
-     * @deprecated Use marketsStats instead
      * @returns Market statistics response
      */
-    async getMarketStats() {
-        return this.marketsStats();
+    async getMarketStats({ marketId, }) {
+        return await this.GET("/market/{market_id}/stats", {
+            params: {
+                path: { market_id: marketId },
+            },
+        });
     }
     /**
      * Check if an account exists for the given address
      *
      * @param address - The public key address to check
      * @returns True if the account exists, false otherwise
+     * @deprecated use getUser instead
      */
-    async accountExists(address) {
-        try {
-            await market.getUserAccountIds(this.webServerUrl, { pubkey: address });
-            return true;
-        }
-        catch {
-            return false;
-        }
+    async accountExists(pubkey) {
+        return !!(await this.getUser({ pubkey }));
     }
 }
 exports.Nord = Nord;

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

@@ -1,7 +1,7 @@
-import { Connection, PublicKey } from "@solana/web3.js";
+import { Connection, PublicKey, Transaction } from "@solana/web3.js";
 import Decimal from "decimal.js";
-import { SPLTokenInfo } from "@n1xyz/proton";
-import { FillMode, Order, Side } from "../../types";
+import { FillMode, Side, SPLTokenInfo } from "../../types";
+import * as proto from "../../gen/nord";
 import { BigIntValue } from "../../utils";
 import { Nord } from "./Nord";
 /**
@@ -17,7 +17,7 @@ export interface NordUserParams {
     /** Function to sign messages with the user's session key */
     sessionSignFn: (message: Uint8Array) => Promise<Uint8Array>;
     /** Function to sign transactions with the user's wallet (optional) */
-    transactionSignFn: (transaction: any) => Promise<any>;
+    transactionSignFn: <T extends Transaction>(tx: T) => Promise<T>;
     /** Solana connection (optional) */
     connection?: Connection;
     /** Session ID (optional) */
@@ -63,6 +63,31 @@ export interface TransferParams {
     /** Destination account ID */
     toAccountId: number;
 }
+/**
+ * Parameters for individual atomic subactions (user-friendly version)
+ */
+export interface UserAtomicSubaction {
+    /** The type of action to perform. */
+    kind: "place" | "cancel";
+    /** The market ID to place the order in. */
+    marketId?: number;
+    /** The order ID to cancel. */
+    orderId?: BigIntValue;
+    /** Order side (bid or ask) */
+    side?: Side;
+    /** Fill mode (limit, market, etc.) */
+    fillMode?: FillMode;
+    /** Whether the order is reduce-only. */
+    isReduceOnly?: boolean;
+    /** The size of the order. */
+    size?: Decimal.Value;
+    /** Order price */
+    price?: Decimal.Value;
+    /** Quote size (for market orders) */
+    quoteSize?: Decimal.Value;
+    /** The client order ID of the order. */
+    clientOrderId?: BigIntValue;
+}
 /**
  * User class for interacting with the Nord protocol
  */
@@ -76,7 +101,7 @@ export declare class NordUser {
     /** Function to sign messages with the user's session key */
     readonly sessionSignFn: (message: Uint8Array) => Promise<Uint8Array>;
     /** Function to sign transactions with the user's wallet */
-    readonly transactionSignFn: (transaction: any) => Promise<any>;
+    readonly transactionSignFn: <T extends Transaction>(tx: T) => Promise<T>;
     /** User balances by token symbol */
     balances: {
         [key: string]: {
@@ -85,10 +110,6 @@ export declare class NordUser {
             symbol: string;
         }[];
     };
-    /** User orders by market symbol */
-    orders: {
-        [key: string]: Order[];
-    };
     /** User positions by account ID */
     positions: {
         [key: string]: {
@@ -170,10 +191,26 @@ export declare class NordUser {
      *
      * @param amount - Amount to deposit
      * @param tokenId - Token ID
+     * @param recipient - Recipient address; defaults to the user's address
      * @returns Transaction signature
+     * @deprecated Use deposit instead
      * @throws {NordError} If required parameters are missing or operation fails
      */
-    depositSpl(amount: number, tokenId: number): Promise<string>;
+    depositSpl(amount: number, tokenId: number, recipient?: PublicKey): Promise<string>;
+    /**
+     * Deposit SPL tokens to the bridge
+     *
+     * @param amount - Amount to deposit
+     * @param tokenId - Token ID
+     * @param recipient - Recipient address; defaults to the user's address
+     * @returns Transaction signature
+     * @throws {NordError} If required parameters are missing or operation fails
+     */
+    deposit({ amount, tokenId, recipient, }: Readonly<{
+        amount: number;
+        tokenId: number;
+        recipient?: PublicKey;
+    }>): Promise<string>;
     /**
      * Get a new nonce for actions
      *
@@ -218,7 +255,10 @@ export declare class NordUser {
      * @param amount - Amount to withdraw
      * @throws {NordError} If the operation fails
      */
-    withdraw(tokenId: number, amount: number): Promise<{
+    withdraw({ amount, tokenId, }: Readonly<{
+        tokenId: number;
+        amount: number;
+    }>): Promise<{
         actionId: bigint;
     }>;
     /**
@@ -245,6 +285,19 @@ export declare class NordUser {
      * @throws {NordError} If the operation fails
      */
     transferToAccount(params: TransferParams): Promise<void>;
+    /**
+     * Execute up to four place/cancel operations atomically.
+     * Per Market:
+     * 1. cancels can only be in the start (one cannot predict future order ids)
+     * 2. intermediate trades can trade only
+     * 3. placements go last
+     *
+     * Across Markets, order action can be any
+     *
+     * @param userActions array of user-friendly subactions
+     * @param providedAccountId optional account performing the action (defaults to first account)
+     */
+    atomic(userActions: UserAtomicSubaction[], providedAccountId?: number): Promise<proto.Receipt_AtomicResult>;
     /**
      * Helper function to retry a promise with exponential backoff
      *

package/dist/nord/client/NordUser.js

@@ -56,8 +56,6 @@ class NordUser {
     constructor({ address, nord, publicKey, sessionPubKey, sessionSignFn, transactionSignFn, walletSignFn, connection, sessionId, }) {
         /** User balances by token symbol */
         this.balances = {};
-        /** User orders by market symbol */
-        this.orders = {};
         /** User positions by account ID */
         this.positions = {};
         /** User margins by account ID */
@@ -126,7 +124,6 @@ class NordUser {
         });
         // Copy other properties
         cloned.balances = { ...this.balances };
-        cloned.orders = { ...this.orders };
         cloned.positions = { ...this.positions };
         cloned.margins = { ...this.margins };
         cloned.accountIds = this.accountIds ? [...this.accountIds] : undefined;
@@ -231,10 +228,24 @@ class NordUser {
      *
      * @param amount - Amount to deposit
      * @param tokenId - Token ID
+     * @param recipient - Recipient address; defaults to the user's address
      * @returns Transaction signature
+     * @deprecated Use deposit instead
      * @throws {NordError} If required parameters are missing or operation fails
      */
-    async depositSpl(amount, tokenId) {
+    async depositSpl(amount, tokenId, recipient) {
+        return this.deposit({ amount, tokenId, recipient });
+    }
+    /**
+     * Deposit SPL tokens to the bridge
+     *
+     * @param amount - Amount to deposit
+     * @param tokenId - Token ID
+     * @param recipient - Recipient address; defaults to the user's address
+     * @returns Transaction signature
+     * @throws {NordError} If required parameters are missing or operation fails
+     */
+    async deposit({ amount, tokenId, recipient, }) {
         try {
             // Find the token info
             const tokenInfo = this.splTokenInfos.find((t) => t.tokenId === tokenId);
@@ -242,24 +253,22 @@ class NordUser {
                 throw new NordError_1.NordError(`Token with ID ${tokenId} not found`);
             }
             const mint = new web3_js_1.PublicKey(tokenInfo.mint);
-            // Get the user's token account
             const fromAccount = await this.getAssociatedTokenAccount(mint);
-            // Convert amount to BN with proper decimals
-            const amountBN = (0, proton_1.floatToBn)(amount, tokenInfo.precision);
-            // Create deposit parameters
-            const depositParams = {
-                amount: amountBN,
+            const payer = this.getSolanaPublicKey();
+            const { ix, extraSigner } = await this.nord.protonClient.buildDepositIx({
+                payer,
+                recipient: recipient ?? payer,
+                quantAmount: (0, proton_1.floatToScaledBigIntLossy)(amount, tokenInfo.precision),
                 mint,
-                fromAccount,
-            };
-            // Build the deposit transaction using proton client
-            const depositTx = await this.nord.protonClient.buildDepositTx(depositParams, this.getSolanaPublicKey(), this.connection);
-            const { blockhash } = await this.connection.getLatestBlockhash();
-            depositTx.recentBlockhash = blockhash;
-            depositTx.feePayer = this.getSolanaPublicKey();
-            const signedTx = await this.transactionSignFn(depositTx);
-            // TODO: should use `VersionedTransaction` and remove any for `transactionSignFn`,
-            // this is incredibly annoying to debug and i could've saved 30 mins.
+                sourceTokenAccount: fromAccount,
+            });
+            const { blockhash } = await this.connection.getLatestBlockhash("confirmed");
+            const tx = new web3_js_1.Transaction();
+            tx.add(ix);
+            tx.recentBlockhash = blockhash;
+            tx.feePayer = payer;
+            const signedTx = await this.transactionSignFn(tx);
+            signedTx.partialSign(extraSigner);
             const signature = await this.connection.sendRawTransaction(signedTx.serialize());
             return signature;
         }
@@ -285,9 +294,12 @@ class NordUser {
             if (!this.publicKey) {
                 throw new NordError_1.NordError("Public key is required to update account ID");
             }
-            const resp = await this.nord.getUserAccountIds({
+            const resp = await this.nord.getUser({
                 pubkey: this.publicKey.toBase58(),
             });
+            if (!resp) {
+                throw new NordError_1.NordError(`User ${this.publicKey.toBase58()} not found`);
+            }
             this.accountIds = resp.accountIds;
         }
         catch (error) {
@@ -320,16 +332,6 @@ class NordUser {
                         symbol: balance.token,
                     });
                 }
-                // Process orders
-                this.orders[accountData.accountId] = accountData.orders.map((order) => {
-                    return {
-                        orderId: order.orderId,
-                        isLong: order.side === "bid",
-                        size: order.size,
-                        price: order.price,
-                        marketId: order.marketId,
-                    };
-                });
                 // Process positions
                 this.positions[accountData.accountId] = accountData.positions;
                 // Process margins
@@ -343,7 +345,6 @@ class NordUser {
      * @throws {NordError} If the operation fails
      */
     async refreshSession() {
-        console.log(this.publicKey);
         this.sessionId = await (0, actions_1.createSession)(this.nord.webServerUrl, this.walletSignFn, await this.nord.getTimestamp(), this.getNonce(), {
             userPubkey: (0, utils_1.optExpect)(this.publicKey.toBytes(), "No user's public key"),
             sessionPubkey: this.sessionPubKey,
@@ -384,7 +385,7 @@ class NordUser {
      * @param amount - Amount to withdraw
      * @throws {NordError} If the operation fails
      */
-    async withdraw(tokenId, amount) {
+    async withdraw({ amount, tokenId, }) {
         try {
             this.checkSessionValidity();
             const { actionId } = await (0, actions_1.withdraw)(this.nord.webServerUrl, this.sessionSignFn, await this.nord.getTimestamp(), this.getNonce(), {
@@ -478,6 +479,62 @@ class NordUser {
             throw new NordError_1.NordError("Failed to transfer tokens", { cause: error });
         }
     }
+    /**
+     * Execute up to four place/cancel operations atomically.
+     * Per Market:
+     * 1. cancels can only be in the start (one cannot predict future order ids)
+     * 2. intermediate trades can trade only
+     * 3. placements go last
+     *
+     * Across Markets, order action can be any
+     *
+     * @param userActions array of user-friendly subactions
+     * @param providedAccountId optional account performing the action (defaults to first account)
+     */
+    async atomic(userActions, providedAccountId) {
+        try {
+            this.checkSessionValidity();
+            const accountId = providedAccountId != null ? providedAccountId : this.accountIds?.[0];
+            if (accountId == null) {
+                throw new NordError_1.NordError("Account ID is undefined. Make sure to call updateAccountId() before atomic operations.");
+            }
+            const apiActions = userActions.map((act) => {
+                if (act.kind === "place") {
+                    const market = (0, utils_1.findMarket)(this.nord.markets, act.marketId);
+                    if (!market) {
+                        throw new NordError_1.NordError(`Market ${act.marketId} not found`);
+                    }
+                    return {
+                        kind: "place",
+                        marketId: act.marketId,
+                        side: act.side,
+                        fillMode: act.fillMode,
+                        isReduceOnly: act.isReduceOnly,
+                        sizeDecimals: market.sizeDecimals,
+                        priceDecimals: market.priceDecimals,
+                        size: act.size,
+                        price: act.price,
+                        quoteSizeSize: act.quoteSize, // treated as quote size; we pass only size component
+                        quoteSizePrice: undefined,
+                        clientOrderId: act.clientOrderId,
+                    };
+                }
+                return {
+                    kind: "cancel",
+                    orderId: act.orderId,
+                };
+            });
+            const result = await (0, actions_1.atomic)(this.nord.webServerUrl, this.sessionSignFn, await this.nord.getTimestamp(), this.getNonce(), {
+                sessionId: (0, utils_1.optExpect)(this.sessionId, "No session"),
+                accountId: accountId,
+                actions: apiActions,
+            });
+            return result;
+        }
+        catch (error) {
+            throw new NordError_1.NordError("Atomic operation failed", { cause: error });
+        }
+    }
     /**
      * Helper function to retry a promise with exponential backoff
      *

package/dist/nord/index.d.ts

@@ -3,7 +3,5 @@ export { NordUser } from "./client/NordUser";
 export { NordError } from "./utils/NordError";
 export * from "./api/core";
 export * from "./api/metrics";
-export * from "./api/queries";
-export * from "./api/market";
 export * from "./api/actions";
 export * from "./models/Subscriber";

package/dist/nord/index.js

@@ -26,8 +26,6 @@ Object.defineProperty(exports, "NordError", { enumerable: true, get: function ()
 // Export API modules
 __exportStar(require("./api/core"), exports);
 __exportStar(require("./api/metrics"), exports);
-__exportStar(require("./api/queries"), exports);
-__exportStar(require("./api/market"), exports);
 __exportStar(require("./api/actions"), exports);
 // Export models
 __exportStar(require("./models/Subscriber"), exports);

package/dist/nord/models/Subscriber.d.ts

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