@konemono/nostr-login 1.7.21 → 1.7.23

package/src/modules/ModalManager.ts

@@ -1,11 +1,13 @@
 import { NostrLoginOptions, StartScreens, TypeModal } from '../types';
-import { checkNip05, getBunkerUrl, getDarkMode, localStorageRemoveRecent, localStorageSetItem, prepareSignupRelays } from '../utils';
+import { checkNip05, getBunkerUrl, getDarkMode, localStorageRemoveRecent, localStorageSetItem, prepareSignupRelays, localStorageGetItem } from '../utils';
 import { AuthNostrService, NostrExtensionService, NostrParams } from '.';
 import { EventEmitter } from 'tseep';
-import { ConnectionString, Info, RecentType } from 'nostr-login-components';
+import { ConnectionString, Info, RecentType } from 'nostr-login-components/dist/types/types';
 import { nip19 } from 'nostr-tools';
 import { setDarkMode } from '..';
 
+const RELAY_STORAGE_KEY = '__nostrlogin_user_relays';
+
 class ModalManager extends EventEmitter {
   private modal: TypeModal | null = null;
   private params: NostrParams;
@@ -23,6 +25,18 @@ class ModalManager extends EventEmitter {
     this.authNostrService = authNostrService;
   }
 
+  private getUserRelays(): string[] {
+    const stored = localStorageGetItem(RELAY_STORAGE_KEY);
+    if (stored && Array.isArray(stored)) {
+      return stored;
+    }
+    return [];
+  }
+
+  private saveUserRelays(relays: string[]) {
+    localStorageSetItem(RELAY_STORAGE_KEY, JSON.stringify(relays));
+  }
+
   public async waitReady() {
     if (this.launcherPromise) {
       try {
@@ -34,10 +48,8 @@ class ModalManager extends EventEmitter {
 
   public async launch(opt: NostrLoginOptions) {
     console.log('nostr-login launch', opt);
-    // mutex
     if (this.launcherPromise) await this.waitReady();
 
-    // hmm?!
     if (this.authNostrService.isAuthing()) this.authNostrService.resetAuth();
 
     this.opt = opt;
@@ -61,7 +73,6 @@ class ModalManager extends EventEmitter {
       this.modal.setAttribute('bunkers', opt.bunkers);
     } else {
       let bunkers = 'nsec.app,highlighter.com';
-      // if (opt.dev) bunkers += ',new.nsec.app';
       this.modal.setAttribute('bunkers', bunkers);
     }
 
@@ -91,6 +102,11 @@ class ModalManager extends EventEmitter {
     this.modal.isLoadingExtension = false;
     this.modal.isLoading = false;
 
+    const userRelays = this.getUserRelays();
+    if (userRelays.length > 0) {
+      this.params.optionsModal.connectRelays = userRelays;
+    }
+
     [this.modal.connectionString, this.modal.connectionStringServices] = await this.authNostrService.getNostrConnectServices();
 
     dialog.appendChild(this.modal);
@@ -100,21 +116,11 @@ class ModalManager extends EventEmitter {
 
     this.launcherPromise = new Promise<void>((ok, err) => {
       dialog.addEventListener('close', () => {
-        // noop if already resolved
         err(new Error('Closed'));
 
         this.authNostrService.resetAuth();
 
         if (this.modal) {
-          // it's reset on modal creation
-          // // reset state
-          // this.modal.isLoading = false;
-          // this.modal.authUrl = '';
-          // this.modal.iframeUrl = '';
-          // this.modal.error = '';
-          // this.modal.isLoadingExtension = false;
-
-          // drop it
           // @ts-ignore
           document.body.removeChild(this.modal.parentNode);
           this.modal = null;
@@ -157,20 +163,16 @@ class ModalManager extends EventEmitter {
 
       const login = async (name: string, domain?: string) => {
         await exec(async () => {
-          // convert name to bunker url
           const bunkerUrl = await getBunkerUrl(name, this.params.optionsModal);
 
-          // connect to bunker by url
           await this.authNostrService.authNip46('login', { name, bunkerUrl, domain });
         });
       };
 
       const signup = async (name: string) => {
         await exec(async () => {
-          // create acc on service and get bunker url
           const { bunkerUrl, sk } = await this.authNostrService.createAccount(name);
 
-          // connect to bunker by url
           await this.authNostrService.authNip46('signup', { name, bunkerUrl, sk });
         });
       };
@@ -190,7 +192,6 @@ class ModalManager extends EventEmitter {
           cs.link = this.authNostrService.prepareImportUrl(cs.link);
 
           if (this.modal && iframeUrl) {
-            // we pass the link down to iframe so it could open it
             this.modal.authUrl = cs.link;
             this.modal.iframeUrl = iframeUrl;
             this.modal.isLoading = false;
@@ -208,7 +209,6 @@ class ModalManager extends EventEmitter {
 
           if (this.modal) {
             if (iframeUrl) {
-              // we pass the link down to iframe so it could open it
               this.modal.authUrl = link;
               this.modal.iframeUrl = iframeUrl;
               this.modal.isLoading = false;
@@ -239,8 +239,6 @@ class ModalManager extends EventEmitter {
               .charAt(0)
               .toUpperCase() + self.hostname.slice(1);
           const relays = prepareSignupRelays(this.params.optionsModal.signupRelays);
-          // const url = `https://start.njump.me/?an=${name}&at=popup&ac=${window.location.href}&s=${this.opt!.followNpubs || ''}&arr=${relays}&awr=${relays}`;
-          // console.log('njump url', url);
 
           this.modal!.njumpIframe = `
           <html><body>
@@ -248,18 +246,15 @@ class ModalManager extends EventEmitter {
           <script>
           new NstartModal({
             baseUrl: 'https://start.njump.me',
-            // Required parameters
             an: '${name}',
-            // Optional parameters
             s: [${this.opt!.followNpubs ? `'${this.opt!.followNpubs}'` : ''}],
-            afb: false, // forceBunker
-            asb: false, // skipBunker
-            aan: false, // avoidNsec
-            aac: true, // avoidNcryptsec
-            ahc: true, // hide close button
-            arr: ${JSON.stringify(relays)}, //readRelays
-            awr: ${JSON.stringify(relays)}, //writeRelays
-            // Callbacks
+            afb: false,
+            asb: false,
+            aan: false,
+            aac: true,
+            ahc: true,
+            arr: ${JSON.stringify(relays)},
+            awr: ${JSON.stringify(relays)},
             onComplete: (result) => {
               console.log('Login token:', result.nostrLogin);
               window.parent.location.href='${window.location.href}#nostr-login='+result.nostrLogin;
@@ -270,11 +265,10 @@ class ModalManager extends EventEmitter {
           }).open();
           </script>
           </body></html>
-          `.replaceAll('&', '&amp;'); // needed?
+          `.replaceAll('&', '&amp;');
 
           return new Promise((ok, err) => {
             const process = async (nsecOrBunker: string) => {
-              // process the returned value
               console.log('nsecOrBunker', nsecOrBunker);
               if (nsecOrBunker.startsWith('nsec1')) {
                 let decoded;
@@ -300,7 +294,6 @@ class ModalManager extends EventEmitter {
               if (window.location.hash.startsWith('#nostr-login=')) {
                 const nsecOrBunker = window.location.hash.split('#nostr-login=')[1];
 
-                // clear hash from history
                 const url = new URL(window.location.toString());
                 url.hash = '';
                 window.history.replaceState({}, '', url.toString());
@@ -309,9 +302,6 @@ class ModalManager extends EventEmitter {
               }
             };
 
-            // // use random 'target' to make sure window.opener is
-            // // accessible to the popup
-            // window.open(url, '' + Date.now(), 'popup=true,width=600,height=950');
             window.addEventListener('hashchange', onOpen);
           });
         });
@@ -359,7 +349,6 @@ class ModalManager extends EventEmitter {
       });
 
       this.modal.addEventListener('nlNostrConnectDefault', () => {
-        // dedup the calls
         if (!this.authNostrService.isAuthing()) nostrConnect();
       });
 
@@ -368,18 +357,30 @@ class ModalManager extends EventEmitter {
         this.authNostrService.cancelNostrConnect();
       });
 
+      this.modal.addEventListener('nlSaveUserRelays', (event: any) => {
+        const relays = event.detail as string[];
+        console.log('nlSaveUserRelays', relays);
+        this.saveUserRelays(relays);
+        this.params.optionsModal.connectRelays = relays;
+      });
+
+      this.modal.addEventListener('nlGetUserRelays', () => {
+        const relays = this.getUserRelays();
+        console.log('nlGetUserRelays', relays);
+        if (this.modal) {
+          this.modal.dispatchEvent(
+            new CustomEvent('nlUserRelaysReply', {
+              detail: relays,
+            }),
+          );
+        }
+      });
+
       this.modal.addEventListener('nlSwitchAccount', (event: any) => {
         const eventInfo: Info = event.detail as Info;
 
         this.emit('onSwitchAccount', eventInfo);
 
-        // wait a bit, if dialog closes before
-        // switching finishes then launched promise rejects
-
-        // FIXME this calls resetAuth which then prevents
-        // endAuth from getting properly called. 300 is not
-        // enough to init iframe, so there should be a
-        // feedback from switchAccount here
         setTimeout(() => dialog.close(), 300);
       });
 
@@ -426,7 +427,7 @@ class ModalManager extends EventEmitter {
           else throw new Error('Bad npub');
         } else if (nameNpub.trim().length === 64) {
           pubkey = nameNpub.trim();
-          nip19.npubEncode(pubkey); // check
+          nip19.npubEncode(pubkey);
         }
         return pubkey;
       };
@@ -466,13 +467,10 @@ class ModalManager extends EventEmitter {
               throw new Error('Failed to send DM');
             }
 
-            // switch to 'enter code' mode
             this.modal.isOTP = true;
 
-            // remember for code handler below
             otpPubkey = pubkey;
 
-            // spinner off
             this.modal.isLoading = false;
           },
           { start: true },
@@ -529,8 +527,6 @@ class ModalManager extends EventEmitter {
           this.modal.isLoading = false;
         }
 
-        // this.authNostrService.cancelListenNostrConnect();
-
         dialog.close();
         err(new Error('Cancelled'));
       };
@@ -555,9 +551,6 @@ class ModalManager extends EventEmitter {
   }
 
   public async showIframeUrl(url: string) {
-    // make sure we consume the previous promise,
-    // otherwise launch will start await-ing
-    // before modal is created and setting iframeUrl will fail
     await this.waitReady();
 
     this.launch({

package/src/modules/Nip46.ts

@@ -1,11 +1,13 @@
 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';
 
 class NostrRpc extends NDKNostrRpc {
   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;
 
@@ -16,19 +18,34 @@ class NostrRpc extends NDKNostrRpc {
   }
 
   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;
     }
   }
 
+  private clearAllTimeouts() {
+    for (const timeout of this.requestTimeouts.values()) {
+      clearTimeout(timeout);
+    }
+    this.requestTimeouts.clear();
+  }
+
+  private clearTimeout(id: string) {
+    const timeout = this.requestTimeouts.get(id);
+    if (timeout) {
+      clearTimeout(timeout);
+      this.requestTimeouts.delete(id);
+    }
+  }
+
   public setUseNip44(useNip44: boolean) {
     this._useNip44 = useNip44;
   }
@@ -39,7 +56,6 @@ 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;
@@ -68,9 +84,6 @@ 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);
@@ -78,61 +91,46 @@ 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);
-      
+        this.stop();
+        err(new Error('NIP46 listen timeout'));
+      }, NIP46_TIMEOUT);
+
       sub.on('event', async (event: NDKEvent) => {
-        if (finished) return;
-        
         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) {
-              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());
         }
+        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 {
@@ -149,22 +147,13 @@ class NostrRpc extends NDKNostrRpc {
   public async sendRequest(remotePubkey: string, method: string, params: string[] = [], kind = 24133, cb?: (res: NDKRpcResponse) => void): Promise<NDKRpcResponse> {
     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, method, remotePubkey, params });
+    console.log('sendRequest', { event, method, remotePubkey, params });
 
-    // send to relays
-    const relays = await event.publish();
-    if (relays.size === 0) throw new Error('Failed to publish 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;
   }
@@ -172,7 +161,25 @@ class NostrRpc extends NDKNostrRpc {
   protected setResponseHandler(id: string, cb?: (res: NDKRpcResponse) => void) {
     let authUrlSent = false;
     const now = Date.now();
-    return new Promise<NDKRpcResponse>((resolve, reject) => {
+
+    const timeoutId = setTimeout(() => {
+      if (this.requests.has(id)) {
+        this.requests.delete(id);
+        this.requestTimeouts.delete(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') {
           this.once(`response-${id}`, responseHandler);
@@ -182,30 +189,18 @@ 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);
-            resolve(response);
           }
         }
       };
 
       this.once(`response-${id}`, responseHandler);
-
-      // timeout
-      setTimeout(() => {
-        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('[Nip46] Request timed out');
-        }
-      }, 30000);
     });
   }
 
-
   protected async createRequestEvent(id: string, remotePubkey: string, method: string, params: string[] = [], kind = 24133) {
     this.requests.add(id);
     const localUser = await this._signer.user();
@@ -232,7 +227,6 @@ 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);
@@ -246,7 +240,6 @@ export class IframeNostrRpc extends NostrRpc {
       this._ndk,
       {},
       {
-        // don't send to relay
         closeOnEose: true,
         cacheUsage: NDKSubscriptionCacheUsage.ONLY_CACHE,
       },
@@ -258,8 +251,7 @@ export class IframeNostrRpc extends NostrRpc {
 
     this.iframePort = port;
 
-    // to make sure Chrome doesn't terminate the channel
-    this.iframePingInterval = setInterval(() => {
+    setInterval(() => {
       console.log('iframe-nip46 ping');
       this.iframePort!.postMessage('ping');
     }, 5000);
@@ -273,7 +265,6 @@ export class IframeNostrRpc extends NostrRpc {
         return;
       }
 
-      // a copy-paste from rpc.subscribe
       try {
         const event = ev.data;
 
@@ -281,7 +272,6 @@ 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);
@@ -292,39 +282,22 @@ 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();
 
-    // 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 {
-      // send to relays
       await event.publish();
     }
 
-    // see notes in 'super'
     // @ts-ignore
     return undefined as NDKRpcResponse;
   }
@@ -341,14 +314,11 @@ 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;
         }
 
@@ -362,14 +332,7 @@ export class ReadyListener {
 
   async wait(): Promise<any> {
     console.log(new Date(), 'waiting for', this.messages);
-    
-    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);
-    });
-    
+    const r = await this.promise;
     console.log(new Date(), 'finished waiting for', this.messages, r);
     return r;
   }
@@ -382,15 +345,11 @@ 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.params.optionsModal.dev);
+    this._rpc.setUseNip44(true);
     this._rpc.on('authUrl', (url: string) => {
       this.emit('authUrl', url);
     });
-    this._rpc.on('timeout', () => {
-      this.emit('timeout');
-    });
 
     this.rpc = this._rpc;
   }
@@ -400,17 +359,14 @@ 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 : '');
   }
 
@@ -425,9 +381,19 @@ 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);
+      console.log('get_public_key', this.remotePubkey);
+
+      const timeoutId = setTimeout(() => {
+        err(new Error('NIP46 get_public_key timeout'));
+      }, NIP46_TIMEOUT);
+
       this._rpc.sendRequest(this.remotePubkey, 'get_public_key', [], 24133, (response: NDKRpcResponse) => {
-        ok(response.result);
+        clearTimeout(timeoutId);
+        if (response.error) {
+          err(new Error(response.error));
+        } else {
+          ok(response.result);
+        }
       });
     });
   }
@@ -449,15 +415,21 @@ export class Nip46Signer extends NDKNip46Signer {
   }
 
   public async createAccount2({ bunkerPubkey, name, domain, perms = '' }: { bunkerPubkey: string; name: string; domain: string; perms?: string }) {
-    const params = [
-      name,
-      domain,
-      '', // email
-      perms,
-    ];
-
-    const r = await new Promise<NDKRpcResponse>(ok => {
-      this.rpc.sendRequest(bunkerPubkey, 'create_account', params, undefined, ok);
+    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);
+        }
+      });
     });
 
     console.log('create_account pubkey', r);