nostr-crypto-utils 0.4.12 → 0.4.13

package/src/__tests__/integration.test.ts

@@ -77,7 +77,7 @@ describe('Integration Utilities', () => {
     });
 
     it('should parse OK message', () => {
-      const message = ['OK', 'event1', true, 'success'];
+      const message = ['OK', 'event1', 'true', 'success'];
       const parsed = parseNostrMessage(message);
       expect(parsed).not.toBeNull();
       if (parsed) {

package/src/__tests__/types.test.ts

@@ -1,150 +1,59 @@
-import { 
+import {
+  NostrEventKind,
+  SignedNostrEvent,
   isNostrEvent,
   isSignedNostrEvent,
   isNostrFilter,
-  isNostrSubscription,
-  NostrEvent,
-  SignedNostrEvent,
-  NostrFilter,
-  NostrSubscription,
-  NostrEventKind
+  NostrFilter
 } from '../types';
 
 import { describe, it, expect } from 'vitest';
 
 describe('Type Guards', () => {
-  describe('isNostrEvent', () => {
-    it('should validate a valid NostrEvent', () => {
-      const validEvent: NostrEvent = {
+  describe('Event Types', () => {
+    it('should validate a SignedNostrEvent', () => {
+      const signedEvent: SignedNostrEvent = {
         kind: NostrEventKind.TEXT_NOTE,
         created_at: Math.floor(Date.now() / 1000),
         content: 'Hello, Nostr!',
         tags: [['p', '1234'], ['t', 'test']],
-        pubkey: '0123456789abcdef'
+        pubkey: '0123456789abcdef',
+        id: '0123456789abcdef',
+        sig: '0123456789abcdef'
       };
       
-      expect(isNostrEvent(validEvent)).toBe(true);
+      expect(isSignedNostrEvent(signedEvent)).toBe(true);
     });
 
-    it('should validate a NostrEvent without optional pubkey', () => {
-      const validEvent: NostrEvent = {
-        kind: NostrEventKind.TEXT_NOTE,
+    it('should handle NIP-42 authentication events', () => {
+      const authEvent: SignedNostrEvent = {
+        kind: NostrEventKind.AUTH_RESPONSE,
         created_at: Math.floor(Date.now() / 1000),
-        content: 'Hello, Nostr!',
-        tags: []
+        content: 'challenge-response',
+        tags: [['challenge', '1234']],
+        pubkey: '0123456789abcdef',
+        id: '0123456789abcdef',
+        sig: '0123456789abcdef'
       };
       
-      expect(isNostrEvent(validEvent)).toBe(true);
-    });
-
-    it('should reject invalid NostrEvent objects', () => {
-      const invalidEvents = [
-        null,
-        undefined,
-        {},
-        { kind: 'not a number' },
-        { kind: 1, created_at: 'not a number' },
-        { kind: 1, created_at: 123, content: 42 },
-        { kind: 1, created_at: 123, content: 'valid', tags: 'not an array' },
-        { kind: 1, created_at: 123, content: 'valid', tags: [['valid'], 42] },
-        { kind: 1, created_at: 123, content: 'valid', tags: [], pubkey: 42 }
-      ];
-
-      invalidEvents.forEach(event => {
-        expect(isNostrEvent(event)).toBe(false);
-      });
-    });
-
-    it('should handle edge cases for NostrEvent', () => {
-      const edgeCases: NostrEvent[] = [
-        // Large tag array
-        {
-          kind: NostrEventKind.TEXT_NOTE,
-          created_at: Math.floor(Date.now() / 1000),
-          content: 'Test',
-          tags: Array(1000).fill(['p', '1234']),
-        },
-        // Unicode content
-        {
-          kind: NostrEventKind.TEXT_NOTE,
-          created_at: Math.floor(Date.now() / 1000),
-          content: '🦄 Unicode test 漢字',
-          tags: [],
-        },
-        // Zero timestamp
-        {
-          kind: NostrEventKind.TEXT_NOTE,
-          created_at: 0,
-          content: 'Test',
-          tags: [],
-        },
-        // Reserved event kind
-        {
-          kind: 10000,
-          created_at: Math.floor(Date.now() / 1000),
-          content: 'Test',
-          tags: [],
-        },
-        // Empty content
-        {
-          kind: NostrEventKind.TEXT_NOTE,
-          created_at: Math.floor(Date.now() / 1000),
-          content: '',
-          tags: [],
-        }
-      ];
-
-      edgeCases.forEach(event => {
-        expect(isNostrEvent(event)).toBe(true);
-      });
+      expect(isSignedNostrEvent(authEvent)).toBe(true);
+      expect(authEvent.kind).toBe(NostrEventKind.AUTH_RESPONSE);
     });
   });
 
-  describe('isSignedNostrEvent', () => {
-    it('should validate a valid SignedNostrEvent', () => {
-      const validEvent: SignedNostrEvent = {
+  describe('isNostrEvent', () => {
+    it('should validate a valid NostrEvent', () => {
+      const event: SignedNostrEvent = {
         kind: NostrEventKind.TEXT_NOTE,
-        created_at: Math.floor(Date.now() / 1000),
         content: 'Hello, Nostr!',
-        tags: [['p', '1234'], ['t', 'test']],
+        created_at: Math.floor(Date.now() / 1000),
+        tags: [],
         pubkey: '0123456789abcdef',
-        id: 'event_id_hash',
-        sig: 'valid_signature'
+        id: '0123456789abcdef',
+        sig: '0123456789abcdef'
       };
-      
-      expect(isSignedNostrEvent(validEvent)).toBe(true);
-    });
-
-    it('should reject invalid SignedNostrEvent objects', () => {
-      const invalidEvents = [
-        null,
-        undefined,
-        {},
-        { ...validNostrEvent }, // Missing id and sig
-        { ...validNostrEvent, id: 42 }, // Wrong id type
-        { ...validNostrEvent, id: 'valid', sig: 42 }, // Wrong sig type
-        { ...validNostrEvent, id: 'valid', sig: 'valid', pubkey: undefined } // Missing required pubkey
-      ];
 
-      invalidEvents.forEach(event => {
-        expect(isSignedNostrEvent(event)).toBe(false);
-      });
-    });
-  });
-
-  describe('NostrFilter Type', () => {
-    it('should validate filter properties', () => {
-      const validFilter: NostrFilter = {
-        ids: ['abc123'],
-        authors: ['def456'],
-        kinds: [1, 2, 3],
-        '#e': ['ghi789'],
-        '#p': ['jkl012'],
-        since: 123456789,
-        until: 987654321,
-        limit: 100
-      };
-      expect(validFilter).toBeDefined();
+      expect(isNostrEvent(event)).toBe(true);
     });
   });
 
@@ -153,130 +62,15 @@ describe('Type Guards', () => {
       const validFilter: NostrFilter = {
         ids: ['1234', '5678'],
         authors: ['abcd', 'efgh'],
-        kinds: [1, 2, 3],
-        '#e': ['event1', 'event2'],
-        '#p': ['pubkey1', 'pubkey2'],
-        since: 123456789,
-        until: 987654321,
-        limit: 100
+        kinds: [NostrEventKind.TEXT_NOTE, NostrEventKind.AUTH_RESPONSE],
+        since: 123,
+        until: 456,
+        limit: 10,
+        '#e': ['1234'],
+        '#p': ['5678']
       };
-      
-      expect(isNostrFilter(validFilter)).toBe(true);
-    });
-
-    it('should validate a NostrFilter with partial fields', () => {
-      const partialFilters: Partial<NostrFilter>[] = [
-        { ids: ['1234'] },
-        { authors: ['abcd'] },
-        { kinds: [1] },
-        { '#e': ['event1'] },
-        { '#p': ['pubkey1'] },
-        { since: 123456789 },
-        { until: 987654321 },
-        { limit: 100 }
-      ];
-
-      partialFilters.forEach(filter => {
-        expect(isNostrFilter(filter)).toBe(true);
-      });
-    });
 
-    it('should reject invalid NostrFilter objects', () => {
-      const invalidFilters = [
-        null,
-        undefined,
-        { ids: [42] },  // Wrong type in array
-        { authors: ['valid', 42] },  // Mixed types in array
-        { kinds: ['1'] },  // Wrong array type
-        { '#e': [42] },  // Wrong type in array
-        { '#p': [true] },  // Wrong type in array
-        { since: '123' },  // Wrong type
-        { until: false },  // Wrong type
-        { limit: '100' }  // Wrong type
-      ];
-
-      invalidFilters.forEach(filter => {
-        expect(isNostrFilter(filter)).toBe(false);
-      });
-    });
-
-    it('should handle edge cases for NostrFilter', () => {
-      const edgeCases: NostrFilter[] = [
-        // Multiple tag types
-        {
-          '#e': ['1234'],
-          '#p': ['5678'],
-          '#t': ['test'],  // Custom tag
-        },
-        // Time range edge cases
-        {
-          since: 0,
-          until: Number.MAX_SAFE_INTEGER,
-        },
-        // Large limit
-        {
-          limit: Number.MAX_SAFE_INTEGER,
-        },
-        // Multiple array fields
-        {
-          ids: ['1', '2', '3'],
-          authors: ['a', 'b', 'c'],
-          kinds: [1, 2, 3, 10000],
-        }
-      ];
-
-      edgeCases.forEach(filter => {
-        expect(isNostrFilter(filter)).toBe(true);
-      });
-    });
-  });
-
-  describe('isNostrSubscription', () => {
-    it('should validate a valid NostrSubscription', () => {
-      const validSubscription: NostrSubscription = {
-        id: 'sub_123',
-        filters: [
-          { kinds: [1], limit: 10 },
-          { authors: ['abcd'], since: 123456789 }
-        ]
-      };
-      
-      expect(isNostrSubscription(validSubscription)).toBe(true);
-    });
-
-    it('should validate a NostrSubscription with empty filters', () => {
-      const validSubscription: NostrSubscription = {
-        id: 'sub_123',
-        filters: []
-      };
-      
-      expect(isNostrSubscription(validSubscription)).toBe(true);
-    });
-
-    it('should reject invalid NostrSubscription objects', () => {
-      const invalidSubscriptions = [
-        null,
-        undefined,
-        {},
-        { id: 123, filters: [] },  // Wrong id type
-        { id: 'valid' },  // Missing filters
-        { id: 'valid', filters: 'not an array' },  // Wrong filters type
-        { id: 'valid', filters: [null] },  // Invalid filter
-        { id: 'valid', filters: [{ invalid: true }] }  // Invalid filter object
-      ];
-
-      invalidSubscriptions.forEach(sub => {
-        expect(isNostrSubscription(sub)).toBe(false);
-      });
+      expect(isNostrFilter(validFilter)).toBe(true);
     });
   });
 });
-
-// Helper for tests
-const validNostrEvent: NostrEvent = {
-  kind: NostrEventKind.TEXT_NOTE,
-  created_at: Math.floor(Date.now() / 1000),
-  content: 'Hello, Nostr!',
-  tags: [['p', '1234'], ['t', 'test']],
-  pubkey: '0123456789abcdef'
-};

package/src/event/index.ts

@@ -0,0 +1,7 @@
+/**
+ * @module event
+ * @description Event handling utilities for Nostr
+ */
+
+export { createEvent, serializeEvent, getEventHash } from './creation';
+export { validateEvent, calculateEventId } from './signing';

package/src/event/signing.ts

@@ -51,3 +51,32 @@ export function verifySignature(event: SignedNostrEvent): boolean {
     return false;
   }
 }
+
+/**
+ * Validates a Nostr event
+ * @param event - Event to validate
+ * @returns True if event is valid
+ */
+export function validateEvent(event: SignedNostrEvent): boolean {
+  try {
+    // Check required fields
+    if (!event.id || !event.pubkey || !event.sig) {
+      return false;
+    }
+
+    // Verify signature
+    return verifySignature(event);
+  } catch (error) {
+    logger.error('Error validating event:', error);
+    return false;
+  }
+}
+
+/**
+ * Calculates the event ID for a Nostr event
+ * @param event - Event to calculate ID for
+ * @returns Event ID
+ */
+export function calculateEventId(event: NostrEvent): Promise<string> {
+  return getEventHash(event);
+}

package/src/index.ts

@@ -1,66 +1,58 @@
 /**
  * @module nostr-crypto-utils
- * @description Main entry point for the nostr-crypto-utils package
+ * @description Core cryptographic utilities for Nostr protocol
  */
 
-// Re-export all types
-export * from './types/index';
+// Core types
+export type {
+  NostrEvent,
+  UnsignedNostrEvent,
+  SignedNostrEvent,
+  NostrFilter,
+  NostrSubscription,
+  PublicKey,
+  KeyPair,
+  NostrMessageTuple,
+} from './types';
 
-// Re-export crypto utilities
+// Event kinds and message types
+export { NostrEventKind, NostrMessageType } from './types';
+
+// Core crypto functions
 export {
-  customCrypto,
-  signSchnorr,
-  verifySchnorrSignature,
   generateKeyPair,
   getPublicKey,
   validateKeyPair,
-  getCompressedPublicKey,
-  getSchnorrPublicKey,
   createEvent,
   signEvent,
   verifySignature,
-  encryptMessage,
-  decryptMessage
-} from './crypto-utils';
+  encrypt,
+  decrypt,
+} from './crypto';
 
-// Re-export protocol utilities
+// Event functions
 export {
-  formatEventForRelay,
-  formatSubscriptionForRelay,
-  formatCloseForRelay,
-  formatAuthForRelay,
-  parseMessage as parseEventFromRelay,
-  createMetadataEvent,
-  createTextNoteEvent,
-  createDirectMessageEvent,
-  createChannelMessageEvent,
-  extractReferencedEvents,
-  extractMentionedPubkeys,
-  createKindFilter,
-  createAuthorFilter,
-  createReplyFilter,
-  createFilter as validateEvent
-} from './protocol/index';
+  validateEvent,
+  calculateEventId,
+} from './event';
 
-// Re-export validation utilities
+// NIP-04 encryption
 export {
-  validateEvent as validateRelayMessage,
-  validateResponse as validateRelayResponse
-} from './validation/index';
+  computeSharedSecret,
+  encryptMessage,
+  decryptMessage,
+} from './nips/nip-04';
 
-// Re-export encoding utilities
-export * from './encoding/index';
+// Re-export NIPs
+export * as nip01 from './nips/nip-01';
+export * as nip04 from './nips/nip-04';
+export * as nip19 from './nips/nip-19';
+export * as nip26 from './nips/nip-26';
 
-// Re-export NIP implementations
+// Utils
 export {
-  npubEncode,
-  nsecEncode,
-  noteEncode,
-  nprofileEncode,
-  neventEncode,
-  naddrEncode,
-  nrelayEncode,
-  decode
-} from './nips/nip-19';
-
-export * from './nips/index';
+  hexToBytes,
+  bytesToHex,
+  utf8ToBytes,
+  bytesToUtf8,
+} from './utils/encoding';

package/src/nips/nip-04.ts

@@ -230,3 +230,5 @@ export function generateSharedSecret(
     throw error;
   }
 }
+
+export { generateSharedSecret as computeSharedSecret };

package/src/protocol/index.ts

@@ -3,8 +3,17 @@
  * @description Core Nostr protocol implementation
  */
 
-import { NostrEvent, SignedNostrEvent, NostrEventKind, NostrFilter, NostrSubscription, NostrResponse, NostrMessageType, PublicKey } from '../types/base';
-import { NOSTR_TAG } from './constants';
+import { 
+  NostrEvent, 
+  NostrFilter, 
+  NostrEventKind, 
+  SignedNostrEvent,
+  NostrMessageType,
+  UnsignedEvent,
+  PublicKey,
+  NostrResponse,
+  NostrSubscription
+} from '../types/base';
 
 /**
  * Formats an event for relay transmission according to NIP-01
@@ -109,9 +118,9 @@ export function parseMessage(message: string): NostrResponse {
  * @category Event Creation
  * @param {Record<string, string>} metadata - User metadata (name, about, picture, etc.)
  * @param {string | PublicKey} pubkey - Public key of the user
- * @returns {NostrEvent} Created metadata event
+ * @returns {UnsignedEvent} Created metadata event
  */
-export function createMetadataEvent(metadata: Record<string, string>, pubkey: string | PublicKey): NostrEvent {
+export function createMetadataEvent(metadata: Record<string, string>, pubkey: string | PublicKey): UnsignedEvent {
   const pubkeyValue = typeof pubkey === 'string' ? pubkey : pubkey.hex;
   return {
     kind: NostrEventKind.SET_METADATA,
@@ -129,24 +138,24 @@ export function createMetadataEvent(metadata: Record<string, string>, pubkey: st
  * @param {string | PublicKey} pubkey - Public key of the author
  * @param {string} [replyTo] - Optional ID of event being replied to
  * @param {string[]} [mentions] - Optional array of pubkeys to mention
- * @returns {NostrEvent} Created text note event
+ * @returns {UnsignedEvent} Created text note event
  */
 export function createTextNoteEvent(
   content: string,
   pubkey: string | PublicKey,
   replyTo?: string,
   mentions?: string[]
-): NostrEvent {
+): UnsignedEvent {
   const pubkeyValue = typeof pubkey === 'string' ? pubkey : pubkey.hex;
   const tags: string[][] = [];
   
   if (replyTo) {
-    tags.push([NOSTR_TAG.EVENT, replyTo]);
+    tags.push(['e', replyTo]);
   }
   
   if (mentions) {
     mentions.forEach(pubkey => {
-      tags.push([NOSTR_TAG.PUBKEY, pubkey]);
+      tags.push(['p', pubkey]);
     });
   }
 
@@ -165,13 +174,13 @@ export function createTextNoteEvent(
  * @param {string | PublicKey} recipientPubkey - Public key of message recipient
  * @param {string} content - Message content (will be encrypted)
  * @param {string | PublicKey} senderPubkey - Public key of the sender
- * @returns {NostrEvent} Created direct message event
+ * @returns {UnsignedEvent} Created direct message event
  */
 export function createDirectMessageEvent(
   recipientPubkey: string | PublicKey,
   content: string,
   senderPubkey: string | PublicKey
-): NostrEvent {
+): UnsignedEvent {
   const recipientKey = typeof recipientPubkey === 'string' ? recipientPubkey : recipientPubkey.hex;
   const senderKey = typeof senderPubkey === 'string' ? senderPubkey : senderPubkey.hex;
   
@@ -191,14 +200,14 @@ export function createDirectMessageEvent(
  * @param {string} content - Message content
  * @param {string | PublicKey} authorPubkey - Public key of the message author
  * @param {string} [replyTo] - Optional ID of message being replied to
- * @returns {NostrEvent} Created channel message event
+ * @returns {UnsignedEvent} Created channel message event
  */
 export function createChannelMessageEvent(
   channelId: string,
   content: string,
   authorPubkey: string | PublicKey,
   replyTo?: string
-): NostrEvent {
+): UnsignedEvent {
   const pubkeyValue = typeof authorPubkey === 'string' ? authorPubkey : authorPubkey.hex;
   const tags = [['e', channelId, '', 'root']];
   if (replyTo) {
@@ -221,7 +230,7 @@ export function createChannelMessageEvent(
  */
 export function extractReferencedEvents(event: NostrEvent): string[] {
   return event.tags
-    .filter((tag: string[]) => tag[0] === NOSTR_TAG.EVENT)
+    .filter((tag: string[]) => tag[0] === 'e')
     .map((tag: string[]) => tag[1]);
 }
 
@@ -233,7 +242,7 @@ export function extractReferencedEvents(event: NostrEvent): string[] {
  */
 export function extractMentionedPubkeys(event: NostrEvent): string[] {
   return event.tags
-    .filter((tag: string[]) => tag[0] === NOSTR_TAG.PUBKEY)
+    .filter((tag: string[]) => tag[0] === 'p')
     .map((tag: string[]) => tag[1]);
 }