@n1xyz/nord-ts 0.0.1 → 0.0.4

package/dist/nord/queries.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queryBlock = queryBlock;
+exports.queryLastNBlocks = queryLastNBlocks;
+exports.queryRecentBlocks = queryRecentBlocks;
+exports.queryAction = queryAction;
+exports.queryRecentActions = queryRecentActions;
+exports.blockQueryRollman = blockQueryRollman;
+exports.blockSummaryQueryRollman = blockSummaryQueryRollman;
+exports.actionQueryRollman = actionQueryRollman;
+exports.actionsQueryRollman = actionsQueryRollman;
+const utils_1 = require("../utils");
+const NordError_1 = require("./NordError");
+/**
+ * Query a specific block
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param query - Block query parameters
+ * @returns Block response
+ * @throws {NordError} If the request fails
+ */
+async function queryBlock(webServerUrl, query) {
+    try {
+        const params = new URLSearchParams();
+        if (query.block_number !== undefined) {
+            params.append("block_height", query.block_number.toString());
+        }
+        const response = await (0, utils_1.checkedFetch)(`${webServerUrl}/block?${params.toString()}`);
+        return await response.json();
+    }
+    catch (error) {
+        throw new NordError_1.NordError("Failed to query block", { cause: error });
+    }
+}
+/**
+ * Query the last N blocks
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @returns Block response for the last N blocks
+ * @throws {NordError} If the request fails
+ */
+async function queryLastNBlocks(webServerUrl) {
+    try {
+        const response = await (0, utils_1.checkedFetch)(`${webServerUrl}/blocks`);
+        return await response.json();
+    }
+    catch (error) {
+        throw new NordError_1.NordError("Failed to query last N blocks", { cause: error });
+    }
+}
+/**
+ * Query recent blocks
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param last_n - Number of recent blocks to query
+ * @returns Block summary response
+ * @throws {NordError} If the request fails
+ */
+async function queryRecentBlocks(webServerUrl, last_n) {
+    try {
+        const response = await (0, utils_1.checkedFetch)(`${webServerUrl}/blocks_summary?last_n=${last_n}`);
+        return await response.json();
+    }
+    catch (error) {
+        throw new NordError_1.NordError(`Failed to query recent blocks (last ${last_n})`, { cause: error });
+    }
+}
+/**
+ * Query a specific action
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param query - Action query parameters
+ * @returns Action response
+ * @throws {NordError} If the request fails
+ */
+async function queryAction(webServerUrl, query) {
+    try {
+        const params = new URLSearchParams();
+        if (query.action_id !== undefined) {
+            params.append("action_id", query.action_id.toString());
+        }
+        const response = await (0, utils_1.checkedFetch)(`${webServerUrl}/action?${params.toString()}`);
+        return await response.json();
+    }
+    catch (error) {
+        throw new NordError_1.NordError("Failed to query action", { cause: error });
+    }
+}
+/**
+ * Query recent actions
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param last_n - Number of recent actions to query
+ * @returns Actions response
+ * @throws {NordError} If the request fails
+ */
+async function queryRecentActions(webServerUrl, last_n) {
+    try {
+        const response = await (0, utils_1.checkedFetch)(`${webServerUrl}/actions?last_n=${last_n}`);
+        return await response.json();
+    }
+    catch (error) {
+        throw new NordError_1.NordError(`Failed to query recent actions (last ${last_n})`, { cause: error });
+    }
+}
+/**
+ * Query a block from Rollman
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param query - Block query parameters
+ * @returns Rollman block response
+ * @throws {NordError} If the request fails
+ */
+async function blockQueryRollman(webServerUrl, query) {
+    try {
+        const params = new URLSearchParams();
+        if (query.block_number !== undefined) {
+            params.append("block_height", query.block_number.toString());
+        }
+        const response = await (0, utils_1.checkedFetch)(`${webServerUrl}/rollman/block?${params.toString()}`);
+        return await response.json();
+    }
+    catch (error) {
+        throw new NordError_1.NordError("Failed to query Rollman block", { cause: error });
+    }
+}
+/**
+ * Query block summaries from Rollman
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param last_n - Number of recent blocks to query
+ * @returns Block summary response
+ * @throws {NordError} If the request fails
+ */
+async function blockSummaryQueryRollman(webServerUrl, last_n) {
+    try {
+        const response = await (0, utils_1.checkedFetch)(`${webServerUrl}/rollman/blocks_summary?last_n=${last_n}`);
+        return await response.json();
+    }
+    catch (error) {
+        throw new NordError_1.NordError(`Failed to query Rollman block summaries (last ${last_n})`, { cause: error });
+    }
+}
+/**
+ * Query an action from Rollman
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param query - Action query parameters
+ * @returns Rollman action response
+ * @throws {NordError} If the request fails
+ */
+async function actionQueryRollman(webServerUrl, query) {
+    try {
+        const params = new URLSearchParams();
+        if (query.action_id !== undefined) {
+            params.append("action_id", query.action_id.toString());
+        }
+        const response = await (0, utils_1.checkedFetch)(`${webServerUrl}/rollman/action?${params.toString()}`);
+        return await response.json();
+    }
+    catch (error) {
+        throw new NordError_1.NordError("Failed to query Rollman action", { cause: error });
+    }
+}
+/**
+ * Query actions from Rollman
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param last_n - Number of recent actions to query
+ * @returns Rollman actions response
+ * @throws {NordError} If the request fails
+ */
+async function actionsQueryRollman(webServerUrl, last_n) {
+    try {
+        const response = await (0, utils_1.checkedFetch)(`${webServerUrl}/rollman/actions?last_n=${last_n}`);
+        return await response.json();
+    }
+    catch (error) {
+        throw new NordError_1.NordError(`Failed to query Rollman actions (last ${last_n})`, { cause: error });
+    }
+}

package/dist/nord/types.d.ts

@@ -0,0 +1,88 @@
+import { EventEmitter } from "events";
+import Decimal from "decimal.js";
+import { Connection, Keypair, PublicKey } from '@solana/web3.js';
+import { FillMode, Side } from "../types";
+import { Nord } from "./Nord";
+import { OrderbookResponse, Trade } from "../types";
+/**
+ * Parameters for creating a NordUser instance
+ */
+export interface NordUserParams {
+    /** Nord client instance */
+    nord: Nord;
+    /** User's blockchain address */
+    address: string;
+    /** Function to sign messages with the user's wallet */
+    walletSignFn: (message: Uint8Array | string) => Promise<string>;
+    /** Function to sign messages with the user's session key */
+    sessionSignFn: (message: Uint8Array) => Promise<Uint8Array>;
+    /** Solana public key (optional) */
+    solanaPublicKey?: PublicKey | string;
+    /** Solana keypair (optional) */
+    keypair?: Keypair;
+    /** Solana connection (optional) */
+    connection?: Connection;
+}
+/**
+ * Parameters for placing an order
+ */
+export interface PlaceOrderParams {
+    /** Market ID */
+    marketId: number;
+    /** Order side (bid or ask) */
+    side: Side;
+    /** Fill mode (limit, market, etc.) */
+    fillMode: FillMode;
+    /** Whether the order is reduce-only */
+    isReduceOnly: boolean;
+    /** Order size */
+    size?: Decimal.Value;
+    /** Order price */
+    price?: Decimal.Value;
+    /** Quote size (for market orders) */
+    quoteSize?: Decimal.Value;
+    /** Account ID to place the order from */
+    accountId?: number;
+}
+/**
+ * Parameters for transferring tokens between accounts
+ */
+export interface TransferParams {
+    /** Recipient user */
+    to: any;
+    /** Token ID to transfer */
+    tokenId: number;
+    /** Amount to transfer */
+    amount: Decimal.Value;
+    /** Source account ID */
+    fromAccountId: number;
+    /** Destination account ID */
+    toAccountId: number;
+}
+/**
+ * Parameters for creating a new account
+ */
+export interface CreateAccountParams {
+    /** Token ID for initial funding */
+    tokenId: number;
+    /** Initial funding amount */
+    amount: Decimal.Value;
+}
+/**
+ * Interface for orderbook subscription events
+ */
+export interface OrderbookSubscription extends EventEmitter {
+    on(event: 'message', listener: (data: OrderbookResponse) => void): this;
+    on(event: 'error', listener: (error: Error) => void): this;
+    close(): void;
+    removeAllListeners(event?: string): this;
+}
+/**
+ * Interface for trade subscription events
+ */
+export interface TradeSubscription extends EventEmitter {
+    on(event: 'message', listener: (data: Trade[]) => void): this;
+    on(event: 'error', listener: (error: Error) => void): this;
+    close(): void;
+    removeAllListeners(event?: string): this;
+}

package/dist/nord/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/nord/utils/NordError.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Options for creating a NordError
+ */
+export interface NordErrorOptions {
+    /** The original error that caused this error */
+    cause?: unknown;
+    /** HTTP status code (if applicable) */
+    statusCode?: number;
+    /** Additional error details */
+    details?: Record<string, unknown>;
+}
+/**
+ * Custom error class for Nord-related errors
+ */
+export declare class NordError extends Error {
+    /** The original error that caused this error */
+    readonly cause?: unknown;
+    /** HTTP status code (if applicable) */
+    readonly statusCode?: number;
+    /** Additional error details */
+    readonly details?: Record<string, unknown>;
+    /**
+     * Create a new NordError
+     *
+     * @param message - Error message
+     * @param options - Error options
+     */
+    constructor(message: string, options?: NordErrorOptions);
+    /**
+     * Convert the error to a string representation
+     *
+     * @returns String representation of the error
+     */
+    toString(): string;
+}

package/dist/nord/utils/NordError.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NordError = void 0;
+/**
+ * Custom error class for Nord-related errors
+ */
+class NordError extends Error {
+    /**
+     * Create a new NordError
+     *
+     * @param message - Error message
+     * @param options - Error options
+     */
+    constructor(message, options = {}) {
+        super(message);
+        this.name = 'NordError';
+        this.cause = options.cause;
+        this.statusCode = options.statusCode;
+        this.details = options.details;
+        // Capture stack trace
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, NordError);
+        }
+        // Handle nested errors
+        if (this.cause instanceof Error) {
+            this.stack =
+                this.stack + '\nCaused by: ' + (this.cause.stack || this.cause.message);
+        }
+    }
+    /**
+     * Convert the error to a string representation
+     *
+     * @returns String representation of the error
+     */
+    toString() {
+        let result = `${this.name}: ${this.message}`;
+        if (this.statusCode) {
+            result += ` (Status: ${this.statusCode})`;
+        }
+        if (this.details && Object.keys(this.details).length > 0) {
+            result += `\nDetails: ${JSON.stringify(this.details, null, 2)}`;
+        }
+        return result;
+    }
+}
+exports.NordError = NordError;

package/dist/nord/websocket.d.ts

@@ -0,0 +1,49 @@
+import { DeltaEvent, Trades, Account } from "../types";
+import { OrderbookSubscription, TradeSubscription } from "./types";
+/**
+ * Configuration for the Subscriber class
+ */
+export interface SubscriberConfig {
+    /** WebSocket stream URL */
+    streamURL: string;
+    /** Maximum buffer length */
+    maxBufferLen?: number;
+}
+/**
+ * Subscriber class for handling WebSocket subscriptions
+ */
+export declare class Subscriber {
+    /** WebSocket stream URL */
+    streamURL: string;
+    /** Buffer for events */
+    buffer: (DeltaEvent | Trades | Account)[];
+    /** Maximum buffer length */
+    maxBufferLen: number;
+    /**
+     * Create a new Subscriber instance
+     * @param config Subscriber configuration
+     */
+    constructor(config: SubscriberConfig);
+    /**
+     * Subscribe to WebSocket events
+     */
+    subscribe(): void;
+}
+/**
+ * Create an orderbook subscription
+ *
+ * @param ws - WebSocket client
+ * @param symbol - Market symbol to subscribe to
+ * @returns EventEmitter that emits orderbook updates
+ */
+export declare function createOrderbookSubscription(ws: any, // Using 'any' to avoid circular dependency, will be NordWebSocketClient
+symbol: string): OrderbookSubscription;
+/**
+ * Create a trade subscription
+ *
+ * @param ws - WebSocket client
+ * @param symbol - Market symbol to subscribe to
+ * @returns EventEmitter that emits trade updates
+ */
+export declare function createTradeSubscription(ws: any, // Using 'any' to avoid circular dependency, will be NordWebSocketClient
+symbol: string): TradeSubscription;

package/dist/nord/websocket.js

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Subscriber = void 0;
+exports.createOrderbookSubscription = createOrderbookSubscription;
+exports.createTradeSubscription = createTradeSubscription;
+const events_1 = require("events");
+const ws_1 = __importDefault(require("ws"));
+const utils_1 = require("../utils");
+/**
+ * Subscriber class for handling WebSocket subscriptions
+ */
+class Subscriber {
+    /**
+     * Create a new Subscriber instance
+     * @param config Subscriber configuration
+     */
+    constructor(config) {
+        this.streamURL = config.streamURL;
+        this.buffer = [];
+        this.maxBufferLen = config.maxBufferLen ?? utils_1.MAX_BUFFER_LEN;
+    }
+    /**
+     * Subscribe to WebSocket events
+     */
+    subscribe() {
+        const ws = new ws_1.default(this.streamURL);
+        ws.on("open", () => { });
+        ws.on("message", (rawData) => {
+            const message = rawData.toLocaleString();
+            const event = JSON.parse(message);
+            this.buffer.push(event);
+            if (this.buffer.length > this.maxBufferLen) {
+                this.buffer.shift();
+            }
+        });
+        ws.on("close", () => { });
+    }
+}
+exports.Subscriber = Subscriber;
+/**
+ * Create an orderbook subscription
+ *
+ * @param ws - WebSocket client
+ * @param symbol - Market symbol to subscribe to
+ * @returns EventEmitter that emits orderbook updates
+ */
+function createOrderbookSubscription(ws, // Using 'any' to avoid circular dependency, will be NordWebSocketClient
+symbol) {
+    if (!symbol) {
+        throw new Error("Market symbol is required for orderbook subscription");
+    }
+    const emitter = new events_1.EventEmitter();
+    // Add close method
+    emitter.close = () => {
+        ws.unsubscribe([`deltas@${symbol}`]);
+        emitter.removeAllListeners();
+    };
+    // Subscribe to the orderbook stream
+    ws.on('delta', (update) => {
+        if (update.market_symbol === symbol) {
+            const orderbookUpdate = {
+                symbol: update.market_symbol,
+                asks: update.asks,
+                bids: update.bids,
+                timestamp: update.timestamp
+            };
+            emitter.emit('message', orderbookUpdate);
+        }
+    });
+    ws.on('error', (error) => {
+        emitter.emit('error', error);
+    });
+    // Start the subscription
+    ws.subscribe([`deltas@${symbol}`]);
+    return emitter;
+}
+/**
+ * Create a trade subscription
+ *
+ * @param ws - WebSocket client
+ * @param symbol - Market symbol to subscribe to
+ * @returns EventEmitter that emits trade updates
+ */
+function createTradeSubscription(ws, // Using 'any' to avoid circular dependency, will be NordWebSocketClient
+symbol) {
+    const emitter = new events_1.EventEmitter();
+    // Add close method
+    emitter.close = () => {
+        ws.unsubscribe([`trades@${symbol}`]);
+        emitter.removeAllListeners();
+    };
+    // Subscribe to the trades stream
+    ws.on('trade', (update) => {
+        if (update.symbol === symbol) {
+            emitter.emit('message', update.trades);
+        }
+    });
+    ws.on('error', (error) => {
+        emitter.emit('error', error);
+    });
+    // Start the subscription
+    ws.subscribe([`trades@${symbol}`]);
+    return emitter;
+}

package/dist/operations/account.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Account-related operations
+ * @module operations/account
+ */
+import { NordClientConfig } from '../types/config';
+import { Account, Balance } from '../models';
+/**
+ * Account operations implementation
+ */
+export declare class AccountOperations {
+    /**
+     * Client configuration
+     */
+    private readonly config;
+    /**
+     * Create a new AccountOperations instance
+     *
+     * @param config - Client configuration
+     */
+    constructor(config: NordClientConfig);
+    /**
+     * Get account information
+     *
+     * @param accountId - Account ID
+     * @returns Promise resolving to account information
+     * @throws {NordValidationError} If the accountId parameter is invalid
+     * @throws {NordApiError} If the API request fails
+     */
+    getAccount(accountId: number): Promise<Account>;
+    /**
+     * Get all accounts for a specific address
+     *
+     * @param address - User's blockchain address
+     * @returns Promise resolving to an array of account IDs
+     * @throws {NordValidationError} If the address parameter is invalid
+     * @throws {NordApiError} If the API request fails
+     */
+    getAccounts(address: string): Promise<number[]>;
+    /**
+     * Get balance for a specific token in an account
+     *
+     * @param accountId - Account ID
+     * @param token - Token symbol (e.g., "BTC")
+     * @returns Promise resolving to balance information
+     * @throws {NordValidationError} If any parameters are invalid
+     * @throws {NordApiError} If the API request fails
+     */
+    getBalance(accountId: number, token: string): Promise<Balance>;
+    /**
+     * Get all balances for an account
+     *
+     * @param accountId - Account ID
+     * @returns Promise resolving to an array of balances
+     * @throws {NordValidationError} If the accountId parameter is invalid
+     * @throws {NordApiError} If the API request fails
+     */
+    getBalances(accountId: number): Promise<Balance[]>;
+}

package/dist/operations/account.js

@@ -0,0 +1,112 @@
+"use strict";
+/**
+ * Account-related operations
+ * @module operations/account
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountOperations = void 0;
+const errors_1 = require("../utils/errors");
+const http_1 = require("../utils/http");
+const endpoints_1 = require("../constants/endpoints");
+/**
+ * Account operations implementation
+ */
+class AccountOperations {
+    /**
+     * Create a new AccountOperations instance
+     *
+     * @param config - Client configuration
+     */
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Get account information
+     *
+     * @param accountId - Account ID
+     * @returns Promise resolving to account information
+     * @throws {NordValidationError} If the accountId parameter is invalid
+     * @throws {NordApiError} If the API request fails
+     */
+    async getAccount(accountId) {
+        if (accountId === undefined || accountId === null) {
+            throw new errors_1.NordValidationError('Account ID is required', 'accountId');
+        }
+        try {
+            const endpoint = `${endpoints_1.ENDPOINTS.ACCOUNT}/${accountId}`;
+            const response = await (0, http_1.httpGet)(this.config.webServerUrl, endpoint);
+            return response;
+        }
+        catch (error) {
+            throw new errors_1.NordApiError(`Failed to fetch account ${accountId}`, error instanceof errors_1.NordApiError ? error.statusCode : 500, endpoints_1.ENDPOINTS.ACCOUNT, error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+     * Get all accounts for a specific address
+     *
+     * @param address - User's blockchain address
+     * @returns Promise resolving to an array of account IDs
+     * @throws {NordValidationError} If the address parameter is invalid
+     * @throws {NordApiError} If the API request fails
+     */
+    async getAccounts(address) {
+        if (!address) {
+            throw new errors_1.NordValidationError('Address is required', 'address');
+        }
+        try {
+            const endpoint = `${endpoints_1.ENDPOINTS.ACCOUNTS}?address=${encodeURIComponent(address)}`;
+            const response = await (0, http_1.httpGet)(this.config.webServerUrl, endpoint);
+            return response.accountIds;
+        }
+        catch (error) {
+            throw new errors_1.NordApiError(`Failed to fetch accounts for address ${address}`, error instanceof errors_1.NordApiError ? error.statusCode : 500, endpoints_1.ENDPOINTS.ACCOUNTS, error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+     * Get balance for a specific token in an account
+     *
+     * @param accountId - Account ID
+     * @param token - Token symbol (e.g., "BTC")
+     * @returns Promise resolving to balance information
+     * @throws {NordValidationError} If any parameters are invalid
+     * @throws {NordApiError} If the API request fails
+     */
+    async getBalance(accountId, token) {
+        if (accountId === undefined || accountId === null) {
+            throw new errors_1.NordValidationError('Account ID is required', 'accountId');
+        }
+        if (!token) {
+            throw new errors_1.NordValidationError('Token symbol is required', 'token');
+        }
+        try {
+            const endpoint = `${endpoints_1.ENDPOINTS.BALANCE}?accountId=${accountId}&token=${encodeURIComponent(token)}`;
+            const response = await (0, http_1.httpGet)(this.config.webServerUrl, endpoint);
+            return response;
+        }
+        catch (error) {
+            throw new errors_1.NordApiError(`Failed to fetch balance for account ${accountId} and token ${token}`, error instanceof errors_1.NordApiError ? error.statusCode : 500, endpoints_1.ENDPOINTS.BALANCE, error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+     * Get all balances for an account
+     *
+     * @param accountId - Account ID
+     * @returns Promise resolving to an array of balances
+     * @throws {NordValidationError} If the accountId parameter is invalid
+     * @throws {NordApiError} If the API request fails
+     */
+    async getBalances(accountId) {
+        if (accountId === undefined || accountId === null) {
+            throw new errors_1.NordValidationError('Account ID is required', 'accountId');
+        }
+        try {
+            const endpoint = `${endpoints_1.ENDPOINTS.BALANCES}?accountId=${accountId}`;
+            const response = await (0, http_1.httpGet)(this.config.webServerUrl, endpoint);
+            return response;
+        }
+        catch (error) {
+            throw new errors_1.NordApiError(`Failed to fetch balances for account ${accountId}`, error instanceof errors_1.NordApiError ? error.statusCode : 500, endpoints_1.ENDPOINTS.BALANCES, error instanceof Error ? error : undefined);
+        }
+    }
+}
+exports.AccountOperations = AccountOperations;