@konemono/nostr-login 1.7.35 → 1.7.37

package/src/modules/Nip46.ts

@@ -1,59 +1,34 @@
 import NDK, { NDKEvent, NDKFilter, NDKNip46Signer, NDKNostrRpc, NDKRpcRequest, NDKRpcResponse, NDKSubscription, NDKSubscriptionCacheUsage, NostrEvent } from '@nostr-dev-kit/ndk';
 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();
-  protected requestTimeouts: Map<string, NodeJS.Timeout> = new Map();
   private sub?: NDKSubscription;
   protected _useNip44: boolean = false;
 
-  public cleanupTimersAndRequests() {
-    this.clearAllTimeouts(); // private/protected なメソッドを呼び出す
-    this.requests.clear(); // requests Setをクリア
-  }
-
-  public constructor(ndk: NDK, signer: PrivateKeySigner, processManager?: ProcessManager) {
+  public constructor(ndk: NDK, signer: PrivateKeySigner) {
     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> {
+    // NOTE: fixing ndk
     filter.kinds = filter.kinds?.filter(k => k === 24133);
     this.sub = await super.subscribe(filter);
     return this.sub;
   }
 
   public stop() {
-    this.clearAllTimeouts();
     if (this.sub) {
       this.sub.stop();
       this.sub = undefined;
     }
   }
 
-  protected clearAllTimeouts() {
-    for (const timeout of this.requestTimeouts.values()) {
-      clearTimeout(timeout);
-    }
-    this.requestTimeouts.clear();
-  }
-
-  protected clearTimeout(id: string) {
-    const timeout = this.requestTimeouts.get(id);
-    if (timeout) {
-      clearTimeout(timeout);
-      this.requestTimeouts.delete(id);
-    }
-  }
-
   public setUseNip44(useNip44: boolean) {
     this._useNip44 = useNip44;
   }
@@ -64,6 +39,7 @@ class NostrRpc extends NDKNostrRpc {
     return ciphertext[l - 28] === '?' && ciphertext[l - 27] === 'i' && ciphertext[l - 26] === 'v' && ciphertext[l - 25] === '=';
   }
 
+  // override to auto-decrypt nip04/nip44
   public async parseEvent(event: NDKEvent): Promise<NDKRpcRequest | NDKRpcResponse> {
     const remoteUser = this._ndk.getUser({ pubkey: event.pubkey });
     remoteUser.ndk = this._ndk;
@@ -92,6 +68,9 @@ class NostrRpc extends NDKNostrRpc {
     }
   }
 
+  // ndk doesn't support nostrconnect:
+  // we just listed to an unsolicited reply to
+  // our pubkey and if it's ack/secret - we're fine
   public async listen(nostrConnectSecret: string): Promise<string> {
     const pubkey = this._signer.pubkey;
     console.log('nostr-login listening for conn to', pubkey);
@@ -100,45 +79,40 @@ class NostrRpc extends NDKNostrRpc {
       '#p': [pubkey],
     });
     return new Promise<string>((ok, err) => {
-      const timeoutId = setTimeout(() => {
-        this.stop();
-        err(new Error('NIP46 listen timeout'));
-      }, NIP46_TIMEOUT);
-
       sub.on('event', async (event: NDKEvent) => {
         try {
           const parsedEvent = await this.parseEvent(event);
+          // console.log('ack parsedEvent', parsedEvent);
           if (!(parsedEvent as NDKRpcRequest).method) {
             const response = parsedEvent as NDKRpcResponse;
 
+            // ignore
             if (response.result === 'auth_url') return;
 
+            // FIXME for now accept 'ack' replies, later on only
+            // accept secrets
             if (response.result === 'ack' || response.result === nostrConnectSecret) {
-              clearTimeout(timeoutId);
               ok(event.pubkey);
             } else {
-              clearTimeout(timeoutId);
               err(response.error);
             }
           }
         } catch (e) {
           console.log('error parsing event', e, event.rawEvent());
         }
+        // done
         this.stop();
       });
     });
   }
 
+  // since ndk doesn't yet support perms param
+  // we reimplement the 'connect' call here
+  // instead of await signer.blockUntilReady();
   public async connect(pubkey: string, token?: string, perms?: string) {
     return new Promise<void>((ok, err) => {
       const connectParams = [pubkey!, token || '', perms || ''];
-
-      const timeoutId = setTimeout(() => {
-        err(new Error('NIP46 connect timeout'));
-      }, NIP46_TIMEOUT);
-
       this.sendRequest(pubkey!, 'connect', connectParams, 24133, (response: NDKRpcResponse) => {
-        clearTimeout(timeoutId);
         if (response.result === 'ack') {
           ok();
         } else {
@@ -152,112 +126,24 @@ class NostrRpc extends NDKNostrRpc {
     return Math.random().toString(36).substring(7);
   }
 
-  protected async ensureConnected(): Promise<void> {
-    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);
-    console.log('connected relays', connectedRelays);
-
-    if (connectedRelays.length === 0) {
-      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'));
-        }, 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(
-              'Successfully reconnected to',
-              connected.length,
-              'relays:',
-              connected.map(r => r.url),
-            );
-            resolve();
-          } else {
-            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> {
-    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();
 
+    // response handler will deduplicate auth urls and responses
     this.setResponseHandler(id, cb);
 
+    // create and sign request
     const event = await this.createRequestEvent(id, remotePubkey, method, params, kind);
-    console.log('sendRequest event created', { event, method, remotePubkey, params });
+    console.log("sendRequest", { event, method, remotePubkey, params });
 
-    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;
-    }
+    // send to relays
+    await event.publish();
 
+    // NOTE: ndk returns a promise that never resolves and
+    // in fact REQUIRES cb to be provided (otherwise no way
+    // to consume the result), we've already stepped on the bug
+    // of waiting for this unresolvable result, so now we return
+    // undefined to make sure waiters fail, not hang.
     // @ts-ignore
     return undefined as NDKRpcResponse;
   }
@@ -265,26 +151,6 @@ class NostrRpc extends NDKNostrRpc {
   protected setResponseHandler(id: string, cb?: (res: NDKRpcResponse) => void) {
     let authUrlSent = false;
     const now = Date.now();
-
-    const timeoutId = setTimeout(() => {
-      if (this.requests.has(id)) {
-        clearTimeout(timeoutId);
-        this.requests.delete(id);
-        this.requestTimeouts.delete(id);
-        console.log('NIP46 request timeout for', id);
-        if (cb) {
-          cb({
-            id,
-            result: '',
-            error: 'NIP46 request timeout',
-            event: undefined as any,
-          });
-        }
-      }
-    }, NIP46_TIMEOUT);
-
-    this.requestTimeouts.set(id, timeoutId);
-
     return new Promise<NDKRpcResponse>(() => {
       const responseHandler = (response: NDKRpcResponse) => {
         if (response.result === 'auth_url') {
@@ -295,7 +161,6 @@ class NostrRpc extends NDKNostrRpc {
           }
         } else if (cb) {
           if (this.requests.has(id)) {
-            this.clearTimeout(id);
             this.requests.delete(id);
             console.log('nostr-login processed nip46 request in', Date.now() - now, 'ms');
             cb(response);
@@ -310,14 +175,6 @@ class NostrRpc extends NDKNostrRpc {
   protected async createRequestEvent(id: string, remotePubkey: string, method: string, params: string[] = [], kind = 24133) {
     this.requests.add(id);
     const localUser = await this._signer.user();
-
-    if (!localUser.pubkey) {
-      throw new Error('CORRUPTION: Missing local pubkey. Signer state compromised.');
-    }
-    if (!remotePubkey) {
-      throw new Error('CORRUPTION: Missing remote pubkey. Signer state compromised.');
-    }
-
     const remoteUser = this._ndk.getUser({ pubkey: remotePubkey });
     const request = { id, method, params };
 
@@ -354,6 +211,7 @@ export class IframeNostrRpc extends NostrRpc {
       this._ndk,
       {},
       {
+        // don't send to relay
         closeOnEose: true,
         cacheUsage: NDKSubscriptionCacheUsage.ONLY_CACHE,
       },
@@ -365,6 +223,7 @@ export class IframeNostrRpc extends NostrRpc {
 
     this.iframePort = port;
 
+    // to make sure Chrome doesn't terminate the channel
     setInterval(() => {
       console.log('iframe-nip46 ping');
       this.iframePort!.postMessage('ping');
@@ -379,6 +238,7 @@ export class IframeNostrRpc extends NostrRpc {
         return;
       }
 
+      // a copy-paste from rpc.subscribe
       try {
         const event = ev.data;
 
@@ -386,6 +246,7 @@ export class IframeNostrRpc extends NostrRpc {
         if (!verifySignature(event)) throw new Error('Invalid event signature from iframe');
         const nevent = new NDKEvent(this._ndk, event);
         const parsedEvent = await this.parseEvent(nevent);
+        // we're only implementing client-side rpc
         if (!(parsedEvent as NDKRpcRequest).method) {
           console.log('parsed response', parsedEvent);
           this.emit(`response-${parsedEvent.id}`, parsedEvent);
@@ -397,60 +258,31 @@ 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) {
-      try {
-        console.log(this.processManager);
-        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();
 
+    // create and sign request event
     const event = await this.createRequestEvent(id, remotePubkey, method, params, kind);
 
+    // set response handler, it will dedup auth urls,
+    // and also dedup response handlers - we're sending
+    // to relays and to iframe
     this.setResponseHandler(id, cb);
 
     if (this.iframePort) {
+      // map request event id to request id, if iframe
+      // has no key it will reply with error:event_id (it can't
+      // decrypt the request id without keys)
       this.iframeRequests.set(event.id, { id, pubkey: remotePubkey });
 
+      // send to iframe
       console.log('iframe-nip46 sending request to', this.peerOrigin, event.rawEvent());
       this.iframePort.postMessage(event.rawEvent());
     } else {
-      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;
-      }
+      // send to relays
+      await event.publish();
     }
 
+    // see notes in 'super'
     // @ts-ignore
     return undefined as NDKRpcResponse;
   }
@@ -467,11 +299,14 @@ export class ReadyListener {
     this.promise = new Promise<any>(ok => {
       console.log(new Date(), 'started listener for', this.messages);
 
+      // ready message handler
       const onReady = async (e: MessageEvent) => {
         const originHostname = new URL(origin!).hostname;
         const messageHostname = new URL(e.origin).hostname;
+        // same host or subdomain
         const validHost = messageHostname === originHostname || messageHostname.endsWith('.' + originHostname);
         if (!validHost || !Array.isArray(e.data) || !e.data.length || !this.messages.includes(e.data[0])) {
+          // console.log(new Date(), 'got invalid ready message', e.origin, e.data);
           return;
         }
 
@@ -486,6 +321,17 @@ 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);
+    // });
+
     console.log(new Date(), 'finished waiting for', this.messages, r);
     return r;
   }
@@ -498,8 +344,9 @@ export class Nip46Signer extends NDKNip46Signer {
   constructor(ndk: NDK, localSigner: PrivateKeySigner, signerPubkey: string, iframeOrigin?: string) {
     super(ndk, signerPubkey, localSigner);
 
+    // override with our own rpc implementation
     this._rpc = new IframeNostrRpc(ndk, localSigner, iframeOrigin);
-    this._rpc.setUseNip44(true);
+    this._rpc.setUseNip44(true); // !!this.params.optionsModal.dev);
     this._rpc.on('authUrl', (url: string) => {
       this.emit('authUrl', url);
     });
@@ -512,29 +359,20 @@ export class Nip46Signer extends NDKNip46Signer {
   }
 
   private async setSignerPubkey(signerPubkey: string, sameAsUser: boolean = false) {
-    console.log('setSignerPubkey', signerPubkey);
+    console.log("setSignerPubkey", signerPubkey);
 
+    // ensure it's set
     this.remotePubkey = signerPubkey;
 
+    // when we're sure it's known
     this._rpc.on(`iframeRestart-${signerPubkey}`, () => {
       this.emit('iframeRestart');
     });
 
+    // now call getPublicKey and swap remotePubkey w/ that
     await this.initUserPubkey(sameAsUser ? signerPubkey : '');
   }
 
-  public forceResetState() {
-    console.log('Nip46Signer state reset due to connection failure or timeout.');
-
-    // 1. ユーザー公開鍵をクリア
-    this._userPubkey = '';
-
-    // 2. リモート公開鍵をクリア
-    this.remotePubkey = ''; // 親クラスのプロパティをクリア
-
-    // 3. RPC側のタイマーとリクエストを、公開メソッド経由でクリア
-    (this._rpc as NostrRpc).cleanupTimersAndRequests();
-  }
   public async initUserPubkey(hintPubkey?: string) {
     if (this._userPubkey) throw new Error('Already called initUserPubkey');
 
@@ -546,19 +384,9 @@ export class Nip46Signer extends NDKNip46Signer {
     this._userPubkey = await new Promise<string>((ok, err) => {
       if (!this.remotePubkey) throw new Error('Signer pubkey not set');
 
-      console.log('get_public_key', this.remotePubkey);
-
-      const timeoutId = setTimeout(() => {
-        err(new Error('NIP46 get_public_key timeout'));
-      }, NIP46_TIMEOUT);
-
+      console.log("get_public_key", this.remotePubkey);
       this._rpc.sendRequest(this.remotePubkey, 'get_public_key', [], 24133, (response: NDKRpcResponse) => {
-        clearTimeout(timeoutId);
-        if (response.error) {
-          err(new Error(response.error));
-        } else {
-          ok(response.result);
-        }
+        ok(response.result);
       });
     });
   }
@@ -580,21 +408,15 @@ export class Nip46Signer extends NDKNip46Signer {
   }
 
   public async createAccount2({ bunkerPubkey, name, domain, perms = '' }: { bunkerPubkey: string; name: string; domain: string; perms?: string }) {
-    const params = [name, domain, '', perms];
-
-    const r = await new Promise<NDKRpcResponse>((ok, err) => {
-      const timeoutId = setTimeout(() => {
-        err(new Error('NIP46 create_account timeout'));
-      }, NIP46_TIMEOUT);
-
-      this.rpc.sendRequest(bunkerPubkey, 'create_account', params, undefined, response => {
-        clearTimeout(timeoutId);
-        if (response.error) {
-          err(new Error(response.error));
-        } else {
-          ok(response);
-        }
-      });
+    const params = [
+      name,
+      domain,
+      '', // email
+      perms,
+    ];
+
+    const r = await new Promise<NDKRpcResponse>(ok => {
+      this.rpc.sendRequest(bunkerPubkey, 'create_account', params, undefined, ok);
     });
 
     console.log('create_account pubkey', r);

package/src/modules/Nostr.ts

@@ -1,4 +1,4 @@
-import { Info } from 'nostr-login-components';
+import { Info } from 'nostr-login-components/dist/types/types';
 
 export interface Signer {
   signEvent: (event: any) => Promise<any>;

package/src/modules/NostrParams.ts

@@ -1,4 +1,4 @@
-import { Info } from 'nostr-login-components';
+import { Info } from 'nostr-login-components/dist/types/types';
 import { NostrLoginOptions } from '../types';
 
 class NostrParams {

package/src/modules/ProcessManager.ts

@@ -2,7 +2,6 @@ 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;
 
@@ -11,41 +10,22 @@ class ProcessManager extends EventEmitter {
   }
 
   public onAuthUrl() {
-    console.log('ProcessManager.onAuthUrl called, resetting timer');
-    this.resetTimer();
+    if (Boolean(this.callTimer)) {
+      clearTimeout(this.callTimer);
+    }
   }
 
   public onIframeUrl() {
-    console.log('ProcessManager.onIframeUrl called, resetting timer');
-    this.resetTimer();
-  }
-
-  private resetTimer() {
-    // 既存のタイマーがあればクリア
-    if (this.callTimer) {
+    if (Boolean(this.callTimer)) {
       clearTimeout(this.callTimer);
-      this.callTimer = undefined; // IDをクリア
-      console.log('ProcessManager: timer reset');
-    }
-
-    // 監視対象が残っていて、かつ一時停止中でなければ、新しいタイマーを設定
-    if (this.callCount > 0 && !this.paused) {
-      this.callTimer = setTimeout(() => {
-        console.log('ProcessManager: timeout reached, emitting onCallTimeout');
-        this.callTimer = undefined; // タイムアウト時にIDをクリア
-        this.emit('onCallTimeout');
-      }, CALL_TIMEOUT);
-      console.log(`ProcessManager: new timer set for ${CALL_TIMEOUT} ms`);
     }
   }
 
   public async wait<T>(cb: () => Promise<T>): Promise<T> {
-    console.log('ProcessManager.wait called, callTimer exists:', !!this.callTimer, 'callCount:', this.callCount);
+    // FIXME only allow 1 parallel req
 
-    // ★ 修正点: タイマーの初期設定を resetTimer に任せる
-    if (!this.callTimer && this.callCount === 0) {
-      // waitの最初の呼び出し時のみ、タイマーを初期設定
-      this.resetTimer();
+    if (!this.callTimer) {
+      this.callTimer = setTimeout(() => this.emit('onCallTimeout'), CALL_TIMEOUT);
     }
 
     if (!this.callCount) {
@@ -54,52 +34,33 @@ class ProcessManager extends EventEmitter {
 
     this.callCount++;
 
-    let error: any;
-    let result: any;
+    let error;
+    let result;
 
-    // 非同期処理の実行
     try {
       result = await cb();
     } catch (e) {
       error = e;
     }
 
-    // ★ 修正点: クリーンアップロジックを resetTimer に置き換え
-    // ProcessManagerの呼び出しカウントをデクリメント
     this.callCount--;
-    this.emit('onCallEnd');
-
-    // リクエスト完了後、タイマーをリセットし、callCountに応じて再設定
-    this.resetTimer();
 
-    // エラーがあればスローし、呼び出し元に伝播させる
-    if (error) {
-      throw error;
-    }
-
-    // @ts-ignore
-    return result as T;
-  }
+    this.emit('onCallEnd');
 
-  public pause() {
-    console.log('ProcessManager: PAUSING timer...');
     if (this.callTimer) {
       clearTimeout(this.callTimer);
     }
-    this.callTimer = undefined; // タイマーをクリア
-    this.paused = true;
-    this.emit('onCallPause');
-  }
 
-  public resume() {
-    console.log('ProcessManager: RESUMING timer...');
-    this.paused = false;
+    this.callTimer = undefined;
 
-    // ★ 修正点: pause解除後、監視対象が残っていればタイマーを再設定 (resetTimerを呼び出す)
-    if (this.callCount > 0 && !this.callTimer) {
-      this.resetTimer();
+    if (error) {
+      throw error;
     }
-    this.emit('onCallResume');
+
+    // we can't return undefined bcs an exception is
+    // thrown above on error
+    // @ts-ignore
+    return result;
   }
 }