nostr-crypto-utils 0.1.5 → 0.1.6

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

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

package/dist/__tests__/nip_compliance.test.js

@@ -0,0 +1,121 @@
+import { generateKeyPair, signEvent, encrypt, decrypt, createEvent, validateEvent, validateSignedEvent, NostrEventKind, formatSubscriptionForRelay, formatEventForRelay, formatCloseForRelay } from '../index';
+describe('NIP-01: Basic Protocol Flow', () => {
+    let keyPair;
+    beforeAll(async () => {
+        keyPair = await generateKeyPair();
+    });
+    test('Event Creation and Signing Flow', async () => {
+        // Create a text note (kind 1) as specified in NIP-01
+        const event = createEvent({
+            kind: NostrEventKind.TEXT_NOTE,
+            content: 'Hello Nostr!',
+            tags: [],
+            created_at: Math.floor(Date.now() / 1000)
+        });
+        // Sign the event
+        const signedEvent = await signEvent(event, keyPair.privateKey);
+        // Verify event structure according to NIP-01
+        const validation = validateSignedEvent(signedEvent);
+        expect(validation.isValid).toBe(true);
+        expect(signedEvent.pubkey).toBe(keyPair.publicKey);
+        expect(typeof signedEvent.created_at).toBe('number');
+        expect(Array.isArray(signedEvent.tags)).toBe(true);
+    });
+    test('Client-Relay Message Format', async () => {
+        // Test REQ message format
+        const reqMessage = formatSubscriptionForRelay({ id: 'test_sub', filters: [{ kinds: [1], limit: 10 }] });
+        expect(reqMessage[0]).toBe('REQ');
+        expect(Array.isArray(reqMessage)).toBe(true);
+        expect(reqMessage.length).toBeGreaterThan(2);
+        // Test EVENT message format
+        const event2 = createEvent({
+            kind: NostrEventKind.TEXT_NOTE,
+            content: 'test message',
+            tags: []
+        });
+        const signedEvent = await signEvent(event2, keyPair.privateKey);
+        const eventMessage = formatEventForRelay(signedEvent);
+        expect(eventMessage[0]).toBe('EVENT');
+        expect(eventMessage[1]).toMatchObject({
+            kind: NostrEventKind.TEXT_NOTE,
+            content: 'test message'
+        });
+        // Test CLOSE message format
+        const closeMessage = JSON.stringify(formatCloseForRelay('subscription_id'));
+        const closeParsed = JSON.parse(closeMessage);
+        expect(closeParsed[0]).toBe('CLOSE');
+        expect(closeParsed[1]).toBe('subscription_id');
+    });
+});
+describe('NIP-02: Contact List', () => {
+    test('Contact List Event Structure', async () => {
+        const keyPair = await generateKeyPair();
+        const contacts = createEvent({
+            kind: NostrEventKind.CONTACTS,
+            content: JSON.stringify([
+                {
+                    pubkey: '0123456789abcdef',
+                    relay: 'wss://relay.example.com',
+                    petname: 'friend'
+                }
+            ]),
+            tags: [],
+            created_at: Math.floor(Date.now() / 1000)
+        });
+        const validation = validateEvent(contacts);
+        expect(validation.isValid).toBe(true);
+        expect(contacts.kind).toBe(NostrEventKind.CONTACTS);
+    });
+});
+describe('NIP-04: Encrypted Direct Messages', () => {
+    test('Message Encryption and Decryption', async () => {
+        const alice = await generateKeyPair();
+        const bob = await generateKeyPair();
+        const message = 'Secret message for testing';
+        // Encrypt message from Alice to Bob
+        const encrypted = await encrypt(message, bob.publicKey, alice.privateKey);
+        expect(encrypted).not.toBe(message);
+        // Bob decrypts message from Alice
+        const decrypted = await decrypt(encrypted, alice.publicKey, bob.privateKey);
+        expect(decrypted).toBe(message);
+    });
+    test('Encrypted DM Event Structure', async () => {
+        const sender = await generateKeyPair();
+        const recipient = await generateKeyPair();
+        const message = 'Secret message';
+        const encrypted = await encrypt(message, recipient.publicKey, sender.privateKey);
+        const dmEvent = createEvent({
+            kind: NostrEventKind.ENCRYPTED_DIRECT_MESSAGE,
+            content: encrypted,
+            tags: [['p', recipient.publicKey]],
+            created_at: Math.floor(Date.now() / 1000)
+        });
+        const validation = validateEvent(dmEvent);
+        expect(validation.isValid).toBe(true);
+        expect(dmEvent.kind).toBe(NostrEventKind.ENCRYPTED_DIRECT_MESSAGE);
+        expect(dmEvent.tags[0][0]).toBe('p');
+        expect(dmEvent.tags[0][1]).toBe(recipient.publicKey);
+    });
+});
+describe('NIP-09: Event Deletion', () => {
+    test('Event Deletion Structure', async () => {
+        const keyPair = await generateKeyPair();
+        const originalEvent = await signEvent(createEvent({
+            kind: NostrEventKind.TEXT_NOTE,
+            content: 'Original post',
+            tags: [],
+            created_at: Math.floor(Date.now() / 1000)
+        }), keyPair.privateKey);
+        const deleteEvent = createEvent({
+            kind: NostrEventKind.DELETE,
+            content: 'Deleted due to error',
+            tags: [['e', originalEvent.id]],
+            created_at: Math.floor(Date.now() / 1000)
+        });
+        const validation = validateEvent(deleteEvent);
+        expect(validation.isValid).toBe(true);
+        expect(deleteEvent.kind).toBe(NostrEventKind.DELETE);
+        expect(deleteEvent.tags[0][0]).toBe('e');
+        expect(deleteEvent.tags[0][1]).toBe(originalEvent.id);
+    });
+});

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

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

package/dist/__tests__/transport.test.js

@@ -0,0 +1,113 @@
+import { parseNostrMessage, NostrEventKind, createEvent, signEvent, generateKeyPair, validateSignedEvent, formatEventForRelay } from '../index';
+// Mock WebSocket for testing
+class MockWebSocket {
+    constructor(url) {
+        this.url = url;
+        this.listeners = {};
+        this.readyState = 1;
+    }
+    send(data) {
+        // Simulate relay behavior
+        const message = JSON.parse(data);
+        if (message[0] === 'REQ') {
+            // Simulate EOSE after subscription
+            this.emit('message', JSON.stringify(['EOSE', message[1]]));
+        }
+    }
+    addEventListener(event, callback) {
+        if (!this.listeners[event]) {
+            this.listeners[event] = [];
+        }
+        this.listeners[event].push(callback);
+    }
+    emit(event, data) {
+        if (this.listeners[event]) {
+            this.listeners[event].forEach(callback => {
+                callback({ data });
+            });
+        }
+    }
+    close() {
+        this.readyState = 3;
+        this.emit('close', null);
+    }
+}
+describe('Transport Layer Integration', () => {
+    let keyPair;
+    let mockRelay;
+    beforeEach(async () => {
+        keyPair = await generateKeyPair();
+        mockRelay = new MockWebSocket('wss://mock.relay');
+    });
+    test('Subscription Flow', done => {
+        // Create subscription request
+        const subId = 'test-sub';
+        const filter = { kinds: [1], limit: 10 };
+        const subMessage = JSON.stringify(['REQ', subId, filter]);
+        // Listen for EOSE
+        mockRelay.addEventListener('message', event => {
+            const message = JSON.parse(event.data);
+            if (message[0] === 'EOSE' && message[1] === subId) {
+                done();
+            }
+        });
+        // Send subscription
+        mockRelay.send(subMessage);
+    });
+    test('Event Publication Flow', async () => {
+        // Create and sign an event
+        const timestamp = Math.floor(Date.now() / 1000);
+        const event = createEvent({
+            kind: NostrEventKind.TEXT_NOTE,
+            content: 'Test message',
+            tags: [],
+            created_at: timestamp,
+            pubkey: keyPair.publicKey
+        });
+        // Sign the event
+        const signedEvent = await signEvent(event, keyPair.privateKey);
+        // Validate event before sending
+        const validation = await validateSignedEvent(signedEvent);
+        expect(validation.isValid).toBe(true);
+        // Format event message
+        const [messageType, eventPayload] = formatEventForRelay(signedEvent);
+        expect(messageType).toBe('EVENT');
+        // Simulate sending to relay
+        mockRelay.send(JSON.stringify([messageType, eventPayload]));
+    });
+    test('Message Parsing', () => {
+        // Test EVENT message parsing
+        const eventMessage = ['EVENT', { id: 'test_id', pubkey: 'test_pubkey', kind: 1, content: 'test', created_at: 123, sig: 'test_sig', tags: [] }];
+        const eventResponse = parseNostrMessage(eventMessage);
+        expect(eventResponse.type).toBe('EVENT');
+        if (eventResponse.type === 'EVENT') {
+            expect(eventResponse.payload).toMatchObject({
+                id: 'test_id',
+                pubkey: 'test_pubkey',
+                kind: 1
+            });
+        }
+        // Test NOTICE message parsing
+        const noticeMessage = ['NOTICE', 'test message'];
+        const noticeResponse = parseNostrMessage(noticeMessage);
+        expect(noticeResponse.type).toBe('NOTICE');
+        if (noticeResponse.type === 'NOTICE') {
+            expect(noticeResponse.payload).toBe('test message');
+        }
+    });
+    test('Connection State Handling', () => {
+        expect(mockRelay.readyState).toBe(1); // Connected
+        mockRelay.close();
+        expect(mockRelay.readyState).toBe(3); // Closed
+    });
+});
+describe('Transport Error Handling', () => {
+    test('Invalid Message Format', () => {
+        const invalidMessage = ['EVENT', { id: 'test_id', pubkey: 'test_pubkey', kind: 1, content: 'test', created_at: 123, sig: 'test_sig', tags: [] }];
+        expect(() => parseNostrMessage(invalidMessage)).not.toThrow();
+    });
+    test('Malformed JSON', () => {
+        const malformedMessage = ['EVENT', { id: 'test_id', pubkey: 'test_pubkey', kind: 1, content: 'test', created_at: 123, sig: 'test_sig', tags: [] }];
+        expect(() => parseNostrMessage(malformedMessage)).not.toThrow();
+    });
+});

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

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

package/dist/__tests__/types.test.js

@@ -0,0 +1,227 @@
+import { isNostrEvent, isSignedNostrEvent, isNostrFilter, isNostrSubscription, NostrEventKind } from '../types';
+describe('Type Guards', () => {
+    describe('isNostrEvent', () => {
+        it('should validate a valid NostrEvent', () => {
+            const validEvent = {
+                kind: NostrEventKind.TEXT_NOTE,
+                created_at: Math.floor(Date.now() / 1000),
+                content: 'Hello, Nostr!',
+                tags: [['p', '1234'], ['t', 'test']],
+                pubkey: '0123456789abcdef'
+            };
+            expect(isNostrEvent(validEvent)).toBe(true);
+        });
+        it('should validate a NostrEvent without optional pubkey', () => {
+            const validEvent = {
+                kind: NostrEventKind.TEXT_NOTE,
+                created_at: Math.floor(Date.now() / 1000),
+                content: 'Hello, Nostr!',
+                tags: []
+            };
+            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 = [
+                // 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);
+            });
+        });
+    });
+    describe('isSignedNostrEvent', () => {
+        it('should validate a valid SignedNostrEvent', () => {
+            const validEvent = {
+                kind: NostrEventKind.TEXT_NOTE,
+                created_at: Math.floor(Date.now() / 1000),
+                content: 'Hello, Nostr!',
+                tags: [['p', '1234'], ['t', 'test']],
+                pubkey: '0123456789abcdef',
+                id: 'event_id_hash',
+                sig: 'valid_signature'
+            };
+            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('isNostrFilter', () => {
+        it('should validate a valid NostrFilter', () => {
+            const validFilter = {
+                ids: ['1234', '5678'],
+                authors: ['abcd', 'efgh'],
+                kinds: [1, 2, 3],
+                '#e': ['event1', 'event2'],
+                '#p': ['pubkey1', 'pubkey2'],
+                since: 123456789,
+                until: 987654321,
+                limit: 100
+            };
+            expect(isNostrFilter(validFilter)).toBe(true);
+        });
+        it('should validate a NostrFilter with partial fields', () => {
+            const partialFilters = [
+                { 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 = [
+                // 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 = {
+                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 = {
+                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);
+            });
+        });
+    });
+});
+// Helper for tests
+const validNostrEvent = {
+    kind: NostrEventKind.TEXT_NOTE,
+    created_at: Math.floor(Date.now() / 1000),
+    content: 'Hello, Nostr!',
+    tags: [['p', '1234'], ['t', 'test']],
+    pubkey: '0123456789abcdef'
+};

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

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

package/dist/__tests__/validation.test.js

@@ -0,0 +1,118 @@
+import { validateEvent, validateSignedEvent, validateFilter, validateSubscription } from '../validation';
+describe('Validation Functions', () => {
+    describe('validateEvent', () => {
+        it('should validate a valid event', () => {
+            const event = {
+                kind: 1,
+                content: 'Hello, Nostr!',
+                created_at: Math.floor(Date.now() / 1000),
+                tags: [['p', '1234567890abcdef']],
+                pubkey: '1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef'
+            };
+            const result = validateEvent(event);
+            expect(result.isValid).toBe(true);
+            expect(result.errors).toHaveLength(0);
+        });
+        it('should reject an event with invalid kind', () => {
+            const event = {
+                kind: -1,
+                content: 'Hello, Nostr!',
+                created_at: Math.floor(Date.now() / 1000),
+                tags: [],
+                pubkey: '1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef'
+            };
+            const result = validateEvent(event);
+            expect(result.isValid).toBe(false);
+            expect(result.errors).toContain('Event kind must be a non-negative integer');
+        });
+        it('should reject an event with future timestamp', () => {
+            const event = {
+                kind: 1,
+                content: 'Hello, Nostr!',
+                created_at: Math.floor(Date.now() / 1000) + 7200, // 2 hours in the future
+                tags: [],
+                pubkey: '1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef'
+            };
+            const result = validateEvent(event);
+            expect(result.isValid).toBe(false);
+            expect(result.errors).toContain('Event timestamp is too far in the future');
+        });
+    });
+    describe('validateSignedEvent', () => {
+        it('should validate a valid signed event', () => {
+            const event = {
+                id: '1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef',
+                sig: '1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef',
+                kind: 1,
+                content: 'Hello, Nostr!',
+                created_at: Math.floor(Date.now() / 1000),
+                tags: [],
+                pubkey: '1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef'
+            };
+            const result = validateSignedEvent(event);
+            expect(result.isValid).toBe(true);
+            expect(result.errors).toHaveLength(0);
+        });
+        it('should reject an event with invalid signature format', () => {
+            const event = {
+                id: '1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef',
+                sig: 'invalid-signature',
+                kind: 1,
+                content: 'Hello, Nostr!',
+                created_at: Math.floor(Date.now() / 1000),
+                tags: [],
+                pubkey: '1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef'
+            };
+            const result = validateSignedEvent(event);
+            expect(result.isValid).toBe(false);
+            expect(result.errors).toContain('Invalid signature format');
+        });
+    });
+    describe('validateFilter', () => {
+        it('should validate a valid filter', () => {
+            const filter = {
+                kinds: [1, 2],
+                authors: ['1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef'],
+                since: Math.floor(Date.now() / 1000) - 3600,
+                until: Math.floor(Date.now() / 1000),
+                limit: 100
+            };
+            const result = validateFilter(filter);
+            expect(result.isValid).toBe(true);
+            expect(result.errors).toHaveLength(0);
+        });
+        it('should reject a filter with invalid timestamps', () => {
+            const filter = {
+                kinds: [1],
+                since: Math.floor(Date.now() / 1000),
+                until: Math.floor(Date.now() / 1000) - 3600 // until before since
+            };
+            const result = validateFilter(filter);
+            expect(result.isValid).toBe(false);
+            expect(result.errors).toContain('since timestamp cannot be greater than until timestamp');
+        });
+    });
+    describe('validateSubscription', () => {
+        it('should validate a valid subscription', () => {
+            const subscription = {
+                id: 'sub1',
+                filters: [{
+                        kinds: [1],
+                        limit: 100
+                    }]
+            };
+            const result = validateSubscription(subscription);
+            expect(result.isValid).toBe(true);
+            expect(result.errors).toHaveLength(0);
+        });
+        it('should reject a subscription without filters', () => {
+            const subscription = {
+                id: 'sub1',
+                filters: []
+            };
+            const result = validateSubscription(subscription);
+            expect(result.isValid).toBe(false);
+            expect(result.errors).toContain('Subscription must contain at least one filter');
+        });
+    });
+});