@konemono/nostr-login 1.11.0 → 1.11.1

package/src/modules/Nip46.ts

@@ -1,138 +1,136 @@
-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, NostrEvent } from '@nostr-dev-kit/ndk';
+import { validateEvent } from 'nostr-tools';
 import { PrivateKeySigner } from './Signer';
 import { NIP46_REQUEST_TIMEOUT, NIP46_CONNECT_TIMEOUT } from '../const';
 
+// タイムアウト付き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);
+
+/**
+ * NDKのリレー接続を待機する
+ */
+export function waitForConnection(ndk: NDK, timeout: number): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const start = Date.now();
+
+    const check = () => {
+      // 接続済みリレーがあるか確認
+      const connected = Array.from(ndk.pool.relays.values()).some(relay => relay.status === 1); // 1 = CONNECTED
+
+      if (connected) {
+        resolve();
+      } else if (Date.now() - start > timeout) {
+        reject(new Error(`接続タイムアウト: ${timeout}ms`));
+      } else {
+        setTimeout(check, 100);
+      }
+    };
+
+    check();
+  });
+}
+
+/**
+ * NDKの接続を強制的に確立する
+ */
+export async function ensureNDKConnection(ndk: NDK, timeout: number): Promise<void> {
+  // connect()は冪等なので安全
+  await ndk.connect();
+  await waitForConnection(ndk, timeout);
+}
+
+/**
+ * NIP-46専用リレーも含めて接続を確立する
+ */
+export async function ensureNIP46Connection(ndk: NDK, timeout: number): Promise<void> {
+  try {
+    await ensureNDKConnection(ndk, timeout);
+  } catch (e) {
+    console.warn('Initial connection attempt failed, retrying with force disconnect...', e);
+    // 接続数0なら明示的に全切断して再試行
+    if (Array.from(ndk.pool.relays.values()).filter(r => r.status === 1).length === 0) {
+      ndk.pool.relays.forEach(relay => {
+        try {
+          relay.disconnect();
+        } catch (err) {
+          console.error('Error disconnecting relay:', err);
+        }
+      });
+      // タイムアウトを延長して再試行
+      await ensureNDKConnection(ndk, timeout * 2);
+    } else {
+      throw e;
+    }
+  }
+
+  // NIP-46用リレーが個別に定義されている場合の接続確認
+  // @ts-ignore
+  const signerRelays = ndk.signer?.relayUrls;
+  if (signerRelays && Array.isArray(signerRelays)) {
+    for (const url of signerRelays) {
+      const relay = ndk.pool.getRelay(url);
+      if (relay && relay.status !== 1) {
+        await relay.connect();
+      }
+    }
   }
-  stop() {
-    this.sub.unsubscribe();
+
+  // 最終チェック
+  const connectedRelays = Array.from(ndk.pool.relays.values()).filter(r => r.status === 1);
+  if (connectedRelays.length === 0) {
+    throw new Error('リレー接続に失敗しました');
   }
 }
 
-// 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;
 
-  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 +141,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 +158,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 +184,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 +195,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) => {
@@ -241,7 +237,7 @@ class NostrRpc extends EventEmitter {
   }
 
   // 接続監視のセットアップ
-  private setupConnectionMonitoring(): void {
+  private setupConnectionMonitoring() {
     // アプリがフォアグラウンドに戻ったときの処理
     if (typeof document !== 'undefined') {
       document.addEventListener('visibilitychange', async () => {
@@ -259,22 +255,11 @@ class NostrRpc extends EventEmitter {
         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');
+    const connectedRelays = Array.from(this._ndk.pool.relays.values()).filter(r => r.status === 1); // 1 = CONNECTED
 
     if (connectedRelays.length === 0) {
       console.log('No connected relays, attempting reconnection...');
@@ -282,7 +267,7 @@ class NostrRpc extends EventEmitter {
     }
   }
 
-  // 再接続処理（指数バックオフ付き）
+  // 再接続処理
   protected async reconnect(): Promise<void> {
     if (this.reconnectAttempts >= this.maxReconnectAttempts) {
       console.error('Max reconnection attempts reached');
@@ -299,42 +284,25 @@ class NostrRpc extends EventEmitter {
         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);
-          }
-        }
+      // 少し待ってから再接続
+      await new Promise(resolve => setTimeout(resolve, this.reconnectDelay));
+
+      // 再接続
+      await this._ndk.connect();
+
+      // サブスクリプションを再開
+      if (this.sub) {
+        await this.sub.start();
       }
 
-      // 再接続成功後、カウンターをリセット
-      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);
+      this.reconnectAttempts = 0;
+      this.emit('reconnected');
+      console.log('Successfully reconnected to relays');
+    } catch (e) {
+      console.error('Reconnection failed:', e);
+
+      // リトライ
+      setTimeout(() => this.reconnect(), this.reconnectDelay * this.reconnectAttempts);
     }
   }
 
@@ -343,6 +311,9 @@ class NostrRpc extends EventEmitter {
   }
 
   public async sendRequest(remotePubkey: string, method: string, params: string[] = [], kind = 24133, cb?: (res: NDKRpcResponse) => void): Promise<NDKRpcResponse> {
+    // リクエスト送信前に接続を確認
+    await ensureNIP46Connection(this._ndk, 5000);
+
     const id = this.getId();
 
     // response handler will deduplicate auth urls and responses
@@ -353,11 +324,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,8 +335,7 @@ 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>(() => {
@@ -393,43 +359,22 @@ class NostrRpc extends EventEmitter {
     });
   }
 
-  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;
@@ -444,29 +389,27 @@ export class IframeNostrRpc extends NostrRpc {
   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 {
+  private startHeartbeat() {
     this.stopHeartbeat();
 
     this.heartbeatInterval = window.setInterval(async () => {
@@ -479,14 +422,14 @@ export class IframeNostrRpc extends NostrRpc {
     }, 10000); // 10秒ごとにチェック
   }
 
-  private stopHeartbeat(): void {
+  private stopHeartbeat() {
     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;
@@ -512,8 +455,7 @@ 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;
+        const nevent = new NDKEvent(this._ndk, event);
         const parsedEvent = await this.parseEvent(nevent);
         // レスポンス受信時にタイムスタンプを更新
         this.lastResponseTime = Date.now();
@@ -529,27 +471,33 @@ export class IframeNostrRpc extends NostrRpc {
   }
 
   public async sendRequest(remotePubkey: string, method: string, params: string[] = [], kind = 24133, cb?: (res: NDKRpcResponse) => void): Promise<NDKRpcResponse> {
+    // リクエスト送信前に接続を確認 (relayを使用する場合に備えて)
+    if (!this.iframePort) {
+      await ensureNIP46Connection(this._ndk, 5000);
+    }
+
     const id = this.getId();
 
     // 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'
@@ -607,20 +555,15 @@ export class ReadyListener {
   }
 }
 
-// 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;
 
-  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 = new IframeNostrRpc(ndk, localSigner, iframeOrigin);
     this._rpc.setUseNip44(true); // !!this.params.optionsModal.dev);
     this._rpc.on('authUrl', (url: string) => {
       this.emit('authUrl', url);
@@ -629,11 +572,11 @@ export class Nip46Signer extends EventEmitter {
     this.rpc = this._rpc;
   }
 
-  get userPubkey(): string {
+  get userPubkey() {
     return this._userPubkey;
   }
 
-  private async setSignerPubkey(signerPubkey: string, sameAsUser: boolean = false): Promise<void> {
+  private async setSignerPubkey(signerPubkey: string, sameAsUser: boolean = false) {
     console.log('setSignerPubkey', signerPubkey);
 
     // ensure it's set
@@ -648,7 +591,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) {
@@ -665,7 +608,7 @@ export class Nip46Signer extends EventEmitter {
           if (response.error) {
             err(new Error(response.error));
           } else {
-            ok(response.result || '');
+            ok(response.result);
           }
         });
       }),
@@ -674,23 +617,23 @@ 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);
   }
 
-  public async connect(token?: string, perms?: string): Promise<void> {
+  public async connect(token?: string, perms?: string) {
     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 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);
   }
 
-  public async createAccount2({ bunkerPubkey, name, domain, perms = '' }: { bunkerPubkey: string; name: string; domain: string; perms?: string }): Promise<string> {
+  public async createAccount2({ bunkerPubkey, name, domain, perms = '' }: { bunkerPubkey: string; name: string; domain: string; perms?: string }) {
     const params = [
       name,
       domain,
@@ -703,52 +646,10 @@ 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]);
-  }
-
-  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);
-      });
-    });
-  }
 }