@konemono/nostr-login 1.7.24 → 1.7.25

package/package.json

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

package/src/modules/Nip46.ts

@@ -38,7 +38,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 +145,106 @@ 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 {
+      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;
+    }
 
     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 +376,23 @@ 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 {
+        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;
+      }
     }
 
     const id = this.getId();
@@ -329,7 +407,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