@konemono/nostr-login 1.8.0 → 1.9.0

package/package.json

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

package/src/modules/AuthNostrService.ts

@@ -656,7 +656,7 @@ class AuthNostrService extends EventEmitter implements Signer {
   }
 
   private async listen(info: Info) {
-    if (!info.iframeUrl) return this.signer!.listen(this.nostrConnectSecret);
+    if (!info.iframeUrl) return this.signer!.listen(this.nostrConnectSecret, 60000);
     const r = await this.starterReady!.wait();
     if (r[0] === 'starterError') throw new Error(r[1]);
     return this.signer!.setListenReply(r[1], this.nostrConnectSecret);
@@ -717,6 +717,11 @@ class AuthNostrService extends EventEmitter implements Signer {
             remotePubkey: info.signerPubkey!,
             relays: info.relays || [],
             timeoutMs: 30000,
+            useNip44: true,
+            retryConfig: {
+              maxRetries: 3,
+              retryDelayMs: 1000,
+            },
           });
 
           const adapter = new Nip46Adapter(client, localSigner);
@@ -773,24 +778,44 @@ class AuthNostrService extends EventEmitter implements Signer {
       if (domain) info.domain = domain;
       if (iframeUrl) info.iframeUrl = iframeUrl;
 
-      // console.log('nostr login auth info', info);
+      console.log('authNip46', type, info);
+
       if (!info.signerPubkey || !info.sk || !info.relays || info.relays.length === 0) {
-        throw new Error(`Bad bunker url ${bunkerUrl}`);
+        throw new Error(`Invalid bunker URL format`);
       }
 
       const eventToAddAccount = Boolean(this.params.userInfo);
-      console.log('authNip46', type, info);
+
+      // 接続モードに応じた処理
+      const connectMode = type === 'login' && !info.token ? 'listen' : 'connect';
+      console.log('authNip46 connection mode:', connectMode);
 
       // updates the info
-      await this.initSigner(info, { connect: true, eventToAddAccount });
+      await this.initSigner(info, {
+        listen: connectMode === 'listen',
+        connect: connectMode === 'connect',
+        eventToAddAccount,
+      });
 
       // callback
       this.onAuth(type, info);
-    } catch (e) {
-      console.log('nostr login auth failed', e);
-      // make ure it's closed
-      // this.popupManager.closePopup();
-      throw e;
+    } catch (error: any) {
+      console.error('nostr-login auth failed:', {
+        type,
+        error: error.message,
+        stack: error.stack,
+      });
+
+      // エラーの種類に応じた処理
+      if (error.message.includes('timeout') || error.message.includes('timed out')) {
+        throw new Error('接続がタイムアウトしました。ネットワークを確認してください。');
+      } else if (error.message.includes('Invalid bunker URL')) {
+        throw new Error('無効なbunker URL形式です。');
+      } else if (error.message.includes('publish')) {
+        throw new Error('リレーへの接続に失敗しました。再度お試しください。');
+      } else {
+        throw new Error(`認証に失敗しました: ${error.message}`);
+      }
     }
   }
 

package/src/modules/nip46/Nip46Adapter.ts

@@ -27,38 +27,83 @@ export class Nip46Adapter extends EventEmitter {
     if (this.userPubkey) throw new Error('Already called initUserPubkey');
     if (hintPubkey) {
       this.userPubkey = hintPubkey;
+      console.log('[Nip46Adapter] User pubkey set from hint:', hintPubkey);
       return;
     }
 
-    const res = await this.client.sendRequest('get_public_key', []);
-    if (!res) throw new Error('No public key returned');
-    this.userPubkey = res;
+    console.log('[Nip46Adapter] Fetching user pubkey');
+    try {
+      const res = await this.client.sendRequest('get_public_key', []);
+      if (!res) throw new Error('No public key returned');
+      this.userPubkey = res;
+      console.log('[Nip46Adapter] User pubkey fetched:', res);
+    } catch (error: any) {
+      console.error('[Nip46Adapter] Failed to get user pubkey:', error.message);
+      throw error;
+    }
   }
 
-  async listen(nostrConnectSecret: string): Promise<string> {
-    return new Promise<string>((ok, err) => {
+  /**
+   * nostrconnect:// フロー - 受信待機
+   * サイナーからの接続を待つ
+   */
+  async listen(nostrConnectSecret: string, timeoutMs: number = 60000): Promise<string> {
+    console.log('[Nip46Adapter] Starting listen mode, timeout:', timeoutMs);
+
+    return new Promise<string>((resolve, reject) => {
+      const timer = setTimeout(() => {
+        cleanup();
+        const error = new Error(`Listen timeout after ${timeoutMs}ms`);
+        console.error('[Nip46Adapter]', error.message);
+        reject(error);
+      }, timeoutMs);
+
+      const cleanup = () => {
+        clearTimeout(timer);
+        this.client.off('response', onResponse);
+      };
+
       const onResponse = ({ response, pubkey }: any) => {
         if (!response) return;
+
+        // auth_urlは無視（別のハンドラが処理）
         if (response.result === 'auth_url') return;
+
+        // 成功: ack または secret が返される
         if (response.result === 'ack' || response.result === nostrConnectSecret) {
-          this.client.off('response', onResponse);
-          ok(pubkey);
+          cleanup();
+          console.log('[Nip46Adapter] Listen succeeded, signer pubkey:', pubkey);
+          resolve(pubkey);
+        } else if (response.error) {
+          cleanup();
+          console.error('[Nip46Adapter] Listen failed:', response.error);
+          reject(new Error(response.error));
         }
       };
 
       this.client.on('response', onResponse);
-
-      // also add a timeout
-      setTimeout(() => {
-        this.client.off('response', onResponse);
-        err(new Error('Listen timeout'));
-      }, 30000);
     });
   }
 
-  async connect(token?: string, perms?: string) {
-    const result = await this.client.sendRequest('connect', [this.localSigner.pubkey, token || '', perms || '']);
-    if (result !== 'ack') throw new Error(result || 'connect failed');
+  /**
+   * bunker:// フロー - 能動的接続
+   * サイナーに接続リクエストを送る
+   */
+  async connect(token?: string, perms?: string, timeoutMs: number = 30000): Promise<void> {
+    console.log('[Nip46Adapter] Connecting with token, timeout:', timeoutMs);
+
+    try {
+      const result = await this.client.sendRequest('connect', [this.localSigner.pubkey, token || '', perms || ''], timeoutMs);
+
+      if (result !== 'ack') {
+        throw new Error(`Connect failed: ${result || 'unknown error'}`);
+      }
+
+      console.log('[Nip46Adapter] Connected successfully');
+    } catch (error: any) {
+      console.error('[Nip46Adapter] Connect failed:', error.message);
+      throw error;
+    }
   }
 
   async setListenReply(reply: any, nostrConnectSecret: string) {
@@ -80,10 +125,17 @@ export class Nip46Adapter extends EventEmitter {
   async createAccount2({ bunkerPubkey, name, domain, perms = '' }: { bunkerPubkey: string; name: string; domain: string; perms?: string }) {
     const params = [name, domain, '', perms];
 
-    const r = await this.client.sendRequest('create_account', params);
-    if (!r) throw new Error('create_account failed');
-    if (r === 'error') throw new Error('create_account error');
-    return r;
+    console.log('[Nip46Adapter] Creating account:', { name, domain });
+    try {
+      const r = await this.client.sendRequest('create_account', params);
+      if (!r) throw new Error('create_account returned empty result');
+      if (r === 'error') throw new Error('create_account failed');
+      console.log('[Nip46Adapter] Account created successfully');
+      return r;
+    } catch (error: any) {
+      console.error('[Nip46Adapter] Failed to create account:', error.message);
+      throw error;
+    }
   }
 
   async encrypt(recipientPubkey: string, plaintext: string) {
@@ -97,14 +149,19 @@ export class Nip46Adapter extends EventEmitter {
   }
 
   async sign(event: any) {
-    const r = await this.client.sendRequest('sign_event', [JSON.stringify(event)]);
     try {
-      const parsed = typeof r === 'string' ? JSON.parse(r) : r;
-      if (parsed && parsed.sig) return parsed.sig;
-    } catch (e) {
-      // not JSON
+      const r = await this.client.sendRequest('sign_event', [JSON.stringify(event)]);
+      try {
+        const parsed = typeof r === 'string' ? JSON.parse(r) : r;
+        if (parsed && parsed.sig) return parsed.sig;
+      } catch (e) {
+        // not JSON
+      }
+      return r;
+    } catch (error: any) {
+      console.error('[Nip46Adapter] Failed to sign event:', error.message);
+      throw error;
     }
-    return r;
   }
 
   // provide rpc compatibility

package/src/modules/nip46/Nip46Client.ts

@@ -15,6 +15,9 @@ export class Nip46Client extends EventEmitter {
   private subscription: any = null;
   private isSubscribed: boolean = false;
   private nip44Codec: Nip44 = new Nip44();
+  private iframeConfig?: { origin: string; port?: MessagePort };
+  private retryConfig: { maxRetries: number; retryDelayMs: number };
+  private iframeKeepaliveInterval?: NodeJS.Timeout;
 
   constructor(options: Nip46ClientOptions) {
     super();
@@ -24,6 +27,13 @@ export class Nip46Client extends EventEmitter {
     this.relays = options.relays;
     this.defaultTimeoutMs = options.timeoutMs || 30000;
     this.useNip44 = options.useNip44 || false;
+    this.iframeConfig = options.iframeConfig;
+    this.retryConfig = options.retryConfig || { maxRetries: 3, retryDelayMs: 1000 };
+
+    // iframe用のメッセージハンドラを設定
+    if (this.iframeConfig?.port) {
+      this.setupIframePort(this.iframeConfig.port);
+    }
   }
 
   get localPubkey(): string {
@@ -31,9 +41,40 @@ export class Nip46Client extends EventEmitter {
   }
 
   /**
-   * NIP-46リクエストを送信
+   * NIP-46リクエストを送信（リトライ機能付き）
    */
   async sendRequest(method: string, params: string[] = [], timeoutMs?: number): Promise<string> {
+    let lastError: Error | null = null;
+
+    for (let attempt = 0; attempt <= this.retryConfig.maxRetries; attempt++) {
+      try {
+        if (attempt > 0) {
+          const delay = this.retryConfig.retryDelayMs * attempt;
+          console.log(`[Nip46Client] Retry attempt ${attempt}/${this.retryConfig.maxRetries} for ${method} after ${delay}ms`);
+          await new Promise(resolve => setTimeout(resolve, delay));
+        }
+
+        return await this.sendRequestInternal(method, params, timeoutMs);
+      } catch (error: any) {
+        lastError = error;
+
+        // タイムアウトまたはネットワークエラーの場合のみリトライ
+        const shouldRetry = error.message.includes('timed out') || error.message.includes('network') || error.message.includes('publish');
+
+        if (!shouldRetry || attempt === this.retryConfig.maxRetries) {
+          console.error(`[Nip46Client] Request failed after ${attempt + 1} attempts:`, error.message);
+          throw error;
+        }
+      }
+    }
+
+    throw lastError || new Error('Request failed after retries');
+  }
+
+  /**
+   * NIP-46リクエストを送信（内部実装）
+   */
+  private async sendRequestInternal(method: string, params: string[] = [], timeoutMs?: number): Promise<string> {
     const timeout = timeoutMs || this.defaultTimeoutMs;
     const id = this.generateId();
     const request: Nip46Request = { id, method, params };
@@ -94,9 +135,25 @@ export class Nip46Client extends EventEmitter {
     // 署名
     event.sig = getSignature(event, this.localPrivateKey);
 
+    // iframeがある場合は優先的に使用
+    if (this.iframeConfig?.port) {
+      try {
+        this.iframeConfig.port.postMessage(event);
+        console.log('[Nip46Client] Request sent via iframe:', request.id);
+        return;
+      } catch (e) {
+        console.warn('[Nip46Client] Iframe send failed, falling back to relays:', e);
+      }
+    }
+
     // リレーに送信
-    await Promise.any(this.pool.publish(this.relays, event));
-    console.log('[Nip46Client] Request published:', request.id);
+    try {
+      await Promise.any(this.pool.publish(this.relays, event));
+      console.log('[Nip46Client] Request published to relays:', request.id);
+    } catch (e) {
+      console.error('[Nip46Client] Failed to publish to relays:', e);
+      throw new Error('Failed to publish request to relays');
+    }
   }
 
   /**
@@ -146,10 +203,12 @@ export class Nip46Client extends EventEmitter {
       // Emit response event for consumers (include sender pubkey)
       this.emit('response', { response, pubkey: event.pubkey });
 
-      // auth_urlの特別処理
+      // auth_urlの特別処理: OAuth完了後に実際のレスポンスが来るまで待つ
       if (response.result === 'auth_url') {
         console.log('[Nip46Client] Auth URL received:', response.error);
         this.emit('authUrl', response.error);
+        // 注意: pendingRequestsは削除しない
+        // OAuth完了後に同じIDで実際のレスポンスが返ってくる
         return;
       }
 
@@ -232,6 +291,12 @@ export class Nip46Client extends EventEmitter {
       this.isSubscribed = false;
     }
 
+    // iframeのkeepaliveをクリア
+    if (this.iframeKeepaliveInterval) {
+      clearInterval(this.iframeKeepaliveInterval);
+      this.iframeKeepaliveInterval = undefined;
+    }
+
     // リレー接続を閉じる
     this.pool.close(this.relays);
 
@@ -245,4 +310,47 @@ export class Nip46Client extends EventEmitter {
   isConnected(): boolean {
     return this.isSubscribed;
   }
+
+  /**
+   * iframeポートを設定
+   */
+  setIframePort(port: MessagePort): void {
+    if (!this.iframeConfig) {
+      throw new Error('Iframe config not set');
+    }
+    this.iframeConfig.port = port;
+    this.setupIframePort(port);
+  }
+
+  /**
+   * iframe用のメッセージハンドラを設定
+   */
+  private setupIframePort(port: MessagePort): void {
+    port.onmessage = async (ev: MessageEvent) => {
+      if (ev.data === 'ping') return;
+
+      try {
+        const event = ev.data;
+        // validate and handle event
+        if (!event || typeof event !== 'object') {
+          console.warn('[Nip46Client] Invalid message from iframe');
+          return;
+        }
+        await this.handleResponseEvent(event);
+      } catch (e) {
+        console.error('[Nip46Client] Iframe message error:', e);
+      }
+    };
+
+    // Keep alive
+    this.iframeKeepaliveInterval = setInterval(() => {
+      try {
+        port.postMessage('ping');
+      } catch (e) {
+        console.warn('[Nip46Client] Failed to send keepalive ping:', e);
+      }
+    }, 5000);
+
+    console.log('[Nip46Client] Iframe port setup complete');
+  }
 }

package/src/modules/nip46/types.ts

@@ -1,26 +1,34 @@
 export interface Nip46Request {
-    id: string;
-    method: string;
-    params: string[];
+  id: string;
+  method: string;
+  params: string[];
 }
 
 export interface Nip46Response {
-    id: string;
-    result?: string;
-    error?: string;
+  id: string;
+  result?: string;
+  error?: string;
 }
 
 export interface PendingRequest {
-    resolve: (result: string) => void;
-    reject: (error: Error) => void;
-    timer: NodeJS.Timeout;
-    method: string;
+  resolve: (result: string) => void;
+  reject: (error: Error) => void;
+  timer: NodeJS.Timeout;
+  method: string;
 }
 
 export interface Nip46ClientOptions {
-    localPrivateKey: string;
-    remotePubkey: string;
-    relays: string[];
-    timeoutMs?: number;
-    useNip44?: boolean;
+  localPrivateKey: string;
+  remotePubkey: string;
+  relays: string[];
+  timeoutMs?: number;
+  useNip44?: boolean;
+  iframeConfig?: {
+    origin: string;
+    port?: MessagePort;
+  };
+  retryConfig?: {
+    maxRetries: number;
+    retryDelayMs: number;
+  };
 }