nostr-websocket-utils 0.3.1 → 0.3.3

package/dist/client.d.ts

@@ -1,129 +0,0 @@
-/// <reference types="node" />
-import { EventEmitter } from 'events';
-import type { NostrWSOptions, NostrWSMessage } from './types/index.js';
-/**
- * WebSocket client implementation for Nostr protocol communication
- * Extends EventEmitter to provide event-based message handling
- *
- * @extends EventEmitter
- * @example
- * ```typescript
- * const client = new NostrWSClient('wss://relay.example.com', {
- *   logger: console,
- *   heartbeatInterval: 30000,
- *   handlers: {
- *     message: async (msg) => console.log('Received:', msg),
- *     error: (err) => console.error('Error:', err),
- *     close: () => console.log('Connection closed')
- *   }
- * });
- *
- * await client.connect();
- * client.send({ type: 'EVENT', data: { ... } });
- * ```
- */
-export declare class NostrWSClient extends EventEmitter {
-    private url;
-    private ws;
-    private options;
-    private reconnectTimeout;
-    private heartbeatInterval;
-    private reconnectAttempts;
-    private messageQueue;
-    private clientId;
-    /**
-     * Creates a new NostrWSClient instance
-     *
-     * @param {string} url - The WebSocket server URL to connect to
-     * @param {Partial<NostrWSOptions>} options - Configuration options
-     * @param {number} [options.heartbeatInterval=30000] - Interval for sending heartbeat messages in milliseconds
-     * @param {object} options.logger - Logger instance (required)
-     * @param {Function} [options.WebSocketImpl=WebSocket] - WebSocket implementation to use
-     * @param {object} [options.handlers] - Event handlers
-     * @param {Function} [options.handlers.message] - Message handler function
-     * @param {Function} [options.handlers.error] - Error handler function
-     * @param {Function} [options.handlers.close] - Connection close handler function
-     * @throws {Error} If logger is not provided
-     */
-    constructor(url: string, options?: Partial<NostrWSOptions>);
-    /**
-     * Establishes a connection to the WebSocket server
-     *
-     * @example
-     * ```typescript
-     * client.connect();
-     * ```
-     */
-    connect(): void;
-    /**
-     * Sets up event handlers for the WebSocket connection
-     *
-     * @private
-     */
-    private setupEventHandlers;
-    /**
-     * Starts sending heartbeat messages at the specified interval
-     *
-     * @private
-     */
-    private startHeartbeat;
-    /**
-     * Stops sending heartbeat messages
-     *
-     * @private
-     */
-    private stopHeartbeat;
-    /**
-     * Handles reconnecting to the WebSocket server after a disconnection
-     *
-     * @private
-     */
-    private handleReconnect;
-    /**
-     * Subscribes to a channel with optional filter
-     *
-     * @param {string} channel - Channel name
-     * @param {unknown} [filter] - Filter data
-     * @example
-     * ```typescript
-     * client.subscribe('channel-name', { ...filterData });
-     * ```
-     */
-    subscribe(channel: string, filter?: unknown): void;
-    /**
-     * Unsubscribes from a channel
-     *
-     * @param {string} channel - Channel name
-     * @example
-     * ```typescript
-     * client.unsubscribe('channel-name');
-     * ```
-     */
-    unsubscribe(channel: string): void;
-    /**
-     * Flushes the message queue by sending pending messages
-     *
-     * @private
-     */
-    private flushMessageQueue;
-    /**
-     * Sends a message to the WebSocket server
-     *
-     * @param {NostrWSMessage} message - Message to send
-     * @returns {Promise<void>}
-     * @example
-     * ```typescript
-     * client.send({ type: 'EVENT', data: { ... } });
-     * ```
-     */
-    send(message: NostrWSMessage): Promise<void>;
-    /**
-     * Closes the WebSocket connection
-     *
-     * @example
-     * ```typescript
-     * client.close();
-     * ```
-     */
-    close(): void;
-}

package/dist/client.js

@@ -1,259 +0,0 @@
-import { v4 as uuidv4 } from 'uuid';
-import WebSocket from 'ws';
-import { EventEmitter } from 'events';
-/**
- * WebSocket client implementation for Nostr protocol communication
- * Extends EventEmitter to provide event-based message handling
- *
- * @extends EventEmitter
- * @example
- * ```typescript
- * const client = new NostrWSClient('wss://relay.example.com', {
- *   logger: console,
- *   heartbeatInterval: 30000,
- *   handlers: {
- *     message: async (msg) => console.log('Received:', msg),
- *     error: (err) => console.error('Error:', err),
- *     close: () => console.log('Connection closed')
- *   }
- * });
- *
- * await client.connect();
- * client.send({ type: 'EVENT', data: { ... } });
- * ```
- */
-export class NostrWSClient extends EventEmitter {
-    /**
-     * Creates a new NostrWSClient instance
-     *
-     * @param {string} url - The WebSocket server URL to connect to
-     * @param {Partial<NostrWSOptions>} options - Configuration options
-     * @param {number} [options.heartbeatInterval=30000] - Interval for sending heartbeat messages in milliseconds
-     * @param {object} options.logger - Logger instance (required)
-     * @param {Function} [options.WebSocketImpl=WebSocket] - WebSocket implementation to use
-     * @param {object} [options.handlers] - Event handlers
-     * @param {Function} [options.handlers.message] - Message handler function
-     * @param {Function} [options.handlers.error] - Error handler function
-     * @param {Function} [options.handlers.close] - Connection close handler function
-     * @throws {Error} If logger is not provided
-     */
-    constructor(url, options = {}) {
-        super();
-        this.url = url;
-        this.ws = null;
-        this.reconnectTimeout = null;
-        this.heartbeatInterval = null;
-        this.reconnectAttempts = 0;
-        this.messageQueue = [];
-        if (!options.logger) {
-            throw new Error('Logger is required');
-        }
-        this.clientId = uuidv4();
-        this.options = {
-            heartbeatInterval: options.heartbeatInterval || 30000,
-            logger: options.logger,
-            WebSocketImpl: options.WebSocketImpl || WebSocket,
-            handlers: {
-                message: options.handlers?.message || (async () => { }),
-                error: options.handlers?.error || (() => { }),
-                close: options.handlers?.close || (() => { })
-            }
-        };
-    }
-    /**
-     * Establishes a connection to the WebSocket server
-     *
-     * @example
-     * ```typescript
-     * client.connect();
-     * ```
-     */
-    connect() {
-        if (this.ws) {
-            this.options.logger.info('WebSocket connection already exists');
-            return;
-        }
-        try {
-            this.options.logger.debug('Creating new WebSocket connection');
-            this.ws = new this.options.WebSocketImpl(this.url);
-            this.options.logger.debug('WebSocket created successfully');
-            this.setupEventHandlers();
-        }
-        catch (error) {
-            this.options.logger.error('Failed to create WebSocket connection:', error);
-            this.handleReconnect();
-        }
-    }
-    /**
-     * Sets up event handlers for the WebSocket connection
-     *
-     * @private
-     */
-    setupEventHandlers() {
-        if (!this.ws)
-            return;
-        this.ws.on('open', () => {
-            this.options.logger.info('WebSocket connection established');
-            this.reconnectAttempts = 0;
-            this.startHeartbeat();
-            this.emit('connect');
-            this.flushMessageQueue();
-        });
-        this.ws.on('message', async (data) => {
-            try {
-                const message = JSON.parse(data.toString());
-                this.emit('message', message);
-                await this.options.handlers.message(this.ws, message);
-            }
-            catch (error) {
-                this.emit('error', error);
-                if (this.options.handlers.error) {
-                    this.options.handlers.error(this.ws, error);
-                }
-            }
-        });
-        this.ws.on('close', () => {
-            this.options.logger.info('WebSocket connection closed');
-            this.stopHeartbeat();
-            this.handleReconnect();
-            this.emit('disconnect');
-            if (this.options.handlers.close) {
-                this.options.handlers.close(this.ws);
-            }
-        });
-        this.ws.on('error', (error) => {
-            this.options.logger.error('WebSocket error:', error);
-            this.emit('error', error);
-            if (this.options.handlers.error) {
-                this.options.handlers.error(this.ws, error);
-            }
-        });
-    }
-    /**
-     * Starts sending heartbeat messages at the specified interval
-     *
-     * @private
-     */
-    startHeartbeat() {
-        if (this.heartbeatInterval)
-            return;
-        this.heartbeatInterval = setInterval(() => {
-            if (this.ws?.readyState === WebSocket.OPEN) {
-                this.ws.ping();
-            }
-        }, this.options.heartbeatInterval || 30000);
-    }
-    /**
-     * Stops sending heartbeat messages
-     *
-     * @private
-     */
-    stopHeartbeat() {
-        if (this.heartbeatInterval) {
-            clearInterval(this.heartbeatInterval);
-            this.heartbeatInterval = null;
-        }
-    }
-    /**
-     * Handles reconnecting to the WebSocket server after a disconnection
-     *
-     * @private
-     */
-    handleReconnect() {
-        if (this.reconnectTimeout)
-            return;
-        this.reconnectAttempts++;
-        this.reconnectTimeout = setTimeout(() => {
-            this.reconnectTimeout = null;
-            this.connect();
-            this.emit('reconnect');
-        }, 5000);
-    }
-    /**
-     * Subscribes to a channel with optional filter
-     *
-     * @param {string} channel - Channel name
-     * @param {unknown} [filter] - Filter data
-     * @example
-     * ```typescript
-     * client.subscribe('channel-name', { ...filterData });
-     * ```
-     */
-    subscribe(channel, filter) {
-        this.send({
-            type: 'subscribe',
-            data: { channel, filter }
-        });
-    }
-    /**
-     * Unsubscribes from a channel
-     *
-     * @param {string} channel - Channel name
-     * @example
-     * ```typescript
-     * client.unsubscribe('channel-name');
-     * ```
-     */
-    unsubscribe(channel) {
-        this.send({
-            type: 'unsubscribe',
-            data: { channel }
-        });
-    }
-    /**
-     * Flushes the message queue by sending pending messages
-     *
-     * @private
-     */
-    flushMessageQueue() {
-        while (this.messageQueue.length > 0 && this.ws?.readyState === WebSocket.OPEN) {
-            const message = this.messageQueue.shift();
-            if (message) {
-                this.send(message);
-            }
-        }
-    }
-    /**
-     * Sends a message to the WebSocket server
-     *
-     * @param {NostrWSMessage} message - Message to send
-     * @returns {Promise<void>}
-     * @example
-     * ```typescript
-     * client.send({ type: 'EVENT', data: { ... } });
-     * ```
-     */
-    async send(message) {
-        message.id = message.id || uuidv4();
-        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-            this.messageQueue.push(message);
-            return;
-        }
-        try {
-            this.ws.send(JSON.stringify(message));
-        }
-        catch (error) {
-            this.options.logger.error('Failed to send message:', error);
-            this.handleReconnect();
-        }
-    }
-    /**
-     * Closes the WebSocket connection
-     *
-     * @example
-     * ```typescript
-     * client.close();
-     * ```
-     */
-    close() {
-        this.stopHeartbeat();
-        if (this.reconnectTimeout) {
-            clearTimeout(this.reconnectTimeout);
-            this.reconnectTimeout = null;
-        }
-        if (this.ws) {
-            this.ws.close();
-            this.ws = null;
-        }
-    }
-}

package/dist/crypto/schnorr.d.ts

@@ -1,16 +0,0 @@
-/**
- * @file Schnorr signature implementation for Nostr
- * @module crypto/schnorr
- */
-/**
- * Sign a message using Schnorr signature
- */
-export declare function schnorrSign(message: string, privateKey: Uint8Array): Promise<string>;
-/**
- * Verify a Schnorr signature
- */
-export declare function schnorrVerify(signature: string, message: string, publicKey: string): Promise<boolean>;
-/**
- * Get public key from private key
- */
-export declare function getPublicKey(privateKey: string): string;

package/dist/crypto/schnorr.js

@@ -1,51 +0,0 @@
-/**
- * @file Schnorr signature implementation for Nostr
- * @module crypto/schnorr
- */
-import { utils } from '@noble/secp256k1';
-import * as secp from '@noble/secp256k1';
-/**
- * Sign a message using Schnorr signature
- */
-export async function schnorrSign(message, privateKey) {
-    try {
-        // Hash the message
-        const messageHash = utils.sha256(Buffer.from(message));
-        // Sign using Schnorr
-        const signature = await secp.sign(messageHash, privateKey, { canonical: true });
-        // Convert to hex
-        return utils.bytesToHex(signature);
-    }
-    catch (error) {
-        throw new Error(`Failed to create Schnorr signature: ${error}`);
-    }
-}
-/**
- * Verify a Schnorr signature
- */
-export async function schnorrVerify(signature, message, publicKey) {
-    try {
-        // Convert inputs to bytes
-        const signatureBytes = utils.hexToBytes(signature);
-        const messageHash = utils.sha256(Buffer.from(message));
-        const publicKeyBytes = utils.hexToBytes(publicKey);
-        // Verify using Schnorr
-        return await secp.verify(signatureBytes, messageHash, publicKeyBytes, { canonical: true });
-    }
-    catch (error) {
-        throw new Error(`Failed to verify Schnorr signature: ${error}`);
-    }
-}
-/**
- * Get public key from private key
- */
-export function getPublicKey(privateKey) {
-    try {
-        const publicKey = secp.getPublicKey(privateKey, true);
-        return Buffer.from(publicKey).toString('hex');
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-        throw new Error(`Failed to get public key: ${errorMessage}`);
-    }
-}

package/dist/nostr-server.js

@@ -1,107 +0,0 @@
-import { Server as WebSocketServer } from 'ws';
-import { getLogger } from './utils/logger';
-/**
- * Represents a Nostr WebSocket server
- */
-export class NostrWSServer {
-    /**
-     * Creates a new Nostr WebSocket server instance
-     *
-     * @param {NostrWSServerOptions} options - Server configuration options
-     */
-    constructor(options) {
-        /**
-         * Logger instance for this server
-         */
-        this.logger = getLogger('NostrWSServer');
-        this.server = new WebSocketServer({ port: options.port });
-        /**
-         * Handles incoming WebSocket connections
-         *
-         * @param {NostrWSSocket} socket - The connected WebSocket client
-         */
-        this.server.on('connection', (socket) => {
-            socket.subscriptions = new Set();
-            socket.isAlive = true;
-            if (options.onConnection) {
-                options.onConnection(socket);
-            }
-            /**
-             * Handles incoming messages from the client
-             *
-             * @param {Buffer | ArrayBuffer | Buffer[]} data - The incoming message data
-             */
-            const handleMessage = async (data) => {
-                try {
-                    const message = JSON.parse(data.toString());
-                    if (options.handlers?.message) {
-                        await options.handlers.message(socket, message);
-                    }
-                }
-                catch (error) {
-                    if (options.handlers?.error) {
-                        options.handlers.error(socket, error);
-                    }
-                }
-            };
-            socket.on('message', handleMessage);
-            /**
-             * Handles client disconnections
-             */
-            socket.on('close', () => {
-                if (options.handlers?.close) {
-                    options.handlers.close(socket);
-                }
-            });
-            /**
-             * Handles WebSocket errors
-             *
-             * @param {Error} error - The error that occurred
-             */
-            socket.on('error', (error) => {
-                if (options.handlers?.error) {
-                    options.handlers.error(socket, error);
-                }
-            });
-            // Setup heartbeat
-            if (options.heartbeatInterval) {
-                const interval = setInterval(() => {
-                    if (!socket.isAlive) {
-                        socket.terminate();
-                        clearInterval(interval);
-                        return;
-                    }
-                    socket.isAlive = false;
-                    socket.ping();
-                }, options.heartbeatInterval);
-                /**
-                 * Handles WebSocket pong responses
-                 */
-                socket.on('pong', () => {
-                    socket.isAlive = true;
-                });
-                /**
-                 * Handles client disconnections (again, to clear the interval)
-                 */
-                socket.on('close', () => {
-                    clearInterval(interval);
-                });
-            }
-        });
-    }
-    /**
-     * Closes the WebSocket server
-     */
-    close() {
-        this.server.close();
-    }
-}
-/**
- * Creates a new Nostr WebSocket server instance
- *
- * @param {NostrWSServerOptions} options - Server configuration options
- * @returns {NostrWSServer} The created server instance
- */
-export function createWSServer(options) {
-    return new NostrWSServer(options);
-}

package/dist/server.d.ts

@@ -1,27 +0,0 @@
-/// <reference types="node" />
-import { WebSocketServer } from 'ws';
-import { EventEmitter } from 'events';
-import type { NostrWSOptions, NostrWSMessage } from './types/index.js';
-/**
- * WebSocket server implementation for Nostr protocol
- * Extends EventEmitter to provide event-based message handling
- */
-export declare class NostrWSServer extends EventEmitter {
-    private wss;
-    private options;
-    private clients;
-    private heartbeatInterval;
-    constructor(wss: WebSocketServer, options?: Partial<NostrWSOptions>);
-    private setupServer;
-    private handleConnection;
-    private startHeartbeat;
-    broadcast(message: NostrWSMessage): void;
-    broadcastToChannel(channel: string, message: NostrWSMessage): void;
-    close(): void;
-    /**
-     * Check if a client with the given ID exists
-     * @param clientId - The ID of the client to check
-     * @returns boolean indicating if the client exists
-     */
-    hasClient(clientId: string): boolean;
-}