@unicitylabs/sphere-sdk 0.7.1-dev.1 → 0.7.1-dev.3

package/dist/index.cjs

@@ -1555,6 +1555,17 @@ var NostrTransportProvider = class _NostrTransportProvider {
   getStorageAdapter() {
     return this.storage;
   }
+  /**
+   * Get the underlying NostrClient (or null if not yet connected).
+   *
+   * Exposed so {@link MultiAddressTransportMux} can share the same
+   * client/socket pair instead of opening a duplicate WebSocket per
+   * relay (#123). The transport owns the client's lifecycle — callers
+   * MUST NOT call {@code disconnect()} on the returned instance.
+   */
+  getNostrClient() {
+    return this.nostrClient;
+  }
   /**
    * Suppress event subscriptions — unsubscribe wallet/chat filters
    * but keep the connection alive for resolve/identity-binding operations.
@@ -3193,9 +3204,6 @@ var MultiAddressTransportMux = class _MultiAddressTransportMux {
   chatSubscriptionId = null;
   chatEoseFired = false;
   resubscribeTimer = null;
-  lastWalletEventAt = Date.now();
-  lastChatEventAt = Date.now();
-  healthCheckTimer = null;
   chatEoseHandlers = [];
   // Dedup — bounded to prevent memory leak in long-running sessions.
   // Set preserves insertion order; evict oldest entries when cap is reached.
@@ -3206,6 +3214,19 @@ var MultiAddressTransportMux = class _MultiAddressTransportMux {
   // Identity key for the Mux's NostrClient — relays may filter gift-wrap
   // delivery to the recipient's subscription key.
   identityPrivateKey;
+  // Resolves the shared NostrClient at use-time (the source provider may
+  // create its client lazily, after the Mux is constructed). null means
+  // "no shared client; create our own."
+  sharedNostrClientGetter;
+  // True when this Mux is using a shared NostrClient and therefore must
+  // not call connect()/disconnect() on it.
+  usingSharedClient = false;
+  // Listener registered on the underlying NostrClient. Tracked so we can
+  // remove it on disconnect / rebind — otherwise a long-lived shared
+  // client accumulates listeners across address switches and (worse)
+  // a "disconnected" Mux still sees onReconnected callbacks fire and
+  // re-establish subscriptions it shouldn't have.
+  connectionListener = null;
   constructor(config) {
     this.identityPrivateKey = config.identityPrivateKey;
     this.config = {
@@ -3218,6 +3239,14 @@ var MultiAddressTransportMux = class _MultiAddressTransportMux {
       generateUUID: config.generateUUID ?? defaultUUIDGenerator
     };
     this.storage = config.storage ?? null;
+    if (typeof config.sharedNostrClient === "function") {
+      this.sharedNostrClientGetter = config.sharedNostrClient;
+    } else if (config.sharedNostrClient) {
+      const c = config.sharedNostrClient;
+      this.sharedNostrClientGetter = () => c;
+    } else {
+      this.sharedNostrClientGetter = null;
+    }
   }
   // ===========================================================================
   // Address Management
@@ -3308,53 +3337,49 @@ var MultiAddressTransportMux = class _MultiAddressTransportMux {
     if (this.status === "connected") return;
     this.status = "connecting";
     try {
-      if (!this.primaryKeyManager) {
-        if (this.identityPrivateKey) {
-          this.primaryKeyManager = import_nostr_js_sdk2.NostrKeyManager.fromPrivateKey(
-            import_buffer2.Buffer.from(this.identityPrivateKey)
+      const shared = this.sharedNostrClientGetter ? this.sharedNostrClientGetter() : null;
+      if (shared) {
+        if (!shared.isConnected()) {
+          throw new SphereError(
+            "sharedNostrClient is not connected; the Mux cannot share a closed socket",
+            "TRANSPORT_ERROR"
           );
-        } else {
-          const tempKey = import_buffer2.Buffer.alloc(32);
-          crypto.getRandomValues(tempKey);
-          this.primaryKeyManager = import_nostr_js_sdk2.NostrKeyManager.fromPrivateKey(tempKey);
         }
+        this.nostrClient = shared;
+        this.usingSharedClient = true;
+      } else {
+        if (!this.primaryKeyManager) {
+          if (this.identityPrivateKey) {
+            this.primaryKeyManager = import_nostr_js_sdk2.NostrKeyManager.fromPrivateKey(
+              import_buffer2.Buffer.from(this.identityPrivateKey)
+            );
+          } else {
+            const tempKey = import_buffer2.Buffer.alloc(32);
+            crypto.getRandomValues(tempKey);
+            this.primaryKeyManager = import_nostr_js_sdk2.NostrKeyManager.fromPrivateKey(tempKey);
+          }
+        }
+        this.nostrClient = new import_nostr_js_sdk2.NostrClient(this.primaryKeyManager, {
+          autoReconnect: this.config.autoReconnect,
+          reconnectIntervalMs: this.config.reconnectDelay,
+          maxReconnectIntervalMs: this.config.reconnectDelay * 16,
+          pingIntervalMs: 15e3
+        });
       }
-      this.nostrClient = new import_nostr_js_sdk2.NostrClient(this.primaryKeyManager, {
-        autoReconnect: this.config.autoReconnect,
-        reconnectIntervalMs: this.config.reconnectDelay,
-        maxReconnectIntervalMs: this.config.reconnectDelay * 16,
-        pingIntervalMs: 15e3
-      });
-      this.nostrClient.addConnectionListener({
-        onConnect: (url) => {
-          logger.debug("Mux", "Connected to relay:", url);
-          this.emitEvent({ type: "transport:connected", timestamp: Date.now() });
-        },
-        onDisconnect: (url, reason) => {
-          logger.debug("Mux", "Disconnected from relay:", url, "reason:", reason);
-        },
-        onReconnecting: (url, attempt) => {
-          logger.debug("Mux", "Reconnecting to relay:", url, "attempt:", attempt);
-          this.emitEvent({ type: "transport:reconnecting", timestamp: Date.now() });
-        },
-        onReconnected: (url) => {
-          logger.debug("Mux", "Reconnected to relay:", url);
-          this.emitEvent({ type: "transport:connected", timestamp: Date.now() });
-          this.updateSubscriptions().catch((err) => {
-            logger.error("Mux", "Failed to re-subscribe after reconnect:", err);
-          });
+      this.connectionListener = this.buildConnectionListener();
+      this.nostrClient.addConnectionListener(this.connectionListener);
+      if (!this.usingSharedClient) {
+        await Promise.race([
+          this.nostrClient.connect(...this.config.relays),
+          new Promise(
+            (_, reject) => setTimeout(() => reject(new Error(
+              `Transport connection timed out after ${this.config.timeout}ms`
+            )), this.config.timeout)
+          )
+        ]);
+        if (!this.nostrClient.isConnected()) {
+          throw new SphereError("Failed to connect to any relay", "TRANSPORT_ERROR");
         }
-      });
-      await Promise.race([
-        this.nostrClient.connect(...this.config.relays),
-        new Promise(
-          (_, reject) => setTimeout(() => reject(new Error(
-            `Transport connection timed out after ${this.config.timeout}ms`
-          )), this.config.timeout)
-        )
-      ]);
-      if (!this.nostrClient.isConnected()) {
-        throw new SphereError("Failed to connect to any relay", "TRANSPORT_ERROR");
       }
       this.status = "connected";
       this.emitEvent({ type: "transport:connected", timestamp: Date.now() });
@@ -3363,6 +3388,21 @@ var MultiAddressTransportMux = class _MultiAddressTransportMux {
       }
     } catch (error) {
       this.status = "error";
+      if (this.connectionListener && this.nostrClient) {
+        try {
+          this.nostrClient.removeConnectionListener(this.connectionListener);
+        } catch {
+        }
+      }
+      this.connectionListener = null;
+      if (this.nostrClient && !this.usingSharedClient) {
+        try {
+          this.nostrClient.disconnect();
+        } catch {
+        }
+      }
+      this.nostrClient = null;
+      this.usingSharedClient = false;
       throw error;
     }
   }
@@ -3371,25 +3411,153 @@ var MultiAddressTransportMux = class _MultiAddressTransportMux {
       clearTimeout(this.resubscribeTimer);
       this.resubscribeTimer = null;
     }
-    if (this.healthCheckTimer) {
-      clearInterval(this.healthCheckTimer);
-      this.healthCheckTimer = null;
-    }
     if (this.nostrClient) {
-      this.nostrClient.disconnect();
+      if (this.walletSubscriptionId) {
+        try {
+          this.nostrClient.unsubscribe(this.walletSubscriptionId);
+        } catch {
+        }
+      }
+      if (this.chatSubscriptionId) {
+        try {
+          this.nostrClient.unsubscribe(this.chatSubscriptionId);
+        } catch {
+        }
+      }
+      if (this.connectionListener) {
+        try {
+          this.nostrClient.removeConnectionListener(this.connectionListener);
+        } catch {
+        }
+      }
+      if (!this.usingSharedClient) {
+        this.nostrClient.disconnect();
+      }
       this.nostrClient = null;
     }
+    this.connectionListener = null;
+    this.usingSharedClient = false;
     this.walletSubscriptionId = null;
     this.chatSubscriptionId = null;
     this.chatEoseFired = false;
-    this.lastWalletEventAt = Date.now();
-    this.lastChatEventAt = Date.now();
     this.status = "disconnected";
     this.emitEvent({ type: "transport:disconnected", timestamp: Date.now() });
   }
   isConnected() {
     return this.status === "connected" && this.nostrClient?.isConnected() === true;
   }
+  /**
+   * Build the connection listener used by both {@link connect} and
+   * {@link rebindToSharedClient}.
+   *
+   * Behavioral notes:
+   * - When the Mux is sharing a {@link NostrClient} with the host
+   *   transport (#123), we deliberately do NOT emit
+   *   {@code transport:connected} / {@code transport:reconnecting} here
+   *   — the host transport's own listener already emits those for the
+   *   same socket event. Re-subscribing after a reconnect IS still our
+   *   responsibility, since the host has
+   *   {@code suppressSubscriptions()}'d its own filters.
+   * - {@code onConnect} does not emit {@code transport:connected}.
+   *   The SDK only fires {@code onConnect} on the initial socket
+   *   connection (subsequent reconnects use {@code onReconnected}),
+   *   and {@link connect()}'s bottom already emits
+   *   {@code transport:connected} once that returns. Emitting here too
+   *   would double-fire on every initial connect.
+   * - Each callback bails out early when the Mux is not in an active
+   *   state ({@code disconnected} / {@code error}). Listeners are
+   *   removed on {@code disconnect()} before the callback can fire,
+   *   so this guard is mainly defense-in-depth against any in-flight
+   *   callback that lands during teardown — but having it at the top
+   *   means we never emit a misleading {@code transport:connected}
+   *   from a Mux that has already torn down.
+   */
+  buildConnectionListener() {
+    const isInactive = () => this.status === "disconnected" || this.status === "error";
+    return {
+      onConnect: (url) => {
+        if (isInactive()) return;
+        logger.debug("Mux", "Connected to relay:", url);
+      },
+      onDisconnect: (url, reason) => {
+        logger.debug("Mux", "Disconnected from relay:", url, "reason:", reason);
+      },
+      onReconnecting: (url, attempt) => {
+        if (isInactive()) return;
+        logger.debug("Mux", "Reconnecting to relay:", url, "attempt:", attempt);
+        if (!this.usingSharedClient) {
+          this.emitEvent({ type: "transport:reconnecting", timestamp: Date.now() });
+        }
+      },
+      onReconnected: (url) => {
+        if (isInactive()) return;
+        logger.debug("Mux", "Reconnected to relay:", url);
+        if (!this.usingSharedClient) {
+          this.emitEvent({ type: "transport:connected", timestamp: Date.now() });
+        }
+        this.updateSubscriptions().catch((err) => {
+          logger.error("Mux", "Failed to re-subscribe after reconnect:", err);
+        });
+      }
+    };
+  }
+  /**
+   * Re-attach to a freshly-created shared NostrClient.
+   *
+   * Call this after the host (e.g. {@link NostrTransportProvider}) has
+   * recreated its NostrClient — typically because the wallet's active
+   * identity changed and the SDK's NostrClient does not support
+   * changing identity at runtime. The previous client has already
+   * been disconnected by the host, so its server-side subscriptions
+   * are gone — we just adopt the new client and re-issue our own.
+   *
+   * The caller is responsible for ordering: by the time rebind runs,
+   * the host transport's new NostrClient must already be created and
+   * connected. In Sphere this is guaranteed because we await
+   * {@code transport.setIdentity()} before calling rebind.
+   *
+   * Returns silently in two cases that are not caller errors:
+   *   - the Mux owns its own client (not sharing) — nothing to rebind
+   *   - the shared client reference hasn't changed (rebind is a no-op)
+   *
+   * Throws otherwise (rather than silently no-op'ing) so a wiring
+   * mistake — for instance, calling rebind before the host's new
+   * client is ready — surfaces immediately instead of leaving the
+   * Mux pinned to a stale client.
+   */
+  async rebindToSharedClient() {
+    if (!this.usingSharedClient) return;
+    if (!this.sharedNostrClientGetter) return;
+    const newClient = this.sharedNostrClientGetter();
+    if (!newClient) {
+      throw new SphereError(
+        "rebindToSharedClient: shared client getter returned null. The host transport must finish (re)creating its NostrClient before rebind is called.",
+        "TRANSPORT_ERROR"
+      );
+    }
+    if (this.nostrClient === newClient) return;
+    if (!newClient.isConnected()) {
+      throw new SphereError(
+        "rebindToSharedClient: new shared client is not connected. Await transport.setIdentity() / transport.connect() before rebinding.",
+        "TRANSPORT_ERROR"
+      );
+    }
+    if (this.nostrClient && this.connectionListener && this.nostrClient !== newClient) {
+      try {
+        this.nostrClient.removeConnectionListener(this.connectionListener);
+      } catch {
+      }
+    }
+    this.nostrClient = newClient;
+    this.walletSubscriptionId = null;
+    this.chatSubscriptionId = null;
+    this.chatEoseFired = false;
+    this.connectionListener = this.buildConnectionListener();
+    this.nostrClient.addConnectionListener(this.connectionListener);
+    if (this.addresses.size > 0) {
+      await this.updateSubscriptions();
+    }
+  }
   /**
    * One-shot fetch of pending events from the relay.
    * Creates a temporary subscription, waits for EOSE (or timeout),
@@ -3518,8 +3686,6 @@ var MultiAddressTransportMux = class _MultiAddressTransportMux {
       this.nostrClient.unsubscribe(this.chatSubscriptionId);
       this.chatSubscriptionId = null;
     }
-    this.lastWalletEventAt = Date.now();
-    this.lastChatEventAt = Date.now();
     if (this.addresses.size === 0) return;
     const allPubkeys = [];
     for (const entry of this.addresses.values()) {
@@ -3606,25 +3772,6 @@ var MultiAddressTransportMux = class _MultiAddressTransportMux {
       }
     });
     logger.debug("Mux", `updateSubscriptions: walletSub=${this.walletSubscriptionId} chatSub=${this.chatSubscriptionId}`);
-    this.startHealthCheck();
-  }
-  startHealthCheck() {
-    if (this.healthCheckTimer) return;
-    this.healthCheckTimer = setInterval(() => {
-      if (!this.isConnected()) return;
-      const chatElapsed = Date.now() - this.lastChatEventAt;
-      const walletElapsed = Date.now() - this.lastWalletEventAt;
-      const needResubscribe = chatElapsed > 6e4 || walletElapsed > 3e5;
-      if (needResubscribe) {
-        const reason = chatElapsed > 6e4 ? `No chat events for ${Math.round(chatElapsed / 1e3)}s` : `No wallet events for ${Math.round(walletElapsed / 1e3)}s`;
-        logger.warn("Mux", `${reason} \u2014 re-subscribing`);
-        this.lastChatEventAt = Date.now();
-        this.lastWalletEventAt = Date.now();
-        this.updateSubscriptions().catch((err) => {
-          logger.warn("Mux", "Health check re-subscription failed:", err);
-        });
-      }
-    }, 3e4);
   }
   /**
    * Schedule a re-subscription after a relay-initiated subscription closure.
@@ -3685,12 +3832,6 @@ var MultiAddressTransportMux = class _MultiAddressTransportMux {
         }
       }
     }
-    if (event.kind !== import_nostr_js_sdk2.EventKinds.GIFT_WRAP) {
-      this.lastWalletEventAt = Date.now();
-    }
-    if (event.kind === import_nostr_js_sdk2.EventKinds.GIFT_WRAP) {
-      this.lastChatEventAt = Date.now();
-    }
     try {
       if (event.kind === import_nostr_js_sdk2.EventKinds.GIFT_WRAP) {
         await this.routeGiftWrap(event);
@@ -28574,6 +28715,9 @@ var Sphere = class _Sphere {
       this._transport.setFallbackSince(fallbackTs);
     }
     await this._transport.setIdentity(this._identity);
+    if (this._transportMux && typeof this._transportMux.rebindToSharedClient === "function") {
+      await this._transportMux.rebindToSharedClient();
+    }
     this.emitEvent("identity:changed", {
       l1Address: this._identity.l1Address,
       directAddress: this._identity.directAddress,
@@ -28784,7 +28928,12 @@ var Sphere = class _Sphere {
       this._transportMux = new MultiAddressTransportMux({
         relays: nostrTransport.getConfiguredRelays(),
         createWebSocket: nostrTransport.getWebSocketFactory(),
-        storage: nostrTransport.getStorageAdapter() ?? void 0
+        storage: nostrTransport.getStorageAdapter() ?? void 0,
+        // #123: share the original transport's NostrClient instead of
+        // opening a second WebSocket per relay. Pass a getter so the
+        // Mux resolves it at connect-time (after the transport finishes
+        // its own connect()).
+        sharedNostrClient: typeof nostrTransport.getNostrClient === "function" ? () => nostrTransport.getNostrClient() : void 0
       });
       await this._transportMux.connect();
       if (typeof nostrTransport.suppressSubscriptions === "function") {