@n1xyz/nord-ts 0.0.1 → 0.0.4

package/dist/nord/Nord.js

@@ -32,345 +32,357 @@ 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.Subscriber = exports.Nord = void 0;
-exports.depositOnlyTx = depositOnlyTx;
-exports.depositOnlyTxRaw = depositOnlyTxRaw;
-exports.createWebSocketSubscription = createWebSocketSubscription;
-const ethers_1 = require("ethers");
-const ws_1 = __importDefault(require("ws"));
+exports.Nord = void 0;
+const events_1 = require("events");
 const types_1 = require("../types");
-const utils_1 = require("../utils");
-const const_1 = require("../const");
-const abis_1 = require("../abis");
-const proto = __importStar(require("../gen/nord"));
-async function depositOnlyTx(privateAddress, publicKey, amount, precision, contractAddress) {
-    const provider = new ethers_1.ethers.JsonRpcProvider(process.env.SECRET_FAUCET_RPC);
-    const wallet = new ethers_1.ethers.Wallet(privateAddress, provider);
-    const nordContract = new ethers_1.ethers.Contract(contractAddress, abis_1.NORD_RAMP_FACET_ABI, wallet);
-    const depositTx = await nordContract.depositUnchecked(publicKey, BigInt(0), ethers_1.ethers.parseUnits(amount.toString(), precision), {
-        gasLimit: 1000000,
-        maxFeePerGas: ethers_1.ethers.parseUnits("100", "gwei"),
-        maxPriorityFeePerGas: ethers_1.ethers.parseUnits("0.01", "gwei"),
-    });
-    return depositTx.hash;
-}
-async function depositOnlyTxRaw(privateAddress, publicKey, amount, precision, contractAddress) {
-    const provider = new ethers_1.ethers.JsonRpcProvider(process.env.SECRET_FAUCET_RPC);
-    const wallet = new ethers_1.ethers.Wallet(privateAddress, provider);
-    const nordContract = new ethers_1.ethers.Contract(contractAddress, abis_1.NORD_RAMP_FACET_ABI, wallet);
-    const depositTx = await nordContract.depositUnchecked.populateTransaction(publicKey, BigInt(0), ethers_1.ethers.parseUnits(amount.toString(), precision), {
-        maxFeePerGas: ethers_1.ethers.parseUnits("0.0003", "gwei"),
-        maxPriorityFeePerGas: ethers_1.ethers.parseUnits("0.0003", "gwei"),
-    });
-    return JSON.stringify(depositTx);
-}
-function makeNordImpl(nord) {
-    return {
-        getTimestamp: () => nord.getTimestamp().then((x) => x + 1n),
-    };
-}
+const NordError_1 = require("./NordError");
+const core = __importStar(require("./core"));
+const metrics = __importStar(require("./metrics"));
+const queries = __importStar(require("./queries"));
+const market = __importStar(require("./market"));
+/**
+ * Main Nord client class for interacting with the Nord API
+ */
 class Nord {
-    constructor({ evmUrl, webServerUrl, tokenInfos, contractAddress, }) {
-        this.impl = makeNordImpl(this);
-        this.evmUrl = evmUrl;
-        this.webServerUrl = webServerUrl;
-        this.tokenInfos = tokenInfos;
-        this.contractAddress = contractAddress;
+    /**
+     * Create a new Nord client instance
+     *
+     * @param config - Configuration options for the Nord client
+     * @throws {Error} If required configuration is missing
+     */
+    constructor({ webServerUrl, tokenInfos, solanaProgramId, solanaUrl, }) {
+        /** Available markets */
         this.markets = [];
+        /** Available tokens */
         this.tokens = [];
+        if (!webServerUrl) {
+            throw new NordError_1.NordError("webServerUrl is required");
+        }
+        this.webServerUrl = webServerUrl;
+        this.tokenInfos = tokenInfos || [];
+        this.solanaProgramId = solanaProgramId;
+        this.solanaUrl = solanaUrl;
+        // Initialize WebSocket client
+        this.ws = core.initWebSocketClient(webServerUrl);
     }
+    /**
+     * Get the current timestamp from the Nord server
+     *
+     * @returns Current timestamp as a bigint
+     * @throws {NordError} If the request fails
+     */
     async getTimestamp() {
-        const resp = await (await (0, utils_1.checkedFetch)(`${this.webServerUrl}/timestamp`, { method: "GET" })).json();
-        return BigInt(resp);
+        return core.getTimestamp(this.webServerUrl);
     }
+    /**
+     * Get the next action nonce from the Nord server
+     *
+     * @returns Next action nonce
+     * @throws {NordError} If the request fails
+     */
     async getActionNonce() {
-        const resp = await (await (0, utils_1.checkedFetch)(`${this.webServerUrl}/action_nonce`, { method: "GET" })).json();
-        return resp;
+        return core.getActionNonce(this.webServerUrl);
     }
+    /**
+     * Fetch information about Nord markets and tokens
+     *
+     * @throws {NordError} If the request fails
+     */
     async fetchNordInfo() {
-        const response = await (0, utils_1.checkedFetch)(`${this.webServerUrl}/info`, {
-            method: "GET",
-        });
-        const info = await response.json();
-        this.markets = info.markets;
-        this.tokens = info.tokens;
+        try {
+            const info = await core.getInfo(this.webServerUrl);
+            this.markets = info.markets;
+            this.tokens = info.tokens;
+        }
+        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
+     * @returns Initialized Nord client
+     * @throws {NordError} If initialization fails
+     */
     static async initNord(nordConfig) {
         const nord = new Nord(nordConfig);
         await nord.fetchNordInfo();
         return nord;
     }
-    static async initDevNord() {
-        const nord = new Nord({
-            evmUrl: const_1.EVM_DEV_URL,
-            webServerUrl: const_1.WEBSERVER_DEV_URL,
-            tokenInfos: const_1.DEV_TOKEN_INFOS,
-            contractAddress: const_1.DEV_CONTRACT_ADDRESS,
-        });
-        await nord.fetchNordInfo();
-        return nord;
-    }
+    /**
+     * Get market statistics
+     *
+     * @returns Market statistics response
+     * @throws {NordError} If the request fails
+     */
     async marketsStats() {
-        const response = await (0, utils_1.checkedFetch)(`${this.webServerUrl}/stats`, {
-            method: "GET",
-        });
-        const stats = await response.json();
-        return stats;
+        return market.marketsStats(this.webServerUrl);
     }
-    // Query the block info from rollman.
+    /**
+     * Query a specific block
+     *
+     * @param query - Block query parameters
+     * @returns Block response
+     * @throws {NordError} If the request fails
+     */
     async queryBlock(query) {
-        const rollmanResponse = await this.blockQueryRollman(query);
-        const queryResponse = {
-            block_number: rollmanResponse.block_number,
-            actions: [],
-        };
-        for (const rollmanAction of rollmanResponse.actions) {
-            const blockAction = {
-                action_id: rollmanAction.action_id,
-                action: (0, utils_1.decodeLengthDelimited)(new Uint8Array(rollmanAction.action_pb), proto.Action),
-                exec_timestamp: rollmanAction.exec_timestamp,
-            };
-            queryResponse.actions.push(blockAction);
-        }
-        return queryResponse;
+        return queries.queryBlock(this.webServerUrl, query);
     }
-    // Query the block info from rollman.
+    /**
+     * Query the last N blocks
+     *
+     * @returns Block response for the last N blocks
+     * @throws {NordError} If the request fails
+     */
     async queryLastNBlocks() {
-        const rollmanResponse = await this.blockQueryRollman({});
-        const queryResponse = {
-            block_number: rollmanResponse.block_number,
-            actions: [],
-        };
-        for (const rollmanAction of rollmanResponse.actions) {
-            const blockAction = {
-                action_id: rollmanAction.action_id,
-                action: (0, utils_1.decodeLengthDelimited)(rollmanAction.action_pb, proto.Action),
-                exec_timestamp: rollmanAction.exec_timestamp,
-            };
-            queryResponse.actions.push(blockAction);
-        }
-        return queryResponse;
+        return queries.queryLastNBlocks(this.webServerUrl);
     }
-    // Query the block summary of recent blocks from rollman.
+    /**
+     * Query recent blocks
+     *
+     * @param last_n - Number of recent blocks to query
+     * @returns Block summary response
+     * @throws {NordError} If the request fails
+     */
     async queryRecentBlocks(last_n) {
-        const response = await this.blockSummaryQueryRollman(last_n);
-        return response;
+        return queries.queryRecentBlocks(this.webServerUrl, last_n);
     }
-    // Query the action info from rollman.
+    /**
+     * Query a specific action
+     *
+     * @param query - Action query parameters
+     * @returns Action response
+     * @throws {NordError} If the request fails
+     */
     async queryAction(query) {
-        const rollmanResponse = await this.actionQueryRollman(query);
-        return {
-            block_number: rollmanResponse.block_number,
-            action: (0, utils_1.decodeLengthDelimited)(rollmanResponse.action_pb, proto.Action),
-        };
+        return queries.queryAction(this.webServerUrl, query);
     }
-    // Query the recent transactions from rollman.
+    /**
+     * Query recent actions
+     *
+     * @param last_n - Number of recent actions to query
+     * @returns Actions response
+     * @throws {NordError} If the request fails
+     */
     async queryRecentActions(last_n) {
-        const rollmanResponse = await this.actionsQueryRollman(last_n);
-        const queryResponse = {
-            actions: [],
-        };
-        for (const rollmanExtendedAction of rollmanResponse.actions) {
-            const extendedActionInfo = {
-                block_number: rollmanExtendedAction.block_number,
-                action_id: rollmanExtendedAction.action_id,
-                action: (0, utils_1.decodeLengthDelimited)(rollmanExtendedAction.action_pb, proto.Action),
-            };
-            queryResponse.actions.push(extendedActionInfo);
-        }
-        return queryResponse;
+        return queries.queryRecentActions(this.webServerUrl, last_n);
     }
-    // Query the aggregate metrics across nord and rollman.
+    /**
+     * 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) {
-        // Get the latest block number for L2 blocks.
-        const blockQuery = {};
-        const rollmanResponse = await this.blockQueryRollman(blockQuery);
-        const period = txPeakTpsPeriod.toString() + txPeakTpsPeriodUnit;
-        const query = `max_over_time(rate(nord_requests_ok_count[1m])[${period}:1m])`;
-        return {
-            blocks_total: rollmanResponse.block_number,
-            tx_total: await this.queryPrometheus("nord_requests_ok_count"),
-            tx_tps: await this.getCurrentTps(),
-            tx_tps_peak: await this.queryPrometheus(query),
-            request_latency_average: await this.queryPrometheus('nord_requests_ok_latency{quantile="0.5"}'),
-        };
+        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 await this.queryPrometheus("rate(nord_requests_ok_count[" + period + "])");
+        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 await this.queryPrometheus("max_over_time(rate(nord_requests_ok_count[30s])[" + period + ":])");
+        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 await this.queryPrometheus(`avg_over_time(nord_requests_ok_latency{quantile="0.5"}[${period}])`);
+        return metrics.getMedianLatency(this.webServerUrl, period);
     }
+    /**
+     * Get total transaction count
+     *
+     * @returns Total transaction count
+     * @throws {NordError} If the request fails
+     */
     async getTotalTransactions() {
-        return await (await (0, utils_1.checkedFetch)(this.webServerUrl + "/last_actionid")).text();
+        return metrics.getTotalTransactions(this.webServerUrl);
     }
-    // Helper to query rollman for block info.
+    /**
+     * Query a block from Rollman
+     *
+     * @param query - Block query parameters
+     * @returns Rollman block response
+     * @throws {NordError} If the request fails
+     */
     async blockQueryRollman(query) {
-        let url = this.webServerUrl + "/block_query";
-        if (query.block_number != null) {
-            url = url + "?block_number=" + query.block_number;
-        }
-        const response = await (0, utils_1.checkedFetch)(url);
-        if (!response.ok) {
-            throw new Error("Rollman query failed " + url);
-        }
-        return await response.json();
+        return queries.blockQueryRollman(this.webServerUrl, query);
     }
-    // Helper to query rollman for recent block summary.
+    /**
+     * Query block summaries from Rollman
+     *
+     * @param last_n - Number of recent blocks to query
+     * @returns Block summary response
+     * @throws {NordError} If the request fails
+     */
     async blockSummaryQueryRollman(last_n) {
-        const url = this.webServerUrl + "/last_n_blocks?last_n=" + last_n;
-        const response = await (0, utils_1.checkedFetch)(url);
-        if (!response.ok) {
-            throw new Error("Rollman query failed " + url);
-        }
-        return await response.json();
+        return queries.blockSummaryQueryRollman(this.webServerUrl, last_n);
     }
-    // Helper to query rollman for action info.
+    /**
+     * Query an action from Rollman
+     *
+     * @param query - Action query parameters
+     * @returns Rollman action response
+     * @throws {NordError} If the request fails
+     */
     async actionQueryRollman(query) {
-        const url = this.webServerUrl + "/tx_query?action_id=" + query.action_id;
-        const response = await (0, utils_1.checkedFetch)(url);
-        if (!response.ok) {
-            throw new Error("Rollman query failed " + url);
-        }
-        return await response.json();
+        return queries.actionQueryRollman(this.webServerUrl, query);
     }
-    // Helper to query rollman for recent actions.
+    /**
+     * 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) {
-        const url = this.webServerUrl + "/last_n_actions?last_n=" + last_n;
-        const response = await (0, utils_1.checkedFetch)(url);
-        if (!response.ok) {
-            throw new Error("Rollman query failed " + url);
-        }
-        return await response.json();
+        return queries.actionsQueryRollman(this.webServerUrl, last_n);
     }
-    // Helper to query prometheus.
+    /**
+     * Query Prometheus metrics
+     *
+     * @param params - Prometheus query parameters
+     * @returns Query result as a number
+     * @throws {NordError} If the request fails
+     */
     async queryPrometheus(params) {
-        const url = this.webServerUrl + "/prometheus_query?query=" + params;
-        const response = await (0, utils_1.checkedFetch)(url);
-        if (!response.ok) {
-            throw new Error("Prometheus query failed " + url);
-        }
-        const json = await response.json();
-        // Prometheus HTTP API: https://prometheus.io/docs/prometheus/latest/querying/api/
-        return Number(json.data.result[0].value[1]);
+        return metrics.queryPrometheus(this.webServerUrl, params);
     }
-    static async approveTx(privateAddress, erc20address, contractAddress) {
-        const provider = new ethers_1.ethers.JsonRpcProvider(process.env.SECRET_FAUCET_RPC);
-        const wallet = new ethers_1.ethers.Wallet(privateAddress, provider);
-        const erc20Contract = new ethers_1.ethers.Contract(erc20address, abis_1.ERC20_ABI, wallet);
-        const maxUint256 = ethers_1.ethers.MaxUint256;
-        const approveTx = await erc20Contract.approve(contractAddress, maxUint256.toString(), {
-            maxFeePerGas: ethers_1.ethers.parseUnits("30", "gwei"),
-            maxPriorityFeePerGas: ethers_1.ethers.parseUnits("0.001", "gwei"),
-        });
-        return approveTx.hash;
+    /**
+     * Get the WebSocket client
+     *
+     * @returns WebSocket client
+     */
+    getWebSocketClient() {
+        return this.ws;
     }
     /**
-     * Fetches a sequence of actions between specified action IDs
-     * @param fromActionId - Starting action ID
-     * @param toActionId - Ending action ID
-     * @returns A promise that resolves to an ActionsResponse
+     * Subscribe to orderbook updates for a market
+     *
+     * @param symbol - Market symbol
+     * @returns Orderbook subscription
      */
-    async getActions(fromActionId, toActionId) {
-        const response = await (0, utils_1.checkedFetch)(`${this.webServerUrl}/actions?from=${fromActionId}&to=${toActionId}`, { method: "GET" });
-        const rawResponse = await response.json();
-        const queryResponse = {
-            actions: [],
+    subscribeOrderbook(symbol) {
+        const subscription = new events_1.EventEmitter();
+        const handleDelta = (update) => {
+            if (update.market_symbol === symbol) {
+                subscription.emit("message", {
+                    asks: update.asks,
+                    bids: update.bids,
+                    market_symbol: update.market_symbol,
+                    last_update_id: update.last_update_id,
+                });
+            }
+        };
+        this.ws.on("delta", handleDelta);
+        this.ws.subscribe([`deltas@${symbol}`]);
+        subscription.close = () => {
+            this.ws.unsubscribe([`deltas@${symbol}`]);
+            this.ws.removeAllListeners("delta");
+            subscription.removeAllListeners();
         };
-        if (Array.isArray(rawResponse.actions)) {
-            for (const action of rawResponse.actions) {
-                const extendedActionInfo = {
-                    block_number: action.block_number,
-                    action_id: action.action_id,
-                    action: (0, utils_1.decodeLengthDelimited)(action.action_pb, proto.Action),
-                };
-                queryResponse.actions.push(extendedActionInfo);
+        return subscription;
+    }
+    /**
+     * Subscribe to trade updates for a market
+     *
+     * @param symbol - Market symbol
+     * @returns Trade subscription
+     */
+    subscribeTrades(symbol) {
+        const subscription = new events_1.EventEmitter();
+        const handleTrade = (update) => {
+            if (update.market_symbol === symbol) {
+                subscription.emit("message", update.trades);
             }
-        }
-        return queryResponse;
+        };
+        this.ws.on("trade", handleTrade);
+        this.ws.subscribe([`trades@${symbol}`]);
+        subscription.close = () => {
+            this.ws.unsubscribe([`trades@${symbol}`]);
+            this.ws.removeAllListeners("trade");
+            subscription.removeAllListeners();
+        };
+        return subscription;
     }
     /**
-     * Fetches trades for a specified account
-     * @param params - Query parameters for fetching trades
-     * @returns A promise that resolves to a TradesResponse
+     * Get trades for a market
+     *
+     * @param query - Trades query parameters
+     * @returns Trades response
+     * @throws {NordError} If the request fails
      */
-    async getTrades(params) {
-        const { accountId, since, until, pageId } = params;
-        let url = `${this.webServerUrl}/trades?accountId=${accountId}`;
-        if (since) {
-            url += `&since=${encodeURIComponent(since)}`;
-        }
-        if (until) {
-            url += `&until=${encodeURIComponent(until)}`;
-        }
-        if (pageId) {
-            url += `&pageId=${encodeURIComponent(pageId)}`;
-        }
-        const response = await (0, utils_1.checkedFetch)(url, { method: "GET" });
-        const tradesResponse = await response.json();
-        return tradesResponse;
+    async getTrades(query) {
+        return market.getTrades(this.webServerUrl, query);
     }
     /**
-     * Fetches the orderbook for a specified market
-     * @param symbol - Market symbol
-     * @returns A promise that resolves to an OrderbookResponse
+     * Get user account IDs
+     *
+     * @param query - User account IDs query parameters
+     * @returns User account IDs response
+     * @throws {NordError} If the request fails
      */
-    async getOrderbook(symbol) {
-        const response = await (0, utils_1.checkedFetch)(`${this.webServerUrl}/orderbook?symbol=${encodeURIComponent(symbol)}`, { method: "GET" });
-        const orderbook = await response.json();
-        return orderbook;
+    async getUserAccountIds(query) {
+        return market.getUserAccountIds(this.webServerUrl, query);
     }
-}
-exports.Nord = Nord;
-class Subscriber {
-    constructor(config) {
-        this.streamURL = config.streamURL;
-        this.buffer = [];
-        this.maxBufferLen = config.maxBufferLen || utils_1.MAX_BUFFER_LEN;
+    /**
+     * Get orderbook for a market
+     *
+     * @param query - Orderbook query parameters
+     * @returns Orderbook response
+     * @throws {NordError} If the request fails
+     */
+    async getOrderbook(query) {
+        return market.getOrderbook(this.webServerUrl, query);
     }
-    subscribe() {
-        const ws = new ws_1.default(this.streamURL);
-        ws.on("message", (data) => {
-            try {
-                const parsed = JSON.parse(data.toString());
-                this.buffer.push(parsed);
-                if (this.buffer.length > this.maxBufferLen) {
-                    this.buffer.shift();
-                }
-            }
-            catch (e) {
-                console.error("Failed to parse websocket message", e);
-            }
-        });
+    /**
+     * 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();
     }
 }
-exports.Subscriber = Subscriber;
-/**
- * Creates a WebSocket subscription to specified streams
- * @param baseUrl - Base URL of the API
- * @param streams - Array of streams to subscribe to
- * @returns A Subscriber instance
- *
- * Syntax for streams:
- * - trades@<symbol>: Subscribe to trades for a market
- * - deltas@<symbol>: Subscribe to orderbook deltas for a market
- * - user@<user id>: Subscribe to user account updates
- *
- * Example: createWebSocketSubscription('https://alpha-api.layern.network', ['trades@BTCUSDC', 'deltas@BTCUSDC', 'user@0'])
- */
-function createWebSocketSubscription(baseUrl, streams) {
-    const streamPath = streams.join('&');
-    const wsUrl = baseUrl.replace(/^http/, 'ws') + `/ws/${streamPath}`;
-    const subscriber = new Subscriber({
-        streamURL: wsUrl,
-    });
-    subscriber.subscribe();
-    return subscriber;
-}
+exports.Nord = Nord;

package/dist/nord/NordError.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Custom error class for Nord-related errors
+ * Extends the standard Error class with additional context
+ */
+export declare class NordError extends Error {
+    /** The original error that caused this error, if any */
+    readonly cause?: unknown;
+    /**
+     * Create a new NordError
+     *
+     * @param message - Error message
+     * @param options - Additional error options
+     */
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+    /**
+     * Get a string representation of the error including the cause if available
+     *
+     * @returns String representation of the error
+     */
+    toString(): string;
+}