@konemono/nostr-login 1.11.0 → 1.11.3

package/src/modules/Nip46.ts

@@ -1,138 +1,58 @@
-import { createRxForwardReq, createRxNostr, RxNostr } from 'rx-nostr';
-import { EventEmitter } from 'tseep';
-import { validateEvent, verifyEvent, type Event as NostrEventSDK } from 'nostr-tools';
+import NDK, { NDKEvent, NDKFilter, NDKNip46Signer, NDKNostrRpc, NDKRpcRequest, NDKRpcResponse, NDKSubscription, NDKSubscriptionCacheUsage, NDKUser, NostrEvent } from '@nostr-dev-kit/ndk';
+import { validateEvent, verifySignature } from 'nostr-tools';
 import { PrivateKeySigner } from './Signer';
 import { NIP46_REQUEST_TIMEOUT, NIP46_CONNECT_TIMEOUT } from '../const';
+import { EventEmitter } from 'events';
 
+// タイムアウト付きPromiseラッパー
 function withTimeout<T>(promise: Promise<T>, timeoutMs: number, errorMessage: string): Promise<T> {
   return Promise.race([promise, new Promise<T>((_, reject) => setTimeout(() => reject(new Error(errorMessage)), timeoutMs))]);
 }
-// nostr-toolsに基づく厳格な型定義
-type NostrFilter = {
-  ids?: string[];
-  kinds?: number[];
-  authors?: string[];
-  since?: number;
-  until?: number;
-  limit?: number;
-  search?: string;
-  [key: `#${string}`]: string[] | undefined; // タグフィルター (#e, #p, etc.)
-};
-
-type NostrEvent = {
-  id?: string;
-  kind: number;
-  pubkey: string;
-  content: string;
-  tags: string[][];
-  created_at: number;
-  sig?: string;
-};
-
-type NostrSubscription = {
-  on: (event: string, cb: any) => void;
-  stop: () => void;
-};
-
-type NDKRpcResponse = {
-  id: string;
-  pubkey: string;
-  content: string;
-  result?: string;
-  error?: string;
-  [key: string]: any;
-};
-
-type NDKRpcRequest = {
-  id: string;
-  pubkey: string;
-  method: string;
-  params: any[];
-  [key: string]: any;
-};
-
-// Helper to wrap rx-nostr subscription
-class RxReqAdapter extends EventEmitter {
-  private sub: any;
-  constructor(rxNostr: RxNostr, filters: NostrFilter[], relays?: string[]) {
-    super();
-    const req = createRxForwardReq();
-    this.sub = rxNostr.use(req).subscribe((packet) => {
-      this.emit('event', packet.event);
-    });
-    // If relays are provided, we might want to ensure they are used?
-    // rx-nostr manages relays globally usually, but we can set default relays in the instance.
-    req.emit(filters as any);
-  }
-  stop() {
-    this.sub.unsubscribe();
-  }
-}
 
-// TODO: NDKの継承を削除する
-class NostrRpc extends EventEmitter {
-  public rxNostr: RxNostr;
+class NostrRpc extends NDKNostrRpc {
+  protected _ndk: NDK;
   protected _signer: PrivateKeySigner;
   protected requests: Set<string> = new Set();
-  // private sub?: NDKSubscription;
-  private sub?: RxReqAdapter;
+  private sub?: NDKSubscription;
   protected _useNip44: boolean = false;
-  private reconnectAttempts: number = 0;
-  private maxReconnectAttempts: number = 3;
-  private reconnectDelay: number = 2000;
+  private eventEmitter: EventEmitter = new EventEmitter();
 
-  public constructor(rxNostr: RxNostr, signer: PrivateKeySigner) {
-    super();
-    this.rxNostr = rxNostr;
+  public constructor(ndk: NDK, signer: PrivateKeySigner) {
+    super(ndk, signer, ndk.debug.extend('nip46:signer:rpc'));
+    this._ndk = ndk;
     this._signer = signer;
-    this.setupConnectionMonitoring();
   }
 
-  public async subscribe(filter: NostrFilter): Promise<NostrSubscription> {
-    const f: any = { ...filter };
-    if (f.kinds) {
-      f.kinds = f.kinds.filter((k: number) => k === 24133);
-    }
-
-    this.sub = new RxReqAdapter(this.rxNostr, [f]);
+  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(): void {
+  public stop() {
     if (this.sub) {
       this.sub.stop();
       this.sub = undefined;
     }
   }
 
-  public setUseNip44(useNip44: boolean): void {
+  public setUseNip44(useNip44: boolean) {
     this._useNip44 = useNip44;
   }
 
-  private isNip04(ciphertext: string): boolean {
+  private isNip04(ciphertext: string) {
     const l = ciphertext.length;
     if (l < 28) return false;
     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: NostrEvent): Promise<any> {
-    // TODO: 元のNDKロジック:
-    // 1. NDKUser.from(event.pubkey) to get remote user.
-    // 2. Check content for NIP-04 pattern (?iv=...).
-    // 3. Call signer.decrypt(remoteUser, content) or signer.decryptNip44(remoteUser, content).
-    //
-    // New Implementation Plan:
-    // 1. Use direct NIP-04/NIP-44 decryption functions from local signer.
-    // 2. Pass event.pubkey (string) instead of NDKUser object.
-
-    // const remoteUser = this._ndk.getUser({ pubkey: event.pubkey });
-    // remoteUser.ndk = this._ndk;
-
+  public async parseEvent(event: NDKEvent): Promise<NDKRpcRequest | NDKRpcResponse> {
+    const remoteUser = this._ndk.getUser({ pubkey: event.pubkey });
+    remoteUser.ndk = this._ndk;
     const decrypt = this.isNip04(event.content) ? this._signer.decrypt : this._signer.decryptNip44;
-
-    // NOTE: We need to adjust _signer.decrypt signature to accept string pubkey
-    const decryptedContent = await decrypt.call(this._signer, event.pubkey as any, event.content);
+    const decryptedContent = await decrypt.call(this._signer, remoteUser, event.content);
     const parsedContent = JSON.parse(decryptedContent);
     const { id, method, params, result, error } = parsedContent;
 
@@ -143,8 +63,8 @@ class NostrRpc extends EventEmitter {
     }
   }
 
-  public async parseNostrConnectReply(reply: any, secret: string): Promise<string> {
-    const event = reply as NostrEvent;
+  public async parseNostrConnectReply(reply: any, secret: string) {
+    const event = new NDKEvent(this._ndk, reply);
     const parsedEvent = await this.parseEvent(event);
     console.log('nostr connect parsedEvent', parsedEvent);
     if (!(parsedEvent as NDKRpcRequest).method) {
@@ -160,15 +80,14 @@ class NostrRpc extends EventEmitter {
   // 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> {
-    // TODO: rx-nostrを使用して実装する
     const pubkey = this._signer.pubkey;
     console.log('nostr-login listening for conn to', pubkey);
     const sub = await this.subscribe({
       'kinds': [24133],
       '#p': [pubkey],
-    } as any); // Cast to any because RxReqAdapter expects NostrFilter but we pass explicit strict filters that might differ slightly in type def
+    });
     return new Promise<string>((ok, err) => {
-      sub.on('event', async (event: NostrEvent) => {
+      sub.on('event', async (event: NDKEvent) => {
         try {
           const parsedEvent = await this.parseEvent(event);
           // console.log('ack parsedEvent', parsedEvent);
@@ -187,7 +106,7 @@ class NostrRpc extends EventEmitter {
             }
           }
         } catch (e) {
-          console.log('error parsing event', e, (event as any).rawEvent?.());
+          console.log('error parsing event', e, event.rawEvent());
         }
         // done
         this.stop();
@@ -198,8 +117,7 @@ class NostrRpc extends EventEmitter {
   // 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): Promise<void> {
-    // TODO: nostr-toolsを使用して実装する
+  public async connect(pubkey: string, token?: string, perms?: string) {
     return new Promise<void>((ok, err) => {
       const connectParams = [pubkey!, token || '', perms || ''];
       this.sendRequest(pubkey!, 'connect', connectParams, 24133, (response: NDKRpcResponse) => {
@@ -217,125 +135,22 @@ class NostrRpc extends EventEmitter {
     return withTimeout(this.connect(pubkey, token, perms), timeoutMs, `Connection timeout after ${timeoutMs}ms`);
   }
 
-  // タイムアウト対応のsendRequest
-  public async sendRequestWithTimeout(
-    remotePubkey: string,
-    method: string,
-    params: string[] = [],
-    kind = 24133,
-    timeoutMs: number = NIP46_REQUEST_TIMEOUT,
-  ): Promise<NDKRpcResponse> {
-    return withTimeout(
-      new Promise<NDKRpcResponse>((resolve, reject) => {
-        this.sendRequest(remotePubkey, method, params, kind, response => {
-          if (response.error) {
-            reject(new Error(response.error));
-          } else {
-            resolve(response);
-          }
-        });
-      }),
-      timeoutMs,
-      `Request timeout after ${timeoutMs}ms for method: ${method}`,
-    );
-  }
-
-  // 接続監視のセットアップ
-  private setupConnectionMonitoring(): void {
-    // アプリがフォアグラウンドに戻ったときの処理
-    if (typeof document !== 'undefined') {
-      document.addEventListener('visibilitychange', async () => {
-        if (document.visibilityState === 'visible') {
-          console.log('App visible, checking relay connections...');
-          await this.ensureConnected();
+  // ping実装
+  public async ping(remotePubkey: string): Promise<void> {
+    return new Promise<void>((ok, err) => {
+      this.sendRequest(remotePubkey, 'ping', [], 24133, (response: NDKRpcResponse) => {
+        if (response.result === 'pong') {
+          ok();
+        } else {
+          err(new Error(response.error || 'ping failed'));
         }
       });
-    }
-
-    // オンライン/オフライン検知
-    if (typeof window !== 'undefined') {
-      window.addEventListener('online', async () => {
-        console.log('Network online, reconnecting relays...');
-        await this.reconnect();
-      });
-    }
-
-    // 定期的な接続状態チェック（オプション）
-    setInterval(() => {
-      const stats = this.rxNostr.getAllRelayStatus();
-      const connected = Object.values(stats).filter(s => String(s) === 'connected').length;
-      if (connected === 0) {
-        console.warn('No relays connected, triggering reconnection...');
-        this.ensureConnected();
-      }
-    }, 60000); // 60秒ごとにチェック
-  }
-
-  // 接続を確認して必要なら再接続
-  private async ensureConnected(): Promise<void> {
-    const states = this.rxNostr.getAllRelayStatus();
-    const connectedRelays = Object.values(states).filter(s => String(s) === 'connected');
-
-    if (connectedRelays.length === 0) {
-      console.log('No connected relays, attempting reconnection...');
-      await this.reconnect();
-    }
+    });
   }
 
-  // 再接続処理（指数バックオフ付き）
-  protected async reconnect(): Promise<void> {
-    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
-      console.error('Max reconnection attempts reached');
-      this.emit('reconnectFailed');
-      return;
-    }
-
-    this.reconnectAttempts++;
-    console.log(`Reconnection attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts}`);
-
-    try {
-      // サブスクリプションを停止
-      if (this.sub) {
-        this.sub.stop();
-      }
-
-      // 指数バックオフ: 2^attempt * baseDelay (最大30秒)
-      const backoffDelay = Math.min(
-        this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1),
-        30000
-      );
-      console.log(`Waiting ${backoffDelay}ms before reconnection...`);
-      await new Promise(resolve => setTimeout(resolve, backoffDelay));
-
-      // 全リレーに再接続を試みる
-      const relays = Object.keys(this.rxNostr.getAllRelayStatus());
-      if (relays.length > 0) {
-        for (const relay of relays) {
-          try {
-            this.rxNostr.reconnect(relay);
-            console.log(`Reconnected to ${relay}`);
-          } catch (error) {
-            console.warn(`Failed to reconnect to ${relay}:`, error);
-          }
-        }
-      }
-
-      // 再接続成功後、カウンターをリセット
-      setTimeout(() => {
-        const states = this.rxNostr.getAllRelayStatus();
-        const connected = Object.values(states).filter(s => String(s) === 'connected').length;
-        if (connected > 0) {
-          console.log('Reconnection successful, resetting attempt counter');
-          this.reconnectAttempts = 0;
-          this.emit('reconnected');
-        }
-      }, 2000);
-    } catch (error) {
-      console.error('Reconnection error:', error);
-      this.emit('reconnectError', error);
-      // 次の再接続を試みる
-      setTimeout(() => this.reconnect(), this.reconnectDelay);
-    }
+  // タイムアウト対応のping
+  public async pingWithTimeout(remotePubkey: string, timeoutMs: number = 10000): Promise<void> {
+    return withTimeout(this.ping(remotePubkey), timeoutMs, `Ping timeout after ${timeoutMs}ms`);
   }
 
   protected getId(): string {
@@ -353,11 +168,7 @@ class NostrRpc extends EventEmitter {
     console.log('sendRequest', { event, method, remotePubkey, params });
 
     // send to relays
-    // await event.publish();
-    this.rxNostr.send(event).subscribe({
-      error: (err) => console.error('Nip46 publish error', err),
-      complete: () => console.log('Nip46 publish complete')
-    });
+    await event.publish();
 
     // NOTE: ndk returns a promise that never resolves and
     // in fact REQUIRES cb to be provided (otherwise no way
@@ -368,17 +179,16 @@ class NostrRpc extends EventEmitter {
     return undefined as NDKRpcResponse;
   }
 
-  protected setResponseHandler(id: string, cb?: (res: NDKRpcResponse) => void): Promise<NDKRpcResponse> {
-    // TODO: 再実装する
+  protected setResponseHandler(id: string, cb?: (res: NDKRpcResponse) => void) {
     let authUrlSent = false;
     const now = Date.now();
     return new Promise<NDKRpcResponse>(() => {
       const responseHandler = (response: NDKRpcResponse) => {
         if (response.result === 'auth_url') {
-          this.once(`response-${id}`, responseHandler);
+          this.eventEmitter.once(`response-${id}`, responseHandler);
           if (!authUrlSent) {
             authUrlSent = true;
-            this.emit('authUrl', response.error);
+            this.eventEmitter.emit('authUrl', response.error);
           }
         } else if (cb) {
           if (this.requests.has(id)) {
@@ -389,108 +199,76 @@ class NostrRpc extends EventEmitter {
         }
       };
 
-      this.once(`response-${id}`, responseHandler);
+      this.eventEmitter.once(`response-${id}`, responseHandler);
     });
   }
 
-  protected async createRequestEvent(id: string, remotePubkey: string, method: string, params: string[] = [], kind = 24133): Promise<NostrEvent> {
-    // TODO: 元のNDKロジック:
-    // const event = new NDKEvent(this._ndk, { ... });
-    // await event.sign(this._signer);
-    //
-    // New Implementation Plan:
-    // 1. Create a plain event object:
-    //    { kind, content, tags, pubkey, created_at: Math.floor(Date.now()/1000) }
-    // 2. Encrypt content:
-    //    if (useNip44) await signer.encryptNip44(remotePubkey, content)
-    //    else await signer.encrypt(remotePubkey, content)
-    // 3. Sign:
-    //    event.id = getEventHash(event)
-    //    event.sig = await signer.signEvent(event)
-    // 4. Return the signed event object.
-
+  protected async createRequestEvent(id: string, remotePubkey: string, method: string, params: string[] = [], kind = 24133) {
     this.requests.add(id);
-    const localUser = await this._signer.user(); // TODO: signerプロパティから取得する
-    // const remoteUser = this._ndk.getUser({ pubkey: remotePubkey });
+    const localUser = await this._signer.user();
+    const remoteUser = this._ndk.getUser({ pubkey: remotePubkey });
     const request = { id, method, params };
 
-    // Placeholder event construction
-    const event = {
+    const event = new NDKEvent(this._ndk, {
       kind,
       content: JSON.stringify(request),
       tags: [['p', remotePubkey]],
       pubkey: localUser.pubkey,
-      created_at: Math.floor(Date.now() / 1000),
-    } as any;
+    } as NostrEvent);
 
     const useNip44 = this._useNip44 && method !== 'create_account';
     const encrypt = useNip44 ? this._signer.encryptNip44 : this._signer.encrypt;
-
-    // NOTE: Adjust encrypt to accept string pubkey
-    event.content = await encrypt.call(this._signer, remotePubkey as any, event.content);
-
-    // NOTE: This assumes _signer has a sign() method compatible with the event
+    event.content = await encrypt.call(this._signer, remoteUser, event.content);
     await event.sign(this._signer);
 
     return event;
   }
+
+  // EventEmitter互換メソッド
+  public override on = <EventKey extends string | symbol = string>(
+    event: EventKey,
+    listener: (...args: any[]) => void
+  ): this => {
+    this.eventEmitter.on(event as string, listener);
+    return this;
+  }
+
+  public override emit = <EventKey extends string | symbol = string>(
+    event: EventKey,
+    ...args: any[]
+  ): boolean => {
+    return this.eventEmitter.emit(event as string, ...args);
+  }
 }
 
 export class IframeNostrRpc extends NostrRpc {
   private peerOrigin?: string;
   private iframePort?: MessagePort;
   private iframeRequests = new Map<string, { id: string; pubkey: string }>();
-  private heartbeatInterval?: number;
-  private lastResponseTime: number = Date.now();
-  private heartbeatTimeoutMs: number = 30000; // 30秒応答がなければ再接続
 
-  public constructor(rxNostr: RxNostr, localSigner: PrivateKeySigner, iframePeerOrigin?: string) {
-    super(rxNostr, localSigner);
+  public constructor(ndk: NDK, localSigner: PrivateKeySigner, iframePeerOrigin?: string) {
+    super(ndk, localSigner);
+    this._ndk = ndk;
     this.peerOrigin = iframePeerOrigin;
   }
 
-  public async subscribe(filter: NostrFilter): Promise<NostrSubscription> {
+  public async subscribe(filter: NDKFilter): Promise<NDKSubscription> {
     if (!this.peerOrigin) return super.subscribe(filter);
-    return super.subscribe(filter);
-    /*
     return new NDKSubscription(
       this._ndk,
       {},
       {
         // don't send to relay
         closeOnEose: true,
-        cacheUsage: 'ONLY_CACHE',
+        cacheUsage: NDKSubscriptionCacheUsage.ONLY_CACHE,
       },
     );
-    */
   }
 
-  // ハートビート開始
-  private startHeartbeat(): void {
-    this.stopHeartbeat();
-
-    this.heartbeatInterval = window.setInterval(async () => {
-      const timeSinceLastResponse = Date.now() - this.lastResponseTime;
-
-      if (timeSinceLastResponse > this.heartbeatTimeoutMs) {
-        console.warn('No response from relay for too long, reconnecting...');
-        await this.reconnect();
-      }
-    }, 10000); // 10秒ごとにチェック
-  }
-
-  private stopHeartbeat(): void {
-    if (this.heartbeatInterval) {
-      clearInterval(this.heartbeatInterval);
-      this.heartbeatInterval = undefined;
-    }
-  }
-
-  public setWorkerIframePort(port: MessagePort): void {
+  public setWorkerIframePort(port: MessagePort) {
     if (!this.peerOrigin) throw new Error('Unexpected iframe port');
 
     this.iframePort = port;
-    this.startHeartbeat();
 
     // to make sure Chrome doesn't terminate the channel
     setInterval(() => {
@@ -512,11 +290,9 @@ export class IframeNostrRpc extends NostrRpc {
         const event = ev.data;
 
         if (!validateEvent(event)) throw new Error('Invalid event from iframe');
-        if (!verifyEvent(event)) throw new Error('Invalid event signature from iframe');
-        const nevent = event as NostrEvent;
+        if (!verifySignature(event)) throw new Error('Invalid event signature from iframe');
+        const nevent = new NDKEvent(this._ndk, event);
         const parsedEvent = await this.parseEvent(nevent);
-        // レスポンス受信時にタイムスタンプを更新
-        this.lastResponseTime = Date.now();
         // we're only implementing client-side rpc
         if (!(parsedEvent as NDKRpcRequest).method) {
           console.log('parsed response', parsedEvent);
@@ -534,22 +310,23 @@ export class IframeNostrRpc extends NostrRpc {
     // create and sign request event
     const event = await this.createRequestEvent(id, remotePubkey, method, params, kind);
 
-    // set response handler
+    // 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) {
-      this.iframeRequests.set(event.id!, { id, pubkey: remotePubkey });
-      console.log('iframe-nip46 sending request to', this.peerOrigin, event);
-      this.iframePort.postMessage(event);
+      // 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 using rx-nostr
-      this.rxNostr.send(event).subscribe({
-        next: (packet) => {
-          console.log('Nip46 request published to', packet.from);
-        },
-        error: (err) => console.error('Nip46 publish error', err),
-        complete: () => console.log('Nip46 publish complete')
-      });
+      // send to relays
+      await event.publish();
     }
 
     // see notes in 'super'
@@ -591,53 +368,80 @@ 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;
   }
 }
 
-// TODO: NDKの継承を削除する
-export class Nip46Signer extends EventEmitter {
-  public remotePubkey: string = '';
-  // @ts-ignore
-  public rpc: NostrRpc;
+export class Nip46Signer extends NDKNip46Signer {
   private _userPubkey: string = '';
   private _rpc: IframeNostrRpc;
+  private lastPingTime: number = 0;
+  private pingCacheDuration: number = 30000; // 30秒
+  private _remotePubkey?: string;
 
-  constructor(rxNostr: RxNostr, localSigner: PrivateKeySigner, signerPubkey: string, iframeOrigin?: string) {
-    super();
-    // super(ndk, signerPubkey, localSigner);
+  constructor(ndk: NDK, localSigner: PrivateKeySigner, signerPubkey: string, iframeOrigin?: string) {
+    super(ndk, signerPubkey, localSigner);
 
     // override with our own rpc implementation
-    this._rpc = new IframeNostrRpc(rxNostr, localSigner, iframeOrigin);
-    this._rpc.setUseNip44(true); // !!this.params.optionsModal.dev);
+    this._rpc = new IframeNostrRpc(ndk, localSigner, iframeOrigin);
+    this._rpc.setUseNip44(true);
     this._rpc.on('authUrl', (url: string) => {
       this.emit('authUrl', url);
     });
 
     this.rpc = this._rpc;
+    this._remotePubkey = signerPubkey;
   }
 
-  get userPubkey(): string {
+  get userPubkey() {
     return this._userPubkey;
   }
 
-  private async setSignerPubkey(signerPubkey: string, sameAsUser: boolean = false): Promise<void> {
+  // Use a different name to avoid conflict with base class property
+  get remotePubkeyAccessor() {
+    return this._remotePubkey;
+  }
+
+  set remotePubkeyAccessor(value: string | undefined) {
+    this._remotePubkey = value;
+  }
+
+  // 接続確認（必要時のみping）
+  private async ensureConnection(retries: number = 2): Promise<void> {
+    if (!this._remotePubkey) return;
+
+    const now = Date.now();
+
+    // 最近ping成功していればスキップ
+    if (now - this.lastPingTime < this.pingCacheDuration) {
+      return;
+    }
+
+    for (let i = 0; i <= retries; i++) {
+      try {
+        await this._rpc.pingWithTimeout(this._remotePubkey, 10000);
+        this.lastPingTime = now;
+        console.log('Connection check OK');
+        return;
+      } catch (error) {
+        if (i === retries) {
+          console.error('Connection check failed after retries', error);
+          throw new Error('NIP-46 connection lost');
+        }
+
+        const delay = Math.min(1000 * Math.pow(2, i), 5000);
+        console.log(`Ping failed, retrying in ${delay}ms...`);
+        await new Promise(resolve => setTimeout(resolve, delay));
+      }
+    }
+  }
+
+  private async setSignerPubkey(signerPubkey: string, sameAsUser: boolean = false) {
     console.log('setSignerPubkey', signerPubkey);
 
     // ensure it's set
-    this.remotePubkey = signerPubkey;
+    this._remotePubkey = signerPubkey;
 
     // when we're sure it's known
     this._rpc.on(`iframeRestart-${signerPubkey}`, () => {
@@ -648,7 +452,7 @@ export class Nip46Signer extends EventEmitter {
     await this.initUserPubkey(sameAsUser ? signerPubkey : '');
   }
 
-  public async initUserPubkey(hintPubkey?: string): Promise<void> {
+  public async initUserPubkey(hintPubkey?: string) {
     if (this._userPubkey) throw new Error('Already called initUserPubkey');
 
     if (hintPubkey) {
@@ -658,14 +462,14 @@ export class Nip46Signer extends EventEmitter {
 
     this._userPubkey = await withTimeout(
       new Promise<string>((ok, err) => {
-        if (!this.remotePubkey) throw new Error('Signer pubkey not set');
+        if (!this._remotePubkey) throw new Error('Signer pubkey not set');
 
-        console.log('get_public_key', this.remotePubkey);
-        this._rpc.sendRequest(this.remotePubkey, 'get_public_key', [], 24133, (response: NDKRpcResponse) => {
+        console.log('get_public_key', this._remotePubkey);
+        this._rpc.sendRequest(this._remotePubkey, 'get_public_key', [], 24133, (response: NDKRpcResponse) => {
           if (response.error) {
             err(new Error(response.error));
           } else {
-            ok(response.result || '');
+            ok(response.result);
           }
         });
       }),
@@ -674,23 +478,48 @@ export class Nip46Signer extends EventEmitter {
     );
   }
 
-  public async listen(nostrConnectSecret: string): Promise<void> {
+  public async listen(nostrConnectSecret: string) {
     const signerPubkey = await (this.rpc as IframeNostrRpc).listen(nostrConnectSecret);
     await this.setSignerPubkey(signerPubkey);
+
+    // ログイン完了後に接続確認
+    await this.ensureConnection();
   }
 
-  public async connect(token?: string, perms?: string): Promise<void> {
-    if (!this.remotePubkey) throw new Error('No signer pubkey');
-    await (this._rpc as any).connectWithTimeout(this.remotePubkey, token, perms, NIP46_CONNECT_TIMEOUT);
-    await this.setSignerPubkey(this.remotePubkey);
+  public async connect(token?: string, perms?: string) {
+    if (!this._remotePubkey) throw new Error('No signer pubkey');
+    await this._rpc.connectWithTimeout(this._remotePubkey, token, perms, NIP46_CONNECT_TIMEOUT);
+    await this.setSignerPubkey(this._remotePubkey);
+
+    // ログイン完了後に接続確認
+    await this.ensureConnection();
   }
 
-  public async setListenReply(reply: any, nostrConnectSecret: string): Promise<void> {
+  public async setListenReply(reply: any, nostrConnectSecret: string) {
     const signerPubkey = await this._rpc.parseNostrConnectReply(reply, nostrConnectSecret);
     await this.setSignerPubkey(signerPubkey, true);
+
+    // ログイン完了後に接続確認
+    await this.ensureConnection();
   }
 
-  public async createAccount2({ bunkerPubkey, name, domain, perms = '' }: { bunkerPubkey: string; name: string; domain: string; perms?: string }): Promise<string> {
+  // 署名メソッドのオーバーライド - 署名前に接続確認
+  async sign(event: NostrEvent): Promise<string> {
+    await this.ensureConnection();
+    return super.sign(event);
+  }
+
+  async encrypt(recipient: NDKUser, value: string): Promise<string> {
+    await this.ensureConnection();
+    return super.encrypt(recipient, value);
+  }
+
+  async decrypt(sender: NDKUser, value: string): Promise<string> {
+    await this.ensureConnection();
+    return super.decrypt(sender, value);
+  }
+
+  public async createAccount2({ bunkerPubkey, name, domain, perms = '' }: { bunkerPubkey: string; name: string; domain: string; perms?: string }) {
     const params = [
       name,
       domain,
@@ -703,52 +532,18 @@ export class Nip46Signer extends EventEmitter {
     });
 
     console.log('create_account pubkey', r);
-    if (r.result === 'error' || !r.result) {
-      throw new Error(r.error || 'Unknown error');
+    if (r.result === 'error') {
+      throw new Error(r.error);
     }
 
     return r.result;
   }
-  // TODO: 必要であればNDKNip46Signerから不足しているメソッドを実装する
-  public async encrypt(recipient: any, value: string): Promise<string> {
-    const recipientPubkey = typeof recipient === 'string' ? recipient : recipient.pubkey;
-    return await this.rpcSend('nip04_encrypt', [recipientPubkey, value]);
-  }
 
-  public async decrypt(sender: any, value: string): Promise<string> {
-    const senderPubkey = typeof sender === 'string' ? sender : sender.pubkey;
-    return await this.rpcSend('nip04_decrypt', [senderPubkey, value]);
+  // EventEmitter互換メソッド
+  public override emit = <EventKey extends string | symbol = string>(
+    event: EventKey,
+    ...args: any[]
+  ): boolean => {
+    return this._rpc.emit(event as string, ...args);
   }
-
-  public async encryptNip44(recipient: any, value: string): Promise<string> {
-    const recipientPubkey = typeof recipient === 'string' ? recipient : recipient.pubkey;
-    return await this.rpcSend('nip44_encrypt', [recipientPubkey, value]);
-  }
-
-  public async decryptNip44(sender: any, value: string): Promise<string> {
-    const senderPubkey = typeof sender === 'string' ? sender : sender.pubkey;
-    return await this.rpcSend('nip44_decrypt', [senderPubkey, value]);
-  }
-
-  public async sign(event: any): Promise<string> {
-    const eventString = JSON.stringify(event);
-    const res = await this.rpcSend('sign_event', [eventString]);
-    // The result matches NIP-46 sign_event response which is the signed event (stringified json)
-    const signedEvent = JSON.parse(res);
-    event.sig = signedEvent.sig;
-    return signedEvent.sig;
-  }
-
-  public async user(): Promise<any> {
-    return { pubkey: this.userPubkey };
-  }
-
-  private async rpcSend(method: string, params: any[]): Promise<string> {
-    return new Promise<string>((resolve, reject) => {
-      this.rpc.sendRequest(this.remotePubkey, method, params, 24133, (response: any) => {
-        if (response.error) reject(new Error(response.error));
-        else resolve(response.result);
-      });
-    });
-  }
-}
+}