@n1xyz/nord-ts 0.1.6 → 0.1.8

package/dist/{nord/client → client}/Nord.js

@@ -1,56 +1,29 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        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 proton_1 = require("@n1xyz/proton");
-const web3_js_1 = require("@solana/web3.js");
-const events_1 = require("events");
-const openapi_fetch_1 = __importDefault(require("openapi-fetch"));
-const proto = __importStar(require("../../gen/nord_pb"));
-const types_1 = require("../../types");
-const utils = __importStar(require("../../utils"));
-const core = __importStar(require("../api/core"));
-const metrics = __importStar(require("../api/metrics"));
-const NordError_1 = require("../utils/NordError");
+import { ProtonClient } from "@n1xyz/proton";
+import { PublicKey } from "@solana/web3.js";
+import { EventEmitter } from "events";
+import createClient from "openapi-fetch";
+import * as proto from "../gen/nord_pb";
+import * as utils from "../utils";
+import { initWebSocketClient } from "../websocket";
+import { NordError } from "../error";
 /**
  * Main Nord client class for interacting with the Nord API
  */
-class Nord {
+export class Nord {
+    /** Base URL for the Nord web server */
+    webServerUrl;
+    /** Solana RPC URL */
+    solanaConnection;
+    /** Available markets */
+    markets = [];
+    /** Available tokens */
+    tokens = [];
+    /** Map of symbol to market_id */
+    symbolToMarketId = new Map();
+    /** Proton client for proton related operations */
+    protonClient;
+    /** HTTP client for Nord operations */
+    httpClient;
     /**
      * Create a new Nord client
      *
@@ -59,22 +32,18 @@ class Nord {
      * @param config.solanaUrl - Solana cluster URL
      * @throws {Error} If required configuration is missing
      */
-    constructor({ solanaUrl, webServerUrl, protonClient, }) {
-        /** Available markets */
-        this.markets = [];
-        /** Available tokens */
-        this.tokens = [];
-        /** Map of symbol to market_id */
-        this.symbolToMarketId = new Map();
+    constructor({ solanaConnection, webServerUrl, protonClient, }) {
         this.webServerUrl = webServerUrl;
-        this.solanaUrl = solanaUrl;
+        this.solanaConnection = solanaConnection;
         this.protonClient = protonClient;
-        this.httpClient = (0, openapi_fetch_1.default)({ baseUrl: webServerUrl });
+        this.httpClient = createClient({ baseUrl: webServerUrl });
     }
     /**
      * Create a WebSocket client with specific subscriptions
      *
-     * @param options - Subscription options that specify which data streams to subscribe to
+     * @param trades - Market symbols to subscribe to for trade updates
+     * @param deltas - Market symbols to subscribe to for orderbook delta updates
+     * @param accounts - Account IDs to subscribe to for account updates
      * @returns A new WebSocket client with the requested subscriptions
      * @throws {NordError} If invalid subscription options are provided
      *
@@ -92,45 +61,45 @@ class Nord {
      *   trades: ["BTCUSDC", "ETHUSDC"]
      * });
      */
-    createWebSocketClient(options) {
+    createWebSocketClient({ trades, deltas, accounts, }) {
         const subscriptions = [];
         // Add trade subscriptions
-        if (options.trades && options.trades.length > 0) {
-            options.trades.forEach((symbol) => {
+        if (trades && trades.length > 0) {
+            trades.forEach((symbol) => {
                 subscriptions.push(`trades@${symbol}`);
             });
         }
         // Add delta subscriptions
-        if (options.deltas && options.deltas.length > 0) {
-            options.deltas.forEach((symbol) => {
+        if (deltas && deltas.length > 0) {
+            deltas.forEach((symbol) => {
                 subscriptions.push(`deltas@${symbol}`);
             });
         }
         // Add account subscriptions
-        if (options.accounts && options.accounts.length > 0) {
-            options.accounts.forEach((accountId) => {
+        if (accounts && accounts.length > 0) {
+            accounts.forEach((accountId) => {
                 if (isNaN(accountId) || accountId <= 0) {
-                    throw new NordError_1.NordError(`Invalid account ID: ${accountId}. Must be a positive number.`);
+                    throw new NordError(`Invalid account ID: ${accountId}. Must be a positive number.`);
                 }
                 subscriptions.push(`account@${accountId}`);
             });
         }
         // Validate that at least one subscription was provided
         if (subscriptions.length === 0) {
-            throw new NordError_1.NordError("At least one subscription must be provided");
+            throw new NordError("At least one subscription must be provided");
         }
         // Create and return a new WebSocket client
-        return core.initWebSocketClient(this.webServerUrl, subscriptions);
+        return 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 });
+            throw new 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 });
+            throw new NordError("internal assertion violation", { cause: r });
         }
         return r.data;
     }
@@ -152,6 +121,15 @@ class Nord {
     async getActionNonce() {
         return await this.GET("/event/last-acked-nonce", {});
     }
+    /**
+     * Get the admin list from the Nord server
+     *
+     * @returns List of admin registration keys paired with their ACL role mask
+     * @throws {NordError} If the request fails
+     */
+    async getAdminList() {
+        return await this.GET("/admin", {});
+    }
     /**
      * Fetch information about Nord markets and tokens
      *
@@ -169,9 +147,13 @@ class Nord {
             });
         }
         catch (error) {
-            throw new NordError_1.NordError("Failed to fetch Nord info", { cause: error });
+            throw new NordError("Failed to fetch Nord info", { cause: error });
         }
     }
+    /** @deprecated use Nord.new */
+    static async initNord(x) {
+        return await Nord.new(x);
+    }
     /**
      * Initialize a new Nord client
      *
@@ -182,19 +164,15 @@ class Nord {
      * @returns Initialized Nord client
      * @throws {NordError} If initialization fails
      */
-    static async initNord({ app, solanaUrl, webServerUrl, protonUrl, }) {
-        // TODO: we should parametrize the connectionn not have it done here.
-        // this is a dogshit api, only here to be compatible with the shitty
-        // vibecoded code and not break zero one team's workflow.
-        const connection = new web3_js_1.Connection(solanaUrl, { commitment: "confirmed" });
-        const protonClient = await proton_1.ProtonClient.init({
+    static async new({ app, solanaConnection, webServerUrl, protonUrl, }) {
+        const protonClient = await ProtonClient.init({
             protonUrl: protonUrl ?? webServerUrl,
-            app: new web3_js_1.PublicKey(app),
-            solConn: connection,
+            app: new PublicKey(app),
+            solConn: solanaConnection,
         });
         const nord = new Nord({
             protonClient,
-            solanaUrl,
+            solanaConnection,
             webServerUrl,
         });
         await nord.init();
@@ -210,28 +188,28 @@ class Nord {
     /**
      * Query a specific action
      *
-     * @param query - Action query parameters
+     * @param actionId - Action identifier to fetch
      * @returns Action response
      * @throws {NordError} If the request fails
      */
-    async queryAction({ action_id, }) {
+    async queryAction({ actionId, }) {
         return ((await this.queryRecentActions({
-            from: action_id,
-            to: action_id,
+            from: actionId,
+            to: actionId,
         }))[0] ?? null);
     }
     /**
      * Query recent actions
      *
-     * @param from - Starting action index
-     * @param to - Ending action index
+     * @param from - Starting action index (inclusive)
+     * @param to - Ending action index (inclusive)
      * @returns Actions response
      * @throws {NordError} If the request fails
      */
-    async queryRecentActions(query) {
+    async queryRecentActions({ from, to, }) {
         const xs = await this.GET("/action", {
             params: {
-                query,
+                query: { from, to },
             },
         });
         return xs.map((x) => ({
@@ -249,66 +227,6 @@ class Nord {
     async getLastActionId() {
         return await this.GET("/action/last-executed-id", {});
     }
-    /**
-     * Fetch aggregate metrics from the Nord API
-     *
-     * @param txPeakTpsPeriod - Period for peak TPS calculation
-     * @param txPeakTpsPeriodUnit - Unit for peak TPS period
-     * @returns Aggregate metrics
-     * @throws {NordError} If the request fails
-     */
-    async aggregateMetrics(txPeakTpsPeriod = 1, txPeakTpsPeriodUnit = types_1.PeakTpsPeriodUnit.Day) {
-        return metrics.aggregateMetrics(this.webServerUrl, txPeakTpsPeriod, txPeakTpsPeriodUnit);
-    }
-    /**
-     * Get current transactions per second
-     *
-     * @param period - Time period for the query
-     * @returns Current TPS value
-     * @throws {NordError} If the request fails
-     */
-    async getCurrentTps(period = "1m") {
-        return metrics.getCurrentTps(this.webServerUrl, period);
-    }
-    /**
-     * Get peak transactions per second
-     *
-     * @param period - Time period for the query
-     * @returns Peak TPS value
-     * @throws {NordError} If the request fails
-     */
-    async getPeakTps(period = "24h") {
-        return metrics.getPeakTps(this.webServerUrl, period);
-    }
-    /**
-     * Get median transaction latency
-     *
-     * @param period - Time period for the query
-     * @returns Median latency in milliseconds
-     * @throws {NordError} If the request fails
-     */
-    async getMedianLatency(period = "1m") {
-        return metrics.getMedianLatency(this.webServerUrl, period);
-    }
-    /**
-     * Get total transaction count
-     *
-     * @returns Total transaction count
-     * @throws {NordError} If the request fails
-     */
-    async getTotalTransactions() {
-        return metrics.getTotalTransactions(this.webServerUrl);
-    }
-    /**
-     * Query Prometheus metrics
-     *
-     * @param params - Prometheus query parameters
-     * @returns Query result as a number
-     * @throws {NordError} If the request fails
-     */
-    async queryPrometheus(params) {
-        return metrics.queryPrometheus(this.webServerUrl, params);
-    }
     /**
      * Subscribe to orderbook updates for a market
      *
@@ -318,9 +236,9 @@ class Nord {
      */
     subscribeOrderbook(symbol) {
         if (!symbol || typeof symbol !== "string") {
-            throw new NordError_1.NordError("Invalid market symbol");
+            throw new NordError("Invalid market symbol");
         }
-        const subscription = new events_1.EventEmitter();
+        const subscription = new EventEmitter();
         const wsClient = this.createWebSocketClient({
             deltas: [symbol],
         });
@@ -346,9 +264,9 @@ class Nord {
      */
     subscribeTrades(symbol) {
         if (!symbol || typeof symbol !== "string") {
-            throw new NordError_1.NordError("Invalid market symbol");
+            throw new NordError("Invalid market symbol");
         }
-        const subscription = new events_1.EventEmitter();
+        const subscription = new EventEmitter();
         const wsClient = this.createWebSocketClient({
             trades: [symbol],
         });
@@ -374,9 +292,9 @@ class Nord {
      */
     subscribeAccount(accountId) {
         if (isNaN(accountId) || accountId <= 0) {
-            throw new NordError_1.NordError("Invalid account ID");
+            throw new NordError("Invalid account ID");
         }
-        const subscription = new events_1.EventEmitter();
+        const subscription = new EventEmitter();
         const wsClient = this.createWebSocketClient({
             accounts: [accountId],
         });
@@ -396,28 +314,35 @@ class Nord {
     /**
      * Get trades for a market
      *
-     * @param query - Trades query parameters
+     * @param marketId - Market identifier to filter by
+     * @param takerId - Taker account identifier
+     * @param makerId - Maker account identifier
+     * @param takerSide - Side executed by the taker
+     * @param pageSize - Maximum number of trades to return
+     * @param since - RFC3339 timestamp to start from (inclusive)
+     * @param until - RFC3339 timestamp to end at (exclusive)
+     * @param pageId - Pagination cursor returned from a prior call
      * @returns Trades response
      * @throws {NordError} If the request fails
      */
-    async getTrades(query) {
-        if (query.sinceRcf3339 && !utils.isRfc3339(query.sinceRcf3339)) {
-            throw new NordError_1.NordError(`Invalid RFC3339 timestamp: ${query.sinceRcf3339}`);
+    async getTrades({ marketId, takerId, makerId, takerSide, pageSize, since, until, startInclusive, }) {
+        if (since && !utils.isRfc3339(since)) {
+            throw new NordError(`Invalid RFC3339 timestamp: ${since}`);
         }
-        if (query.untilRfc3339 && !utils.isRfc3339(query.untilRfc3339)) {
-            throw new NordError_1.NordError(`Invalid RFC3339 timestamp: ${query.untilRfc3339}`);
+        if (until && !utils.isRfc3339(until)) {
+            throw new NordError(`Invalid RFC3339 timestamp: ${until}`);
         }
         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,
+                    takerId,
+                    makerId,
+                    marketId,
+                    pageSize,
+                    takerSide,
+                    since,
+                    until,
+                    startInclusive,
                 },
             },
         });
@@ -425,14 +350,14 @@ class Nord {
     /**
      * Get user account IDs
      *
-     * @param query - User account IDs query parameters
+     * @param pubkey - User public key to query
      * @returns User account IDs response
      * @throws {NordError} If the request fails
      */
-    async getUser(query) {
+    async getUser({ pubkey, }) {
         const r = await this.httpClient.GET("/user/{pubkey}", {
             params: {
-                path: { pubkey: query.pubkey.toString() },
+                path: { pubkey: pubkey.toString() },
             },
         });
         if (r.response.status === 404) {
@@ -443,35 +368,36 @@ class Nord {
     /**
      * Get orderbook for a market
      *
-     * @param query - Orderbook query parameters (either market_id or symbol must be provided)
+     * @param symbol - Market symbol to resolve into an id
+     * @param marketId - Market identifier
      * @returns Orderbook response
      * @throws {NordError} If the request fails or if the market symbol is unknown
      * @remarks It's recommended to initialize the Nord client using the static `initNord` method
      * to ensure market information is properly loaded before calling this method.
      */
-    async getOrderbook(query) {
+    async getOrderbook({ symbol, marketId, }) {
         // If only symbol is provided, convert it to market_id
-        let marketId;
-        if (query.symbol && query.market_id === undefined) {
+        let _marketId;
+        if (symbol && marketId === undefined) {
             // If the map is empty, try to fetch market information first
             if (this.symbolToMarketId.size === 0) {
                 await this.fetchNordInfo();
             }
-            const id = this.symbolToMarketId.get(query.symbol);
+            const id = this.symbolToMarketId.get(symbol);
             if (id === undefined) {
-                throw new NordError_1.NordError(`Unknown market symbol: ${query.symbol}`);
+                throw new NordError(`Unknown market symbol: ${symbol}`);
             }
-            marketId = id;
+            _marketId = id;
         }
-        else if (query.market_id !== undefined) {
-            marketId = query.market_id;
+        else if (marketId !== undefined) {
+            _marketId = marketId;
         }
         else {
-            throw new NordError_1.NordError("Either symbol or market_id must be provided for orderbook query");
+            throw new NordError("Either symbol or market_id must be provided for orderbook query");
         }
         return await this.GET("/market/{market_id}/orderbook", {
             params: {
-                path: { market_id: marketId },
+                path: { market_id: _marketId },
             },
         });
     }
@@ -553,30 +479,34 @@ class Nord {
      * Get open orders for an account.
      *
      * @param accountId - Account id to query
-     * @param query - Optional pagination parameters
+     * @param startInclusive - Pagination cursor (client order id) to resume from
+     * @param pageSize - Maximum number of orders to return
      * @returns Page of orders keyed by client order id
      * @throws {NordError} If the request fails
      */
-    async getAccountOrders(accountId, query) {
+    async getAccountOrders(accountId, { startInclusive, pageSize, } = {}) {
         return await this.GET("/account/{account_id}/orders", {
             params: {
                 path: { account_id: accountId },
                 query: {
-                    startInclusive: query?.startInclusive,
-                    pageSize: query?.pageSize,
+                    startInclusive,
+                    pageSize,
                 },
             },
         });
     }
     /**
      * List account fee tiers with pagination support.
+     *
+     * @param startInclusive - Account id cursor to resume from
+     * @param pageSize - Maximum number of entries to return
      */
-    async getAccountsFeeTiers(query) {
+    async getAccountsFeeTiers({ startInclusive, pageSize, } = {}) {
         return await this.GET("/accounts/fee-tiers", {
             params: {
                 query: {
-                    startInclusive: query?.startInclusive ?? undefined,
-                    pageSize: query?.pageSize ?? undefined,
+                    startInclusive: startInclusive ?? undefined,
+                    pageSize: pageSize ?? undefined,
                 },
             },
         });
@@ -585,19 +515,22 @@ class Nord {
      * Get profit and loss history for an account
      *
      * @param accountId - Account ID to query
-     * @param query - Optional time and pagination filters
+     * @param since - RFC3339 timestamp to start from (inclusive)
+     * @param until - RFC3339 timestamp to end at (exclusive)
+     * @param startInclusive - Pagination cursor to resume from
+     * @param pageSize - Maximum number of entries to return
      * @returns Page of PnL entries ordered from latest to oldest
      * @throws {NordError} If the request fails
      */
-    async getAccountPnl(accountId, query) {
+    async getAccountPnl(accountId, { since, until, startInclusive, pageSize, } = {}) {
         return await this.GET("/account/{account_id}/pnl", {
             params: {
                 path: { account_id: accountId },
                 query: {
-                    since: query?.since,
-                    until: query?.until,
-                    startInclusive: query?.startInclusive,
-                    pageSize: query?.pageSize,
+                    since,
+                    until,
+                    startInclusive,
+                    pageSize,
                 },
             },
         });
@@ -605,6 +538,9 @@ class Nord {
     /**
      * Get market statistics (alias for marketsStats for backward compatibility)
      *
+     *
+     * @param marketId - Market identifier
+     *
      * @returns Market statistics response
      */
     async getMarketStats({ marketId, }) {
@@ -617,7 +553,9 @@ class Nord {
     /**
      * Fetch the per-market fee quote for an account.
      *
-     * @param params - Market id, fee kind, and account id to quote
+     * @param marketId - Market identifier
+     * @param feeKind - Fill role (maker/taker) to quote
+     * @param accountId - Account identifier to quote
      * @returns Fee in quote token units (negative means fee is charged)
      * @throws {NordError} If the request fails
      */
@@ -664,17 +602,18 @@ class Nord {
      * Get trade history for a specific order.
      *
      * @param orderId - Order identifier
-     * @param query - Optional pagination parameters
+     * @param startInclusive - Trade pagination cursor
+     * @param pageSize - Maximum number of trades to return
      * @returns Page of trades associated with the order
      * @throws {NordError} If the request fails
      */
-    async getOrderTrades(orderId, query) {
+    async getOrderTrades(orderId, { startInclusive, pageSize, } = {}) {
         return await this.GET("/order/{order_id}/trades", {
             params: {
                 path: { order_id: orderId },
                 query: {
-                    startInclusive: query?.startInclusive,
-                    pageSize: query?.pageSize,
+                    startInclusive,
+                    pageSize,
                 },
             },
         });
@@ -692,13 +631,12 @@ class Nord {
     /**
      * Fetch active triggers for an account.
      *
-     * @param params Optional parameters containing an explicit account id.
+     * @param accountId - Account identifier owning the triggers
      * @throws {NordError} If no account can be resolved or the request fails.
      */
-    async getAccountTriggers(params) {
-        const accountId = params?.accountId;
+    async getAccountTriggers({ accountId, } = {}) {
         if (accountId == null) {
-            throw new NordError_1.NordError("Account ID is undefined. Make sure to call updateAccountId() before requesting triggers.");
+            throw new NordError("Account ID is undefined. Make sure to call updateAccountId() before requesting triggers.");
         }
         try {
             const triggers = await this.GET("/account/{account_id}/triggers", {
@@ -709,39 +647,40 @@ class Nord {
             return triggers ?? [];
         }
         catch (error) {
-            throw new NordError_1.NordError("Failed to fetch account triggers", { cause: error });
+            throw new NordError("Failed to fetch account triggers", { cause: error });
         }
     }
     /**
      * Fetch trigger history for an account.
      *
-     * @param params Optional parameters with account id and history query filters.
+     * @param accountId - Account identifier owning the triggers
+     * @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 getAccountTriggerHistory(params) {
-        const accountId = params?.accountId;
+    async getAccountTriggerHistory({ accountId, since, until, pageSize, startInclusive, }) {
         if (accountId == null) {
-            throw new NordError_1.NordError("Account ID is undefined. Make sure to call updateAccountId() before requesting trigger history.");
+            throw new NordError("Account ID is undefined. Make sure to call updateAccountId() before requesting trigger history.");
         }
-        const { accountId: _, ...query } = params;
         try {
             return await this.GET("/account/{account_id}/triggers/history", {
                 params: {
                     path: { account_id: accountId },
                     query: {
-                        since: query.since,
-                        until: query.until,
-                        pageSize: query.pageSize,
-                        startInclusive: query.startInclusive,
+                        since,
+                        until,
+                        pageSize,
+                        startInclusive,
                     },
                 },
             });
         }
         catch (error) {
-            throw new NordError_1.NordError("Failed to fetch account trigger history", {
+            throw new NordError("Failed to fetch account trigger history", {
                 cause: error,
             });
         }
     }
 }
-exports.Nord = Nord;