fix(relay): don't skip events in seenEvents for new subscriptions (#375)

The early-return optimization for "already seen" events was causing a bug
when running without a cache: when subscription A sees event X, then
subscription B is created later and requests the same event X, the relay
sends it but it was being skipped because it's "already seen" globally.

Without a cache, the event wasn't stored anywhere, so new subscriptions
would never receive events they requested if those events had already
been seen by other subscriptions.

The fix removes the early-return and lets dispatchEvent handle routing
to ALL matching subscriptions. Each subscription's eventFirstSeen
(checked in eventReceived) handles per-subscription deduplication.

Also removes the now-unused getEventIdFromMessage helper method.

Author: pablof7z

core/src/relay/connectivity.test.ts

@@ -1,5 +1,6 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import type { NDK } from "../ndk";
+import { NDKSubscriptionManager } from "../subscription/manager";
 import { NDKRelayConnectivity } from "./connectivity";
 import { type NDKRelay, NDKRelayStatus } from "./index";
 
@@ -296,4 +297,74 @@ describe("NDKRelayConnectivity", () => {
             expect(connectivity["reconnectTimeout"]).toBeUndefined();
         });
     });
+
+    describe("seenEvents deduplication bug", () => {
+        it("should deliver events to new subscriptions even if event was previously seen", () => {
+            // This test reproduces the bug where:
+            // 1. Subscription A sees event X -> event X added to seenEvents
+            // 2. Subscription B is created later, asks for event X
+            // 3. Relay sends event X back for subscription B
+            // 4. BUG: event is skipped because it's in seenEvents
+            // 5. Subscription B never receives the event
+
+            const eventId = "abc123def456789012345678901234567890123456789012345678901234abcd";
+            const subId = "test-sub";
+
+            // Create a real subManager
+            const subManager = new NDKSubscriptionManager();
+
+            // Pre-populate seenEvents (simulating event was seen by subscription A)
+            subManager.seenEvent(eventId, mockRelay);
+
+            // Verify seenEvents is populated
+            const seenRelays = subManager.seenEvents.get(eventId);
+            expect(seenRelays).toBeDefined();
+            expect(seenRelays!.length).toBe(1);
+
+            // Create mockNDK with real subManager
+            const ndkWithSubManager = {
+                ...mockNDK,
+                subManager,
+            } as any;
+
+            // Create a relay mock with getProtocolHandler
+            const relayWithProtocolHandler = {
+                ...mockRelay,
+                getProtocolHandler: vi.fn(() => undefined),
+            } as any;
+
+            // Create connectivity with the NDK that has seenEvents populated
+            const conn = new NDKRelayConnectivity(relayWithProtocolHandler, ndkWithSubManager);
+            conn["_status"] = NDKRelayStatus.CONNECTED;
+
+            // Track if dispatchEvent was called
+            const dispatchEventSpy = vi.spyOn(subManager, "dispatchEvent");
+
+            // Create a mock relay subscription (subscription B)
+            const mockRelaySub = {
+                onevent: vi.fn((event) => {
+                    // This should call dispatchEvent on the subManager
+                    subManager.dispatchEvent(event, mockRelay);
+                }),
+            };
+
+            // Register the subscription
+            conn.openSubs.set(subId, mockRelaySub as any);
+
+            // Verify subscription is registered
+            expect(conn.openSubs.get(subId)).toBe(mockRelaySub);
+
+            // Send the event via WebSocket message
+            const eventMsg = `["EVENT","${subId}",{"id":"${eventId}","pubkey":"xyz","created_at":1234567890,"kind":1,"tags":[],"content":"hello","sig":"sig123"}]`;
+            const mockMessageEvent = new MessageEvent("message", { data: eventMsg });
+
+            conn["onMessage"](mockMessageEvent);
+
+            // The subscription's onevent should have been called
+            expect(mockRelaySub.onevent).toHaveBeenCalled();
+
+            // And dispatchEvent should have been called to route to all matching subs
+            expect(dispatchEventSpy).toHaveBeenCalled();
+        });
+    });
 });

core/src/relay/connectivity.ts

@@ -346,46 +346,25 @@ export class NDKRelayConnectivity {
      *
      * @param event - The MessageEvent containing the received message data.
      */
-    /**
-     * Fast extraction of event ID from JSON string without parsing.
-     * Returns event ID if message is EVENT type, null otherwise.
-     * This optimization avoids expensive JSON.parse() for duplicate events.
-     */
-    private getEventIdFromMessage(msg: string): string | null {
-        // Fast check: msg[2] === 'E' && msg[3] === 'V' (EVENT message)
-        // Format: ["EVENT","subId",{...}]
-        if (msg.charCodeAt(2) !== 69 || msg.charCodeAt(3) !== 86) {
-            return null;
-        }
-        const idPos = msg.indexOf('"id":"');
-        if (idPos === -1) {
-            return null;
-        }
-        // Extract 64 chars after "id":"
-        // Event IDs are always 64 hex chars. If not valid, LRU lookup will fail
-        // and we'll parse normally - no harm done.
-        return msg.substring(idPos + 6, idPos + 70);
-    }
-
     private onMessage(event: MessageEvent): void {
         this.netDebug?.(event.data, this.ndkRelay, "recv");
 
         // Record any activity from relay
         this.keepalive?.recordActivity();
 
-        // Early exit for duplicate events before JSON.parse
-        // This optimization can save significant CPU on busy relays where
-        // the same events are broadcast to multiple subscriptions
-        const msg = event.data as string;
-        const eventId = this.getEventIdFromMessage(msg);
-        if (eventId && this.ndk) {
-            const seenRelays = this.ndk.subManager.seenEvents.get(eventId);
-            if (seenRelays && seenRelays.length > 0) {
-                // Already processed from any relay, just track this relay saw it
-                this.ndk.subManager.seenEvent(eventId, this.ndkRelay);
-                return;
-            }
-        }
+        // NOTE: We intentionally DON'T early-return for "already seen" events.
+        // The seenEvents optimization was causing a bug: if subscription A sees event X,
+        // then subscription B is created later and requests event X, the relay sends it
+        // but it was being skipped because it's "already seen" globally.
+        //
+        // Instead, we let dispatchEvent handle routing to ALL matching subscriptions.
+        // Each subscription's eventFirstSeen (checked in eventReceived) will skip
+        // re-validation for events it's already processed, maintaining the performance
+        // benefit while ensuring new subscriptions receive events they need.
+        //
+        // The seenEvents tracking in dispatchEvent() is still used for:
+        // - exclusiveRelay filtering (checking which relays have sent an event)
+        // - Tracking event provenance
 
         try {
             const data = JSON.parse(event.data);