nostr-websocket-utils 0.2.4 → 0.3.0

package/dist/core/server.js

@@ -0,0 +1,114 @@
+/**
+ * @file WebSocket server implementation
+ * @module core/server
+ */
+import { WebSocketServer, WebSocket } from 'ws';
+import { v4 as uuidv4 } from 'uuid';
+import { getLogger } from '../utils/logger';
+import { createRateLimiter } from '../utils/rate-limiter';
+const logger = getLogger('NostrWSServer');
+/**
+ * NostrWSServer class for handling WebSocket connections
+ */
+export class NostrWSServer {
+    constructor(options) {
+        this.options = {
+            ...options,
+            port: options.port || 8080,
+            host: options.host || 'localhost',
+            maxConnections: options.maxConnections || 1000,
+            pingInterval: options.pingInterval || 30000,
+            rateLimits: options.rateLimits
+        };
+        this.wss = new WebSocketServer({
+            port: this.options.port,
+            host: this.options.host
+        });
+        this.setupServer();
+        this.startPingInterval();
+        if (this.options.rateLimits) {
+            this.rateLimiter = createRateLimiter({
+                EVENT: this.options.rateLimits
+            }, logger);
+        }
+    }
+    /**
+     * Set up WebSocket server event handlers
+     */
+    setupServer() {
+        this.wss.on('connection', async (ws) => {
+            const socket = ws;
+            socket.clientId = uuidv4();
+            socket.subscriptions = new Set();
+            socket.isAlive = true;
+            logger.info(`Client connected: ${socket.clientId}`);
+            if (this.wss.clients.size > this.options.maxConnections) {
+                logger.warn(`Max connections (${this.options.maxConnections}) reached`);
+                socket.close(1008, 'Max connections reached');
+                return;
+            }
+            socket.on('message', async (data) => {
+                try {
+                    const message = JSON.parse(data.toString());
+                    if (this.rateLimiter && await this.rateLimiter.shouldLimit(socket.clientId, message)) {
+                        socket.send(JSON.stringify({
+                            type: 'NOTICE',
+                            data: { message: 'Rate limit exceeded' }
+                        }));
+                        return;
+                    }
+                    await this.options.onMessage?.(message, socket);
+                }
+                catch (error) {
+                    logger.error('Error processing message:', error);
+                    this.options.onError?.(error, socket);
+                }
+            });
+            socket.on('error', (error) => {
+                logger.error(`Client error (${socket.clientId}):`, error);
+                this.options.onError?.(error, socket);
+            });
+            socket.on('close', () => {
+                logger.info(`Client disconnected: ${socket.clientId}`);
+                this.options.onClose?.(socket);
+            });
+            socket.on('pong', () => {
+                socket.isAlive = true;
+            });
+            await this.options.onConnection?.(socket);
+        });
+    }
+    /**
+     * Start ping interval to check client connections
+     */
+    startPingInterval() {
+        if (this.options.pingInterval) {
+            this.pingInterval = setInterval(() => {
+                this.wss.clients.forEach((socket) => {
+                    const nostrSocket = socket;
+                    if (!nostrSocket.isAlive) {
+                        nostrSocket.terminate();
+                        return;
+                    }
+                    nostrSocket.isAlive = false;
+                    nostrSocket.ping();
+                });
+            }, this.options.pingInterval);
+        }
+    }
+    /**
+     * Stop the server and clean up resources
+     */
+    stop() {
+        if (this.pingInterval) {
+            clearInterval(this.pingInterval);
+        }
+        this.wss.clients.forEach((socket) => {
+            const nostrSocket = socket;
+            if (nostrSocket.readyState === WebSocket.OPEN) {
+                nostrSocket.close();
+            }
+        });
+        this.wss.close();
+    }
+}

package/dist/crypto/bech32.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @file Bech32 encoding/decoding utilities
+ * @module crypto/bech32
+ */
+/**
+ * Encode data to bech32
+ */
+export declare function bech32Encode(hrp: string, data: number[]): string;
+/**
+ * Decode bech32 string
+ */
+export declare function bech32Decode(str: string): {
+    hrp: string;
+    data: number[];
+};
+/**
+ * Encode hex string to bech32
+ */
+export declare function encodeToBech32(hrp: string, hex: string): string;
+/**
+ * Decode bech32 to hex string
+ */
+export declare function decodeFromBech32(str: string): {
+    prefix: string;
+    hex: string;
+};

package/dist/crypto/bech32.js

@@ -0,0 +1,163 @@
+/**
+ * @file Bech32 encoding/decoding utilities
+ * @module crypto/bech32
+ */
+const CHARSET = 'qpzry9x8gf2tvdw0s3jn54khce6mua7l';
+const GENERATOR = [0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3];
+/**
+ * Convert 5-bit groups to base32
+ */
+function toChars(data) {
+    let result = '';
+    for (let i = 0; i < data.length; i++) {
+        result += CHARSET.charAt(data[i]);
+    }
+    return result;
+}
+/**
+ * Convert string to 5-bit groups
+ */
+function fromChars(str) {
+    const result = [];
+    for (let i = 0; i < str.length; i++) {
+        const index = CHARSET.indexOf(str.charAt(i));
+        if (index === -1)
+            throw new Error(`Invalid character: ${str.charAt(i)}`);
+        result.push(index);
+    }
+    return result;
+}
+/**
+ * Compute checksum
+ */
+function polymod(values) {
+    let chk = 1;
+    for (let p = 0; p < values.length; p++) {
+        const top = chk >> 25;
+        chk = (chk & 0x1ffffff) << 5 ^ values[p];
+        for (let i = 0; i < 5; i++) {
+            if ((top >> i) & 1) {
+                chk ^= GENERATOR[i];
+            }
+        }
+    }
+    return chk;
+}
+/**
+ * Expand human-readable part
+ */
+function expandHRP(hrp) {
+    const result = [];
+    for (let i = 0; i < hrp.length; i++) {
+        result.push(hrp.charCodeAt(i) >> 5);
+    }
+    result.push(0);
+    for (let i = 0; i < hrp.length; i++) {
+        result.push(hrp.charCodeAt(i) & 31);
+    }
+    return result;
+}
+/**
+ * Verify checksum
+ */
+function verifyChecksum(hrp, data) {
+    return polymod(expandHRP(hrp).concat(data)) === 1;
+}
+/**
+ * Create checksum
+ */
+function createChecksum(hrp, data) {
+    const values = expandHRP(hrp).concat(data).concat([0, 0, 0, 0, 0, 0]);
+    const mod = polymod(values) ^ 1;
+    const result = [];
+    for (let p = 0; p < 6; p++) {
+        result.push((mod >> 5 * (5 - p)) & 31);
+    }
+    return result;
+}
+/**
+ * Convert data to 5-bit groups
+ */
+function convertBits(data, frombits, tobits, pad) {
+    let acc = 0;
+    let bits = 0;
+    const result = [];
+    const maxv = (1 << tobits) - 1;
+    for (let i = 0; i < data.length; i++) {
+        const value = data[i];
+        if (value < 0 || value >> frombits !== 0) {
+            throw new Error('Invalid value');
+        }
+        acc = (acc << frombits) | value;
+        bits += frombits;
+        while (bits >= tobits) {
+            bits -= tobits;
+            result.push((acc >> bits) & maxv);
+        }
+    }
+    if (pad) {
+        if (bits > 0) {
+            result.push((acc << (tobits - bits)) & maxv);
+        }
+    }
+    else if (bits >= frombits || ((acc << (tobits - bits)) & maxv)) {
+        throw new Error('Invalid padding');
+    }
+    return result;
+}
+/**
+ * Encode data to bech32
+ */
+export function bech32Encode(hrp, data) {
+    const combined = data.concat(createChecksum(hrp, data));
+    return hrp + '1' + toChars(combined);
+}
+/**
+ * Decode bech32 string
+ */
+export function bech32Decode(str) {
+    if (str.length < 8 || str.length > 90) {
+        throw new Error('Invalid length');
+    }
+    let lower = false;
+    let upper = false;
+    for (let i = 0; i < str.length; i++) {
+        if (str.charCodeAt(i) < 33 || str.charCodeAt(i) > 126) {
+            throw new Error('Invalid character');
+        }
+        if (str.charCodeAt(i) >= 97 && str.charCodeAt(i) <= 122)
+            lower = true;
+        if (str.charCodeAt(i) >= 65 && str.charCodeAt(i) <= 90)
+            upper = true;
+    }
+    if (lower && upper) {
+        throw new Error('Mixed case');
+    }
+    const pos = str.lastIndexOf('1');
+    if (pos < 1 || pos + 7 > str.length) {
+        throw new Error('Invalid separator position');
+    }
+    const hrp = str.substring(0, pos).toLowerCase();
+    const data = fromChars(str.substring(pos + 1));
+    if (!verifyChecksum(hrp, data)) {
+        throw new Error('Invalid checksum');
+    }
+    return { hrp, data: data.slice(0, -6) };
+}
+/**
+ * Encode hex string to bech32
+ */
+export function encodeToBech32(hrp, hex) {
+    const data = new Uint8Array(hex.match(/.{1,2}/g)?.map(byte => parseInt(byte, 16)) || []);
+    const words = convertBits(Array.from(data), 8, 5, true);
+    return bech32Encode(hrp, words);
+}
+/**
+ * Decode bech32 to hex string
+ */
+export function decodeFromBech32(str) {
+    const { hrp, data } = bech32Decode(str);
+    const bytes = convertBits(data, 5, 8, false);
+    const hex = bytes.map(b => b.toString(16).padStart(2, '0')).join('');
+    return { prefix: hrp, hex };
+}

package/dist/crypto/handlers.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @file Crypto handlers for Nostr messages
+ * @module crypto/handlers
+ */
+import type { NostrWSMessage } from '../types/messages';
+/**
+ * Validates a signed message
+ * @param message - Message to validate
+ * @returns Promise resolving to true if message is valid
+ */
+export declare function validateSignedMessage(message: NostrWSMessage): Promise<boolean>;

package/dist/crypto/handlers.js

@@ -0,0 +1,36 @@
+/**
+ * @file Crypto handlers for Nostr messages
+ * @module crypto/handlers
+ */
+import { getLogger } from '../utils/logger';
+import { MESSAGE_TYPES } from '../types/messages';
+import { validateEvent, verifySignature } from 'nostr-crypto-utils';
+const logger = getLogger('crypto');
+/**
+ * Validates a signed message
+ * @param message - Message to validate
+ * @returns Promise resolving to true if message is valid
+ */
+export async function validateSignedMessage(message) {
+    try {
+        if (message.type !== MESSAGE_TYPES.EVENT || !message.data) {
+            logger.debug('Invalid message format');
+            return false;
+        }
+        const event = message.data;
+        if (!validateEvent(event)) {
+            logger.debug('Invalid event format');
+            return false;
+        }
+        const isValid = await verifySignature(event);
+        if (!isValid) {
+            logger.debug('Invalid signature');
+            return false;
+        }
+        return true;
+    }
+    catch (error) {
+        logger.error('Error validating signed message:', error);
+        return false;
+    }
+}

package/dist/crypto/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @file Crypto operations index
+ * @module crypto
+ */
+export * from './handlers';

package/dist/crypto/index.js

@@ -0,0 +1,5 @@
+/**
+ * @file Crypto operations index
+ * @module crypto
+ */
+export * from './handlers';

package/dist/crypto/schnorr.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @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

@@ -0,0 +1,51 @@
+/**
+ * @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/endpoints/metrics.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @file Metrics endpoint for Nostr WebSocket server
+ * @module endpoints/metrics
+ */
+export interface MetricsEndpointOptions {
+    port?: number;
+    host?: string;
+    path?: string;
+    auth?: {
+        username: string;
+        password: string;
+    };
+}
+export declare class MetricsEndpoint {
+    private server;
+    private options;
+    constructor(options?: MetricsEndpointOptions);
+    private checkAuth;
+    private handleRequest;
+    /**
+     * Start the metrics endpoint server
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the metrics endpoint server
+     */
+    stop(): Promise<void>;
+}
+export declare const metricsEndpoint: MetricsEndpoint;

package/dist/endpoints/metrics.js

@@ -0,0 +1,101 @@
+/**
+ * @file Metrics endpoint for Nostr WebSocket server
+ * @module endpoints/metrics
+ */
+import { createServer } from 'http';
+import { metricsTracker } from '../utils/metrics';
+import { getLogger } from '../utils/logger';
+const logger = getLogger('MetricsEndpoint');
+export class MetricsEndpoint {
+    constructor(options = {}) {
+        this.options = {
+            port: options.port || 9100,
+            host: options.host || 'localhost',
+            path: options.path || '/metrics',
+            auth: options.auth || { username: '', password: '' }
+        };
+        this.server = createServer((req, res) => this.handleRequest(req, res));
+    }
+    checkAuth(req) {
+        if (!this.options.auth.username)
+            return true;
+        const authHeader = req.headers.authorization || '';
+        const [type, credentials] = authHeader.split(' ');
+        if (type !== 'Basic')
+            return false;
+        const [username, password] = Buffer.from(credentials, 'base64')
+            .toString()
+            .split(':');
+        return username === this.options.auth.username &&
+            password === this.options.auth.password;
+    }
+    async handleRequest(req, res) {
+        try {
+            // Only handle GET requests to metrics path
+            if (req.method !== 'GET' || req.url !== this.options.path) {
+                res.writeHead(404);
+                res.end('Not Found');
+                return;
+            }
+            // Check authentication if configured
+            if (!this.checkAuth(req)) {
+                res.writeHead(401, {
+                    'WWW-Authenticate': 'Basic realm="Nostr Metrics"'
+                });
+                res.end('Unauthorized');
+                return;
+            }
+            // Get metrics in Prometheus format
+            const metrics = metricsTracker.getPrometheusMetrics();
+            // Send response
+            res.writeHead(200, {
+                'Content-Type': 'text/plain; version=0.0.4',
+                'Cache-Control': 'no-cache'
+            });
+            res.end(metrics);
+            logger.info({
+                method: req.method,
+                path: req.url,
+                status: 200,
+                metrics: metrics.split('\n').length
+            }, 'Metrics request served');
+        }
+        catch (error) {
+            logger.error({ error }, 'Error serving metrics');
+            res.writeHead(500);
+            res.end('Internal Server Error');
+        }
+    }
+    /**
+     * Start the metrics endpoint server
+     */
+    start() {
+        return new Promise((resolve, reject) => {
+            this.server.listen(this.options.port, this.options.host, () => {
+                logger.info({
+                    host: this.options.host,
+                    port: this.options.port,
+                    path: this.options.path
+                }, 'Metrics endpoint started');
+                resolve();
+            }).on('error', reject);
+        });
+    }
+    /**
+     * Stop the metrics endpoint server
+     */
+    stop() {
+        return new Promise((resolve, reject) => {
+            this.server.close((err) => {
+                if (err)
+                    reject(err);
+                else {
+                    logger.info('Metrics endpoint stopped');
+                    resolve();
+                }
+            });
+        });
+    }
+}
+// Export singleton instance with default configuration
+export const metricsEndpoint = new MetricsEndpoint();

package/dist/index.d.ts

@@ -1,7 +1,12 @@
-export { NostrWSClient } from './client.js';
-export { NostrWSServer } from './server.js';
-export { NostrWSServer as NostrServer } from './nostr-server.js';
-export { createWSServer as createServer } from './nostr-server.js';
+/**
+ * @file Main entry point for the nostr-websocket-utils library
+ * @module nostr-websocket-utils
+ */
+export { NostrWSClient } from './core/client.js';
+export { NostrWSServer } from './core/server.js';
+export { NostrWSServer as NostrServer } from './core/nostr-server.js';
+export { createWSServer as createServer } from './core/nostr-server.js';
 export { getLogger } from './utils/logger.js';
-export type { NostrWSOptions, NostrWSMessage, NostrWSSubscription, NostrWSClientEvents, NostrWSServerEvents, ExtendedWebSocket, NostrWSValidationResult, NostrWSConnectionState } from './types/index.js';
-export type { NostrWSEvent as NostrEvent, NostrWSFilter as NostrFilter, NostrWSSocket as NostrSocket, NostrWSServerOptions, NostrWSServerMessage, NostrWSMessageType } from './types/nostr.js';
+export * from './crypto';
+export * from './nips';
+export * from './types';

package/dist/index.js

@@ -1,5 +1,17 @@
-export { NostrWSClient } from './client.js';
-export { NostrWSServer } from './server.js';
-export { NostrWSServer as NostrServer } from './nostr-server.js';
-export { createWSServer as createServer } from './nostr-server.js';
+/**
+ * @file Main entry point for the nostr-websocket-utils library
+ * @module nostr-websocket-utils
+ */
+// Core functionality
+export { NostrWSClient } from './core/client.js';
+export { NostrWSServer } from './core/server.js';
+export { NostrWSServer as NostrServer } from './core/nostr-server.js';
+export { createWSServer as createServer } from './core/nostr-server.js';
+// Utilities
 export { getLogger } from './utils/logger.js';
+// Crypto operations
+export * from './crypto';
+// NIP implementations
+export * from './nips';
+// Type definitions
+export * from './types';

package/dist/nips/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @file NIPs implementation index
+ * @module nips
+ */
+export * from './nip-01';
+export * from './nip-02';
+export * from './nip-04';
+export * from './nip-05';
+export * from './nip-09';
+export * from './nip-19';
+export * from './nip-26';
+export * from './nip-11';
+export * from './nip-20';
+export * from './nip-13';
+export * from './nip-16';
+export * from './nip-15';
+export * from './nip-22';
+export * from './nip-28';
+export * from './nip-33';

package/dist/nips/index.js

@@ -0,0 +1,34 @@
+/**
+ * @file NIPs implementation index
+ * @module nips
+ */
+// Basic protocol flow
+export * from './nip-01';
+// Contact List and Petnames
+export * from './nip-02';
+// Encrypted Direct Messages
+export * from './nip-04';
+// DNS Identity Verification
+export * from './nip-05';
+// Event Deletion
+export * from './nip-09';
+// bech32-encoded entities
+export * from './nip-19';
+// Delegated Event Signing
+export * from './nip-26';
+// Relay Information Document
+export * from './nip-11';
+// Command Results
+export * from './nip-20';
+// Proof of Work
+export * from './nip-13';
+// Event Treatment
+export * from './nip-16';
+// End of Stored Events Notice
+export * from './nip-15';
+// Event Created At Limits
+export * from './nip-22';
+// Public Chat
+export * from './nip-28';
+// Parameterized Replaceable Events
+export * from './nip-33';