@konemono/nostr-login 1.10.15 → 1.11.0

package/src/modules/Nip46.ts

@@ -1,60 +1,138 @@
-import NDK, { NDKEvent, NDKFilter, NDKNip46Signer, NDKNostrRpc, NDKRpcRequest, NDKRpcResponse, NDKSubscription, NDKSubscriptionCacheUsage, NostrEvent } from '@nostr-dev-kit/ndk';
-import { validateEvent, verifySignature } from 'nostr-tools';
+import { createRxForwardReq, createRxNostr, RxNostr } from 'rx-nostr';
+import { EventEmitter } from 'tseep';
+import { validateEvent, verifyEvent, type Event as NostrEventSDK } 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);
+  }
+  stop() {
+    this.sub.unsubscribe();
+  }
+}
 
-class NostrRpc extends NDKNostrRpc {
-  protected _ndk: NDK;
+// TODO: NDKの継承を削除する
+class NostrRpc extends EventEmitter {
+  public rxNostr: RxNostr;
   protected _signer: PrivateKeySigner;
   protected requests: Set<string> = new Set();
-  private sub?: NDKSubscription;
+  // private sub?: NDKSubscription;
+  private sub?: RxReqAdapter;
   protected _useNip44: boolean = false;
   private reconnectAttempts: number = 0;
   private maxReconnectAttempts: number = 3;
   private reconnectDelay: number = 2000;
 
-  public constructor(ndk: NDK, signer: PrivateKeySigner) {
-    super(ndk, signer, ndk.debug.extend('nip46:signer:rpc'));
-    this._ndk = ndk;
+  public constructor(rxNostr: RxNostr, signer: PrivateKeySigner) {
+    super();
+    this.rxNostr = rxNostr;
     this._signer = signer;
     this.setupConnectionMonitoring();
   }
 
-  public async subscribe(filter: NDKFilter): Promise<NDKSubscription> {
-    // NOTE: fixing ndk
-    filter.kinds = filter.kinds?.filter(k => k === 24133);
-    this.sub = await super.subscribe(filter);
+  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]);
     return this.sub;
   }
 
-  public stop() {
+  public stop(): void {
     if (this.sub) {
       this.sub.stop();
       this.sub = undefined;
     }
   }
 
-  public setUseNip44(useNip44: boolean) {
+  public setUseNip44(useNip44: boolean): void {
     this._useNip44 = useNip44;
   }
 
-  private isNip04(ciphertext: string) {
+  private isNip04(ciphertext: string): boolean {
     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: NDKEvent): Promise<NDKRpcRequest | NDKRpcResponse> {
-    const remoteUser = this._ndk.getUser({ pubkey: event.pubkey });
-    remoteUser.ndk = this._ndk;
+  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;
+
     const decrypt = this.isNip04(event.content) ? this._signer.decrypt : this._signer.decryptNip44;
-    const decryptedContent = await decrypt.call(this._signer, remoteUser, event.content);
+
+    // 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 parsedContent = JSON.parse(decryptedContent);
     const { id, method, params, result, error } = parsedContent;
 
@@ -65,8 +143,8 @@ class NostrRpc extends NDKNostrRpc {
     }
   }
 
-  public async parseNostrConnectReply(reply: any, secret: string) {
-    const event = new NDKEvent(this._ndk, reply);
+  public async parseNostrConnectReply(reply: any, secret: string): Promise<string> {
+    const event = reply as NostrEvent;
     const parsedEvent = await this.parseEvent(event);
     console.log('nostr connect parsedEvent', parsedEvent);
     if (!(parsedEvent as NDKRpcRequest).method) {
@@ -82,14 +160,15 @@ class NostrRpc extends NDKNostrRpc {
   // 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: NDKEvent) => {
+      sub.on('event', async (event: NostrEvent) => {
         try {
           const parsedEvent = await this.parseEvent(event);
           // console.log('ack parsedEvent', parsedEvent);
@@ -108,7 +187,7 @@ class NostrRpc extends NDKNostrRpc {
             }
           }
         } catch (e) {
-          console.log('error parsing event', e, event.rawEvent());
+          console.log('error parsing event', e, (event as any).rawEvent?.());
         }
         // done
         this.stop();
@@ -119,7 +198,8 @@ class NostrRpc extends NDKNostrRpc {
   // 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) {
+  public async connect(pubkey: string, token?: string, perms?: string): Promise<void> {
+    // TODO: nostr-toolsを使用して実装する
     return new Promise<void>((ok, err) => {
       const connectParams = [pubkey!, token || '', perms || ''];
       this.sendRequest(pubkey!, 'connect', connectParams, 24133, (response: NDKRpcResponse) => {
@@ -161,7 +241,7 @@ class NostrRpc extends NDKNostrRpc {
   }
 
   // 接続監視のセットアップ
-  private setupConnectionMonitoring() {
+  private setupConnectionMonitoring(): void {
     // アプリがフォアグラウンドに戻ったときの処理
     if (typeof document !== 'undefined') {
       document.addEventListener('visibilitychange', async () => {
@@ -179,11 +259,22 @@ class NostrRpc extends NDKNostrRpc {
         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 connectedRelays = Array.from(this._ndk.pool.relays.values()).filter(r => r.status === 1); // 1 = CONNECTED
+    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...');
@@ -191,7 +282,7 @@ class NostrRpc extends NDKNostrRpc {
     }
   }
 
-  // 再接続処理
+  // 再接続処理（指数バックオフ付き）
   protected async reconnect(): Promise<void> {
     if (this.reconnectAttempts >= this.maxReconnectAttempts) {
       console.error('Max reconnection attempts reached');
@@ -208,25 +299,42 @@ class NostrRpc extends NDKNostrRpc {
         this.sub.stop();
       }
 
-      // 少し待ってから再接続
-      await new Promise(resolve => setTimeout(resolve, this.reconnectDelay));
-
-      // 再接続
-      await this._ndk.connect();
-
-      // サブスクリプションを再開
-      if (this.sub) {
-        await this.sub.start();
+      // 指数バックオフ: 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);
+          }
+        }
       }
 
-      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);
+      // 再接続成功後、カウンターをリセット
+      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);
     }
   }
 
@@ -245,7 +353,11 @@ class NostrRpc extends NDKNostrRpc {
     console.log('sendRequest', { event, method, remotePubkey, params });
 
     // send to relays
-    await event.publish();
+    // await event.publish();
+    this.rxNostr.send(event).subscribe({
+      error: (err) => console.error('Nip46 publish error', err),
+      complete: () => console.log('Nip46 publish complete')
+    });
 
     // NOTE: ndk returns a promise that never resolves and
     // in fact REQUIRES cb to be provided (otherwise no way
@@ -256,7 +368,8 @@ class NostrRpc extends NDKNostrRpc {
     return undefined as NDKRpcResponse;
   }
 
-  protected setResponseHandler(id: string, cb?: (res: NDKRpcResponse) => void) {
+  protected setResponseHandler(id: string, cb?: (res: NDKRpcResponse) => void): Promise<NDKRpcResponse> {
+    // TODO: 再実装する
     let authUrlSent = false;
     const now = Date.now();
     return new Promise<NDKRpcResponse>(() => {
@@ -280,22 +393,43 @@ class NostrRpc extends NDKNostrRpc {
     });
   }
 
-  protected async createRequestEvent(id: string, remotePubkey: string, method: string, params: string[] = [], kind = 24133) {
+  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.
+
     this.requests.add(id);
-    const localUser = await this._signer.user();
-    const remoteUser = this._ndk.getUser({ pubkey: remotePubkey });
+    const localUser = await this._signer.user(); // TODO: signerプロパティから取得する
+    // const remoteUser = this._ndk.getUser({ pubkey: remotePubkey });
     const request = { id, method, params };
 
-    const event = new NDKEvent(this._ndk, {
+    // Placeholder event construction
+    const event = {
       kind,
       content: JSON.stringify(request),
       tags: [['p', remotePubkey]],
       pubkey: localUser.pubkey,
-    } as NostrEvent);
+      created_at: Math.floor(Date.now() / 1000),
+    } as any;
 
     const useNip44 = this._useNip44 && method !== 'create_account';
     const encrypt = useNip44 ? this._signer.encryptNip44 : this._signer.encrypt;
-    event.content = await encrypt.call(this._signer, remoteUser, event.content);
+
+    // 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
     await event.sign(this._signer);
 
     return event;
@@ -310,27 +444,29 @@ export class IframeNostrRpc extends NostrRpc {
   private lastResponseTime: number = Date.now();
   private heartbeatTimeoutMs: number = 30000; // 30秒応答がなければ再接続
 
-  public constructor(ndk: NDK, localSigner: PrivateKeySigner, iframePeerOrigin?: string) {
-    super(ndk, localSigner);
-    this._ndk = ndk;
+  public constructor(rxNostr: RxNostr, localSigner: PrivateKeySigner, iframePeerOrigin?: string) {
+    super(rxNostr, localSigner);
     this.peerOrigin = iframePeerOrigin;
   }
 
-  public async subscribe(filter: NDKFilter): Promise<NDKSubscription> {
+  public async subscribe(filter: NostrFilter): Promise<NostrSubscription> {
     if (!this.peerOrigin) return super.subscribe(filter);
+    return super.subscribe(filter);
+    /*
     return new NDKSubscription(
       this._ndk,
       {},
       {
         // don't send to relay
         closeOnEose: true,
-        cacheUsage: NDKSubscriptionCacheUsage.ONLY_CACHE,
+        cacheUsage: 'ONLY_CACHE',
       },
     );
+    */
   }
 
   // ハートビート開始
-  private startHeartbeat() {
+  private startHeartbeat(): void {
     this.stopHeartbeat();
 
     this.heartbeatInterval = window.setInterval(async () => {
@@ -343,14 +479,14 @@ export class IframeNostrRpc extends NostrRpc {
     }, 10000); // 10秒ごとにチェック
   }
 
-  private stopHeartbeat() {
+  private stopHeartbeat(): void {
     if (this.heartbeatInterval) {
       clearInterval(this.heartbeatInterval);
       this.heartbeatInterval = undefined;
     }
   }
 
-  public setWorkerIframePort(port: MessagePort) {
+  public setWorkerIframePort(port: MessagePort): void {
     if (!this.peerOrigin) throw new Error('Unexpected iframe port');
 
     this.iframePort = port;
@@ -376,8 +512,8 @@ export class IframeNostrRpc extends NostrRpc {
         const event = ev.data;
 
         if (!validateEvent(event)) throw new Error('Invalid event from iframe');
-        if (!verifySignature(event)) throw new Error('Invalid event signature from iframe');
-        const nevent = new NDKEvent(this._ndk, event);
+        if (!verifyEvent(event)) throw new Error('Invalid event signature from iframe');
+        const nevent = event as NostrEvent;
         const parsedEvent = await this.parseEvent(nevent);
         // レスポンス受信時にタイムスタンプを更新
         this.lastResponseTime = Date.now();
@@ -398,23 +534,22 @@ export class IframeNostrRpc extends NostrRpc {
     // 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
+    // set response handler
     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());
+      this.iframeRequests.set(event.id!, { id, pubkey: remotePubkey });
+      console.log('iframe-nip46 sending request to', this.peerOrigin, event);
+      this.iframePort.postMessage(event);
     } else {
-      // send to relays
-      await event.publish();
+      // 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')
+      });
     }
 
     // see notes in 'super'
@@ -472,15 +607,20 @@ export class ReadyListener {
   }
 }
 
-export class Nip46Signer extends NDKNip46Signer {
+// TODO: NDKの継承を削除する
+export class Nip46Signer extends EventEmitter {
+  public remotePubkey: string = '';
+  // @ts-ignore
+  public rpc: NostrRpc;
   private _userPubkey: string = '';
   private _rpc: IframeNostrRpc;
 
-  constructor(ndk: NDK, localSigner: PrivateKeySigner, signerPubkey: string, iframeOrigin?: string) {
-    super(ndk, signerPubkey, localSigner);
+  constructor(rxNostr: RxNostr, localSigner: PrivateKeySigner, signerPubkey: string, iframeOrigin?: string) {
+    super();
+    // super(ndk, signerPubkey, localSigner);
 
     // override with our own rpc implementation
-    this._rpc = new IframeNostrRpc(ndk, localSigner, iframeOrigin);
+    this._rpc = new IframeNostrRpc(rxNostr, localSigner, iframeOrigin);
     this._rpc.setUseNip44(true); // !!this.params.optionsModal.dev);
     this._rpc.on('authUrl', (url: string) => {
       this.emit('authUrl', url);
@@ -489,11 +629,11 @@ export class Nip46Signer extends NDKNip46Signer {
     this.rpc = this._rpc;
   }
 
-  get userPubkey() {
+  get userPubkey(): string {
     return this._userPubkey;
   }
 
-  private async setSignerPubkey(signerPubkey: string, sameAsUser: boolean = false) {
+  private async setSignerPubkey(signerPubkey: string, sameAsUser: boolean = false): Promise<void> {
     console.log('setSignerPubkey', signerPubkey);
 
     // ensure it's set
@@ -508,7 +648,7 @@ export class Nip46Signer extends NDKNip46Signer {
     await this.initUserPubkey(sameAsUser ? signerPubkey : '');
   }
 
-  public async initUserPubkey(hintPubkey?: string) {
+  public async initUserPubkey(hintPubkey?: string): Promise<void> {
     if (this._userPubkey) throw new Error('Already called initUserPubkey');
 
     if (hintPubkey) {
@@ -525,7 +665,7 @@ export class Nip46Signer extends NDKNip46Signer {
           if (response.error) {
             err(new Error(response.error));
           } else {
-            ok(response.result);
+            ok(response.result || '');
           }
         });
       }),
@@ -534,23 +674,23 @@ export class Nip46Signer extends NDKNip46Signer {
     );
   }
 
-  public async listen(nostrConnectSecret: string) {
+  public async listen(nostrConnectSecret: string): Promise<void> {
     const signerPubkey = await (this.rpc as IframeNostrRpc).listen(nostrConnectSecret);
     await this.setSignerPubkey(signerPubkey);
   }
 
-  public async connect(token?: string, perms?: string) {
+  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 setListenReply(reply: any, nostrConnectSecret: string) {
+  public async setListenReply(reply: any, nostrConnectSecret: string): Promise<void> {
     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 }) {
+  public async createAccount2({ bunkerPubkey, name, domain, perms = '' }: { bunkerPubkey: string; name: string; domain: string; perms?: string }): Promise<string> {
     const params = [
       name,
       domain,
@@ -563,10 +703,52 @@ export class Nip46Signer extends NDKNip46Signer {
     });
 
     console.log('create_account pubkey', r);
-    if (r.result === 'error') {
-      throw new Error(r.error);
+    if (r.result === 'error' || !r.result) {
+      throw new Error(r.error || 'Unknown 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);
+      });
+    });
+  }
 }

package/src/modules/NostrExtensionService.ts

@@ -60,6 +60,7 @@ class NostrExtensionService extends EventEmitter {
   }
 
   private async setExtensionReadPubkey(expectedPubkey?: string) {
+    // @ts-ignore
     window.nostr = this.nostrExtension;
     // @ts-ignore
     const pubkey = await window.nostr.getPublicKey();
@@ -81,6 +82,7 @@ class NostrExtensionService extends EventEmitter {
   }
 
   public unsetExtension(nostr: Nostr) {
+    // @ts-ignore
     if (window.nostr === this.nostrExtension) {
       // @ts-ignore
       window.nostr = nostr;