nostr-mcp-server 2.0.0

package/build/__tests__/nip19-conversion.test.js

@@ -0,0 +1,268 @@
+import { convertNip19, analyzeNip19 } from '../utils/nip19-tools.js';
+import { generateKeypair, encodePublicKey, encodePrivateKey, encodeNoteId, encodeProfile, encodeEvent, encodeAddress } from 'snstr';
+describe('NIP-19 Conversion Tools', () => {
+    let testKeys;
+    let testNpub;
+    let testNsec;
+    beforeAll(async () => {
+        // Generate test keypair
+        testKeys = await generateKeypair();
+        testNpub = encodePublicKey(testKeys.publicKey);
+        testNsec = encodePrivateKey(testKeys.privateKey);
+    });
+    describe('convertNip19', () => {
+        describe('hex to other formats', () => {
+            it('should convert hex pubkey to npub', async () => {
+                const result = await convertNip19(testKeys.publicKey, 'npub');
+                expect(result.success).toBe(true);
+                expect(result.result).toBe(testNpub);
+                expect(result.originalType).toBe('hex');
+                expect(result.message).toContain('Successfully converted');
+            });
+            it('should convert hex to hex (no-op)', async () => {
+                const result = await convertNip19(testKeys.publicKey, 'hex');
+                expect(result.success).toBe(true);
+                expect(result.result).toBe(testKeys.publicKey);
+                expect(result.originalType).toBe('hex');
+            });
+            it('should convert hex event ID to note', async () => {
+                const eventId = '1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef';
+                const result = await convertNip19(eventId, 'note');
+                expect(result.success).toBe(true);
+                expect(result.result).toMatch(/^note1/);
+                expect(result.originalType).toBe('hex');
+            });
+            it('should convert hex to nprofile with relays', async () => {
+                const relays = ['wss://relay.damus.io', 'wss://nos.lol'];
+                const result = await convertNip19(testKeys.publicKey, 'nprofile', relays);
+                expect(result.success).toBe(true);
+                expect(result.result).toMatch(/^nprofile1/);
+                expect(result.originalType).toBe('hex');
+            });
+            it('should convert hex to nevent with metadata', async () => {
+                const eventId = '1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef';
+                const relays = ['wss://relay.damus.io'];
+                const result = await convertNip19(eventId, 'nevent', relays, testKeys.publicKey, 1);
+                expect(result.success).toBe(true);
+                expect(result.result).toMatch(/^nevent1/);
+                expect(result.originalType).toBe('hex');
+            });
+            it('should convert hex to naddr with required fields', async () => {
+                const relays = ['wss://relay.damus.io'];
+                const result = await convertNip19(testKeys.publicKey, 'naddr', relays, undefined, 30023, 'test-identifier');
+                expect(result.success).toBe(true);
+                expect(result.result).toMatch(/^naddr1/);
+                expect(result.originalType).toBe('hex');
+            });
+        });
+        describe('npub conversions', () => {
+            it('should convert npub to hex', async () => {
+                const result = await convertNip19(testNpub, 'hex');
+                expect(result.success).toBe(true);
+                expect(result.result).toBe(testKeys.publicKey);
+                expect(result.originalType).toBe('npub');
+            });
+            it('should convert npub to nprofile', async () => {
+                const relays = ['wss://relay.primal.net'];
+                const result = await convertNip19(testNpub, 'nprofile', relays);
+                expect(result.success).toBe(true);
+                expect(result.result).toMatch(/^nprofile1/);
+                expect(result.originalType).toBe('npub');
+            });
+        });
+        describe('nsec conversions', () => {
+            it('should convert nsec to hex', async () => {
+                const result = await convertNip19(testNsec, 'hex');
+                expect(result.success).toBe(true);
+                expect(result.result).toBe(testKeys.privateKey);
+                expect(result.originalType).toBe('nsec');
+            });
+            it('should handle nsec to npub conversion', async () => {
+                const result = await convertNip19(testNsec, 'npub');
+                // The implementation might derive the public key from the private key
+                // or it might fail - let's check what actually happens
+                if (result.success) {
+                    // If it succeeds, it should return the corresponding npub
+                    expect(result.result).toMatch(/^npub1/);
+                    expect(result.originalType).toBe('nsec');
+                }
+                else {
+                    // If it fails, check the error message
+                    expect(result.message).toBeDefined();
+                }
+            });
+        });
+        describe('complex entity conversions', () => {
+            it('should convert nprofile to npub', async () => {
+                const nprofile = encodeProfile({
+                    pubkey: testKeys.publicKey,
+                    relays: ['wss://relay.damus.io']
+                });
+                const result = await convertNip19(nprofile, 'npub');
+                expect(result.success).toBe(true);
+                expect(result.result).toBe(testNpub);
+                expect(result.originalType).toBe('nprofile');
+            });
+            it('should convert nevent to note', async () => {
+                const eventId = '1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef';
+                const nevent = encodeEvent({
+                    id: eventId,
+                    relays: ['wss://relay.damus.io'],
+                    author: testKeys.publicKey,
+                    kind: 1
+                });
+                const result = await convertNip19(nevent, 'note');
+                expect(result.success).toBe(true);
+                expect(result.result).toBe(encodeNoteId(eventId));
+                expect(result.originalType).toBe('nevent');
+            });
+            it('should extract author from nevent to npub', async () => {
+                const eventId = '1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef';
+                const nevent = encodeEvent({
+                    id: eventId,
+                    relays: ['wss://relay.damus.io'],
+                    author: testKeys.publicKey,
+                    kind: 1
+                });
+                const result = await convertNip19(nevent, 'npub');
+                expect(result.success).toBe(true);
+                expect(result.result).toBe(testNpub);
+                expect(result.originalType).toBe('nevent');
+            });
+            it('should convert naddr to hex (pubkey)', async () => {
+                const naddr = encodeAddress({
+                    identifier: 'test-article',
+                    pubkey: testKeys.publicKey,
+                    kind: 30023,
+                    relays: ['wss://relay.damus.io']
+                });
+                const result = await convertNip19(naddr, 'hex');
+                expect(result.success).toBe(true);
+                expect(result.result).toBe(testKeys.publicKey);
+                expect(result.originalType).toBe('naddr');
+            });
+        });
+        describe('error handling', () => {
+            it('should fail with invalid input', async () => {
+                const result = await convertNip19('invalid_input', 'npub');
+                expect(result.success).toBe(false);
+                expect(result.message).toContain('not a valid NIP-19 entity');
+            });
+            it('should handle converting note to npub', async () => {
+                const note = encodeNoteId('1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef');
+                const result = await convertNip19(note, 'npub');
+                // Note entities don't contain pubkey information
+                if (!result.success) {
+                    expect(result.message).toBeDefined();
+                }
+            });
+            it('should fail naddr conversion without required fields', async () => {
+                const result = await convertNip19(testKeys.publicKey, 'naddr');
+                expect(result.success).toBe(false);
+                expect(result.message).toContain('requires identifier and kind');
+            });
+            it('should filter out invalid relay URLs', async () => {
+                const invalidRelays = [
+                    'wss://valid.relay.com',
+                    'https://invalid.relay.com', // Wrong protocol
+                    'wss://user:pass@relay.com', // Has credentials
+                    'invalid-url' // Not a URL
+                ];
+                const result = await convertNip19(testKeys.publicKey, 'nprofile', invalidRelays);
+                expect(result.success).toBe(true);
+                expect(result.result).toMatch(/^nprofile1/);
+                // Should only include the valid relay
+                expect(result.data).toBeDefined();
+            });
+        });
+    });
+    describe('analyzeNip19', () => {
+        it('should analyze hex string', async () => {
+            const result = await analyzeNip19(testKeys.publicKey);
+            expect(result.success).toBe(true);
+            expect(result.type).toBe('hex');
+            expect(result.data).toBe(testKeys.publicKey);
+            expect(result.message).toContain('Valid 64-character hex string');
+        });
+        it('should analyze npub', async () => {
+            const result = await analyzeNip19(testNpub);
+            expect(result.success).toBe(true);
+            expect(result.type).toBe('npub');
+            expect(result.data).toBe(testKeys.publicKey);
+            expect(result.message).toContain('Valid npub entity');
+        });
+        it('should analyze nsec', async () => {
+            const result = await analyzeNip19(testNsec);
+            expect(result.success).toBe(true);
+            expect(result.type).toBe('nsec');
+            expect(result.data).toBe(testKeys.privateKey);
+            expect(result.message).toContain('Valid nsec entity');
+        });
+        it('should analyze note', async () => {
+            const eventId = '1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef';
+            const note = encodeNoteId(eventId);
+            const result = await analyzeNip19(note);
+            expect(result.success).toBe(true);
+            expect(result.type).toBe('note');
+            expect(result.data).toBe(eventId);
+            expect(result.message).toContain('Valid note entity');
+        });
+        it('should analyze nprofile with relays', async () => {
+            const nprofile = encodeProfile({
+                pubkey: testKeys.publicKey,
+                relays: ['wss://valid.relay.com']
+            });
+            const result = await analyzeNip19(nprofile);
+            expect(result.success).toBe(true);
+            expect(result.type).toBe('nprofile');
+            expect(result.data.pubkey).toBe(testKeys.publicKey);
+            expect(result.data.relays).toEqual(['wss://valid.relay.com']);
+            expect(result.message).toContain('Valid nprofile entity');
+        });
+        it('should analyze nevent', async () => {
+            const eventId = '1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef';
+            const nevent = encodeEvent({
+                id: eventId,
+                relays: ['wss://relay.damus.io'],
+                author: testKeys.publicKey,
+                kind: 1
+            });
+            const result = await analyzeNip19(nevent);
+            expect(result.success).toBe(true);
+            expect(result.type).toBe('nevent');
+            expect(result.data.id).toBe(eventId);
+            expect(result.data.author).toBe(testKeys.publicKey);
+            if (result.data.kind)
+                expect(result.data.kind).toBe(1);
+            expect(result.data.relays).toEqual(['wss://relay.damus.io']);
+            expect(result.message).toContain('Valid nevent entity');
+        });
+        it('should analyze naddr', async () => {
+            const naddr = encodeAddress({
+                identifier: 'test-article',
+                pubkey: testKeys.publicKey,
+                kind: 30023,
+                relays: ['wss://relay.damus.io']
+            });
+            const result = await analyzeNip19(naddr);
+            expect(result.success).toBe(true);
+            expect(result.type).toBe('naddr');
+            expect(result.data.identifier).toBe('test-article');
+            expect(result.data.pubkey).toBe(testKeys.publicKey);
+            expect(result.data.kind).toBe(30023);
+            expect(result.data.relays).toEqual(['wss://relay.damus.io']);
+            expect(result.message).toContain('Valid naddr entity');
+        });
+        it('should fail with invalid input', async () => {
+            const result = await analyzeNip19('not_a_valid_nip19_or_hex');
+            expect(result.success).toBe(false);
+            expect(result.message).toBeDefined();
+            expect(result.message.toLowerCase()).toContain('unknown prefix');
+        });
+        it('should fail with invalid hex (wrong length)', async () => {
+            const result = await analyzeNip19('abcdef123456'); // Too short
+            expect(result.success).toBe(false);
+            expect(result.message).toBeDefined();
+        });
+    });
+});

package/build/__tests__/nips-search.test.js

@@ -0,0 +1,109 @@
+import { describe, expect, test, jest } from '@jest/globals';
+// Mock NIP data for testing
+const mockNips = [
+    {
+        id: '01',
+        title: 'Basic Protocol Flow Description',
+        content: 'This NIP defines the basic protocol flow between clients and relays...',
+        keywords: ['protocol', 'relay', 'client', 'basic']
+    },
+    {
+        id: '19',
+        title: 'bech32-encoded entities',
+        content: 'This NIP defines how to encode and reference different Nostr entities...',
+        keywords: ['encoding', 'bech32', 'npub', 'note', 'nevent', 'naddr', 'identifier']
+    },
+    {
+        id: '57',
+        title: 'Lightning Zaps',
+        content: 'This NIP defines how users can send zaps to each other using lightning...',
+        keywords: ['lightning', 'zap', 'payment', 'tip', 'lnurl']
+    }
+];
+// Mock data for testing
+const mockSearchResults = (query, limit = 10, includeContent = false) => {
+    // Simple relevance scoring algorithm for testing
+    const results = mockNips.map(nip => {
+        const titleMatches = (nip.title.toLowerCase().includes(query.toLowerCase()) ? 2 : 0);
+        const keywordMatches = nip.keywords.filter(kw => kw.includes(query.toLowerCase())).length;
+        const contentMatches = (nip.content.toLowerCase().includes(query.toLowerCase()) ? 1 : 0);
+        const relevance = titleMatches + keywordMatches + contentMatches;
+        return {
+            id: nip.id,
+            title: nip.title,
+            relevance: relevance,
+            content: includeContent ? nip.content : undefined
+        };
+    })
+        .filter(result => result.relevance > 0)
+        .sort((a, b) => b.relevance - a.relevance)
+        .slice(0, limit);
+    return results;
+};
+// Mock search function
+const searchNips = jest.fn((query, options = {}) => {
+    const { limit = 10, includeContent = false } = options;
+    return Promise.resolve(mockSearchResults(query, limit, includeContent));
+});
+describe('NIP Search Functionality', () => {
+    beforeEach(() => {
+        searchNips.mockClear();
+    });
+    test('basic search returns relevant results', async () => {
+        const results = await searchNips('lightning');
+        expect(results.length).toBeGreaterThan(0);
+        expect(results[0].id).toBe('57'); // NIP-57 is most relevant for 'lightning'
+        expect(results[0].title).toBe('Lightning Zaps');
+        expect(results[0].relevance).toBeGreaterThan(0);
+        expect(results[0].content).toBeUndefined(); // Content shouldn't be included by default
+    });
+    test('search with includeContent option', async () => {
+        const results = await searchNips('protocol', { includeContent: true });
+        expect(results.length).toBeGreaterThan(0);
+        expect(results[0].id).toBe('01'); // NIP-01 is most relevant for 'protocol'
+        expect(results[0].content).toBeDefined();
+        expect(results[0].content).toContain('protocol flow');
+    });
+    test('search respects limit parameter', async () => {
+        // Create a search term that matches multiple NIPs
+        const results = await searchNips('n', { limit: 2 });
+        // Should return only two results even though more match
+        expect(results.length).toBe(2);
+    });
+    test('search with no matches returns empty array', async () => {
+        const results = await searchNips('nonexistentterm');
+        expect(results).toEqual([]);
+    });
+    test('search relevance sorting', async () => {
+        // 'encoding' appears in both NIP-19 title/keywords and NIP-57 content, but NIP-19 should rank higher
+        const results = await searchNips('encoding');
+        expect(results.length).toBeGreaterThan(0);
+        expect(results[0].id).toBe('19');
+    });
+    test('search is case insensitive', async () => {
+        const lowerResults = await searchNips('lightning');
+        const upperResults = await searchNips('LIGHTNING');
+        const mixedResults = await searchNips('LiGhTnInG');
+        expect(lowerResults.length).toBeGreaterThan(0);
+        expect(upperResults.length).toBeGreaterThan(0);
+        expect(mixedResults.length).toBeGreaterThan(0);
+        // All should find the same results
+        expect(lowerResults[0].id).toBe(upperResults[0].id);
+        expect(lowerResults[0].id).toBe(mixedResults[0].id);
+    });
+    test('search works with partial word matches', async () => {
+        const results = await searchNips('light');
+        expect(results.length).toBeGreaterThan(0);
+        expect(results[0].id).toBe('57'); // Should find 'lightning' in NIP-57
+    });
+    test('very large limit is handled gracefully', async () => {
+        // Even with a large limit, should only return matches
+        const results = await searchNips('protocol', { limit: 1000 });
+        // Should not break or return more than the available matches
+        expect(results.length).toBeLessThanOrEqual(mockNips.length);
+    });
+    test('zero limit returns empty array', async () => {
+        const results = await searchNips('protocol', { limit: 0 });
+        expect(results).toEqual([]);
+    });
+});

package/build/__tests__/note-creation.test.js

@@ -0,0 +1,148 @@
+import { createNote, signNote, publishNote } from '../note/note-tools.js';
+import { createKeypair } from '../profile/profile-tools.js';
+describe('Note Creation Tools', () => {
+    describe('createNote', () => {
+        it('should create a valid unsigned note event', async () => {
+            const { privateKey } = await createKeypair('hex');
+            const result = await createNote(privateKey, 'Hello Nostr world!', [['t', 'test']]);
+            expect(result.success).toBe(true);
+            expect(result.message).toContain('created successfully');
+            expect(result.noteEvent).toBeDefined();
+            expect(result.publicKey).toBeDefined();
+            // Check the note event structure
+            const note = result.noteEvent;
+            expect(note.kind).toBe(1);
+            expect(note.content).toBe('Hello Nostr world!');
+            expect(note.tags).toEqual([['t', 'test']]);
+            expect(note.pubkey).toBe(result.publicKey);
+            expect(note.created_at).toBeDefined();
+            expect(typeof note.created_at).toBe('number');
+            // Should not have id or sig (unsigned)
+            expect(note.id).toBeUndefined();
+            expect(note.sig).toBeUndefined();
+        });
+        it('should create a note with no tags', async () => {
+            const { privateKey } = await createKeypair('hex');
+            const result = await createNote(privateKey, 'Simple note without tags');
+            expect(result.success).toBe(true);
+            expect(result.noteEvent.tags).toEqual([]);
+        });
+        it('should handle nsec format private keys', async () => {
+            const { nsec } = await createKeypair('npub');
+            const result = await createNote(nsec, 'Note with nsec key');
+            expect(result.success).toBe(true);
+            expect(result.noteEvent).toBeDefined();
+            expect(result.publicKey).toBeDefined();
+        });
+        it('should fail with invalid private key', async () => {
+            const result = await createNote('invalid_private_key', 'This should fail');
+            expect(result.success).toBe(false);
+            expect(result.message).toContain('Error creating note');
+        });
+    });
+    describe('signNote', () => {
+        it('should sign a note event correctly', async () => {
+            const { privateKey } = await createKeypair('hex');
+            // First create a note
+            const createResult = await createNote(privateKey, 'Note to be signed', [['hashtag', 'test']]);
+            expect(createResult.success).toBe(true);
+            // Then sign it
+            const signResult = await signNote(privateKey, createResult.noteEvent);
+            expect(signResult.success).toBe(true);
+            expect(signResult.message).toContain('signed successfully');
+            expect(signResult.signedNote).toBeDefined();
+            // Check the signed note structure
+            const signedNote = signResult.signedNote;
+            expect(signedNote.id).toBeDefined();
+            expect(signedNote.sig).toBeDefined();
+            expect(signedNote.kind).toBe(1);
+            expect(signedNote.content).toBe('Note to be signed');
+            expect(signedNote.tags).toEqual([['hashtag', 'test']]);
+            expect(signedNote.pubkey).toBe(createResult.publicKey);
+            // Verify the signature is valid (basic check)
+            expect(typeof signedNote.id).toBe('string');
+            expect(signedNote.id).toMatch(/^[0-9a-f]{64}$/);
+            expect(typeof signedNote.sig).toBe('string');
+            expect(signedNote.sig).toMatch(/^[0-9a-f]{128}$/);
+        });
+        it('should fail when private key does not match note pubkey', async () => {
+            const { privateKey: privateKey1 } = await createKeypair('hex');
+            const { privateKey: privateKey2 } = await createKeypair('hex');
+            // Create note with first key
+            const createResult = await createNote(privateKey1, 'Note created with key 1');
+            expect(createResult.success).toBe(true);
+            // Try to sign with second key
+            const signResult = await signNote(privateKey2, createResult.noteEvent);
+            expect(signResult.success).toBe(false);
+            expect(signResult.message).toContain('does not match');
+        });
+        it('should handle nsec format private keys', async () => {
+            const { nsec, npub } = await createKeypair('npub');
+            // Create note using nsec
+            const createResult = await createNote(nsec, 'Note with nsec');
+            expect(createResult.success).toBe(true);
+            // Sign note using nsec
+            const signResult = await signNote(nsec, createResult.noteEvent);
+            expect(signResult.success).toBe(true);
+            expect(signResult.signedNote).toBeDefined();
+        });
+    });
+    describe('publishNote', () => {
+        it('should handle publishing with no relays', async () => {
+            const { privateKey } = await createKeypair('hex');
+            // Create and sign a note
+            const createResult = await createNote(privateKey, 'Test note');
+            const signResult = await signNote(privateKey, createResult.noteEvent);
+            expect(createResult.success).toBe(true);
+            expect(signResult.success).toBe(true);
+            // Publish with no relays
+            const publishResult = await publishNote(signResult.signedNote, []);
+            expect(publishResult.success).toBe(true);
+            expect(publishResult.message).toContain('no relays specified');
+            expect(publishResult.noteId).toBe(signResult.signedNote.id);
+        });
+        it('should validate note structure', async () => {
+            const { privateKey } = await createKeypair('hex');
+            // Create and sign a note
+            const createResult = await createNote(privateKey, 'Valid note');
+            const signResult = await signNote(privateKey, createResult.noteEvent);
+            expect(createResult.success).toBe(true);
+            expect(signResult.success).toBe(true);
+            // The note should have all required fields
+            const note = signResult.signedNote;
+            expect(note.id).toBeDefined();
+            expect(note.pubkey).toBeDefined();
+            expect(note.created_at).toBeDefined();
+            expect(note.kind).toBe(1);
+            expect(note.tags).toBeDefined();
+            expect(note.content).toBe('Valid note');
+            expect(note.sig).toBeDefined();
+        });
+    });
+    describe('Full workflow', () => {
+        it('should complete a full note creation, signing, and publishing workflow', async () => {
+            const { privateKey } = await createKeypair('hex');
+            // Step 1: Create note
+            const createResult = await createNote(privateKey, 'Complete workflow test', [['t', 'workflow'], ['client', 'test']]);
+            expect(createResult.success).toBe(true);
+            expect(createResult.noteEvent.kind).toBe(1);
+            expect(createResult.noteEvent.content).toBe('Complete workflow test');
+            // Step 2: Sign note
+            const signResult = await signNote(privateKey, createResult.noteEvent);
+            expect(signResult.success).toBe(true);
+            expect(signResult.signedNote.id).toBeDefined();
+            expect(signResult.signedNote.sig).toBeDefined();
+            // Step 3: Publish note (no relays for testing)
+            const publishResult = await publishNote(signResult.signedNote, []);
+            expect(publishResult.success).toBe(true);
+            expect(publishResult.noteId).toBe(signResult.signedNote.id);
+            // Verify the complete signed event
+            const finalNote = signResult.signedNote;
+            expect(finalNote.id).toMatch(/^[0-9a-f]{64}$/);
+            expect(finalNote.sig).toMatch(/^[0-9a-f]{128}$/);
+            expect(finalNote.pubkey).toBe(createResult.publicKey);
+            expect(finalNote.content).toBe('Complete workflow test');
+            expect(finalNote.tags).toEqual([['t', 'workflow'], ['client', 'test']]);
+        });
+    });
+});