nostr-mcp-server 2.0.0

package/build/__tests__/error-handling.test.js

@@ -0,0 +1,145 @@
+import { describe, expect, test, jest, beforeEach } from '@jest/globals';
+// Mock the actual Nostr pool functionality
+jest.mock('../utils/pool.js', () => {
+    return {
+        getRelayPool: jest.fn(() => ({
+            connect: jest.fn(),
+            close: jest.fn(),
+            subscribeMany: jest.fn(),
+        })),
+    };
+});
+// Mock setTimeout for testing timeouts
+jest.useFakeTimers();
+// Helper function for creating timed out promises
+const createTimedOutPromise = () => new Promise((resolve, reject) => {
+    setTimeout(() => reject(new Error('Request timed out')), 10000);
+});
+// Mock getProfile that simulates various error scenarios
+const mockGetProfile = jest.fn();
+// Helpers for common error scenarios
+const simulateTimeoutError = () => {
+    mockGetProfile.mockImplementationOnce(() => createTimedOutPromise());
+};
+const simulateNetworkError = () => {
+    mockGetProfile.mockImplementationOnce(() => Promise.reject(new Error('Failed to connect to relay')));
+};
+const simulateInvalidPubkey = () => {
+    mockGetProfile.mockImplementationOnce(() => Promise.reject(new Error('Invalid pubkey format')));
+};
+const simulateMalformedEvent = () => {
+    mockGetProfile.mockImplementationOnce(() => Promise.resolve({
+        error: 'Malformed event',
+        details: 'Event missing required signature'
+    }));
+};
+describe('Error Handling and Edge Cases', () => {
+    beforeEach(() => {
+        mockGetProfile.mockReset();
+    });
+    test('timeout handling', async () => {
+        simulateTimeoutError();
+        try {
+            jest.useFakeTimers();
+            const profilePromise = mockGetProfile('valid-pubkey');
+            // Fast-forward time to trigger timeout
+            jest.advanceTimersByTime(10000);
+            await profilePromise;
+            fail('Expected promise to reject with timeout error');
+        }
+        catch (error) {
+            expect(error.message).toContain('timed out');
+        }
+    });
+    test('invalid pubkey format handling', async () => {
+        simulateInvalidPubkey();
+        try {
+            await mockGetProfile('invalid-pubkey-format');
+            fail('Expected promise to reject with invalid pubkey error');
+        }
+        catch (error) {
+            expect(error.message).toContain('Invalid pubkey');
+        }
+    });
+    test('network error handling', async () => {
+        simulateNetworkError();
+        try {
+            await mockGetProfile('valid-pubkey');
+            fail('Expected promise to reject with network error');
+        }
+        catch (error) {
+            expect(error.message).toContain('Failed to connect');
+        }
+    });
+    test('malformed event handling', async () => {
+        simulateMalformedEvent();
+        const result = await mockGetProfile('valid-pubkey');
+        expect(result.error).toBeDefined();
+        expect(result.error).toContain('Malformed event');
+    });
+    test('empty pubkey handling', async () => {
+        // Empty string pubkey
+        simulateInvalidPubkey();
+        try {
+            await mockGetProfile('');
+            fail('Expected promise to reject with invalid pubkey error');
+        }
+        catch (error) {
+            expect(error.message).toContain('Invalid pubkey');
+        }
+    });
+    test('extremely long pubkey handling', async () => {
+        // Extremely long input should be rejected
+        simulateInvalidPubkey();
+        const veryLongPubkey = 'a'.repeat(1000);
+        try {
+            await mockGetProfile(veryLongPubkey);
+            fail('Expected promise to reject with invalid pubkey error');
+        }
+        catch (error) {
+            expect(error.message).toContain('Invalid pubkey');
+        }
+    });
+    test('special character handling in pubkey', async () => {
+        // Pubkey with special characters
+        simulateInvalidPubkey();
+        try {
+            await mockGetProfile('npub1<script>alert("xss")</script>');
+            fail('Expected promise to reject with invalid pubkey error');
+        }
+        catch (error) {
+            expect(error.message).toContain('Invalid pubkey');
+        }
+    });
+    test('null or undefined pubkey handling', async () => {
+        // Null pubkey
+        simulateInvalidPubkey();
+        try {
+            await mockGetProfile(null);
+            fail('Expected promise to reject with invalid pubkey error');
+        }
+        catch (error) {
+            expect(error.message).toContain('Invalid pubkey');
+        }
+        // Undefined pubkey
+        simulateInvalidPubkey();
+        try {
+            await mockGetProfile(undefined);
+            fail('Expected promise to reject with invalid pubkey error');
+        }
+        catch (error) {
+            expect(error.message).toContain('Invalid pubkey');
+        }
+    });
+    test('all relays failing scenario', async () => {
+        // Simulate all relays failing
+        simulateNetworkError();
+        try {
+            await mockGetProfile('valid-pubkey', { relays: ['wss://relay1.example.com', 'wss://relay2.example.com'] });
+            fail('Expected promise to reject when all relays fail');
+        }
+        catch (error) {
+            expect(error.message).toContain('Failed to connect');
+        }
+    });
+});

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

@@ -0,0 +1,137 @@
+import { describe, expect, test } from '@jest/globals';
+import * as nip19 from 'nostr-tools/nip19';
+// Import local conversion utilities
+import { npubToHex, hexToNpub } from '../utils/conversion.js';
+describe('Nostr format conversion', () => {
+    // Known test vectors - generate these dynamically to ensure they match
+    const testHexPubkeys = [
+        '3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d',
+        '63fe6318dc58583cfe16810f86dd09e18bfd76aabc24a0081ce2856f330504ed'
+    ];
+    // Generate matching npubs using the library directly
+    const knownPairs = testHexPubkeys.map(hex => ({
+        hex,
+        npub: nip19.npubEncode(hex)
+    }));
+    // Generate test event IDs and their encoded forms
+    const testEventIds = [
+        '5c83da77af1dec6d7289834998ad7aafbd9e2191396d75ec3cc27f5a77226f36',
+        '9ae37aa68f48645127299e9595f545f942a8314455cbafd9d913ed19c7fc0462'
+    ];
+    const eventIdPairs = testEventIds.map(hex => ({
+        hex,
+        note: nip19.noteEncode(hex)
+    }));
+    test('hex to npub conversion', () => {
+        knownPairs.forEach(pair => {
+            expect(hexToNpub(pair.hex)).toBe(pair.npub);
+        });
+    });
+    test('npub to hex conversion', () => {
+        knownPairs.forEach(pair => {
+            const result = npubToHex(pair.npub);
+            expect(result).toBe(pair.hex);
+        });
+    });
+    test('hex to note conversion using nostr-tools', () => {
+        eventIdPairs.forEach(pair => {
+            expect(nip19.noteEncode(pair.hex)).toBe(pair.note);
+        });
+    });
+    test('note to hex conversion using nostr-tools', () => {
+        eventIdPairs.forEach(pair => {
+            const decoded = nip19.decode(pair.note);
+            expect(decoded.type).toBe('note');
+            expect(decoded.data).toBe(pair.hex);
+        });
+    });
+    test('nevent encoding and decoding using nostr-tools', () => {
+        const eventPointer = {
+            id: '5c83da77af1dec6d7289834998ad7aafbd9e2191396d75ec3cc27f5a77226f36',
+            relays: ['wss://relay.example.com', 'wss://relay.nostr.org'],
+            author: '3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d',
+            kind: 1
+        };
+        const nevent = nip19.neventEncode(eventPointer);
+        expect(nevent).toMatch(/^nevent1/);
+        const decoded = nip19.decode(nevent);
+        expect(decoded.type).toBe('nevent');
+        const data = decoded.data;
+        expect(data.id).toBe(eventPointer.id);
+        expect(data.author).toBe(eventPointer.author);
+        expect(data.kind).toBe(eventPointer.kind);
+        expect(data.relays).toEqual(eventPointer.relays);
+    });
+    test('naddr encoding and decoding using nostr-tools', () => {
+        const addressPointer = {
+            identifier: 'test-article',
+            pubkey: '3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d',
+            kind: 30023,
+            relays: ['wss://relay.example.com']
+        };
+        const naddr = nip19.naddrEncode(addressPointer);
+        expect(naddr).toMatch(/^naddr1/);
+        const decoded = nip19.decode(naddr);
+        expect(decoded.type).toBe('naddr');
+        const data = decoded.data;
+        expect(data.identifier).toBe(addressPointer.identifier);
+        expect(data.pubkey).toBe(addressPointer.pubkey);
+        expect(data.kind).toBe(addressPointer.kind);
+        expect(data.relays).toEqual(addressPointer.relays);
+    });
+    test('validate Nostr identifiers using regex', () => {
+        // Valid identifiers
+        expect(/^npub1[a-z0-9]{58}$/.test(knownPairs[0].npub)).toBe(true);
+        expect(/^note1[a-z0-9]{58}$/.test(eventIdPairs[0].note)).toBe(true);
+        // Invalid identifiers with correct regex patterns
+        expect(/^npub1[a-z0-9]{58}$/.test('npub1invalid')).toBe(false);
+        expect(/^note1[a-z0-9]{58}$/.test('note1invalid')).toBe(false);
+        // Fix the regex patterns to be more specific
+        expect(/^nevent1[a-z0-9]{58,}$/.test('nevent1invalid')).toBe(false);
+        expect(/^naddr1[a-z0-9]{58,}$/.test('naddr1invalid')).toBe(false);
+    });
+    test('error handling for npub conversion', () => {
+        expect(npubToHex('npub1invalid')).toBeNull();
+        expect(hexToNpub('invalidhex')).toBeNull();
+    });
+    test('partial nevent data', () => {
+        // Test with minimal data
+        const minimalPointer = {
+            id: '5c83da77af1dec6d7289834998ad7aafbd9e2191396d75ec3cc27f5a77226f36'
+        };
+        const nevent = nip19.neventEncode(minimalPointer);
+        expect(nevent).toMatch(/^nevent1/);
+        const decoded = nip19.decode(nevent);
+        expect(decoded.type).toBe('nevent');
+        const data = decoded.data;
+        expect(data.id).toBe(minimalPointer.id);
+        expect(data.relays).toEqual([]);
+        expect(data.author).toBeUndefined();
+        expect(data.kind).toBeUndefined();
+    });
+    test('bech32 conversion limits', () => {
+        // Test with very long relay list
+        const manyRelays = Array(20).fill(0).map((_, i) => `wss://relay${i}.example.com`);
+        const eventPointer = {
+            id: '5c83da77af1dec6d7289834998ad7aafbd9e2191396d75ec3cc27f5a77226f36',
+            relays: manyRelays
+        };
+        const nevent = nip19.neventEncode(eventPointer);
+        expect(nevent).toMatch(/^nevent1/);
+        const decoded = nip19.decode(nevent);
+        expect(decoded.type).toBe('nevent');
+        const data = decoded.data;
+        expect(data.id).toBe(eventPointer.id);
+        expect(data.relays.length).toBe(manyRelays.length);
+    });
+    test('edge case: nostr URI handling', () => {
+        // Generate a fresh npub
+        const hex = '3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d';
+        const npub = nip19.npubEncode(hex);
+        // Test with nostr: prefix
+        const nostrUriNpub = 'nostr:' + npub;
+        // When handling the nostr: prefix in our conversion functions
+        const result = npubToHex(nostrUriNpub.replace('nostr:', ''));
+        expect(result).toBe(hex);
+    });
+});

package/build/__tests__/integration.test.js

@@ -0,0 +1,163 @@
+import { NostrRelay } from '../utils/ephemeral-relay.js';
+import { schnorr } from '@noble/curves/secp256k1';
+import { randomBytes } from 'crypto';
+import { sha256 } from '@noble/hashes/sha256';
+// Generate a keypair for testing
+function generatePrivateKey() {
+    return Buffer.from(randomBytes(32)).toString('hex');
+}
+function getPublicKey(privateKey) {
+    return Buffer.from(schnorr.getPublicKey(privateKey)).toString('hex');
+}
+// Create a signed event
+function createSignedEvent(privateKey, kind, content, tags = []) {
+    const pubkey = getPublicKey(privateKey);
+    const created_at = Math.floor(Date.now() / 1000);
+    // Create event
+    const event = {
+        pubkey,
+        created_at,
+        kind,
+        tags,
+        content,
+    };
+    // Calculate event ID
+    const eventData = JSON.stringify([0, event.pubkey, event.created_at, event.kind, event.tags, event.content]);
+    const id = Buffer.from(sha256(eventData)).toString('hex');
+    // Sign the event
+    const sig = Buffer.from(schnorr.sign(id, privateKey)).toString('hex');
+    return {
+        ...event,
+        id,
+        sig
+    };
+}
+describe('Nostr Integration Tests', () => {
+    let relay;
+    const testPort = 9700;
+    let privateKey;
+    let publicKey;
+    beforeAll(async () => {
+        privateKey = generatePrivateKey();
+        publicKey = getPublicKey(privateKey);
+        // Start the ephemeral relay
+        relay = new NostrRelay(testPort);
+        await relay.start();
+    });
+    afterAll(async () => {
+        // Shutdown relay
+        await relay.close();
+    });
+    test('should publish and retrieve a profile', async () => {
+        // Create a profile event (kind 0)
+        const profileContent = JSON.stringify({
+            name: 'Test User',
+            about: 'This is a test profile',
+            picture: 'https://example.com/avatar.jpg'
+        });
+        const profileEvent = createSignedEvent(privateKey, 0, profileContent);
+        // Store it in the relay
+        relay.store(profileEvent);
+        // Verify it was stored
+        expect(relay.cache.length).toBeGreaterThan(0);
+        // Find the profile in the cache
+        const retrievedProfile = relay.cache.find(event => event.kind === 0 && event.pubkey === publicKey);
+        // Verify profile data
+        expect(retrievedProfile).toBeDefined();
+        expect(retrievedProfile?.id).toBe(profileEvent.id);
+        // Parse the content
+        const parsedContent = JSON.parse(retrievedProfile?.content || '{}');
+        expect(parsedContent.name).toBe('Test User');
+        expect(parsedContent.about).toBe('This is a test profile');
+    });
+    test('should publish and retrieve a text note', async () => {
+        // Create a text note (kind 1)
+        const noteContent = 'This is a test note posted from integration tests!';
+        const noteEvent = createSignedEvent(privateKey, 1, noteContent);
+        // Store it in the relay
+        relay.store(noteEvent);
+        // Find the note in the cache
+        const retrievedNote = relay.cache.find(event => event.kind === 1 && event.pubkey === publicKey && event.content === noteContent);
+        // Verify note data
+        expect(retrievedNote).toBeDefined();
+        expect(retrievedNote?.id).toBe(noteEvent.id);
+        expect(retrievedNote?.content).toBe(noteContent);
+    });
+    test('should publish and retrieve a zap receipt', async () => {
+        // Create a mock recipient public key
+        const recipientKey = generatePrivateKey();
+        const recipientPubkey = getPublicKey(recipientKey);
+        // Create zap receipt tags
+        const zapTags = [
+            ['p', recipientPubkey],
+            ['amount', '100000'], // 100 sats in millisats
+            ['bolt11', 'lnbc100n...'],
+            ['description', ''],
+        ];
+        // Create a zap receipt (kind 9735)
+        const zapEvent = createSignedEvent(privateKey, 9735, '', zapTags);
+        // Store it in the relay
+        relay.store(zapEvent);
+        // Find the zap in the cache
+        const retrievedZap = relay.cache.find(event => event.kind === 9735 && event.pubkey === publicKey);
+        // Verify zap data
+        expect(retrievedZap).toBeDefined();
+        expect(retrievedZap?.id).toBe(zapEvent.id);
+        // Verify zap tags
+        const pTag = retrievedZap?.tags.find(tag => tag[0] === 'p');
+        const amountTag = retrievedZap?.tags.find(tag => tag[0] === 'amount');
+        expect(pTag?.[1]).toBe(recipientPubkey);
+        expect(amountTag?.[1]).toBe('100000');
+    });
+    test('should filter events correctly', async () => {
+        // Create multiple events of different kinds
+        const profileEvent = createSignedEvent(privateKey, 0, JSON.stringify({ name: 'Filter Test' }));
+        const textNote1 = createSignedEvent(privateKey, 1, 'Filter test note 1');
+        const textNote2 = createSignedEvent(privateKey, 1, 'Filter test note 2');
+        const reactionEvent = createSignedEvent(privateKey, 7, '+', [['e', 'fake-event-id']]);
+        // Store all events
+        relay.store(profileEvent);
+        relay.store(textNote1);
+        relay.store(textNote2);
+        relay.store(reactionEvent);
+        // Filter for just kind 1 events
+        const textNotes = relay.cache.filter(event => event.kind === 1 && event.pubkey === publicKey);
+        // We should have at least 3 text notes (2 from this test plus 1 from earlier test)
+        expect(textNotes.length).toBeGreaterThanOrEqual(3);
+        // Filter for reaction events
+        const reactions = relay.cache.filter(event => event.kind === 7 && event.pubkey === publicKey);
+        expect(reactions.length).toBeGreaterThanOrEqual(1);
+        expect(reactions[0].content).toBe('+');
+    });
+    // The ephemeral-relay validates events during WebSocket communication,
+    // but doesn't validate during direct store() calls - this test verifies this behavior
+    test('should store events without validation when using direct store() method', () => {
+        // Create a properly signed event
+        const signedEvent = createSignedEvent(privateKey, 1, 'Verification test');
+        // Store it in the relay
+        relay.store(signedEvent);
+        // Create an event with invalid signature
+        const invalidEvent = {
+            pubkey: publicKey,
+            created_at: Math.floor(Date.now() / 1000),
+            kind: 1,
+            tags: [],
+            content: 'Invalid signature event',
+            id: 'invalid_id_that_doesnt_match_content',
+            sig: 'invalid_signature_0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000'
+        };
+        // Get the current cache size
+        const cacheSizeBefore = relay.cache.length;
+        // Store the invalid event (this should succeed since store() doesn't validate)
+        relay.store(invalidEvent);
+        // Cache size should increase since the invalid event should be added
+        const cacheSizeAfter = relay.cache.length;
+        // Verify the event was added (expected behavior for direct store calls)
+        expect(cacheSizeAfter).toBe(cacheSizeBefore + 1);
+        // Find the invalid event in the cache
+        const invalidEventInCache = relay.cache.find(event => event.id === 'invalid_id_that_doesnt_match_content');
+        expect(invalidEventInCache).toBeDefined();
+        // Note: This confirms the current behavior, but in websocket-integration.test.ts we
+        // verify that invalid events are properly rejected over WebSocket communication
+    });
+});

package/build/__tests__/mocks.js

@@ -0,0 +1,109 @@
+// Mock Nostr events and utility functions for testing
+import { jest } from '@jest/globals';
+export const MOCK_HEX_PUBKEY = '7e7e9c42a91bfef19fa929e5fda1b72e0ebc1a4c1141673e2794234d86addf4e';
+export const MOCK_NPUB = 'npub180cvv07tjdrrgpa0j7j7tmnyl2yr6yr7l8j4s3evf6u64th6gkwsyjh6w6';
+export const mockProfile = {
+    id: '1234',
+    pubkey: MOCK_HEX_PUBKEY,
+    created_at: Math.floor(Date.now() / 1000) - 3600,
+    kind: 0,
+    tags: [],
+    content: JSON.stringify({
+        name: 'Test User',
+        display_name: 'Tester',
+        about: 'A test profile for unit tests',
+        picture: 'https://example.com/avatar.jpg',
+        nip05: 'test@example.com'
+    }),
+    sig: 'mock_signature'
+};
+export const mockNote = {
+    id: '5678',
+    pubkey: MOCK_HEX_PUBKEY,
+    created_at: Math.floor(Date.now() / 1000) - 1800,
+    kind: 1,
+    tags: [],
+    content: 'This is a test note from the test user.',
+    sig: 'mock_signature'
+};
+export const mockLongFormNote = {
+    id: '9012',
+    pubkey: MOCK_HEX_PUBKEY,
+    created_at: Math.floor(Date.now() / 1000) - 86400,
+    kind: 30023,
+    tags: [
+        ['title', 'Test Long Form Content'],
+        ['summary', 'This is a test summary of a long form article'],
+        ['published_at', (Math.floor(Date.now() / 1000) - 86400).toString()],
+        ['d', 'test-identifier']
+    ],
+    content: 'This is a test long form content article with much more text than a normal note would have.',
+    sig: 'mock_signature'
+};
+export const mockZapReceipt = {
+    id: 'abcd',
+    pubkey: 'lightning_service_pubkey',
+    created_at: Math.floor(Date.now() / 1000) - 900,
+    kind: 9735,
+    tags: [
+        ['p', MOCK_HEX_PUBKEY],
+        ['bolt11', 'lnbc100n1...'],
+        ['description', JSON.stringify({
+                content: '',
+                created_at: Math.floor(Date.now() / 1000) - 901,
+                id: 'zap_request_id',
+                kind: 9734,
+                pubkey: 'sender_pubkey',
+                tags: [
+                    ['amount', '10000'], // 100 sats in millisats
+                    ['relays', 'wss://relay.example.com'],
+                    ['p', MOCK_HEX_PUBKEY]
+                ]
+            })]
+    ],
+    content: '',
+    sig: 'mock_signature'
+};
+// Mock pool functions
+export const mockPool = {
+    get: jest.fn(),
+    querySync: jest.fn(),
+    close: jest.fn()
+};
+// Mock for getFreshPool function
+export const getFreshPoolMock = jest.fn().mockReturnValue(mockPool);
+// Mock response for lightning service for anonymous zaps
+export const mockLightningServiceResponse = {
+    callback: 'https://example.com/callback',
+    maxSendable: 100000000,
+    minSendable: 1000,
+    metadata: JSON.stringify({
+        name: 'Test User',
+        pubkey: MOCK_HEX_PUBKEY
+    }),
+    allowsNostr: true,
+    nostrPubkey: MOCK_HEX_PUBKEY
+};
+// Mock response for invoice generation
+export const mockInvoiceResponse = {
+    pr: 'lnbc100n1...', // Mock lightning invoice
+    success: true,
+    verify: 'https://example.com/verify'
+};
+// Mock response for NIP search
+export const mockNipSearchResults = [
+    {
+        number: 57,
+        title: 'Lightning Zaps',
+        summary: 'This NIP defines a protocol for sending zaps via the Lightning Network.',
+        relevance: 0.95,
+        content: '# NIP-57\n\n## Lightning Zaps\n\nThis is mock content for the zaps NIP.'
+    },
+    {
+        number: 1,
+        title: 'Basic protocol flow description',
+        summary: 'Basic protocol flow and interaction between clients and relays.',
+        relevance: 0.5,
+        content: '# NIP-01\n\n## Basic protocol flow description\n\nThis is mock content for the basic protocol NIP.'
+    }
+];