nostr-crypto-utils 0.1.4 → 0.1.5

package/dist/index.d.ts

@@ -1,4 +1,5 @@
-import type { KeyPair, NostrEvent, SignedNostrEvent, ValidationResult } from './types';
+import type { KeyPair, NostrEvent, SignedNostrEvent, ValidationResult, EncryptionResult } from './types';
+export type { KeyPair, NostrEvent, SignedNostrEvent, ValidationResult, EncryptionResult };
 /**
  * Generate a private key for use with NOSTR
  */
@@ -9,8 +10,9 @@ export declare function generatePrivateKey(): string;
 export declare function getPublicKey(privateKey: string): string;
 /**
  * Generate a new key pair
+ * @param seedPhrase Optional seed phrase to generate deterministic key pair
  */
-export declare function generateKeyPair(): KeyPair;
+export declare function generateKeyPair(seedPhrase?: string): KeyPair;
 /**
  * Get the hash of a NOSTR event
  */

package/dist/index.js

@@ -4,6 +4,9 @@ import { sha256 } from '@noble/hashes/sha256';
 import { randomBytes } from '@noble/hashes/utils';
 import * as secp256k1 from '@noble/secp256k1';
 import { generateSecretKey, getPublicKey as getNostrPublicKey } from 'nostr-tools';
+import { webcrypto } from 'node:crypto';
+// Use Node.js crypto API
+const crypto = webcrypto;
 /**
  * Generate a private key for use with NOSTR
  */
@@ -18,8 +21,18 @@ export function getPublicKey(privateKey) {
 }
 /**
  * Generate a new key pair
+ * @param seedPhrase Optional seed phrase to generate deterministic key pair
  */
-export function generateKeyPair() {
+export function generateKeyPair(seedPhrase) {
+    if (seedPhrase) {
+        // Use the seed phrase to generate a deterministic private key
+        const encoder = new TextEncoder();
+        const seedBytes = encoder.encode(seedPhrase);
+        const hash = sha256(seedBytes);
+        const privateKey = bytesToHex(hash);
+        const publicKey = getPublicKey(privateKey);
+        return { privateKey, publicKey };
+    }
     const privateKey = generatePrivateKey();
     const publicKey = getPublicKey(privateKey);
     return { privateKey, publicKey };
@@ -43,37 +56,60 @@ export function getEventHash(event) {
  * Sign a NOSTR event
  */
 export async function signEvent(event, privateKey) {
-    const hash = getEventHash(event);
-    const signature = bytesToHex(await schnorr.sign(hexToBytes(hash), hexToBytes(privateKey)));
-    return {
+    const pubkey = getPublicKey(privateKey);
+    const eventToSign = {
         ...event,
+        pubkey,
+        created_at: event.created_at || Math.floor(Date.now() / 1000),
+        tags: event.tags || []
+    };
+    const hash = getEventHash(eventToSign);
+    const sig = bytesToHex(await schnorr.sign(hexToBytes(hash), hexToBytes(privateKey)));
+    return {
+        ...eventToSign,
         id: hash,
-        sig: signature,
-        pubkey: getPublicKey(privateKey)
+        sig
     };
 }
 /**
  * Verify a signature
  */
 export function verifySignature(event) {
-    const hash = getEventHash(event);
-    return schnorr.verify(hexToBytes(event.sig), hexToBytes(hash), hexToBytes(event.pubkey));
+    try {
+        const hash = getEventHash({
+            kind: event.kind,
+            created_at: event.created_at,
+            tags: event.tags,
+            content: event.content,
+            pubkey: event.pubkey
+        });
+        if (hash !== event.id) {
+            return false;
+        }
+        return schnorr.verify(hexToBytes(event.sig), hexToBytes(hash), hexToBytes(event.pubkey));
+    }
+    catch (error) {
+        return false;
+    }
 }
 /**
  * Validate a key pair
  */
 export function validateKeyPair(publicKey, privateKey) {
     try {
-        const derivedPubKey = getPublicKey(privateKey);
-        return {
-            isValid: derivedPubKey === publicKey,
-            error: derivedPubKey !== publicKey ? 'Public key does not match derived key' : undefined
-        };
+        const derivedPublicKey = getPublicKey(privateKey);
+        if (derivedPublicKey !== publicKey) {
+            return {
+                isValid: false,
+                error: 'Public key does not match private key'
+            };
+        }
+        return { isValid: true };
     }
     catch (error) {
         return {
             isValid: false,
-            error: error instanceof Error ? error.message : 'Unknown error occurred'
+            error: 'Invalid key pair'
         };
     }
 }
@@ -81,24 +117,28 @@ export function validateKeyPair(publicKey, privateKey) {
  * Encrypt a message using NIP-04
  */
 export async function encrypt(message, recipientPubKey, senderPrivKey) {
-    const sharedSecret = secp256k1.getSharedSecret(senderPrivKey, '02' + recipientPubKey);
+    const sharedPoint = secp256k1.getSharedSecret(senderPrivKey, '02' + recipientPubKey);
+    const sharedX = sharedPoint.slice(1, 33);
     const iv = randomBytes(16);
-    const key = sha256(sharedSecret);
     const textEncoder = new TextEncoder();
-    const cryptoKey = await crypto.subtle.importKey('raw', key, { name: 'AES-CBC' }, false, ['encrypt']);
-    const encrypted = await crypto.subtle.encrypt({ name: 'AES-CBC', iv }, cryptoKey, textEncoder.encode(message));
-    return bytesToHex(iv) + bytesToHex(new Uint8Array(encrypted));
+    const plaintext = textEncoder.encode(message);
+    const key = await crypto.subtle.importKey('raw', sharedX, { name: 'AES-CBC', length: 256 }, false, ['encrypt']);
+    const ciphertext = await crypto.subtle.encrypt({ name: 'AES-CBC', iv }, key, plaintext);
+    const ctb64 = Buffer.from(new Uint8Array(ciphertext)).toString('base64');
+    const ivb64 = Buffer.from(new Uint8Array(iv)).toString('base64');
+    return `${ctb64}?iv=${ivb64}`;
 }
 /**
  * Decrypt a message using NIP-04
  */
 export async function decrypt(encryptedMessage, senderPubKey, recipientPrivKey) {
-    const sharedSecret = secp256k1.getSharedSecret(recipientPrivKey, '02' + senderPubKey);
-    const key = sha256(sharedSecret);
-    const iv = hexToBytes(encryptedMessage.slice(0, 32));
-    const ciphertext = hexToBytes(encryptedMessage.slice(32));
+    const [ctb64, ivb64] = encryptedMessage.split('?iv=');
+    const sharedPoint = secp256k1.getSharedSecret(recipientPrivKey, '02' + senderPubKey);
+    const sharedX = sharedPoint.slice(1, 33);
+    const key = await crypto.subtle.importKey('raw', sharedX, { name: 'AES-CBC', length: 256 }, false, ['decrypt']);
+    const iv = Buffer.from(ivb64, 'base64');
+    const ciphertext = Buffer.from(ctb64, 'base64');
+    const decrypted = await crypto.subtle.decrypt({ name: 'AES-CBC', iv }, key, ciphertext);
     const textDecoder = new TextDecoder();
-    const cryptoKey = await crypto.subtle.importKey('raw', key, { name: 'AES-CBC' }, false, ['decrypt']);
-    const decrypted = await crypto.subtle.decrypt({ name: 'AES-CBC', iv }, cryptoKey, ciphertext);
     return textDecoder.decode(new Uint8Array(decrypted));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nostr-crypto-utils",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Cryptographic utilities for NOSTR",
   "type": "module",
   "main": "dist/index.js",