holosphere 2.0.0-alpha11 → 2.0.0-alpha13

package/src/storage/nostr-client.js

@@ -1,46 +1,98 @@
 /**
- * @fileoverview Nostr Client - SimplePool wrapper for relay management.
+ * @fileoverview Nostr Client - NDK-based wrapper for relay management.
  *
  * Provides connection pooling, relay management, event caching, persistent storage,
  * outbox queue for guaranteed delivery, and background sync services.
+ * Uses @nostr-dev-kit/ndk for improved relay handling and NIP support.
  *
  * @module storage/nostr-client
  */
 
-import { SimplePool, finalizeEvent, getPublicKey } from 'nostr-tools';
+import NDK, { NDKEvent, NDKPrivateKeySigner, NDKSubscriptionCacheUsage } from '@nostr-dev-kit/ndk';
+import { getPublicKey as nostrToolsGetPublicKey, finalizeEvent as nostrToolsFinalizeEvent } from 'nostr-tools';
 import { OutboxQueue } from './outbox-queue.js';
 import { SyncService } from './sync-service.js';
 
 /**
- * Global pool singleton - reuse connections across NostrClient instances.
+ * Lazy-load NDK cache adapter for browser environments.
+ * Falls back to null if not available (Node.js or package not installed).
  * @private
  */
-let globalPool = null;
+let NDKCacheAdapterDexie = null;
+let ndkCacheAdapterLoaded = false;
+
+async function loadNDKCacheAdapter() {
+  if (ndkCacheAdapterLoaded) return NDKCacheAdapterDexie;
+  ndkCacheAdapterLoaded = true;
+
+  // Only try to load in browser environment with IndexedDB support
+  if (typeof window !== 'undefined' && typeof indexedDB !== 'undefined') {
+    try {
+      const module = await import('@nostr-dev-kit/ndk-cache-dexie');
+      NDKCacheAdapterDexie = module.default || module.NDKCacheAdapterDexie;
+    } catch (e) {
+      // Package not available, use fallback caching
+      console.debug('[nostr] NDK cache adapter not available, using LRU cache');
+    }
+  }
+  return NDKCacheAdapterDexie;
+}
 
 /**
- * Set of relays used by the global pool.
+ * Global NDK singleton - reuse connections across NostrClient instances.
  * @private
  */
-let globalPoolRelays = new Set();
+let globalNDK = null;
 
 /**
- * Get or create global SimplePool singleton.
+ * Set of relays used by the global NDK.
+ * @private
+ */
+let globalNDKRelays = new Set();
+
+/**
+ * NDK cache adapter instance (shared across clients).
+ * @private
+ */
+let globalNDKCacheAdapter = null;
+
+/**
+ * Get or create global NDK singleton.
  * This ensures WebSocket connections are reused across all operations.
  *
  * @private
- * @param {Object} [config={}] - Pool configuration
- * @param {boolean} [config.enableReconnect=true] - Enable auto-reconnect
- * @param {boolean} [config.enablePing=true] - Enable ping/pong
- * @returns {SimplePool} The global SimplePool instance
+ * @param {Object} [config={}] - NDK configuration
+ * @param {string[]} [config.relays=[]] - Array of relay URLs
+ * @param {NDKPrivateKeySigner} [config.signer] - NDK signer instance
+ * @param {Object} [config.cacheAdapter] - Optional cache adapter instance
+ * @returns {NDK} The global NDK instance
  */
-function getGlobalPool(config = {}) {
-  if (!globalPool) {
-    globalPool = new SimplePool({
-      enableReconnect: config.enableReconnect !== false,
-      enablePing: config.enablePing !== false,
-    });
+function getGlobalNDK(config = {}) {
+  if (!globalNDK) {
+    const ndkOptions = {
+      explicitRelayUrls: config.relays || [],
+      signer: config.signer,
+      autoConnectUserRelays: false,
+      autoFetchUserMutelist: false,
+    };
+
+    // Use cache adapter if provided
+    if (config.cacheAdapter) {
+      ndkOptions.cacheAdapter = config.cacheAdapter;
+      globalNDKCacheAdapter = config.cacheAdapter;
+    }
+
+    globalNDK = new NDK(ndkOptions);
+  } else if (config.relays) {
+    // Add any new relays to existing NDK
+    for (const relay of config.relays) {
+      if (!globalNDKRelays.has(relay)) {
+        globalNDK.addExplicitRelay(relay);
+        globalNDKRelays.add(relay);
+      }
+    }
   }
-  return globalPool;
+  return globalNDK;
 }
 
 /**
@@ -211,7 +263,33 @@ function ensureWebSocket() {
 import { createPersistentStorage } from './persistent-storage.js';
 
 /**
- * NostrClient - Manages connections to Nostr relays.
+ * Convert hex string to Uint8Array.
+ * @private
+ * @param {string} hex - Hexadecimal string
+ * @returns {Uint8Array} Byte array
+ */
+function hexToBytes(hex) {
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < hex.length; i += 2) {
+    bytes[i / 2] = parseInt(hex.substr(i, 2), 16);
+  }
+  return bytes;
+}
+
+/**
+ * Convert Uint8Array to hex string.
+ * @private
+ * @param {Uint8Array} bytes - Byte array
+ * @returns {string} Hexadecimal string
+ */
+function bytesToHex(bytes) {
+  return Array.from(bytes)
+    .map((b) => b.toString(16).padStart(2, '0'))
+    .join('');
+}
+
+/**
+ * NostrClient - Manages connections to Nostr relays using NDK.
  *
  * Provides event publishing, querying, subscription management, persistent caching,
  * and guaranteed delivery via outbox queue.
@@ -252,7 +330,14 @@ export class NostrClient {
     // IMPORTANT: If you want keys to persist across restarts, you MUST provide
     // a privateKey in config. Otherwise, a new key is generated each time.
     this.privateKey = config.privateKey || this._generatePrivateKey();
-    this.publicKey = getPublicKey(this.privateKey);
+
+    // Create NDK signer
+    this.signer = new NDKPrivateKeySigner(this.privateKey);
+
+    // Set public key synchronously for immediate access
+    // This uses nostr-tools which is synchronous, unlike NDK's async signer.user()
+    this.publicKey = nostrToolsGetPublicKey(this.privateKey);
+
     this.config = config;
 
     this._subscriptions = new Map();
@@ -265,38 +350,72 @@ export class NostrClient {
     this._persistTimer = null;
     this._persistBatchMs = config.persistBatchMs || 100; // Batch writes within 100ms window
 
-    // Initialize pool and storage asynchronously
+    // Initialize NDK and storage asynchronously
     this._initReady = this._initialize();
   }
 
   /**
-   * Initialize WebSocket polyfill and pool.
+   * Initialize WebSocket polyfill and NDK.
    *
    * @private
    * @returns {Promise<void>}
    */
   async _initialize() {
-    // Ensure WebSocket is available before initializing pool
+    // Ensure WebSocket is available before initializing NDK
     await ensureWebSocket();
 
-    // Initialize SimplePool with options (only if relays exist)
+    // Try to load NDK cache adapter for browser environments
+    const CacheAdapter = await loadNDKCacheAdapter();
+    let cacheAdapter = null;
+
+    if (CacheAdapter && this.config.appName) {
+      // Use distinct name from IndexedDBStorage to avoid conflicts
+      const dbName = `holosphere_ndk_${this.config.appName}`;
+
+      // Pre-emptively check for and clear incompatible NDK cache database
+      // This prevents async Dexie UpgradeError crashes during background cache operations
+      await this._clearIncompatibleNDKCache(dbName);
+
+      try {
+        // Create NDK cache adapter with app-specific database name
+        cacheAdapter = new CacheAdapter({ dbName });
+        this._useNDKCache = true;
+      } catch (e) {
+        console.warn('[nostr] Failed to initialize NDK cache adapter:', e.message);
+        // Try once more after clearing the database
+        await this._deleteDexieDatabase(dbName);
+        try {
+          cacheAdapter = new CacheAdapter({ dbName });
+          this._useNDKCache = true;
+        } catch (retryError) {
+          console.warn('[nostr] Failed to initialize NDK cache adapter after reset:', retryError.message);
+        }
+      }
+    }
+
+    // Initialize NDK with options (only if relays exist)
     if (this.relays.length > 0) {
-      // Use global pool singleton to reuse WebSocket connections
-      this.pool = getGlobalPool(this.config);
+      // Use global NDK singleton to reuse WebSocket connections
+      this.ndk = getGlobalNDK({
+        relays: this.relays,
+        signer: this.signer,
+        cacheAdapter,
+      });
 
       // Track relays used by this client
-      this.relays.forEach(r => globalPoolRelays.add(r));
+      this.relays.forEach(r => globalNDKRelays.add(r));
+
+      // Connect to relays
+      await this.ndk.connect();
+
+      // Note: publicKey is already set synchronously in constructor using nostr-tools
     } else {
-      // Mock pool for testing - returns mock promise that resolves immediately
-      this.pool = {
-        publish: (relays, event) => [Promise.resolve()],
-        querySync: (relays, filter, options) => Promise.resolve([]),
-        subscribeMany: (relays, filters, opts) => ({ close: () => {} }),
-        close: (relays) => {},
-      };
+      // Mock NDK for testing - returns mock promises that resolve immediately
+      this.ndk = null;
+      // Note: publicKey is already set synchronously in constructor using nostr-tools
     }
 
-    // Initialize persistent storage
+    // Initialize persistent storage (used for outbox queue and fallback caching)
     await this._initPersistentStorage();
 
     // Start long-lived subscription for real-time cache updates
@@ -339,28 +458,29 @@ export class NostrClient {
       authors: [this.publicKey],
     };
 
-    const sub = this.pool.subscribeMany(
-      this.relays,
-      [filter],
-      {
-        onevent: (event) => {
-          // Verify author (relay may not respect filter)
-          if (event.pubkey !== this.publicKey) {
-            return;
-          }
+    const sub = this.ndk.subscribe(filter, {
+      closeOnEose: false,
+      cacheUsage: NDKSubscriptionCacheUsage.ONLY_RELAY,
+    });
 
-          // Cache the event - this keeps our local cache in sync
-          this._cacheEvent(event);
-        },
-        oneose: () => {
-          // End of stored events - initial load complete
-          if (!subInfo.initialized) {
-            subInfo.initialized = true;
-            subInfo.initResolve();
-          }
-        },
+    sub.on('event', (ndkEvent) => {
+      // Verify author (relay may not respect filter)
+      if (ndkEvent.pubkey !== this.publicKey) {
+        return;
       }
-    );
+
+      // Convert NDKEvent to raw event format and cache it
+      const event = ndkEvent.rawEvent();
+      this._cacheEvent(event);
+    });
+
+    sub.on('eose', () => {
+      // End of stored events - initial load complete
+      if (!subInfo.initialized) {
+        subInfo.initialized = true;
+        subInfo.initResolve();
+      }
+    });
 
     subInfo.subscription = sub;
 
@@ -422,6 +542,83 @@ export class NostrClient {
     }
   }
 
+  /**
+   * Check if NDK cache database exists with potentially incompatible schema.
+   * NDK cache adapter uses Dexie which can't handle primary key changes.
+   * We detect this by checking if the database exists and clearing it if needed.
+   * @param {string} dbName - The database name to check
+   * @returns {Promise<void>}
+   * @private
+   */
+  async _clearIncompatibleNDKCache(dbName) {
+    if (typeof indexedDB === 'undefined') return;
+
+    // Check if database exists and get its version
+    const databases = await indexedDB.databases?.() || [];
+    const existingDb = databases.find(db => db.name === dbName);
+
+    if (existingDb) {
+      // NDK cache adapter expects specific schema versions
+      // If the database exists but was created with an incompatible version,
+      // we need to delete it to prevent UpgradeError crashes
+      // The NDK cache adapter will recreate it with the correct schema
+      try {
+        await new Promise((resolve, reject) => {
+          const request = indexedDB.open(dbName);
+          request.onsuccess = () => {
+            const db = request.result;
+            const storeNames = Array.from(db.objectStoreNames);
+            db.close();
+
+            // Check for known incompatible schemas (missing required stores or wrong structure)
+            // NDK cache adapter expects: events, eventTags, users, nip05, profiles, etc.
+            const requiredStores = ['events', 'eventTags'];
+            const hasRequiredStores = requiredStores.every(name => storeNames.includes(name));
+
+            if (!hasRequiredStores && storeNames.length > 0) {
+              // Database exists but doesn't have the right structure
+              console.warn(`[nostr] NDK cache database ${dbName} has incompatible schema, clearing...`);
+              this._deleteDexieDatabase(dbName).then(resolve).catch(resolve);
+            } else {
+              resolve();
+            }
+          };
+          request.onerror = () => resolve(); // Ignore errors, continue without cache
+          request.onblocked = () => resolve();
+        });
+      } catch {
+        // Ignore errors during compatibility check
+      }
+    }
+  }
+
+  /**
+   * Delete a Dexie database by name.
+   * Used to recover from schema upgrade errors.
+   * @param {string} dbName - The database name to delete
+   * @returns {Promise<void>}
+   * @private
+   */
+  async _deleteDexieDatabase(dbName) {
+    if (typeof indexedDB === 'undefined') return;
+
+    return new Promise((resolve) => {
+      const request = indexedDB.deleteDatabase(dbName);
+      request.onsuccess = () => {
+        console.log(`[nostr] Deleted incompatible database: ${dbName}`);
+        resolve();
+      };
+      request.onerror = () => {
+        console.warn(`[nostr] Failed to delete database: ${dbName}`);
+        resolve(); // Resolve anyway to continue initialization
+      };
+      request.onblocked = () => {
+        console.warn(`[nostr] Database deletion blocked: ${dbName}`);
+        resolve(); // Resolve anyway to continue initialization
+      };
+    });
+  }
+
   /**
    * Load events from persistent storage into cache
    * @private
@@ -538,6 +735,7 @@ export class NostrClient {
    * @param {Object} [options={}] - Publish options
    * @param {boolean} [options.waitForRelays=false] - Wait for relay confirmation
    * @param {boolean} [options.debounce=true] - Debounce rapid writes to same d-tag
+   * @param {string} [options.signingKey] - Private key to sign with (hex format). If not provided, uses client's default key.
    * @returns {Promise<Object>} Signed event with relay publish results
    * @example
    * const result = await client.publish({
@@ -600,23 +798,89 @@ export class NostrClient {
       pendingWrites.set(dTagPath, { event, timer, resolve, reject });
 
       // Cache immediately for local-first reads (even before relay publish)
-      const signedEvent = finalizeEvent(event, this.privateKey);
+      const signedEvent = this._createSignedEvent(event, options.signingKey);
       this._cacheEvent(signedEvent);
     });
   }
 
+  /**
+   * Create a signed event using NDK or nostr-tools fallback.
+   * @private
+   * @param {Object} event - Unsigned event
+   * @param {string} [signingKey] - Optional private key to sign with (hex format)
+   * @returns {Object} Signed event
+   */
+  _createSignedEvent(event, signingKey = null) {
+    const keyToUse = signingKey || this.privateKey;
+    const pubkeyToUse = signingKey ? nostrToolsGetPublicKey(hexToBytes(signingKey)) : this.publicKey;
+
+    // If NDK is available and we have a signer, use NDKEvent
+    if (this.ndk) {
+      const ndkEvent = new NDKEvent(this.ndk);
+      ndkEvent.kind = event.kind;
+      ndkEvent.content = event.content;
+      ndkEvent.tags = event.tags || [];
+      ndkEvent.created_at = event.created_at || Math.floor(Date.now() / 1000);
+
+      // NDK will sign when publishing, for now return raw event format
+      return {
+        kind: ndkEvent.kind,
+        content: ndkEvent.content,
+        tags: ndkEvent.tags,
+        created_at: ndkEvent.created_at,
+        pubkey: pubkeyToUse,
+        id: '', // Will be set during actual publish
+        sig: '', // Will be set during actual publish
+      };
+    }
+
+    // Mock mode - use nostr-tools to create a properly signed event
+    try {
+      return nostrToolsFinalizeEvent(event, hexToBytes(keyToUse));
+    } catch (e) {
+      // Return mock signed event if signing fails
+      return {
+        ...event,
+        pubkey: pubkeyToUse,
+        id: Math.random().toString(16).slice(2).padStart(64, '0'),
+        sig: 'mock-signature',
+        created_at: event.created_at || Math.floor(Date.now() / 1000),
+      };
+    }
+  }
+
   /**
    * Internal publish implementation
    * @private
    */
   async _doPublish(event, options = {}) {
     const waitForRelays = options.waitForRelays || false;
+    const signingKey = options.signingKey || null;
 
     // Check if event is already signed (has id and sig)
-    // If so, use it as-is; otherwise sign it
-    const signedEvent = (event.id && event.sig)
-      ? event
-      : finalizeEvent(event, this.privateKey);
+    let signedEvent;
+    if (event.id && event.sig) {
+      signedEvent = event;
+    } else if (this.ndk) {
+      // Use NDK to create and sign the event
+      const ndkEvent = new NDKEvent(this.ndk);
+      ndkEvent.kind = event.kind;
+      ndkEvent.content = event.content;
+      ndkEvent.tags = event.tags || [];
+      ndkEvent.created_at = event.created_at || Math.floor(Date.now() / 1000);
+
+      // Sign the event - use different signer if signingKey provided
+      if (signingKey) {
+        const tempSigner = new NDKPrivateKeySigner(signingKey);
+        await ndkEvent.sign(tempSigner);
+      } else {
+        await ndkEvent.sign(this.signer);
+      }
+      signedEvent = ndkEvent.rawEvent();
+    } else {
+      // Mock mode - create mock signed event
+      signedEvent = this._createSignedEvent(event, signingKey);
+    }
 
     // 1. Cache the event locally first (this makes reads instant)
     await this._cacheEvent(signedEvent);
@@ -627,28 +891,37 @@ export class NostrClient {
     }
 
     // 3. Publish to relays
-    if (waitForRelays) {
-      // Wait for relay confirmation if explicitly requested
-      const deliveryResult = await this._attemptDelivery(signedEvent, this.relays);
-
-      return {
-        event: signedEvent,
-        results: deliveryResult.results,
-        queued: !!this.outboxQueue,
-      };
-    } else {
-      // Fire and forget - publish in background, return immediately
-      this._attemptDelivery(signedEvent, this.relays).catch(() => {
-        // Silent - event is cached locally and queued for retry
-      });
+    if (this.ndk && this.relays.length > 0) {
+      if (waitForRelays) {
+        // Wait for relay confirmation if explicitly requested
+        const deliveryResult = await this._attemptDelivery(signedEvent, this.relays);
+
+        return {
+          event: signedEvent,
+          results: deliveryResult.results,
+          queued: !!this.outboxQueue,
+        };
+      } else {
+        // Fire and forget - publish in background, return immediately
+        this._attemptDelivery(signedEvent, this.relays).catch(() => {
+          // Silent - event is cached locally and queued for retry
+        });
 
-      // Return immediately (data is in local cache and queued for delivery)
-      return {
-        event: signedEvent,
-        results: [],
-        queued: !!this.outboxQueue,
-      };
+        // Return immediately (data is in local cache and queued for delivery)
+        return {
+          event: signedEvent,
+          results: [],
+          queued: !!this.outboxQueue,
+        };
+      }
     }
+
+    // No relays configured - just return the signed event
+    return {
+      event: signedEvent,
+      results: [],
+      queued: !!this.outboxQueue,
+    };
   }
 
   /**
@@ -659,28 +932,50 @@ export class NostrClient {
    * @returns {Promise<Object>} Delivery result with successful/failed relays
    */
   async _attemptDelivery(event, relays) {
-    const results = await Promise.allSettled(
-      this.pool.publish(relays, event)
-    );
+    if (!this.ndk) {
+      return { successful: [], failed: relays, results: [] };
+    }
+
+    const ndkEvent = new NDKEvent(this.ndk, event);
 
     const successful = [];
     const failed = [];
     const formattedResults = [];
 
-    results.forEach((r, i) => {
-      formattedResults.push({
-        relay: relays[i],
-        status: r.status,
-        value: r.value,
-        reason: r.reason,
-      });
-
-      if (r.status === 'fulfilled') {
-        successful.push(relays[i]);
-      } else {
-        failed.push(relays[i]);
+    try {
+      // Publish using NDK
+      const publishedRelays = await ndkEvent.publish();
+
+      // Track results
+      for (const relay of relays) {
+        const wasPublished = publishedRelays.has(this.ndk.pool.getRelay(relay));
+        if (wasPublished) {
+          successful.push(relay);
+          formattedResults.push({
+            relay,
+            status: 'fulfilled',
+            value: true,
+          });
+        } else {
+          failed.push(relay);
+          formattedResults.push({
+            relay,
+            status: 'rejected',
+            reason: 'Not published to relay',
+          });
+        }
       }
-    });
+    } catch (error) {
+      // All failed
+      for (const relay of relays) {
+        failed.push(relay);
+        formattedResults.push({
+          relay,
+          status: 'rejected',
+          reason: error.message,
+        });
+      }
+    }
 
     // Update outbox queue with delivery status
     if (this.outboxQueue) {
@@ -689,16 +984,12 @@ export class NostrClient {
 
     // Log failures only at debug level (common during network issues)
     if (failed.length > 0 && successful.length === 0) {
-      // Only warn if ALL relays failed (likely a real issue)
-      const reasons = results
+      const reasons = formattedResults
         .filter(r => r.status === 'rejected')
-        .map(f => f.reason?.message || f.reason || 'unknown')
+        .map(f => f.reason || 'unknown')
         .join(', ');
-      // Use debug level for timeout issues (very common)
-      if (reasons.includes('timed out')) {
-        // Silent - event is queued for retry anyway
-      } else {
-        console.warn(`[nostr] All relays failed for ${event.id.slice(0, 8)}: ${reasons}`);
+      if (!reasons.includes('timed out')) {
+        console.warn(`[nostr] All relays failed for ${event.id?.slice(0, 8)}: ${reasons}`);
       }
     }
 
@@ -732,7 +1023,7 @@ export class NostrClient {
     const forceRelay = options.forceRelay === true;
 
     // If no relays, query from cache only
-    if (this.relays.length === 0) {
+    if (this.relays.length === 0 || !this.ndk) {
       const matchingEvents = this._getMatchingCachedEvents(filter);
       return matchingEvents;
     }
@@ -812,7 +1103,17 @@ export class NostrClient {
     // Create the query promise
     const queryPromise = (async () => {
       try {
-        let events = await this.pool.querySync(this.relays, filter, { timeout });
+        let events = [];
+
+        if (this.ndk) {
+          // Use NDK to fetch events
+          const fetchedEvents = await this.ndk.fetchEvents(filter, {
+            closeOnEose: true,
+          });
+
+          // Convert NDKEvent Set to raw event array
+          events = Array.from(fetchedEvents).map(e => e.rawEvent());
+        }
 
         // CRITICAL: Filter out events from other authors (relay may not respect filter)
         if (filter.authors && filter.authors.length > 0) {
@@ -925,7 +1226,7 @@ export class NostrClient {
    * @private
    */
   async _doBackgroundPathRefresh(path, kind, options) {
-    if (this.relays.length === 0) return;
+    if (this.relays.length === 0 || !this.ndk) return;
 
     // Throttle: Skip if we've refreshed this path recently
     const lastRefresh = backgroundRefreshThrottle.get(path);
@@ -954,7 +1255,7 @@ export class NostrClient {
     };
     const cacheKey = JSON.stringify(filter);
 
-    // Use our query deduplication by calling query() instead of pool.querySync() directly
+    // Use our query deduplication by calling query() instead of direct fetch
     const timeout = options.timeout || 30000;
     const events = await this._queryRelaysAndCache(filter, cacheKey, timeout);
 
@@ -988,7 +1289,7 @@ export class NostrClient {
    * @private
    */
   async _doBackgroundPrefixRefresh(prefix, kind, options) {
-    if (this.relays.length === 0) return;
+    if (this.relays.length === 0 || !this.ndk) return;
 
     // Throttle: Skip if we've refreshed this prefix recently
     const throttleKey = `prefix:${prefix}`;
@@ -1047,14 +1348,17 @@ export class NostrClient {
     const localEvents = this._getMatchingCachedEvents(filter);
 
     // If no relays configured, return local only
-    if (this.relays.length === 0) {
+    if (this.relays.length === 0 || !this.ndk) {
       return localEvents;
     }
 
     // Step 2: Query relays
     let relayEvents = [];
     try {
-      relayEvents = await this.pool.querySync(this.relays, filter, { timeout });
+      const fetchedEvents = await this.ndk.fetchEvents(filter, {
+        closeOnEose: true,
+      });
+      relayEvents = Array.from(fetchedEvents).map(e => e.rawEvent());
 
       // Filter out events from other authors
       if (filter.authors && filter.authors.length > 0) {
@@ -1142,7 +1446,7 @@ export class NostrClient {
     const filterKey = JSON.stringify(filter);
 
     // If no relays, check cache for matching events and trigger callbacks
-    if (this.relays.length === 0) {
+    if (this.relays.length === 0 || !this.ndk) {
       // Trigger with cached events that match the filter
       const matchingEvents = this._getMatchingCachedEvents(filter);
 
@@ -1192,8 +1496,8 @@ export class NostrClient {
 
           // Only close actual subscription when no more callbacks
           if (existing.refCount === 0) {
-            if (existing.subscription && existing.subscription.close) {
-              existing.subscription.close();
+            if (existing.subscription && existing.subscription.stop) {
+              existing.subscription.stop();
             }
             activeSubscriptions.delete(filterKey);
           }
@@ -1213,39 +1517,41 @@ export class NostrClient {
     // Store before creating subscription to handle race conditions
     activeSubscriptions.set(filterKey, subscriptionInfo);
 
-    const sub = this.pool.subscribeMany(
-      this.relays,
-      [filter],
-      {
-        onevent: (event) => {
-          // CRITICAL: Filter out events from other authors immediately
-          // Many relays don't respect the authors filter, so we must do it client-side
-          if (filter.authors && filter.authors.length > 0) {
-            if (!filter.authors.includes(event.pubkey)) {
-              // Silently reject events from other authors
-              return;
-            }
-          }
+    const sub = this.ndk.subscribe(filter, {
+      closeOnEose: false,
+      cacheUsage: NDKSubscriptionCacheUsage.ONLY_RELAY,
+    });
 
-          this._cacheEvent(event);
+    sub.on('event', (ndkEvent) => {
+      const event = ndkEvent.rawEvent();
 
-          // Dispatch to ALL registered callbacks for this subscription
-          const subInfo = activeSubscriptions.get(filterKey);
-          if (subInfo) {
-            for (const cb of subInfo.callbacks) {
-              try {
-                cb(event);
-              } catch (err) {
-                console.warn('[nostr] Subscription callback error:', err.message);
-              }
-            }
+      // CRITICAL: Filter out events from other authors immediately
+      // Many relays don't respect the authors filter, so we must do it client-side
+      if (filter.authors && filter.authors.length > 0) {
+        if (!filter.authors.includes(event.pubkey)) {
+          // Silently reject events from other authors
+          return;
+        }
+      }
+
+      this._cacheEvent(event);
+
+      // Dispatch to ALL registered callbacks for this subscription
+      const subInfo = activeSubscriptions.get(filterKey);
+      if (subInfo) {
+        for (const cb of subInfo.callbacks) {
+          try {
+            cb(event);
+          } catch (err) {
+            console.warn('[nostr] Subscription callback error:', err.message);
           }
-        },
-        oneose: () => {
-          if (options.onEOSE) options.onEOSE();
-        },
+        }
       }
-    );
+    });
+
+    sub.on('eose', () => {
+      if (options.onEOSE) options.onEOSE();
+    });
 
     // Store the actual subscription object
     subscriptionInfo.subscription = sub;
@@ -1259,7 +1565,7 @@ export class NostrClient {
 
         // Only close actual subscription when no more callbacks
         if (subscriptionInfo.refCount === 0) {
-          if (sub.close) sub.close();
+          if (sub.stop) sub.stop();
           activeSubscriptions.delete(filterKey);
         }
         this._subscriptions.delete(subId);
@@ -1379,7 +1685,7 @@ export class NostrClient {
     }
 
     // Trigger any active subscriptions that match this event
-    if (this.relays.length === 0) {
+    if (this.relays.length === 0 || !this.ndk) {
       for (const sub of this._subscriptions.values()) {
         if (sub.active && this._eventMatchesFilter(event, sub.filter)) {
           // Trigger callback asynchronously, but check active status again
@@ -1559,16 +1865,16 @@ export class NostrClient {
     // Close long-lived author subscription
     const authorSub = authorSubscriptions.get(this.publicKey);
     if (authorSub && authorSub.subscription) {
-      if (authorSub.subscription.close) {
-        authorSub.subscription.close();
+      if (authorSub.subscription.stop) {
+        authorSub.subscription.stop();
       }
       authorSubscriptions.delete(this.publicKey);
     }
 
     // Close all subscriptions
     for (const sub of this._subscriptions.values()) {
-      if (sub.close) {
-        sub.close();
+      if (sub.stop) {
+        sub.stop();
       } else if (sub.active !== undefined) {
         // Mock subscription
         sub.active = false;
@@ -1576,8 +1882,8 @@ export class NostrClient {
     }
     this._subscriptions.clear();
 
-    // Close pool
-    this.pool.close(this.relays);
+    // Note: We don't close the global NDK as it may be used by other clients
+    // The pool connections will be cleaned up when the process exits
 
     // Clear cache and index
     this._eventCache.clear();
@@ -1589,10 +1895,20 @@ export class NostrClient {
    * @returns {Array} Relay connection statuses
    */
   getRelayStatus() {
-    return this.relays.map(relay => ({
-      url: relay,
-      connected: true, // SimplePool manages this internally
-    }));
+    if (!this.ndk) {
+      return this.relays.map(relay => ({
+        url: relay,
+        connected: false,
+      }));
+    }
+
+    return this.relays.map(relay => {
+      const ndkRelay = this.ndk.pool.getRelay(relay);
+      return {
+        url: relay,
+        connected: ndkRelay?.status === 1, // WebSocket.OPEN
+      };
+    });
   }
 }