@konemono/nostr-login 1.7.14 → 1.7.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@konemono/nostr-login",
-  "version": "1.7.14",
+  "version": "1.7.16",
   "description": "",
   "main": "./dist/index.esm.js",
   "types": "./dist/index.d.ts",

package/src/index.ts

@@ -94,6 +94,7 @@ export class NostrLoginInitializer {
     });
 
     this.authNostrService.on('timeout', () => {
+      console.log('nostr-login: timeout event received, calling cancelNostrConnect');
       this.bannerManager.onCallTimeout();
       this.authNostrService.cancelNostrConnect();
     });

package/src/modules/AuthNostrService.ts

@@ -323,6 +323,14 @@ class AuthNostrService extends EventEmitter implements Signer {
   }
 
   private releaseSigner() {
+    // cleanup iframe ping interval if using IframeNostrRpc
+    if (this.signer && '_rpc' in this.signer) {
+      const rpc = (this.signer as any)._rpc;
+      if (rpc && typeof rpc.cleanup === 'function') {
+        rpc.cleanup();
+      }
+    }
+    
     this.signer = null;
     this.signerErrCallback?.('cancelled');
     this.localSigner = null;
@@ -465,8 +473,12 @@ class AuthNostrService extends EventEmitter implements Signer {
     // with 'load' event below
     const ready = new ReadyListener(['workerReady', 'workerError'], url.origin);
 
-    await new Promise(ok => {
-      iframe!.addEventListener('load', ok);
+    await new Promise((ok, err) => {
+      const timeoutId = setTimeout(() => err('Iframe load timeout'), 30000);
+      iframe!.addEventListener('load', () => {
+        clearTimeout(timeoutId);
+        ok(undefined);
+      });
     });
 
     // now make sure the iframe is ready,
@@ -584,6 +596,7 @@ class AuthNostrService extends EventEmitter implements Signer {
            setTimeout(() => {
              if (!finished) {
                finished = true
+               console.log('nostr-login: relay connection timeout, emitting timeout event');
                this.emit('timeout');
                reject('Connection timed out')
              }

package/src/modules/BannerManager.ts

@@ -48,6 +48,7 @@ class BannerManager extends EventEmitter {
 
   public onCallTimeout() {
     if (this.banner) {
+      this.banner.isLoading = false;
       this.banner.notify = {
         mode: 'timeout',
       };

package/src/modules/Nip46.ts

@@ -78,8 +78,24 @@ class NostrRpc extends NDKNostrRpc {
       'kinds': [24133],
       '#p': [pubkey],
     });
+    
     return new Promise<string>((ok, err) => {
+      let finished = false;
+      
+      // 30 sec timeout
+      const timeoutId = setTimeout(() => {
+        if (!finished) {
+          finished = true;
+          this.stop();
+          console.log('nostr-login: listen timeout, emitting timeout event');
+          this.emit('timeout');
+          err('Listen timed out');
+        }
+      }, 30000);
+      
       sub.on('event', async (event: NDKEvent) => {
+        if (finished) return;
+        
         try {
           const parsedEvent = await this.parseEvent(event);
           // console.log('ack parsedEvent', parsedEvent);
@@ -92,16 +108,20 @@ class NostrRpc extends NDKNostrRpc {
             // FIXME for now accept 'ack' replies, later on only
             // accept secrets
             if (response.result === 'ack' || response.result === nostrConnectSecret) {
+              finished = true;
+              clearTimeout(timeoutId);
+              this.stop();
               ok(event.pubkey);
             } else {
+              finished = true;
+              clearTimeout(timeoutId);
+              this.stop();
               err(response.error);
             }
           }
         } catch (e) {
           console.log('error parsing event', e, event.rawEvent());
         }
-        // done
-        this.stop();
       });
     });
   }
@@ -177,6 +197,7 @@ class NostrRpc extends NDKNostrRpc {
         if (this.requests.has(id)) {
           this.requests.delete(id);
           this.removeListener(`response-${id}`, responseHandler);
+          console.log('nostr-login: NIP-46 request timeout, emitting timeout event');
           this.emit('timeout');
           reject('Request timed out');
         }
@@ -211,6 +232,7 @@ export class IframeNostrRpc extends NostrRpc {
   private peerOrigin?: string;
   private iframePort?: MessagePort;
   private iframeRequests = new Map<string, { id: string; pubkey: string }>();
+  private iframePingInterval?: NodeJS.Timeout;
 
   public constructor(ndk: NDK, localSigner: PrivateKeySigner, iframePeerOrigin?: string) {
     super(ndk, localSigner);
@@ -237,7 +259,7 @@ export class IframeNostrRpc extends NostrRpc {
     this.iframePort = port;
 
     // to make sure Chrome doesn't terminate the channel
-    setInterval(() => {
+    this.iframePingInterval = setInterval(() => {
       console.log('iframe-nip46 ping');
       this.iframePort!.postMessage('ping');
     }, 5000);
@@ -270,6 +292,13 @@ export class IframeNostrRpc extends NostrRpc {
     };
   }
 
+  public cleanup() {
+    if (this.iframePingInterval) {
+      clearInterval(this.iframePingInterval);
+      this.iframePingInterval = undefined;
+    }
+  }
+
   public async sendRequest(remotePubkey: string, method: string, params: string[] = [], kind = 24133, cb?: (res: NDKRpcResponse) => void): Promise<NDKRpcResponse> {
     const id = this.getId();
 
@@ -333,18 +362,14 @@ export class ReadyListener {
 
   async wait(): Promise<any> {
     console.log(new Date(), 'waiting for', this.messages);
-    const r = await this.promise;
-    // NOTE: timer here doesn't help bcs it must be activated when
-    // user "confirms", but that's happening on a different
-    // origin and we can't really know.
-    // await new Promise<any>((ok, err) => {
-    //   // 10 sec should be more than enough
-    //   setTimeout(() => err(new Date() + ' timeout for ' + this.message), 10000);
-
-    //   // if promise already resolved or will resolve in the future
-    //   this.promise.then(ok);
-    // });
-
+    
+    const r = await new Promise<any>((ok, err) => {
+      // 30 sec timeout for iframe ready
+      setTimeout(() => err(new Date() + ' timeout for ' + this.messages), 30000);
+      
+      this.promise.then(ok).catch(err);
+    });
+    
     console.log(new Date(), 'finished waiting for', this.messages, r);
     return r;
   }

package/src/modules/ProcessManager.ts

@@ -24,8 +24,18 @@ class ProcessManager extends EventEmitter {
   public async wait<T>(cb: () => Promise<T>): Promise<T> {
     // FIXME only allow 1 parallel req
 
+    let timeoutReject: ((reason?: any) => void) | undefined;
+    const timeoutPromise = new Promise<T>((_, reject) => {
+      timeoutReject = reject;
+    });
+
     if (!this.callTimer) {
-      this.callTimer = setTimeout(() => this.emit('onCallTimeout'), CALL_TIMEOUT);
+      this.callTimer = setTimeout(() => {
+        this.emit('onCallTimeout');
+        if (timeoutReject) {
+          timeoutReject(new Error('Request timed out'));
+        }
+      }, CALL_TIMEOUT);
     }
 
     if (!this.callCount) {
@@ -38,7 +48,7 @@ class ProcessManager extends EventEmitter {
     let result;
 
     try {
-      result = await cb();
+      result = await Promise.race([cb(), timeoutPromise]);
     } catch (e) {
       error = e;
     }

package/src/utils/index.ts

@@ -115,22 +115,36 @@ export const getBunkerUrl = async (value: string, optionsModal: NostrLoginOption
     const origin = optionsModal.devOverrideBunkerOrigin || `https://${domain}`;
     const bunkerUrl = `${origin}/.well-known/nostr.json?name=_`;
     const userUrl = `${origin}/.well-known/nostr.json?name=${name}`;
-    const bunker = await fetch(bunkerUrl);
-    const bunkerData = await bunker.json();
-    const bunkerPubkey = bunkerData.names['_'];
-    const bunkerRelays = bunkerData.nip46[bunkerPubkey];
-    const user = await fetch(userUrl);
-    const userData = await user.json();
-    const userPubkey = userData.names[name];
-    // console.log({
-    //     bunkerData, userData, bunkerPubkey, bunkerRelays, userPubkey,
-    //     name, domain, origin
-    // })
-    if (!bunkerRelays.length) {
-      throw new Error('Bunker relay not provided');
-    }
+    
+    // 10 sec timeout for fetch
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 10000);
+    
+    try {
+      const bunker = await fetch(bunkerUrl, { signal: controller.signal });
+      const bunkerData = await bunker.json();
+      const bunkerPubkey = bunkerData.names['_'];
+      const bunkerRelays = bunkerData.nip46[bunkerPubkey];
+      const user = await fetch(userUrl, { signal: controller.signal });
+      const userData = await user.json();
+      const userPubkey = userData.names[name];
+      // console.log({
+      //     bunkerData, userData, bunkerPubkey, bunkerRelays, userPubkey,
+      //     name, domain, origin
+      // })
+      if (!bunkerRelays.length) {
+        throw new Error('Bunker relay not provided');
+      }
 
-    return `bunker://${userPubkey}?relay=${bunkerRelays[0]}`;
+      return `bunker://${userPubkey}?relay=${bunkerRelays[0]}`;
+    } catch (e: any) {
+      if (e.name === 'AbortError') {
+        throw new Error('Request timed out');
+      }
+      throw e;
+    } finally {
+      clearTimeout(timeoutId);
+    }
   }
 
   throw new Error('Invalid user name or bunker url');