nostr-crypto-utils 0.4.2 → 0.4.3

package/dist/nips/nip-19.d.ts

@@ -50,3 +50,4 @@ export declare function neventEncode(eventId: string, relays?: string[], author?
  * @returns Decoded data with type and metadata
  */
 export declare function decode(str: string): Nip19Data;
+export declare function encodeBytes(prefix: string, data: Uint8Array): string;

package/dist/nips/nip-19.js

@@ -111,8 +111,7 @@ export function decode(str) {
     }
 }
 // Helper functions
-function encodeBytes(prefix, hex) {
-    const data = Buffer.from(hex, 'hex');
+export function encodeBytes(prefix, data) {
     const words = bech32.toWords(data);
     return bech32.encode(prefix, words, 1000);
 }

package/dist/nips/nip-26.js

@@ -38,7 +38,6 @@ export async function verifyDelegation(delegation) {
  * @returns True if conditions are met
  */
 export function checkDelegationConditions(event, conditions) {
-    const now = Math.floor(Date.now() / 1000);
     if (conditions.kind !== undefined && event.kind !== conditions.kind) {
         return false;
     }

package/dist/utils/logger.d.ts

@@ -4,20 +4,21 @@
  */
 import pino from 'pino';
 /**
- * Create a logger instance
+ * Create a logger instance with consistent configuration
+ * @param name - Component or module name for the logger
+ * @param _options - Optional additional configuration
+ * @returns Configured pino logger instance
  */
 export declare function createLogger(name: string, _options?: unknown): pino.Logger;
 /**
- * @description Simple logger utility
- */
-/**
- * Log a message with optional data
+ * Simple log function for basic logging needs
  * @param message - Message to log
- * @param data - Optional data to log
+ * @param data - Optional data to include
  */
 export declare function log(message: string, data?: unknown): void;
 /**
- * Logger instance for the application
+ * Default logger instance for the application
+ * Includes enhanced error handling and formatting
  */
 export declare const logger: pino.Logger;
 export type { Logger } from 'pino';

package/dist/utils/logger.js

@@ -4,7 +4,10 @@
  */
 import pino from 'pino';
 /**
- * Create a logger instance
+ * Create a logger instance with consistent configuration
+ * @param name - Component or module name for the logger
+ * @param _options - Optional additional configuration
+ * @returns Configured pino logger instance
  */
 export function createLogger(name, _options) {
     return pino({
@@ -13,36 +16,56 @@ export function createLogger(name, _options) {
         transport: process.env.NODE_ENV === 'development' ? {
             target: 'pino-pretty',
             options: {
-                colorize: true
+                colorize: true,
+                translateTime: 'HH:MM:ss',
+                ignore: 'pid,hostname',
             }
-        } : undefined
+        } : undefined,
+        formatters: {
+            level: (label) => {
+                return { level: label.toUpperCase() };
+            }
+        }
     });
 }
 /**
- * @description Simple logger utility
- */
-/**
- * Log a message with optional data
+ * Simple log function for basic logging needs
  * @param message - Message to log
- * @param data - Optional data to log
+ * @param data - Optional data to include
  */
 export function log(message, data) {
     console.log(message, data);
 }
-// Export a default logger instance
 /**
- * Logger instance for the application
+ * Default logger instance for the application
+ * Includes enhanced error handling and formatting
  */
 export const logger = pino({
-    name: 'default',
-    level: 'info',
+    name: 'nostr-crypto-utils',
+    level: process.env.LOG_LEVEL || 'info',
+    transport: process.env.NODE_ENV === 'development' ? {
+        target: 'pino-pretty',
+        options: {
+            colorize: true,
+            translateTime: 'HH:MM:ss',
+            ignore: 'pid,hostname',
+        }
+    } : undefined,
     formatters: {
+        level: (label) => {
+            return { level: label.toUpperCase() };
+        },
         log: (obj) => {
             // Convert error objects to strings for better logging
             if (obj && typeof obj === 'object' && 'err' in obj) {
                 const newObj = { ...obj };
                 if (newObj.err instanceof Error) {
-                    newObj.err = newObj.err.message;
+                    const err = newObj.err;
+                    newObj.err = {
+                        message: err.message,
+                        stack: err.stack,
+                        name: err.name,
+                    };
                 }
                 return newObj;
             }

package/dist/utils/validation.d.ts

@@ -21,6 +21,12 @@ export interface ValidationResult {
  * ```
  */
 export declare function validateEvent(event: NostrEvent): ValidationResult;
+/**
+ * Gets the hex representation of a public key
+ * @param pubkey - Public key in either hex or details format
+ * @returns Hex representation of the public key
+ */
+export declare function getPublicKeyHex(pubkey: string): string;
 /**
  * Validates a signed Nostr event (NIP-01)
  * @category Validation

package/dist/utils/validation.js

@@ -60,8 +60,8 @@ export function validateEvent(event) {
  * @param pubkey - Public key in either hex or details format
  * @returns Hex representation of the public key
  */
-function getPublicKeyHex(pubkey) {
-    return typeof pubkey === 'string' ? pubkey : pubkey.hex;
+export function getPublicKeyHex(pubkey) {
+    return pubkey.startsWith('npub1') ? pubkey.slice(5) : pubkey;
 }
 /**
  * Validates a signed Nostr event (NIP-01)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nostr-crypto-utils",
-  "version": "0.4.2",
+  "version": "0.4.3",
   "description": "A comprehensive TypeScript library for Nostr protocol implementation, supporting multiple NIPs with strict validation",
   "type": "module",
   "main": "./dist/index.js",

package/dist/functions.d.ts

@@ -1,19 +0,0 @@
-import type { KeyPair, NostrEvent, SignedNostrEvent, ValidationResult } from './types';
-import { NostrEventKind } from './types';
-export declare function generatePrivateKey(): Promise<string>;
-export declare function generateKeyPair(seed?: string): Promise<KeyPair>;
-export declare function getPublicKey(privateKey: string): string;
-export declare function getEventHash(event: NostrEvent): Promise<string>;
-export declare function serializeEvent(event: NostrEvent): string;
-export declare function createEvent(params: {
-    kind: NostrEventKind;
-    content: string;
-    tags?: string[][];
-    created_at?: number;
-    pubkey?: string;
-}): NostrEvent;
-export declare function signEvent(event: NostrEvent, privateKey: string): SignedNostrEvent;
-export declare function verifySignature(event: SignedNostrEvent): boolean;
-export declare function validateKeyPair(publicKey: string, privateKey: string): ValidationResult;
-export declare function encrypt(message: string, recipientPubKey: string, senderPrivKey: string): Promise<string>;
-export declare function decrypt(encryptedMessage: string, senderPubKey: string, recipientPrivKey: string): Promise<string>;

package/dist/functions.js

@@ -1,127 +0,0 @@
-import { schnorr } from '@noble/curves/secp256k1';
-import { bytesToHex, hexToBytes } from '@noble/hashes/utils';
-import { sha256 } from '@noble/hashes/sha256';
-import * as secp256k1 from '@noble/secp256k1';
-import { generatePrivateKey as generateNostrPrivateKey } from 'nostr-tools';
-import { webcrypto } from 'node:crypto';
-import pino from 'pino';
-const logger = pino({
-    level: process.env.LOG_LEVEL || 'info',
-    transport: {
-        target: 'pino-pretty',
-        options: {
-            colorize: true
-        }
-    }
-});
-// Configure crypto for Node.js and test environments
-let customCrypto;
-if (typeof window !== 'undefined' && window.crypto) {
-    customCrypto = window.crypto;
-}
-else {
-    customCrypto = webcrypto;
-}
-export async function generatePrivateKey() {
-    return generateNostrPrivateKey();
-}
-export async function generateKeyPair(seed) {
-    const privateKey = await generatePrivateKey();
-    const publicKey = getPublicKey(privateKey);
-    return { privateKey, publicKey };
-}
-export function getPublicKey(privateKey) {
-    return secp256k1.getPublicKey(privateKey, true);
-}
-export async function getEventHash(event) {
-    const serialized = serializeEvent(event);
-    const hash = await sha256(new TextEncoder().encode(serialized));
-    return bytesToHex(hash);
-}
-export function serializeEvent(event) {
-    return JSON.stringify([
-        0,
-        event.pubkey,
-        event.created_at,
-        event.kind,
-        event.tags,
-        event.content
-    ]);
-}
-export function createEvent(params) {
-    const { kind, content, tags = [], created_at = Math.floor(Date.now() / 1000), pubkey = '' } = params;
-    return {
-        kind,
-        content,
-        tags,
-        created_at,
-        pubkey,
-    };
-}
-export function signEvent(event, privateKey) {
-    const hash = getEventHash(event);
-    const sig = secp256k1.sign(hash, privateKey);
-    return {
-        ...event,
-        id: hash,
-        sig: sig.toCompactHex(),
-    };
-}
-export function verifySignature(event) {
-    try {
-        const hash = getEventHash(event);
-        return schnorr.verify(event.sig, hash, event.pubkey);
-    }
-    catch (error) {
-        logger.error('Failed to verify signature:', error);
-        return false;
-    }
-}
-export function validateKeyPair(publicKey, privateKey) {
-    try {
-        const derivedPublicKey = getPublicKey(privateKey);
-        const isValid = derivedPublicKey === publicKey;
-        return {
-            isValid,
-            error: isValid ? undefined : 'Public key does not match private key'
-        };
-    }
-    catch (error) {
-        return {
-            isValid: false,
-            error: error instanceof Error ? error.message : 'Unknown error'
-        };
-    }
-}
-export async function encrypt(message, recipientPubKey, senderPrivKey) {
-    try {
-        const sharedSecret = secp256k1.getSharedSecret(senderPrivKey, '02' + recipientPubKey);
-        const sharedKey = await customCrypto.subtle.importKey('raw', sharedSecret.slice(1), { name: 'AES-CBC', length: 256 }, true, ['encrypt']);
-        const iv = crypto.getRandomValues(new Uint8Array(16));
-        const encrypted = await customCrypto.subtle.encrypt({ name: 'AES-CBC', iv }, sharedKey, new TextEncoder().encode(message));
-        const encryptedArray = new Uint8Array(encrypted);
-        const combined = new Uint8Array(iv.length + encryptedArray.length);
-        combined.set(iv);
-        combined.set(encryptedArray, iv.length);
-        return bytesToHex(combined);
-    }
-    catch (error) {
-        logger.error('Failed to encrypt:', error);
-        throw error;
-    }
-}
-export async function decrypt(encryptedMessage, senderPubKey, recipientPrivKey) {
-    try {
-        const sharedSecret = secp256k1.getSharedSecret(recipientPrivKey, '02' + senderPubKey);
-        const sharedKey = await customCrypto.subtle.importKey('raw', sharedSecret.slice(1), { name: 'AES-CBC', length: 256 }, true, ['decrypt']);
-        const encrypted = hexToBytes(encryptedMessage);
-        const iv = encrypted.slice(0, 16);
-        const ciphertext = encrypted.slice(16);
-        const decrypted = await customCrypto.subtle.decrypt({ name: 'AES-CBC', iv }, sharedKey, ciphertext);
-        return new TextDecoder().decode(decrypted);
-    }
-    catch (error) {
-        logger.error('Failed to decrypt:', error);
-        throw error;
-    }
-}

package/dist/types.d.ts

@@ -1,82 +0,0 @@
-/**
- * @module nostr-crypto-utils/types
- * @description Type definitions for the nostr-crypto-utils library
- */
-export interface KeyPair {
-    privateKey: string;
-    publicKey: string;
-}
-export interface NostrEvent {
-    kind: NostrEventKind;
-    content: string;
-    tags: string[][];
-    created_at: number;
-    pubkey: string;
-}
-export interface SignedNostrEvent extends NostrEvent {
-    id: string;
-    sig: string;
-}
-export interface ValidationResult {
-    isValid: boolean;
-    error?: string;
-}
-export interface EncryptionResult {
-    ciphertext: string;
-    iv: string;
-}
-export interface NostrFilter {
-    ids?: string[];
-    authors?: string[];
-    kinds?: number[];
-    since?: number;
-    until?: number;
-    limit?: number;
-    search?: string;
-    [key: string]: any;
-}
-export interface NostrSubscription {
-    id: string;
-    filters: NostrFilter[];
-}
-export interface NostrMessage {
-    type: NostrMessageType;
-    payload: any;
-}
-export interface NostrResponse {
-    success: boolean;
-    message?: string;
-    data?: any;
-}
-export interface NostrError {
-    code: string;
-    message: string;
-    details?: any;
-}
-export declare enum NostrEventKind {
-    SET_METADATA = 0,
-    TEXT_NOTE = 1,
-    RECOMMEND_SERVER = 2,
-    CONTACT_LIST = 3,
-    ENCRYPTED_DIRECT_MESSAGE = 4,
-    DELETE = 5,
-    REPOST = 6,
-    REACTION = 7,
-    CHANNEL_CREATE = 40,
-    CHANNEL_METADATA = 41,
-    CHANNEL_MESSAGE = 42,
-    CHANNEL_HIDE_MESSAGE = 43,
-    CHANNEL_MUTE_USER = 44,
-    REPORT = 1984,
-    ZAP_REQUEST = 9734,
-    ZAP = 9735
-}
-export declare enum NostrMessageType {
-    EVENT = "EVENT",
-    REQ = "REQ",
-    CLOSE = "CLOSE",
-    NOTICE = "NOTICE",
-    EOSE = "EOSE",
-    OK = "OK",
-    AUTH = "AUTH"
-}

package/dist/types.js

@@ -1,33 +0,0 @@
-/**
- * @module nostr-crypto-utils/types
- * @description Type definitions for the nostr-crypto-utils library
- */
-export var NostrEventKind;
-(function (NostrEventKind) {
-    NostrEventKind[NostrEventKind["SET_METADATA"] = 0] = "SET_METADATA";
-    NostrEventKind[NostrEventKind["TEXT_NOTE"] = 1] = "TEXT_NOTE";
-    NostrEventKind[NostrEventKind["RECOMMEND_SERVER"] = 2] = "RECOMMEND_SERVER";
-    NostrEventKind[NostrEventKind["CONTACT_LIST"] = 3] = "CONTACT_LIST";
-    NostrEventKind[NostrEventKind["ENCRYPTED_DIRECT_MESSAGE"] = 4] = "ENCRYPTED_DIRECT_MESSAGE";
-    NostrEventKind[NostrEventKind["DELETE"] = 5] = "DELETE";
-    NostrEventKind[NostrEventKind["REPOST"] = 6] = "REPOST";
-    NostrEventKind[NostrEventKind["REACTION"] = 7] = "REACTION";
-    NostrEventKind[NostrEventKind["CHANNEL_CREATE"] = 40] = "CHANNEL_CREATE";
-    NostrEventKind[NostrEventKind["CHANNEL_METADATA"] = 41] = "CHANNEL_METADATA";
-    NostrEventKind[NostrEventKind["CHANNEL_MESSAGE"] = 42] = "CHANNEL_MESSAGE";
-    NostrEventKind[NostrEventKind["CHANNEL_HIDE_MESSAGE"] = 43] = "CHANNEL_HIDE_MESSAGE";
-    NostrEventKind[NostrEventKind["CHANNEL_MUTE_USER"] = 44] = "CHANNEL_MUTE_USER";
-    NostrEventKind[NostrEventKind["REPORT"] = 1984] = "REPORT";
-    NostrEventKind[NostrEventKind["ZAP_REQUEST"] = 9734] = "ZAP_REQUEST";
-    NostrEventKind[NostrEventKind["ZAP"] = 9735] = "ZAP";
-})(NostrEventKind || (NostrEventKind = {}));
-export var NostrMessageType;
-(function (NostrMessageType) {
-    NostrMessageType["EVENT"] = "EVENT";
-    NostrMessageType["REQ"] = "REQ";
-    NostrMessageType["CLOSE"] = "CLOSE";
-    NostrMessageType["NOTICE"] = "NOTICE";
-    NostrMessageType["EOSE"] = "EOSE";
-    NostrMessageType["OK"] = "OK";
-    NostrMessageType["AUTH"] = "AUTH";
-})(NostrMessageType || (NostrMessageType = {}));