@konemono/nostr-login 1.10.15 → 1.11.0

package/src/modules/AuthNostrService.ts

@@ -1,8 +1,14 @@
-import { localStorageAddAccount, bunkerUrlToInfo, isBunkerUrl, fetchProfile, getBunkerUrl, localStorageRemoveCurrentAccount, createProfile, getIcon } from '../utils';
+import { localStorageAddAccount, bunkerUrlToInfo, isBunkerUrl, fetchProfile, getBunkerUrl, localStorageRemoveCurrentAccount, createProfile, getIcon, bytesToHex, hexToBytes } from '../utils';
 import { ConnectionString, Info } from 'nostr-login-components/dist/types/types';
-import { generatePrivateKey, getEventHash, getPublicKey, nip19 } from 'nostr-tools';
+import { createRxNostr, RxNostr } from 'rx-nostr';
+import { generateSecretKey, getEventHash, getPublicKey, nip19 } from 'nostr-tools';
 import { NostrLoginAuthOptions, Response } from '../types';
-import NDK, { NDKEvent, NDKNip46Signer, NDKRpcResponse, NDKUser, NostrEvent } from '@nostr-dev-kit/ndk';
+
+
+
+// Placeholder types for SimplePool transition
+// private pool: SimplePool;
+// private outboxPool: SimplePool;
 import { NostrParams } from './';
 import { EventEmitter } from 'tseep';
 import { Signer } from './Nostr';
@@ -33,8 +39,7 @@ const NOSTRCONNECT_APPS: ConnectionString[] = [
 ];
 
 class AuthNostrService extends EventEmitter implements Signer {
-  private ndk: NDK;
-  private profileNdk: NDK;
+  private rxNostr: RxNostr;
   private signer: Nip46Signer | null = null;
   private localSigner: PrivateKeySigner | null = null;
   private params: NostrParams;
@@ -61,15 +66,11 @@ class AuthNostrService extends EventEmitter implements Signer {
   constructor(params: NostrParams) {
     super();
     this.params = params;
-    this.ndk = new NDK({
-      enableOutboxModel: false,
-    });
 
-    this.profileNdk = new NDK({
-      enableOutboxModel: true,
-      explicitRelayUrls: OUTBOX_RELAYS,
-    });
-    this.profileNdk.connect();
+    this.rxNostr = createRxNostr({} as any);
+    // Default relays for initial connection if needed, though they are usually set per-action
+    // @ts-ignore
+    this.rxNostr.switchRelays(DEFAULT_NIP46_RELAYS);
 
     this.nip04 = {
       encrypt: this.encrypt04.bind(this),
@@ -81,30 +82,30 @@ class AuthNostrService extends EventEmitter implements Signer {
     };
   }
 
-  public isIframe() {
+  public isIframe(): boolean {
     return !!this.iframe;
   }
 
-  public async waitReady() {
+  public async waitReady(): Promise<void> {
     if (this.signerPromise) {
       try {
         await this.signerPromise;
-      } catch {}
+      } catch { }
     }
 
     if (this.readyPromise) {
       try {
         await this.readyPromise;
-      } catch {}
+      } catch { }
     }
   }
 
-  public cancelNostrConnect() {
+  public cancelNostrConnect(): void {
     this.releaseSigner();
     this.resetAuth();
   }
 
-  public cancelSignerInit() {
+  public cancelSignerInit(): void {
     if (this.signerAbortController) {
       this.signerAbortController.abort();
       this.signerAbortController = undefined;
@@ -133,7 +134,7 @@ class AuthNostrService extends EventEmitter implements Signer {
       iframeUrl?: string;
       customRelays?: string[];
     } = {},
-  ) {
+  ): Promise<Info> {
     // カスタムリレーが指定されていれば使用、そうでなければ単一リレーまたはデフォルト
     const relays = customRelays && customRelays.length > 0 ? customRelays : relay ? [relay] : DEFAULT_NIP46_RELAYS;
 
@@ -168,11 +169,13 @@ class AuthNostrService extends EventEmitter implements Signer {
     return info;
   }
 
-  public async createNostrConnect() {
-    this.nostrConnectKey = generatePrivateKey();
+  public async createNostrConnect(): Promise<string> {
+    const skBytes = generateSecretKey();
+    // @ts-ignore
+    this.nostrConnectKey = bytesToHex(skBytes);
     this.nostrConnectSecret = Math.random().toString(36).substring(7);
 
-    const pubkey = getPublicKey(this.nostrConnectKey);
+    const pubkey = getPublicKey(skBytes);
     const meta = {
       name: encodeURIComponent(document.location.host),
       url: encodeURIComponent(document.location.origin),
@@ -229,10 +232,14 @@ class AuthNostrService extends EventEmitter implements Signer {
     return [nostrconnect, apps];
   }
 
-  public async localSignup(name: string, sk?: string) {
+  public async localSignup(name: string, sk?: string): Promise<void> {
     const signup = !sk;
-    sk = sk || generatePrivateKey();
-    const pubkey = getPublicKey(sk);
+    if (!sk) {
+      const skBytes = generateSecretKey();
+      sk = bytesToHex(skBytes);
+    }
+    // @ts-ignore
+    const pubkey = getPublicKey(hexToBytes(sk!));
     const info: Info = {
       pubkey,
       sk,
@@ -243,25 +250,118 @@ class AuthNostrService extends EventEmitter implements Signer {
     await this.setLocal(info, signup);
   }
 
-  public async setLocal(info: Info, signup?: boolean) {
+  public async setLocal(info: Info, signup?: boolean): Promise<void> {
     this.releaseSigner();
-    this.localSigner = new PrivateKeySigner(info.sk!);
+    this.localSigner = new PrivateKeySigner(hexToBytes(info.sk!));
 
-    if (signup) await createProfile(info, this.profileNdk, this.localSigner, this.params.optionsModal.signupRelays, this.params.optionsModal.outboxRelays);
+    // TODO: nostr-toolsを使用するようにcreateProfileをリファクタリングする
+    if (signup) {
+      await createProfile(info, this.rxNostr, this.localSigner, this.params.optionsModal.signupRelays, this.params.optionsModal.outboxRelays);
+    }
 
     this.onAuth(signup ? 'signup' : 'login', info);
   }
 
-  public prepareImportUrl(url: string) {
+  public prepareImportUrl(url: string): string {
     // for OTP we choose interactive import
     if (this.params.userInfo?.authMethod === 'otp') return url + '&import=true';
 
     // for local we export our existing key
     if (!this.localSigner || this.params.userInfo?.authMethod !== 'local') throw new Error('Most be local keys');
-    return url + '#import=' + nip19.nsecEncode(this.localSigner.privateKey!);
+    // Ensure privateKey is Uint8Array for nsecEncode if needed, but nip19.nsecEncode usually takes Uint8Array
+    const skBytes = this.localSigner.privateKey!;
+    return url + '#import=' + nip19.nsecEncode(skBytes);
+  }
+
+  // リレー管理メソッド
+  public getRelayStatus(): Record<string, string> {
+    const status = this.rxNostr.getAllRelayStatus();
+    const result: Record<string, string> = {};
+    for (const [url, state] of Object.entries(status)) {
+      result[url] = String(state);
+    }
+    return result;
+  }
+
+  public getRelayStats(): {
+    total: number;
+    connected: number;
+    connecting: number;
+    disconnected: number;
+    error: number;
+  } {
+    const status = this.rxNostr.getAllRelayStatus();
+    const stats = {
+      total: 0,
+      connected: 0,
+      connecting: 0,
+      disconnected: 0,
+      error: 0,
+    };
+
+    for (const state of Object.values(status)) {
+      stats.total++;
+      const stateStr = String(state).toLowerCase();
+      if (stateStr === 'connected') stats.connected++;
+      else if (stateStr === 'connecting') stats.connecting++;
+      else if (stateStr === 'error') stats.error++;
+      else stats.disconnected++;
+    }
+
+    return stats;
+  }
+
+  public async connectToRelay(relayUrl: string): Promise<void> {
+    try {
+      this.rxNostr.reconnect(relayUrl);
+      console.log(`Connecting to relay: ${relayUrl}`);
+    } catch (error) {
+      console.error(`Failed to connect to relay ${relayUrl}:`, error);
+      throw error;
+    }
+  }
+
+  public async disconnectFromRelay(relayUrl: string): Promise<void> {
+    try {
+      // rx-nostrにはdisconnect APIがないため、リレーリストから除外する方法を使用
+      const currentRelays = Object.keys(this.rxNostr.getAllRelayStatus());
+      const newRelays = currentRelays.filter(url => url !== relayUrl);
+      if (newRelays.length > 0) {
+        // @ts-ignore
+        this.rxNostr.switchRelays(newRelays);
+      }
+      console.log(`Disconnected from relay: ${relayUrl}`);
+    } catch (error) {
+      console.error(`Failed to disconnect from relay ${relayUrl}:`, error);
+      throw error;
+    }
+  }
+
+  public async reconnectAllRelays(): Promise<void> {
+    try {
+      const relays = Object.keys(this.rxNostr.getAllRelayStatus());
+      console.log(`Reconnecting to ${relays.length} relays...`);
+
+      for (const relay of relays) {
+        try {
+          this.rxNostr.reconnect(relay);
+        } catch (error) {
+          console.warn(`Failed to reconnect to ${relay}:`, error);
+        }
+      }
+    } catch (error) {
+      console.error('Failed to reconnect all relays:', error);
+      throw error;
+    }
   }
 
-  public async importAndConnect(cs: ConnectionString) {
+  public async checkRelayHealth(): Promise<boolean> {
+    const stats = this.getRelayStats();
+    // 少なくとも1つのリレーが接続されていればOK
+    return stats.connected > 0;
+  }
+
+  public async importAndConnect(cs: ConnectionString): Promise<void> {
     const { relay, domain, link, iframeUrl } = cs;
     if (!domain) throw new Error('Domain required');
 
@@ -278,22 +378,22 @@ class AuthNostrService extends EventEmitter implements Signer {
     this.onAuth('login', info);
   }
 
-  public setReadOnly(pubkey: string) {
+  public setReadOnly(pubkey: string): void {
     const info: Info = { pubkey, authMethod: 'readOnly' };
     this.onAuth('login', info);
   }
 
-  public setExtension(pubkey: string) {
+  public setExtension(pubkey: string): void {
     const info: Info = { pubkey, authMethod: 'extension' };
     this.onAuth('login', info);
   }
 
-  public setOTP(pubkey: string, data: string) {
+  public setOTP(pubkey: string, data: string): void {
     const info: Info = { pubkey, authMethod: 'otp', otpData: data };
     this.onAuth('login', info);
   }
 
-  public async setConnect(info: Info) {
+  public async setConnect(info: Info): Promise<void> {
     this.releaseSigner();
     await this.startAuth();
     await this.initSigner(info);
@@ -301,7 +401,7 @@ class AuthNostrService extends EventEmitter implements Signer {
     await this.endAuth();
   }
 
-  public async createAccount(nip05: string) {
+  public async createAccount(nip05: string): Promise<{ bunkerUrl: string; sk: string | undefined }> {
     const [name, domain] = nip05.split('@');
 
     // bunker's own url
@@ -325,18 +425,19 @@ class AuthNostrService extends EventEmitter implements Signer {
     };
   }
 
-  private releaseSigner() {
+  private releaseSigner(): void {
     this.signer = null;
     this.signerErrCallback?.('cancelled');
     this.localSigner = null;
 
     // disconnect from signer relays
-    for (const r of this.ndk.pool.relays.keys()) {
-      this.ndk.pool.removeRelay(r);
-    }
+    // rx-nostr manages relays, we can switch to empty or default if needed
+    // or just leave them be as they might be reused?
+    // For now, let's just clear the signer instance.
+    // this.rxNostr.switchRelays([]); // Should we disconnect? Maybe better to keep connection for next signer?
   }
 
-  public async logout(keepSigner = false) {
+  public async logout(keepSigner = false): Promise<void> {
     if (!keepSigner) this.releaseSigner();
 
     // move current to recent
@@ -348,7 +449,7 @@ class AuthNostrService extends EventEmitter implements Signer {
     this.emit('updateAccounts');
   }
 
-  private setUserInfo(userInfo: Info | null) {
+  private setUserInfo(userInfo: Info | null): void {
     this.params.userInfo = userInfo;
     this.emit('onUserInfo', userInfo);
 
@@ -358,13 +459,14 @@ class AuthNostrService extends EventEmitter implements Signer {
     }
   }
 
-  public exportKeys() {
+  public exportKeys(): string {
     if (!this.params.userInfo) return '';
     if (this.params.userInfo.authMethod !== 'local') return '';
-    return nip19.nsecEncode(this.params.userInfo.sk!);
+    const skBytes = hexToBytes(this.params.userInfo.sk!);
+    return nip19.nsecEncode(skBytes);
   }
 
-  private onAuth(type: 'login' | 'signup' | 'logout', info: Info | null = null) {
+  private onAuth(type: 'login' | 'signup' | 'logout', info: Info | null = null): void {
     if (type !== 'logout' && !info) throw new Error('No user info in onAuth');
 
     // make sure we emulate logout first
@@ -378,7 +480,8 @@ class AuthNostrService extends EventEmitter implements Signer {
 
     if (info) {
       // async profile fetch
-      fetchProfile(info, this.profileNdk).then(p => {
+      // TODO: nostr-toolsを使用するようにfetchProfileをリファクタリングする
+      fetchProfile(info, this.rxNostr as any).then(p => {
         if (this.params.userInfo !== info) return;
 
         const userInfo = {
@@ -411,7 +514,7 @@ class AuthNostrService extends EventEmitter implements Signer {
         options.name = info!.name;
 
         if (info!.sk) {
-          options.localNsec = nip19.nsecEncode(info!.sk);
+          options.localNsec = nip19.nsecEncode(hexToBytes(info!.sk));
         }
 
         if (info!.relays) {
@@ -437,7 +540,7 @@ class AuthNostrService extends EventEmitter implements Signer {
     }
   }
 
-  private async createIframe(iframeUrl?: string) {
+  private async createIframe(iframeUrl?: string): Promise<{ iframe: HTMLIFrameElement; port: MessagePort } | undefined> {
     if (!iframeUrl) return undefined;
 
     // ensure iframe
@@ -496,18 +599,18 @@ class AuthNostrService extends EventEmitter implements Signer {
   //   }
   // }
 
-  public async sendNeedAuth() {
+  public async sendNeedAuth(): Promise<void> {
     const [nostrconnect] = await this.getNostrConnectServices();
     const event = new CustomEvent('nlNeedAuth', { detail: { nostrconnect } });
     console.log('nostr-login need auth', nostrconnect);
     document.dispatchEvent(event);
   }
 
-  public isAuthing() {
+  public isAuthing(): boolean {
     return !!this.readyCallback;
   }
 
-  public async startAuth() {
+  public async startAuth(): Promise<void> {
     console.log('startAuth');
     if (this.readyCallback) throw new Error('Already started');
 
@@ -515,7 +618,7 @@ class AuthNostrService extends EventEmitter implements Signer {
     this.readyPromise = new Promise<void>(ok => (this.readyCallback = ok));
   }
 
-  public async endAuth() {
+  public async endAuth(): Promise<void> {
     console.log('endAuth', this.params.userInfo);
     if (this.params.userInfo && this.params.userInfo.iframeUrl) {
       // create iframe
@@ -531,28 +634,28 @@ class AuthNostrService extends EventEmitter implements Signer {
     this.readyCallback = undefined;
   }
 
-  public resetAuth() {
+  public resetAuth(): void {
     if (this.readyCallback) this.readyCallback();
     this.readyCallback = undefined;
   }
 
-  private async listen(info: Info) {
+  private async listen(info: Info): Promise<void> {
     if (!info.iframeUrl) return this.signer!.listen(this.nostrConnectSecret);
     const r = await this.starterReady!.wait();
     if (r[0] === 'starterError') throw new Error(r[1]);
     return this.signer!.setListenReply(r[1], this.nostrConnectSecret);
   }
 
-  public async connect(info: Info, perms?: string) {
+  public async connect(info: Info, perms?: string): Promise<void> {
     return this.signer!.connect(info.token, perms);
   }
 
-  public async initSigner(info: Info, { listen = false, connect = false, eventToAddAccount = false } = {}) {
+  public async initSigner(info: Info, { listen = false, connect = false, eventToAddAccount = false } = {}): Promise<void> {
     // mutex
     if (this.signerPromise) {
       try {
         await this.signerPromise;
-      } catch {}
+      } catch { }
     }
 
     // we remove support for iframe from nip05 and bunker-url methods,
@@ -593,22 +696,28 @@ class AuthNostrService extends EventEmitter implements Signer {
     return this.signerPromise;
   }
 
-  private async initSignerInternal(info: Info, listen: boolean, connect: boolean, eventToAddAccount: boolean, resolve: () => void) {
+  private async initSignerInternal(info: Info, listen: boolean, connect: boolean, eventToAddAccount: boolean, resolve: () => void): Promise<void> {
     // pre-connect if we're creating the connection (listen|connect) or
     // not iframe mode
     if (info.relays && !info.iframeUrl) {
-      for (const r of info.relays) {
-        this.ndk.addExplicitRelay(r, undefined);
-      }
+      // @ts-ignore
+      this.rxNostr.switchRelays(info.relays);
     }
 
-    // wait until we connect, otherwise
-    // signer won't start properly
-    await this.ndk.connect();
+    // rx-nostr connects automatically
 
     // create and prepare the signer
-    const localSigner = new PrivateKeySigner(info.sk!);
-    this.signer = new Nip46Signer(this.ndk, localSigner, info.signerPubkey!, info.iframeUrl ? new URL(info.iframeUrl!).origin : undefined);
+    const localSigner = new PrivateKeySigner(hexToBytes(info.sk!));
+
+    // TODO: 元のNDKロジック:
+    // This initialized the Nip46Signer with NDK instance.
+    //
+    // New Implementation Plan:
+    // 1. Pass the SimplePool instance or relay list to Nip46Signer.
+    // 2. Nip46Signer should manage its own connection or use the shared pool to publish/subscribe.
+
+    // TODO: ndk引数を削除する
+    this.signer = new Nip46Signer(this.rxNostr, localSigner, info.signerPubkey!, info.iframeUrl ? new URL(info.iframeUrl!).origin : undefined);
 
     // we should notify the banner the same way as
     // the onAuthUrl does
@@ -660,7 +769,7 @@ class AuthNostrService extends EventEmitter implements Signer {
       iframeUrl = '',
       customRelays,
     }: { name: string; bunkerUrl: string; sk?: string; domain?: string; iframeUrl?: string; customRelays?: string[] },
-  ) {
+  ): Promise<void> {
     try {
       const info = bunkerUrlToInfo(bunkerUrl, sk);
       if (isBunkerUrl(name)) info.bunkerUrl = name;
@@ -697,8 +806,9 @@ class AuthNostrService extends EventEmitter implements Signer {
     }
   }
 
-  public async signEvent(event: any) {
+  public async signEvent(event: any): Promise<any> {
     if (this.localSigner) {
+      // this.localSigner.privateKey is Uint8Array
       event.pubkey = getPublicKey(this.localSigner.privateKey!);
       event.id = getEventHash(event);
       event.sig = await this.localSigner.sign(event);
@@ -713,11 +823,12 @@ class AuthNostrService extends EventEmitter implements Signer {
     return event;
   }
 
-  private async ensureSigner() {
+  private async ensureSigner(): Promise<void> {
     // signerがキャンセル等で破棄されている場合は再初期化
     if (!this.signer && this.params.userInfo) {
       console.log('Signer was destroyed, reinitializing...');
       await this.initSigner(this.params.userInfo);
+      return; // initSignerで接続も行われるので終了
     }
 
     if (!this.signer) {
@@ -725,87 +836,76 @@ class AuthNostrService extends EventEmitter implements Signer {
     }
 
     // リレー接続を確認・再接続
-    const stats = this.ndk.pool.stats();
-    console.log('NDK pool stats:', stats);
-    
-    if (stats.connected === 0) {
-      console.log('NDK relays disconnected, forcing reconnection...');
-      
-      // 既存のリレーを一度切断してから再接続
-      for (const relay of this.ndk.pool.relays.values()) {
-        try {
-          relay.disconnect();
-        } catch (e) {
-          console.log('Error disconnecting relay:', e);
-        }
-      }
-      
-      // 少し待ってから再接続
-      await new Promise(resolve => setTimeout(resolve, 100));
-      await this.ndk.connect();
-      
-      // 接続を待つ
-      await new Promise(resolve => setTimeout(resolve, 500));
-      
-      const newStats = this.ndk.pool.stats();
-      console.log('NDK pool stats after reconnect:', newStats);
-      
-      if (newStats.connected === 0) {
-        throw new Error('Failed to reconnect to relays');
+    // TODO: 元のNDKロジック:
+    // Checks ndk.pool.stats() for connectivity.
+    //
+    // New Implementation Plan:
+    // 1. Iterate through SimplePool.relays or listConnectionStatus().
+    // 2. If no relays are connected, modify code to reconnect.
+
+    // TODO: rx-nostrの統計を確認する
+    // const stats = this.pool.listConnectionStatus();
+    // const stats = this.pool.listConnectionStatus();
+    // const stats = this.ndk.pool.stats();
+    // console.log('NDK pool stats:', stats);
+    const relayStates = this.rxNostr.getAllRelayStatus();
+    const connectedCount = Object.values(relayStates).filter(s => String(s) === 'connected').length;
+
+    if (connectedCount === 0) {
+      console.log('RxNostr relays disconnected, reinitializing signer...');
+
+      // リレーが完全に切断されている場合、signerも再初期化する必要がある
+      // （RPCサブスクリプションも切断されているため）
+      if (this.params.userInfo) {
+        // 古いsignerを破棄
+        this.signer = null;
+
+        // 既存のリレーを一度切断 (rx-nostr reconnects automatically, but we might want to force it)
+        this.rxNostr.reconnect(Object.keys(relayStates)[0]);
+
+        // signerを再初期化（リレー接続も含む）
+        await this.initSigner(this.params.userInfo);
+      } else {
+        throw new Error('Cannot reconnect: no user info');
       }
     }
   }
 
-  private async codec_call(method: string, pubkey: string, param: string) {
-    return new Promise<string>((resolve, reject) => {
-      this.signer!.rpc.sendRequest(this.signer!.remotePubkey!, method, [pubkey, param], 24133, (response: NDKRpcResponse) => {
-        if (!response.error) {
-          resolve(response.result);
-        } else {
-          reject(response.error);
-        }
-      });
-    });
-  }
 
-  public async encrypt04(pubkey: string, plaintext: string) {
+
+  public async encrypt04(pubkey: string, plaintext: string): Promise<string> {
     if (this.localSigner) {
-      return this.localSigner.encrypt(new NDKUser({ pubkey }), plaintext);
+      return this.localSigner.encrypt(pubkey as any, plaintext);
     } else {
       await this.ensureSigner();
-      return this.signer!.encrypt(new NDKUser({ pubkey }), plaintext);
+      return this.signer!.encrypt(pubkey, plaintext);
     }
   }
 
-  public async decrypt04(pubkey: string, ciphertext: string) {
+  public async decrypt04(pubkey: string, ciphertext: string): Promise<string> {
     if (this.localSigner) {
-      return this.localSigner.decrypt(new NDKUser({ pubkey }), ciphertext);
+      return this.localSigner.decrypt(pubkey as any, ciphertext);
     } else {
-      // decrypt is broken in ndk v2.3.1, and latest
-      // ndk v2.8.1 doesn't allow to override connect easily,
-      // so we reimplement and fix decrypt here as a temporary fix
       await this.ensureSigner();
-      return this.codec_call('nip04_decrypt', pubkey, ciphertext);
+      return this.signer!.decrypt(pubkey, ciphertext);
     }
   }
 
-  public async encrypt44(pubkey: string, plaintext: string) {
+  public async encrypt44(pubkey: string, plaintext: string): Promise<string> {
     if (this.localSigner) {
       return this.nip44Codec.encrypt(this.localSigner.privateKey!, pubkey, plaintext);
     } else {
-      // no support of nip44 in ndk yet
       await this.ensureSigner();
-      return this.codec_call('nip44_encrypt', pubkey, plaintext);
+      return this.signer!.encryptNip44(pubkey, plaintext);
     }
   }
 
-  public async decrypt44(pubkey: string, ciphertext: string) {
+  public async decrypt44(pubkey: string, ciphertext: string): Promise<string> {
     if (this.localSigner) {
       return this.nip44Codec.decrypt(this.localSigner.privateKey!, pubkey, ciphertext);
     } else {
-      // no support of nip44 in ndk yet
       await this.ensureSigner();
-      return this.codec_call('nip44_decrypt', pubkey, ciphertext);
+      return this.signer!.decryptNip44(pubkey, ciphertext);
     }
   }
 }

package/src/modules/ModalManager.ts

@@ -1,5 +1,5 @@
 import { NostrLoginOptions, StartScreens, TypeModal } from '../types';
-import { checkNip05, getBunkerUrl, getDarkMode, localStorageRemoveRecent, localStorageSetItem, prepareSignupRelays } from '../utils';
+import { checkNip05, getBunkerUrl, getDarkMode, localStorageRemoveRecent, localStorageSetItem, prepareSignupRelays, bytesToHex } from '../utils';
 import { AuthNostrService, NostrExtensionService, NostrParams } from '.';
 import { EventEmitter } from 'tseep';
 import { ConnectionString, Info, RecentType } from 'nostr-login-components/dist/types/types';
@@ -28,7 +28,7 @@ class ModalManager extends EventEmitter {
     if (this.launcherPromise) {
       try {
         await this.launcherPromise;
-      } catch {}
+      } catch { }
       this.launcherPromise = undefined;
     }
   }
@@ -281,7 +281,7 @@ class ModalManager extends EventEmitter {
                   throw new Error('Bad nsec value');
                 }
                 if (decoded.type !== 'nsec') throw new Error('Bad bech32 type');
-                await this.authNostrService.localSignup('', decoded.data);
+                await this.authNostrService.localSignup('', bytesToHex(decoded.data));
                 ok();
               } else if (nsecOrBunker.startsWith('bunker:')) {
                 await this.authNostrService.authNip46('login', { name: '', bunkerUrl: nsecOrBunker });