@konemono/nostr-login 1.7.24 → 1.7.26

package/package.json

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

package/src/index.ts

@@ -93,6 +93,11 @@ export class NostrLoginInitializer {
       this.bannerManager.onUserInfo(info);
     });
 
+    this.authNostrService.on('reconnecting', () => {
+      // リレー再接続中はProcessManagerのタイマーをリセット
+      this.processManager.onIframeUrl();
+    });
+
     this.modalManager.on('onAuthUrlClick', url => {
       this.openPopup(url);
     });
@@ -322,7 +327,7 @@ export class NostrLoginInitializer {
   };
 
   public cancelNeedAuth = () => {
-    console.log("cancelNeedAuth");
+    console.log('cancelNeedAuth');
     this.fulfillCustomLaunchPromise();
     this.authNostrService.cancelNostrConnect();
   };

package/src/modules/Nip46.ts

@@ -2,8 +2,10 @@ import NDK, { NDKEvent, NDKFilter, NDKNip46Signer, NDKNostrRpc, NDKRpcRequest, N
 import { validateEvent, verifySignature } from 'nostr-tools';
 import { PrivateKeySigner } from './Signer';
 import { NIP46_TIMEOUT } from '../const';
+import ProcessManager from './ProcessManager';
 
 class NostrRpc extends NDKNostrRpc {
+  protected processManager?: ProcessManager;
   protected _ndk: NDK;
   protected _signer: PrivateKeySigner;
   protected requests: Set<string> = new Set();
@@ -11,10 +13,11 @@ class NostrRpc extends NDKNostrRpc {
   private sub?: NDKSubscription;
   protected _useNip44: boolean = false;
 
-  public constructor(ndk: NDK, signer: PrivateKeySigner) {
+  public constructor(ndk: NDK, signer: PrivateKeySigner, processManager?: ProcessManager) {
     super(ndk, signer, ndk.debug.extend('nip46:signer:rpc'));
     this._ndk = ndk;
     this._signer = signer;
+    this.processManager = processManager;
   }
 
   public async subscribe(filter: NDKFilter): Promise<NDKSubscription> {
@@ -38,7 +41,7 @@ class NostrRpc extends NDKNostrRpc {
     this.requestTimeouts.clear();
   }
 
-  private clearTimeout(id: string) {
+  protected clearTimeout(id: string) {
     const timeout = this.requestTimeouts.get(id);
     if (timeout) {
       clearTimeout(timeout);
@@ -145,43 +148,109 @@ class NostrRpc extends NDKNostrRpc {
   }
 
   protected async ensureConnected(): Promise<void> {
-    const connectedRelays = Array.from(this._ndk.pool.relays.values()).filter(r => r.status === 1);
+    const relays = Array.from(this._ndk.pool.relays.values());
+    console.log(
+      'Checking relay connections:',
+      relays.map(r => ({ url: r.url, status: r.status })),
+    );
+
+    const connectedRelays = relays.filter(r => r.status === 1);
 
     if (connectedRelays.length === 0) {
-      console.log('No connected relays, reconnecting...');
+      console.log('No connected relays, forcing reconnection...');
+
+      // 既存の接続を全てクリーンアップ
+      for (const relay of relays) {
+        try {
+          await relay.disconnect();
+        } catch (e) {
+          console.log('Error disconnecting relay:', relay.url, e);
+        }
+      }
+
+      // 再接続
       await this._ndk.connect();
 
+      // 接続確立を待つ
       await new Promise<void>((resolve, reject) => {
         const timeout = setTimeout(() => {
+          const status = Array.from(this._ndk.pool.relays.values()).map(r => ({ url: r.url, status: r.status }));
+          console.error('Failed to reconnect to relays within 10s. Status:', status);
           reject(new Error('Failed to reconnect to relays'));
-        }, 5000);
+        }, 10000);
 
         const checkConnection = () => {
           const connected = Array.from(this._ndk.pool.relays.values()).filter(r => r.status === 1);
           if (connected.length > 0) {
             clearTimeout(timeout);
-            console.log('Reconnected to', connected.length, 'relays');
+            console.log(
+              'Successfully reconnected to',
+              connected.length,
+              'relays:',
+              connected.map(r => r.url),
+            );
             resolve();
           } else {
-            setTimeout(checkConnection, 100);
+            setTimeout(checkConnection, 200);
           }
         };
         checkConnection();
       });
+    } else {
+      console.log(
+        'Already connected to',
+        connectedRelays.length,
+        'relays:',
+        connectedRelays.map(r => r.url),
+      );
     }
   }
 
   public async sendRequest(remotePubkey: string, method: string, params: string[] = [], kind = 24133, cb?: (res: NDKRpcResponse) => void): Promise<NDKRpcResponse> {
-    await this.ensureConnected();
+    console.log('sendRequest called:', method, 'to', remotePubkey);
+
+    try {
+      this.processManager?.pause();
+      await this.ensureConnected();
+    } catch (e) {
+      console.error('Failed to ensure connection:', e);
+      if (cb) {
+        cb({
+          id: '',
+          result: '',
+          error: 'Failed to connect to relays: ' + (e as Error).message,
+          event: undefined as any,
+        });
+      }
+      throw e;
+    } finally {
+      this.processManager?.resume();
+    }
 
     const id = this.getId();
 
     this.setResponseHandler(id, cb);
 
     const event = await this.createRequestEvent(id, remotePubkey, method, params, kind);
-    console.log('sendRequest', { event, method, remotePubkey, params });
+    console.log('sendRequest event created', { event, method, remotePubkey, params });
 
-    await event.publish();
+    try {
+      await event.publish();
+      console.log('sendRequest event published successfully');
+    } catch (e) {
+      console.error('Failed to publish event:', e);
+      this.clearTimeout(id);
+      this.requests.delete(id);
+      if (cb) {
+        cb({
+          id,
+          result: '',
+          error: 'Failed to publish event: ' + (e as Error).message,
+          event: undefined as any,
+        });
+      }
+      throw e;
+    }
 
     // @ts-ignore
     return undefined as NDKRpcResponse;
@@ -313,8 +382,26 @@ export class IframeNostrRpc extends NostrRpc {
   }
 
   public async sendRequest(remotePubkey: string, method: string, params: string[] = [], kind = 24133, cb?: (res: NDKRpcResponse) => void): Promise<NDKRpcResponse> {
+    console.log('IframeNostrRpc.sendRequest called:', method, 'iframePort:', !!this.iframePort);
+
     if (!this.iframePort) {
-      await this.ensureConnected();
+      try {
+        this.processManager?.pause();
+        await this.ensureConnected();
+      } catch (e) {
+        console.error('Failed to ensure connection:', e);
+        if (cb) {
+          cb({
+            id: '',
+            result: '',
+            error: 'Failed to connect to relays: ' + (e as Error).message,
+            event: undefined as any,
+          });
+        }
+        throw e;
+      } finally {
+        this.processManager?.resume();
+      }
     }
 
     const id = this.getId();
@@ -329,7 +416,23 @@ export class IframeNostrRpc extends NostrRpc {
       console.log('iframe-nip46 sending request to', this.peerOrigin, event.rawEvent());
       this.iframePort.postMessage(event.rawEvent());
     } else {
-      await event.publish();
+      try {
+        await event.publish();
+        console.log('Request published to relays successfully');
+      } catch (e) {
+        console.error('Failed to publish event:', e);
+        this.clearTimeout(id);
+        this.requests.delete(id);
+        if (cb) {
+          cb({
+            id,
+            result: '',
+            error: 'Failed to publish event: ' + (e as Error).message,
+            event: undefined as any,
+          });
+        }
+        throw e;
+      }
     }
 
     // @ts-ignore

package/src/modules/ProcessManager.ts

@@ -2,6 +2,7 @@ import { EventEmitter } from 'tseep';
 import { CALL_TIMEOUT } from '../const';
 
 class ProcessManager extends EventEmitter {
+  private paused = false;
   private callCount: number = 0;
   private callTimer: NodeJS.Timeout | undefined;
 
@@ -10,22 +11,38 @@ class ProcessManager extends EventEmitter {
   }
 
   public onAuthUrl() {
-    if (Boolean(this.callTimer)) {
-      clearTimeout(this.callTimer);
-    }
+    console.log('ProcessManager.onAuthUrl called, resetting timer');
+    this.resetTimer();
   }
 
   public onIframeUrl() {
-    if (Boolean(this.callTimer)) {
+    console.log('ProcessManager.onIframeUrl called, resetting timer');
+    this.resetTimer();
+  }
+
+  private resetTimer() {
+    if (this.callTimer) {
       clearTimeout(this.callTimer);
+      console.log('ProcessManager: timer reset');
+    }
+    if (this.callCount > 0) {
+      this.callTimer = setTimeout(() => {
+        console.log('ProcessManager: timeout reached, emitting onCallTimeout');
+        this.emit('onCallTimeout');
+      }, CALL_TIMEOUT);
+      console.log(`ProcessManager: new timer set for ${CALL_TIMEOUT} ms`);
     }
   }
 
   public async wait<T>(cb: () => Promise<T>): Promise<T> {
-    // FIXME only allow 1 parallel req
+    console.log('ProcessManager.wait called, callTimer exists:', !!this.callTimer, 'callCount:', this.callCount);
 
     if (!this.callTimer) {
-      this.callTimer = setTimeout(() => this.emit('onCallTimeout'), CALL_TIMEOUT);
+      this.callTimer = setTimeout(() => {
+        console.log('ProcessManager: timeout reached, emitting onCallTimeout');
+        this.emit('onCallTimeout');
+      }, CALL_TIMEOUT);
+      console.log(`Setting up timeout timer for ${CALL_TIMEOUT} ms`);
     }
 
     if (!this.callCount) {
@@ -57,11 +74,23 @@ class ProcessManager extends EventEmitter {
       throw error;
     }
 
-    // we can't return undefined bcs an exception is
-    // thrown above on error
     // @ts-ignore
     return result;
   }
+  public pause() {
+    if (this.callTimer) clearTimeout(this.callTimer);
+    this.callTimer = undefined;
+    this.paused = true;
+  }
+
+  public resume() {
+    this.paused = false;
+    if (this.callCount > 0 && !this.callTimer) {
+      this.callTimer = setTimeout(() => {
+        this.emit('onCallTimeout');
+      }, CALL_TIMEOUT);
+    }
+  }
 }
 
 export default ProcessManager;