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

package/dist/nord/client/Nord.js

@@ -1,491 +0,0 @@
-"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;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Nord = void 0;
-const events_1 = require("events");
-const types_1 = require("../../types");
-const proton_1 = require("@n1xyz/proton");
-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 NordError_1 = require("../utils/NordError");
-const web3_js_1 = require("@solana/web3.js");
-/**
- * Main Nord client class for interacting with the Nord API
- */
-class Nord {
-    /**
-     * Create a new Nord client
-     *
-     * @param config - Configuration options for the Nord client
-     * @param config.webServerUrl - Base URL for the Nord web server
-     * @param config.bridgeVk - Bridge verification key
-     * @param config.solanaUrl - Solana cluster URL
-     * @throws {Error} If required configuration is missing
-     */
-    constructor({ bridgeVk, solanaUrl, webServerUrl, protonClient, }) {
-        /** Available markets */
-        this.markets = [];
-        /** Available tokens */
-        this.tokens = [];
-        /** Map of symbol to market_id */
-        this.symbolToMarketId = new Map();
-        this.webServerUrl = webServerUrl;
-        this.bridgeVk = bridgeVk;
-        this.solanaUrl = solanaUrl;
-        this.protonClient = protonClient;
-    }
-    /**
-     * Create a WebSocket client with specific subscriptions
-     *
-     * @param options - Subscription options that specify which data streams to subscribe to
-     * @returns A new WebSocket client with the requested subscriptions
-     * @throws {NordError} If invalid subscription options are provided
-     *
-     * @example
-     * // Create a client for trades and deltas from one market and an account
-     * const wsClient = nord.createWebSocketClient({
-     *   trades: ["BTCUSDC"],
-     *   deltas: ["BTCUSDC"],
-     *   accounts: [123]
-     * });
-     *
-     * @example
-     * // Create a client for trades from multiple markets
-     * const tradesClient = nord.createWebSocketClient({
-     *   trades: ["BTCUSDC", "ETHUSDC"]
-     * });
-     */
-    createWebSocketClient(options) {
-        const subscriptions = [];
-        // Add trade subscriptions
-        if (options.trades && options.trades.length > 0) {
-            options.trades.forEach((symbol) => {
-                subscriptions.push(`trades@${symbol}`);
-            });
-        }
-        // Add delta subscriptions
-        if (options.deltas && options.deltas.length > 0) {
-            options.deltas.forEach((symbol) => {
-                subscriptions.push(`deltas@${symbol}`);
-            });
-        }
-        // Add account subscriptions
-        if (options.accounts && options.accounts.length > 0) {
-            options.accounts.forEach((accountId) => {
-                if (isNaN(accountId) || accountId <= 0) {
-                    throw new NordError_1.NordError(`Invalid account ID: ${accountId}. Must be a positive number.`);
-                }
-                subscriptions.push(`account@${accountId}`);
-            });
-        }
-        // Validate that at least one subscription was provided
-        if (subscriptions.length === 0) {
-            throw new NordError_1.NordError("At least one subscription must be provided");
-        }
-        // Create and return a new WebSocket client
-        return core.initWebSocketClient(this.webServerUrl, subscriptions);
-    }
-    /**
-     * Get the current timestamp from the Nord server
-     *
-     * @returns Current timestamp as a bigint
-     * @throws {NordError} If the request fails
-     */
-    async getTimestamp() {
-        return core.getTimestamp(this.webServerUrl);
-    }
-    /**
-     * Get the last event nonce from the Nord server
-     *
-     * @returns Next action nonce
-     * @throws {NordError} If the request fails
-     */
-    async getActionNonce() {
-        return core.getLastEventNonce(this.webServerUrl);
-    }
-    /**
-     * Fetch information about Nord markets and tokens
-     *
-     * @throws {NordError} If the request fails
-     */
-    async fetchNordInfo() {
-        try {
-            const info = await core.getInfo(this.webServerUrl);
-            this.markets = info.markets;
-            this.tokens = info.tokens;
-            // Populate the symbolToMarketId map
-            this.symbolToMarketId.clear();
-            info.markets.forEach((market) => {
-                this.symbolToMarketId.set(market.symbol, market.marketId);
-            });
-        }
-        catch (error) {
-            throw new NordError_1.NordError("Failed to fetch Nord info", { cause: error });
-        }
-    }
-    /**
-     * Initialize a new Nord client
-     *
-     * @param nordConfig - Configuration options for the Nord client
-     * @param nordConfig.webServerUrl - Base URL for the Nord web server
-     * @param nordConfig.bridgeVk - Bridge verification key
-     * @param nordConfig.solanaUrl - Solana cluster URL
-     * @returns Initialized Nord client
-     * @throws {NordError} If initialization fails
-     */
-    static async initNord({ bridgeVk: bridgeVk_, solanaUrl, webServerUrl, }) {
-        // 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 bridgeVk = new web3_js_1.PublicKey(bridgeVk_);
-        const protonClient = await proton_1.ProtonClient.init({
-            protonUrl: webServerUrl,
-            bridgeVk,
-            solConn: connection,
-        });
-        const nord = new Nord({
-            bridgeVk,
-            protonClient,
-            solanaUrl,
-            webServerUrl,
-        });
-        await nord.init();
-        return nord;
-    }
-    /**
-     * Initialize the Nord client
-     * @private
-     */
-    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
-     *
-     * @param query - Action query parameters
-     * @returns Action response
-     * @throws {NordError} If the request fails
-     */
-    async queryAction(query) {
-        return queries.queryAction(this.webServerUrl, query);
-    }
-    /**
-     * Query recent actions
-     *
-     * @param from - Starting action index
-     * @param to - Ending action index
-     * @returns Actions response
-     * @throws {NordError} If the request fails
-     */
-    async queryRecentActions(from, to) {
-        return queries.queryRecentActions(this.webServerUrl, from, to);
-    }
-    /**
-     * Get the last action ID
-     *
-     * @returns Last action ID
-     * @throws {NordError} If the request fails
-     */
-    async getLastActionId() {
-        return queries.getLastActionId(this.webServerUrl);
-    }
-    /**
-     * 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 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
-     *
-     * @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
-     *
-     * @param symbol - Market symbol
-     * @returns Orderbook subscription
-     * @throws {NordError} If symbol is invalid
-     */
-    subscribeOrderbook(symbol) {
-        if (!symbol || typeof symbol !== "string") {
-            throw new NordError_1.NordError("Invalid market symbol");
-        }
-        const subscription = new events_1.EventEmitter();
-        const wsClient = this.createWebSocketClient({
-            deltas: [symbol],
-        });
-        const handleDelta = (update) => {
-            if (update.symbol !== symbol) {
-                return;
-            }
-            subscription.emit("message", update);
-        };
-        wsClient.on("delta", handleDelta);
-        subscription.close = () => {
-            wsClient.unsubscribe([`deltas@${symbol}`]);
-            wsClient.removeListener("delta", handleDelta);
-            subscription.removeAllListeners();
-        };
-        return subscription;
-    }
-    /**
-     * Subscribe to trade updates for a market
-     *
-     * @param symbol - Market symbol
-     * @returns Trade subscription
-     * @throws {NordError} If symbol is invalid
-     */
-    subscribeTrades(symbol) {
-        if (!symbol || typeof symbol !== "string") {
-            throw new NordError_1.NordError("Invalid market symbol");
-        }
-        const subscription = new events_1.EventEmitter();
-        const wsClient = this.createWebSocketClient({
-            trades: [symbol],
-        });
-        const handleTrade = (update) => {
-            if (update.symbol !== symbol) {
-                return;
-            }
-            subscription.emit("message", update);
-        };
-        wsClient.on("trades", handleTrade);
-        subscription.close = () => {
-            wsClient.unsubscribe([`trades@${symbol}`]);
-            wsClient.removeListener("trades", handleTrade);
-            subscription.removeAllListeners();
-        };
-        return subscription;
-    }
-    /**
-     * Subscribe to account updates
-     *
-     * @param accountId - Account ID to subscribe to
-     * @returns User subscription
-     * @throws {NordError} If accountId is invalid
-     */
-    subscribeAccount(accountId) {
-        if (isNaN(accountId) || accountId <= 0) {
-            throw new NordError_1.NordError("Invalid account ID");
-        }
-        const subscription = new events_1.EventEmitter();
-        const wsClient = this.createWebSocketClient({
-            accounts: [accountId],
-        });
-        const handleAccountUpdate = (update) => {
-            if (update.account_id !== accountId) {
-                return;
-            }
-            subscription.emit("message", update);
-        };
-        wsClient.on("account", handleAccountUpdate);
-        subscription.close = () => {
-            wsClient.unsubscribe([`account@${accountId}`]);
-            wsClient.removeListener("account", handleAccountUpdate);
-            subscription.removeAllListeners();
-        };
-        return subscription;
-    }
-    /**
-     * Get trades for a market
-     *
-     * @param query - Trades query parameters
-     * @returns Trades response
-     * @throws {NordError} If the request fails
-     */
-    async getTrades(query) {
-        return market.getTrades(this.webServerUrl, query);
-    }
-    /**
-     * Get user account IDs
-     *
-     * @param query - User account IDs query parameters
-     * @returns User account IDs response
-     * @throws {NordError} If the request fails
-     */
-    async getUserAccountIds(query) {
-        return market.getUserAccountIds(this.webServerUrl, query);
-    }
-    /**
-     * Get orderbook for a market
-     *
-     * @param query - Orderbook query parameters (either market_id or symbol must be provided)
-     * @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) {
-        // If only symbol is provided, convert it to market_id
-        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) {
-                throw new NordError_1.NordError(`Unknown market symbol: ${query.symbol}`);
-            }
-            query = { market_id: marketId };
-        }
-        return market.getOrderbook(this.webServerUrl, query);
-    }
-    /**
-     * Get information about the Nord server
-     *
-     * @returns Information about markets and tokens
-     * @throws {NordError} If the request fails
-     */
-    async getInfo() {
-        return core.getInfo(this.webServerUrl);
-    }
-    /**
-     * Get account information
-     *
-     * @param accountId - Account ID to get information for
-     * @returns Account information
-     * @throws {NordError} If the request fails
-     */
-    async getAccount(accountId) {
-        return core.getAccount(this.webServerUrl, accountId);
-    }
-    /**
-     * Get market statistics (alias for marketsStats for backward compatibility)
-     *
-     * @deprecated Use marketsStats instead
-     * @returns Market statistics response
-     */
-    async getMarketStats() {
-        return this.marketsStats();
-    }
-    /**
-     * 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
-     */
-    async accountExists(address) {
-        try {
-            await market.getUserAccountIds(this.webServerUrl, { pubkey: address });
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-}
-exports.Nord = Nord;