nostr-crypto-utils 0.1.4 → 0.1.6

package/README.md

@@ -1,101 +1,90 @@
 # @humanjavaenterprises/nostr-crypto-utils
 
-A comprehensive cryptographic utilities package for NOSTR applications, designed to work seamlessly with [@humanjavaenterprises/nostr-nsec-seedphrase](https://github.com/humanjavaenterprises/nostr-nsec-seedphrase).
+A comprehensive TypeScript library providing cryptographic utilities and protocol-compliant message handling for Nostr applications, designed to work seamlessly with [@humanjavaenterprises/nostr-nsec-seedphrase](https://github.com/HumanjavaEnterprises/nostr-nsec-seedphrase).
 
-⚠️ **Important Security Notice**
+[![npm version](https://badge.fury.io/js/%40humanjavaenterprises%2Fnostr-crypto-utils.svg)](https://www.npmjs.com/package/@humanjavaenterprises/nostr-crypto-utils)
+[![TypeScript](https://img.shields.io/badge/%3C%2F%3E-TypeScript-%230074c1.svg)](http://www.typescriptlang.org/)
+[![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/HumanjavaEnterprises/nostr-crypto-utils/blob/main/LICENSE)
 
-This library handles cryptographic keys and seed phrases that are critical for securing your Nostr identity and data. Just like Bitcoin, any seed phrase or private key (`nsec`) generated by this library must be stored with the utmost security and care.
+⚠️ **Important Security Notice**
 
-Developers using this library must inform their users about the critical nature of managing seed phrases, `nsec`, and hex keys. It is the user's responsibility to securely store and manage these keys. The library and its authors disclaim any responsibility or liability for lost keys, seed phrases, or data resulting from mismanagement.
+This library handles cryptographic keys and operations that are critical for securing your Nostr identity and data. All cryptographic operations, including key generation, signing, and encryption, must be handled with appropriate security measures.
 
 ## Features
 
-- 🔑 Complete key pair management (generation, validation, public key derivation)
-- 📝 Event signing and verification
-- 🔒 NIP-04 encryption and decryption
-- 🌱 Seed phrase support via integration with nostr-nsec-seedphrase
-- 📦 Modern ESM package with full TypeScript support
-- ⚡️ Built on established crypto libraries (noble-curves, noble-hashes)
-- 🤝 Compatible with nostr-tools as a peer dependency
+- **Complete NIP Compliance**: Implements all required cryptographic operations according to Nostr Implementation Possibilities (NIPs)
+- **Type Safety**: Full TypeScript support with comprehensive type definitions
+- **Event Handling**: Create, sign, and validate Nostr events
+- **Message Formatting**: Protocol-compliant message formatting for relay communication
+- **Encryption**: Secure encryption and decryption for direct messages (NIP-04)
+- **Validation**: Comprehensive validation for events, filters, and subscriptions
 
 ## Installation
 
 ```bash
-npm install @humanjavaenterprises/nostr-crypto-utils @humanjavaenterprises/nostr-nsec-seedphrase nostr-tools
+npm install @humanjavaenterprises/nostr-crypto-utils
 ```
 
-## Architecture Overview
-
-This library serves as a crucial middleware layer in NOSTR applications:
-
-```
-┌─────────────────────────────────────────────────────┐
-│                  Your NOSTR App                     │
-└───────────────────────┬─────────────────────────────┘
-                        │
-┌───────────────────────▼─────────────────────────────┐
-│           @humanjavaenterprises/nostr-crypto-utils  │
-│                                                     │
-│  ┌─────────────────┐        ┌──────────────────┐    │
-│  │   Key Manager   │        │  Event Handler   │    │
-│  └────────┬────────┘        └────────┬─────────┘    │
-│           │                          │              │
-│  ┌────────▼────────┐        ┌───────▼─────────┐    │
-│  │ nostr-nsec-     │        │   nostr-tools   │    │
-│  │ seedphrase      │        │                 │    │
-│  └─────────────────┘        └─────────────────┘    │
-└─────────────────────────────────────────────────────┘
-                        │
-┌───────────────────────▼─────────────────────────────┐
-│               NOSTR Protocol / Relays               │
-└─────────────────────────────────────────────────────┘
-```
-
-## Usage Examples
+## Usage
 
 ### Key Management
 
 ```typescript
-import { generateKeyPair, derivePublicKey, validateKeyPair } from '@humanjavaenterprises/nostr-crypto-utils';
+import { generateKeyPair, getPublicKey } from '@humanjavaenterprises/nostr-crypto-utils';
 
 // Generate a new key pair
 const keyPair = await generateKeyPair();
-console.log(keyPair);
-// { privateKey: '...', publicKey: '...' }
+console.log('Public Key:', keyPair.publicKey);
+console.log('Private Key:', keyPair.privateKey);
 
-// Generate from seed phrase
-const seedPhrase = 'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about';
-const keyPairFromSeed = await generateKeyPair(seedPhrase);
+// Get public key from private key
+const pubKey = getPublicKey(privateKey);
+```
 
-// Derive public key from private key
-const publicKey = await derivePublicKey(keyPair.privateKey);
+### Event Operations
 
-// Validate a key pair
-const validation = await validateKeyPair(keyPair.publicKey, keyPair.privateKey);
-console.log(validation);
-// { isValid: true, error: undefined }
+```typescript
+import { createEvent, signEvent, validateEvent } from '@humanjavaenterprises/nostr-crypto-utils';
+
+// Create and sign an event
+const event = createEvent({
+  kind: NostrEventKind.TEXT_NOTE,
+  content: 'Hello Nostr!',
+  tags: []
+});
+const signedEvent = await signEvent(event, privateKey);
+
+// Validate an event
+const validation = validateEvent(event);
+if (validation.isValid) {
+  console.log('Event is valid');
+} else {
+  console.log('Validation errors:', validation.errors);
+}
 ```
 
-### Event Operations
+### Message Handling
 
 ```typescript
-import { signEvent, verifySignature } from '@humanjavaenterprises/nostr-crypto-utils';
-
-// Create and sign a NOSTR event
-const event = {
-  kind: 1,
-  created_at: Math.floor(Date.now() / 1000),
-  tags: [],
-  content: 'Hello NOSTR!'
+import { 
+  formatEventForRelay, 
+  formatSubscriptionForRelay,
+  parseNostrMessage 
+} from '@humanjavaenterprises/nostr-crypto-utils';
+
+// Format event for relay
+const eventMessage = formatEventForRelay(signedEvent);
+
+// Format subscription request
+const subscription = {
+  id: 'sub1',
+  filters: [{ kinds: [1], limit: 10 }]
 };
+const subMessage = formatSubscriptionForRelay(subscription);
 
-const signedEvent = await signEvent(event, keyPair.privateKey);
-console.log(signedEvent);
-// { id: '...', pubkey: '...', sig: '...', ...event }
-
-// Verify an event signature
-const isValid = await verifySignature(signedEvent);
-console.log(isValid); // true
+// Parse incoming messages
+const message = ['EVENT', signedEvent];
+const parsed = parseNostrMessage(message);
 ```
 
 ### Encryption (NIP-04)
@@ -118,67 +107,29 @@ const decrypted = await decrypt(
 );
 ```
 
-## Integration Examples
+## Protocol Compliance
 
-### Authentication Flow
+This library implements the following Nostr Implementation Possibilities (NIPs):
 
-```typescript
-import { generateKeyPair, signEvent } from '@humanjavaenterprises/nostr-crypto-utils';
-
-async function authenticateUser(seedPhrase?: string) {
-  // Generate or recover keys
-  const keyPair = await generateKeyPair(seedPhrase);
-  
-  // Create auth event
-  const authEvent = {
-    kind: 22242,
-    created_at: Math.floor(Date.now() / 1000),
-    tags: [['challenge', 'authentication-challenge']],
-    content: 'Authenticating...'
-  };
-  
-  // Sign the event
-  const signedAuthEvent = await signEvent(authEvent, keyPair.privateKey);
-  
-  return signedAuthEvent;
-}
-```
+- NIP-01: Basic protocol flow description
+- NIP-02: Contact List and Petnames
+- NIP-04: Encrypted Direct Message
+- NIP-09: Event Deletion
+- NIP-25: Reactions
+- NIP-28: Public Chat Channels
 
-### Secure Messaging
+## Contributing
 
-```typescript
-import { generateKeyPair, encrypt, decrypt } from '@humanjavaenterprises/nostr-crypto-utils';
-
-async function secureMessaging() {
-  // Generate keys for both parties
-  const alice = await generateKeyPair();
-  const bob = await generateKeyPair();
-  
-  // Alice encrypts a message for Bob
-  const encrypted = await encrypt(
-    'Hey Bob!',
-    bob.publicKey,
-    alice.privateKey
-  );
-  
-  // Bob decrypts Alice's message
-  const decrypted = await decrypt(
-    encrypted,
-    alice.publicKey,
-    bob.privateKey
-  );
-}
-```
+Contributions are welcome! Please feel free to submit a Pull Request. For major changes, please open an issue first to discuss what you would like to change.
 
-## Contributing
+## Security
 
-Contributions are welcome! Please feel free to submit a Pull Request.
+If you discover a security vulnerability within this library, please send an e-mail to security@humanjavaenterprises.com. All security vulnerabilities will be promptly addressed.
 
 ## License
 
-MIT
+This project is licensed under the MIT License - see the [LICENSE](https://github.com/HumanjavaEnterprises/nostr-crypto-utils/blob/main/LICENSE) file for details.
 
-## Related Projects
+---
 
-- [@humanjavaenterprises/nostr-nsec-seedphrase](https://github.com/humanjavaenterprises/nostr-nsec-seedphrase) - Seed phrase management for NOSTR
-- [nostr-tools](https://github.com/nbd-wtf/nostr-tools) - Core NOSTR functionality
+Built with ❤️ by [Human Java Enterprises](https://github.com/HumanjavaEnterprises)

package/dist/__tests__/crypto.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/crypto.test.js

@@ -0,0 +1,186 @@
+/// <reference types="jest" />
+import { generateKeyPair, getPublicKey, validateKeyPair, signEvent, verifySignature, encrypt, decrypt } from '../index';
+describe('NOSTR Crypto Utils', () => {
+    describe('Key Management', () => {
+        it('should generate valid key pairs', async () => {
+            const keyPair = await generateKeyPair();
+            expect(keyPair.privateKey).toBeDefined();
+            expect(keyPair.publicKey).toBeDefined();
+            expect(keyPair.privateKey).toHaveLength(64);
+            expect(keyPair.publicKey).toHaveLength(64);
+        });
+        it('should derive the correct public key', async () => {
+            const keyPair = await generateKeyPair();
+            const derivedPubKey = await getPublicKey(keyPair.privateKey);
+            expect(derivedPubKey).toBe(keyPair.publicKey);
+        });
+        it('should validate key pairs', async () => {
+            const keyPair = await generateKeyPair();
+            const result = await validateKeyPair(keyPair.publicKey, keyPair.privateKey);
+            expect(result.isValid).toBe(true);
+            expect(result.error).toBeUndefined();
+        });
+        it('should generate consistent key pairs from seed phrase', async () => {
+            const seedPhrase = 'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about';
+            const keyPair1 = await generateKeyPair(seedPhrase);
+            const keyPair2 = await generateKeyPair(seedPhrase);
+            expect(keyPair1.privateKey).toBe(keyPair2.privateKey);
+            expect(keyPair1.publicKey).toBe(keyPair2.publicKey);
+        });
+    });
+    describe('Event Operations', () => {
+        it('should sign and verify events', async () => {
+            const keyPair = await generateKeyPair();
+            const event = {
+                kind: 1,
+                created_at: Math.floor(Date.now() / 1000),
+                tags: [],
+                content: 'Hello NOSTR!'
+            };
+            const signedEvent = await signEvent(event, keyPair.privateKey);
+            expect(signedEvent.sig).toBeDefined();
+            expect(signedEvent.id).toBeDefined();
+            expect(signedEvent.pubkey).toBe(keyPair.publicKey);
+            const isValid = await verifySignature(signedEvent);
+            expect(isValid).toBe(true);
+        });
+    });
+    describe('Encryption/Decryption', () => {
+        it('should encrypt and decrypt messages', async () => {
+            const alice = await generateKeyPair();
+            const bob = await generateKeyPair();
+            const message = 'Secret message for Bob';
+            const encrypted = await encrypt(message, bob.publicKey, alice.privateKey);
+            const decrypted = await decrypt(encrypted, alice.publicKey, bob.privateKey);
+            expect(decrypted).toBe(message);
+        });
+    });
+    describe('verifySignature', () => {
+        it('should verify a valid signature', async () => {
+            const event = {
+                kind: 1,
+                created_at: Math.floor(Date.now() / 1000),
+                tags: [],
+                content: 'Hello, World!'
+            };
+            const privateKey = await generateKeyPair().privateKey;
+            const signedEvent = await signEvent(event, privateKey);
+            expect(await verifySignature(signedEvent)).toBe(true);
+        });
+        it('should reject an invalid signature', async () => {
+            const event = {
+                kind: 1,
+                created_at: Math.floor(Date.now() / 1000),
+                tags: [],
+                content: 'Hello, World!'
+            };
+            const privateKey = await generateKeyPair().privateKey;
+            const signedEvent = await signEvent(event, privateKey);
+            // Tamper with the signature
+            signedEvent.sig = signedEvent.sig.replace('a', 'b');
+            expect(await verifySignature(signedEvent)).toBe(false);
+        });
+        it('should reject if event hash does not match', async () => {
+            const event = {
+                kind: 1,
+                created_at: Math.floor(Date.now() / 1000),
+                tags: [],
+                content: 'Hello, World!'
+            };
+            const privateKey = await generateKeyPair().privateKey;
+            const signedEvent = await signEvent(event, privateKey);
+            // Tamper with the content which affects the hash
+            signedEvent.content = 'Modified content';
+            expect(await verifySignature(signedEvent)).toBe(false);
+        });
+        it('should handle invalid hex in signature', async () => {
+            const event = {
+                kind: 1,
+                created_at: Math.floor(Date.now() / 1000),
+                tags: [],
+                content: 'Hello, World!'
+            };
+            const privateKey = await generateKeyPair().privateKey;
+            const signedEvent = await signEvent(event, privateKey);
+            // Add invalid hex character
+            signedEvent.sig = 'XYZ' + signedEvent.sig.slice(3);
+            expect(await verifySignature(signedEvent)).toBe(false);
+        });
+    });
+    describe('validateKeyPair', () => {
+        it('should validate a correct key pair', async () => {
+            const privateKey = await generateKeyPair().privateKey;
+            const publicKey = await getPublicKey(privateKey);
+            const result = await validateKeyPair(publicKey, privateKey);
+            expect(result.isValid).toBe(true);
+            expect(result.error).toBeUndefined();
+        });
+        it('should reject mismatched key pair', async () => {
+            const privateKey1 = await generateKeyPair().privateKey;
+            const privateKey2 = await generateKeyPair().privateKey;
+            const publicKey = await getPublicKey(privateKey1);
+            const result = await validateKeyPair(publicKey, privateKey2);
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('Public key does not match private key');
+        });
+        it('should handle invalid private key', async () => {
+            const publicKey = await getPublicKey(await generateKeyPair().privateKey);
+            const result = await validateKeyPair(publicKey, 'invalid-private-key');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('Invalid key pair');
+        });
+    });
+    describe('signEvent', () => {
+        it('should sign an event with all fields', async () => {
+            const event = {
+                kind: 1,
+                created_at: Math.floor(Date.now() / 1000),
+                tags: [['p', '1234']],
+                content: 'Hello, World!'
+            };
+            const privateKey = await generateKeyPair().privateKey;
+            const signedEvent = await signEvent(event, privateKey);
+            expect(signedEvent.sig).toBeTruthy();
+            expect(signedEvent.id).toBeTruthy();
+            expect(signedEvent.pubkey).toBeTruthy();
+        });
+        it('should handle missing optional fields', async () => {
+            const event = {
+                kind: 1,
+                created_at: 1734127200, // 2024-12-14 18:14:51 PST
+                content: 'Hello, World!',
+                tags: [] // Adding the required tags property
+            };
+            const privateKey = await generateKeyPair().privateKey;
+            const signedEvent = await signEvent(event, privateKey);
+            expect(signedEvent.sig).toBeTruthy();
+            expect(signedEvent.id).toBeTruthy();
+            expect(signedEvent.pubkey).toBeTruthy();
+            expect(signedEvent.created_at).toBeDefined();
+            expect(signedEvent.tags).toEqual([]);
+        });
+        it('should handle undefined tags', async () => {
+            const event = {
+                kind: 1,
+                created_at: Math.floor(Date.now() / 1000),
+                content: 'Hello, World!',
+                tags: [] // Add empty tags array to satisfy NostrEvent interface
+            };
+            const privateKey = await generateKeyPair().privateKey;
+            const signedEvent = await signEvent(event, privateKey);
+            expect(signedEvent.tags).toEqual([]);
+        });
+        it('should handle undefined created_at', async () => {
+            const event = {
+                kind: 1,
+                content: 'Hello, World!',
+                tags: [],
+                created_at: Math.floor(Date.now() / 1000)
+            };
+            const privateKey = await generateKeyPair().privateKey;
+            const signedEvent = await signEvent(event, privateKey);
+            expect(signedEvent.created_at).toBeDefined();
+            expect(typeof signedEvent.created_at).toBe('number');
+        });
+    });
+});

package/dist/__tests__/guards.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/guards.test.js

@@ -0,0 +1,80 @@
+import { isNostrEvent, isSignedNostrEvent } from '../types/guards';
+describe('Type Guards', () => {
+    describe('isNostrEvent', () => {
+        it('should return true for valid NostrEvent with all fields', () => {
+            const event = {
+                kind: 1,
+                created_at: Math.floor(Date.now() / 1000),
+                content: 'Hello, Nostr!',
+                tags: [['p', '1234']],
+                pubkey: '0123456789abcdef'
+            };
+            expect(isNostrEvent(event)).toBe(true);
+        });
+        it('should return true for valid NostrEvent with only required fields', () => {
+            const event = {
+                kind: 1,
+                content: 'Minimal event',
+                created_at: Math.floor(Date.now() / 1000),
+                tags: []
+            };
+            expect(isNostrEvent(event)).toBe(true);
+        });
+        it('should return true for valid NostrEvent with empty tags', () => {
+            const event = {
+                kind: 1,
+                content: 'Empty tags',
+                created_at: Math.floor(Date.now() / 1000),
+                tags: []
+            };
+            expect(isNostrEvent(event)).toBe(true);
+        });
+        it('should return false for invalid NostrEvent missing required fields', () => {
+            const event = {
+                created_at: Math.floor(Date.now() / 1000),
+                content: 'Missing kind'
+            };
+            expect(isNostrEvent(event)).toBe(false);
+        });
+        it('should return false for invalid NostrEvent with wrong field types', () => {
+            const event = {
+                kind: '1', // should be number
+                content: 123, // should be string
+                tags: ['not an array of arrays']
+            };
+            expect(isNostrEvent(event)).toBe(false);
+        });
+    });
+    describe('isSignedNostrEvent', () => {
+        it('should return true for valid signed NostrEvent', () => {
+            const event = {
+                kind: 1,
+                created_at: Math.floor(Date.now() / 1000),
+                content: 'Signed event',
+                tags: [],
+                pubkey: '0123456789abcdef',
+                id: '0123456789abcdef',
+                sig: '0123456789abcdef'
+            };
+            expect(isSignedNostrEvent(event)).toBe(true);
+        });
+        it('should return false for unsigned NostrEvent', () => {
+            const event = {
+                kind: 1,
+                created_at: Math.floor(Date.now() / 1000),
+                content: 'Unsigned event',
+                tags: [],
+                pubkey: '0123456789abcdef'
+            };
+            expect(isSignedNostrEvent(event)).toBe(false);
+        });
+        it('should return false for signed event with missing required fields', () => {
+            const event = {
+                content: 'Missing fields',
+                id: '0123456789abcdef',
+                sig: '0123456789abcdef'
+            };
+            expect(isSignedNostrEvent(event)).toBe(false);
+        });
+    });
+});

package/dist/__tests__/integration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/integration.test.js

@@ -0,0 +1,148 @@
+import { formatEventForRelay, formatSubscriptionForRelay, formatCloseForRelay, formatAuthForRelay, parseNostrMessage, createMetadataEvent, createTextNoteEvent, createDirectMessageEvent, createChannelMessageEvent, extractReferencedEvents, extractMentionedPubkeys, createKindFilter, createAuthorFilter, createReplyFilter } from '../integration';
+import { NOSTR_KIND } from '../constants';
+describe('Integration Utilities', () => {
+    const mockSignedEvent = {
+        id: '123',
+        pubkey: '456',
+        created_at: 1234567890,
+        kind: 1,
+        tags: [],
+        content: 'test',
+        sig: '789'
+    };
+    describe('Message Formatting', () => {
+        it('should format event message', () => {
+            const formatted = formatEventForRelay(mockSignedEvent);
+            expect(formatted).toEqual(['EVENT', mockSignedEvent]);
+        });
+        it('should format subscription message', () => {
+            const subscription = {
+                id: 'sub1',
+                filters: [{ kinds: [1], limit: 10 }]
+            };
+            const formatted = formatSubscriptionForRelay(subscription);
+            expect(formatted).toEqual(['REQ', 'sub1', { kinds: [1], limit: 10 }]);
+        });
+        it('should format close message', () => {
+            const formatted = formatCloseForRelay('sub1');
+            expect(formatted).toEqual(['CLOSE', 'sub1']);
+        });
+        it('should format auth message', () => {
+            const formatted = formatAuthForRelay(mockSignedEvent);
+            expect(formatted).toEqual(['AUTH', mockSignedEvent]);
+        });
+    });
+    describe('Message Parsing', () => {
+        it('should parse EVENT message', () => {
+            const message = ['EVENT', mockSignedEvent];
+            const parsed = parseNostrMessage(message);
+            expect(parsed.type).toBe('EVENT');
+            expect(parsed.payload).toEqual(mockSignedEvent);
+        });
+        it('should parse NOTICE message', () => {
+            const message = ['NOTICE', 'test message'];
+            const parsed = parseNostrMessage(message);
+            expect(parsed.type).toBe('NOTICE');
+            expect(parsed.payload).toBe('test message');
+        });
+        it('should parse OK message', () => {
+            const message = ['OK', 'event1', true, 'success'];
+            const parsed = parseNostrMessage(message);
+            expect(parsed.type).toBe('OK');
+            expect(parsed.payload).toEqual(['event1', true, 'success']);
+        });
+        it('should throw error for invalid message', () => {
+            expect(() => parseNostrMessage('invalid')).toThrow('Invalid relay message: not an array');
+            expect(() => parseNostrMessage([123])).toThrow('Invalid relay message: type must be a string');
+            expect(() => parseNostrMessage(['UNKNOWN'])).toThrow('Unknown message type: UNKNOWN');
+        });
+    });
+    describe('Event Creation', () => {
+        const now = Math.floor(Date.now() / 1000);
+        it('should create metadata event', () => {
+            const metadata = { name: 'test', about: 'test user' };
+            const event = createMetadataEvent(metadata);
+            expect(event.kind).toBe(NOSTR_KIND.METADATA);
+            expect(JSON.parse(event.content)).toEqual(metadata);
+            expect(event.created_at).toBeGreaterThanOrEqual(now);
+            expect(event.tags).toEqual([]);
+        });
+        it('should create text note event', () => {
+            const content = 'Hello, Nostr!';
+            const replyTo = 'event123';
+            const mentions = ['pubkey123'];
+            const event = createTextNoteEvent(content, replyTo, mentions);
+            expect(event.kind).toBe(NOSTR_KIND.TEXT_NOTE);
+            expect(event.content).toBe(content);
+            expect(event.created_at).toBeGreaterThanOrEqual(now);
+            expect(event.tags).toHaveLength(2);
+            expect(event.tags).toContainEqual(['e', replyTo]);
+            expect(event.tags).toContainEqual(['p', mentions[0]]);
+        });
+        it('should create direct message event', () => {
+            const recipientPubkey = 'pubkey123';
+            const content = 'Secret message';
+            const event = createDirectMessageEvent(recipientPubkey, content);
+            expect(event.kind).toBe(NOSTR_KIND.ENCRYPTED_DIRECT_MESSAGE);
+            expect(event.content).toBe(content);
+            expect(event.created_at).toBeGreaterThanOrEqual(now);
+            expect(event.tags).toHaveLength(1);
+            expect(event.tags[0]).toEqual(['p', recipientPubkey]);
+        });
+        it('should create channel message event', () => {
+            const channelId = 'channel123';
+            const content = 'Channel message';
+            const replyTo = 'event123';
+            const event = createChannelMessageEvent(channelId, content, replyTo);
+            expect(event.kind).toBe(NOSTR_KIND.CHANNEL_MESSAGE);
+            expect(event.content).toBe(content);
+            expect(event.created_at).toBeGreaterThanOrEqual(now);
+            expect(event.tags).toHaveLength(2);
+            expect(event.tags).toContainEqual(['e', channelId, '', 'root']);
+            expect(event.tags).toContainEqual(['e', replyTo, '', 'reply']);
+        });
+    });
+    describe('Event Analysis', () => {
+        const mockEvent = {
+            kind: 1,
+            content: 'test',
+            created_at: 1234567890,
+            tags: [
+                ['e', 'event1'],
+                ['e', 'event2'],
+                ['p', 'pubkey1'],
+                ['p', 'pubkey2']
+            ]
+        };
+        it('should extract referenced events', () => {
+            const refs = extractReferencedEvents(mockEvent);
+            expect(refs).toEqual(['event1', 'event2']);
+        });
+        it('should extract mentioned pubkeys', () => {
+            const mentions = extractMentionedPubkeys(mockEvent);
+            expect(mentions).toEqual(['pubkey1', 'pubkey2']);
+        });
+    });
+    describe('Filter Creation', () => {
+        it('should create kind filter', () => {
+            const filter = createKindFilter(1, 10);
+            expect(filter).toEqual({ kinds: [1], limit: 10 });
+        });
+        it('should create author filter', () => {
+            const filter = createAuthorFilter('pubkey123', [1, 2], 10);
+            expect(filter).toEqual({
+                authors: ['pubkey123'],
+                kinds: [1, 2],
+                limit: 10
+            });
+        });
+        it('should create reply filter', () => {
+            const filter = createReplyFilter('event123', 10);
+            expect(filter).toEqual({
+                '#e': ['event123'],
+                kinds: [NOSTR_KIND.TEXT_NOTE, NOSTR_KIND.CHANNEL_MESSAGE],
+                limit: 10
+            });
+        });
+    });
+});