@konemono/nostr-login 1.9.13 → 1.10.0

package/src/modules/NostrExtensionService.ts

@@ -1,12 +1,6 @@
 import { Nostr, NostrParams } from './';
 import { EventEmitter } from 'tseep';
 
-declare global {
-  interface Window {
-    nostr?: any;
-  }
-}
-
 class NostrExtensionService extends EventEmitter {
   private params: NostrParams;
   private nostrExtension: any | undefined;

package/src/modules/Signer.ts

@@ -1,13 +1,13 @@
+import { NDKPrivateKeySigner, NDKUser } from '@nostr-dev-kit/ndk';
 import { Nip44 } from '../utils/nip44';
-import { getPublicKey, getEventHash, getSignature, nip04 } from 'nostr-tools';
+import { getPublicKey } from 'nostr-tools';
 
-export class PrivateKeySigner {
+export class PrivateKeySigner extends NDKPrivateKeySigner {
   private nip44: Nip44 = new Nip44();
   private _pubkey: string;
-  public privateKey: string;
 
   constructor(privateKey: string) {
-    this.privateKey = privateKey;
+    super(privateKey);
     this._pubkey = getPublicKey(privateKey);
   }
 
@@ -15,42 +15,11 @@ export class PrivateKeySigner {
     return this._pubkey;
   }
 
-  async blockUntilReady() {
-    return Promise.resolve();
+  encryptNip44(recipient: NDKUser, value: string): Promise<string> {
+    return Promise.resolve(this.nip44.encrypt(this.privateKey!, recipient.pubkey, value));
   }
 
-  async user() {
-    return { pubkey: this.pubkey };
-  }
-
-  async sign(event: any): Promise<string> {
-    // ensure event has created_at
-    if (!event.created_at) event.created_at = Math.floor(Date.now() / 1000);
-    // compute id and signature
-    const id = getEventHash(event as any);
-    event.id = id;
-    const sig = getSignature(event as any, this.privateKey);
-    event.sig = sig;
-    return sig;
-  }
-
-  async encrypt(recipient: any, plaintext: string): Promise<string> {
-    const pubkey = typeof recipient === 'string' ? recipient : recipient.pubkey;
-    return nip04.encrypt(this.privateKey, pubkey, plaintext);
-  }
-
-  async decrypt(sender: any, ciphertext: string): Promise<string> {
-    const pubkey = typeof sender === 'string' ? sender : sender.pubkey;
-    return nip04.decrypt(this.privateKey, pubkey, ciphertext);
-  }
-
-  encryptNip44(recipient: any, value: string): Promise<string> {
-    const pubkey = typeof recipient === 'string' ? recipient : recipient.pubkey;
-    return Promise.resolve(this.nip44.encrypt(this.privateKey, pubkey, value));
-  }
-
-  decryptNip44(sender: any, value: string): Promise<string> {
-    const pubkey = typeof sender === 'string' ? sender : sender.pubkey;
-    return Promise.resolve(this.nip44.decrypt(this.privateKey, pubkey, value));
+  decryptNip44(sender: NDKUser, value: string): Promise<string> {
+    return Promise.resolve(this.nip44.decrypt(this.privateKey!, sender.pubkey, value));
   }
 }

package/src/types.ts

@@ -122,10 +122,3 @@ export interface Response {
   result?: string;
   error?: string;
 }
-
-
-export interface AmberResponse {
-  id: string;
-  type: string;
-  result: string;
-}

package/src/utils/index.ts

@@ -1,5 +1,6 @@
 import { Info, RecentType } from 'nostr-login-components/dist/types/types';
-import { generatePrivateKey, SimplePool, getEventHash } from 'nostr-tools';
+import NDK, { NDKEvent, NDKRelaySet, NDKSigner, NDKUser } from '@nostr-dev-kit/ndk';
+import { generatePrivateKey } from 'nostr-tools';
 import { NostrLoginOptions } from '../types';
 
 const LOCAL_STORE_KEY = '__nostrlogin_nip46';
@@ -28,53 +29,12 @@ export const localStorageRemoveItem = (key: string) => {
   localStorage.removeItem(key);
 };
 
-export const fetchProfile = async (info: Info, profileNdkOrRelays?: any) => {
-  // support legacy external profile fetcher (NDK compatibility)
-  if (profileNdkOrRelays && typeof profileNdkOrRelays.fetchEvents === 'function') {
-    try {
-      const user = (profileNdkOrRelays as any).getUser({ pubkey: info.pubkey });
-      user.ndk = profileNdkOrRelays;
-      return await user.fetchProfile();
-    } catch (e) {
-      // fallthrough to SimplePool-based fetch
-    }
-  }
+export const fetchProfile = async (info: Info, profileNdk: NDK) => {
+  const user = new NDKUser({ pubkey: info.pubkey });
 
-  // fallback: use SimplePool to fetch latest kind:0 metadata for the pubkey
-  const relays = Array.isArray(profileNdkOrRelays) && profileNdkOrRelays.length ? profileNdkOrRelays : DEFAULT_SIGNUP_RELAYS;
-  const pool = new SimplePool();
-  const sub = pool.sub(relays, [{ kinds: [0], authors: [info.pubkey], limit: 1 }]);
-
-  return await new Promise(resolve => {
-    const timer = setTimeout(() => {
-      try {
-        sub.unsub();
-      } catch {}
-      resolve(null);
-    }, 3000);
-
-    sub.on('event', (event: any) => {
-      clearTimeout(timer);
-      try {
-        sub.unsub();
-      } catch {}
-      if (!event || !event.content) return resolve(null);
-      try {
-        const profile = JSON.parse(event.content);
-        resolve(profile);
-      } catch (e) {
-        resolve(null);
-      }
-    });
-
-    sub.on('eose', () => {
-      clearTimeout(timer);
-      try {
-        sub.unsub();
-      } catch {}
-      resolve(null);
-    });
-  });
+  user.ndk = profileNdk;
+
+  return await user.fetchProfile();
 };
 
 export const prepareSignupRelays = (signupRelays?: string) => {
@@ -86,46 +46,43 @@ export const prepareSignupRelays = (signupRelays?: string) => {
   return relays;
 };
 
-export const createProfile = async (info: Info, signer: any, signupRelays?: string, outboxRelays?: string[]) => {
+export const createProfile = async (info: Info, profileNdk: NDK, signer: NDKSigner, signupRelays?: string, outboxRelays?: string[]) => {
   const meta = {
     name: info.name,
   };
 
-  const profileEvent: any = {
+  const profileEvent = new NDKEvent(profileNdk, {
     kind: 0,
     created_at: Math.floor(Date.now() / 1000),
     pubkey: info.pubkey,
     content: JSON.stringify(meta),
     tags: [],
-  };
+  });
   if (window.location.hostname) profileEvent.tags.push(['client', window.location.hostname]);
 
-  const relaysEvent: any = {
+  const relaysEvent = new NDKEvent(profileNdk, {
     kind: 10002,
     created_at: Math.floor(Date.now() / 1000),
     pubkey: info.pubkey,
     content: '',
     tags: [],
-  };
+  });
 
-  const relays = prepareSignupRelays(signupRelays);
+  const relays = prepareSignupRelays(signupRelays)
   for (const r of relays) {
     relaysEvent.tags.push(['r', r]);
   }
 
-  // signer is expected to implement sign(event)
-  await signer.sign(profileEvent);
+  await profileEvent.sign(signer);
   console.log('signed profile', profileEvent);
-  await signer.sign(relaysEvent);
+  await relaysEvent.sign(signer);
   console.log('signed relays', relaysEvent);
 
   const outboxRelaysFinal = outboxRelays && outboxRelays.length ? outboxRelays : OUTBOX_RELAYS;
 
-  // publish using SimplePool
-  const pool = new SimplePool();
-  await Promise.any(pool.publish(outboxRelaysFinal, profileEvent));
+  await profileEvent.publish(NDKRelaySet.fromRelayUrls(outboxRelaysFinal, profileNdk));
   console.log('published profile', profileEvent);
-  await Promise.any(pool.publish(outboxRelaysFinal, relaysEvent));
+  await relaysEvent.publish(NDKRelaySet.fromRelayUrls(outboxRelaysFinal, profileNdk));
   console.log('published relays', relaysEvent);
 };
 
@@ -145,7 +102,9 @@ export const bunkerUrlToInfo = (bunkerUrl: string, sk = ''): Info => {
 export const isBunkerUrl = (value: string) => value.startsWith('bunker://');
 
 export const getBunkerUrl = async (value: string, optionsModal: NostrLoginOptions) => {
-  if (!value) return '';
+  if (!value) {
+    return '';
+  }
 
   if (isBunkerUrl(value)) {
     return value;
@@ -154,26 +113,24 @@ export const getBunkerUrl = async (value: string, optionsModal: NostrLoginOption
   if (value.includes('@')) {
     const [name, domain] = value.toLocaleLowerCase().split('@');
     const origin = optionsModal.devOverrideBunkerOrigin || `https://${domain}`;
-
     const bunkerUrl = `${origin}/.well-known/nostr.json?name=_`;
     const userUrl = `${origin}/.well-known/nostr.json?name=${name}`;
-
-    const bunkerRes = await fetch(bunkerUrl);
-    const bunkerData = await bunkerRes.json();
+    const bunker = await fetch(bunkerUrl);
+    const bunkerData = await bunker.json();
     const bunkerPubkey = bunkerData.names['_'];
-    const bunkerRelays: string[] = bunkerData.nip46[bunkerPubkey];
-
-    const userRes = await fetch(userUrl);
-    const userData = await userRes.json();
+    const bunkerRelays = bunkerData.nip46[bunkerPubkey];
+    const user = await fetch(userUrl);
+    const userData = await user.json();
     const userPubkey = userData.names[name];
-
-    if (!bunkerRelays || bunkerRelays.length === 0) {
+    // console.log({
+    //     bunkerData, userData, bunkerPubkey, bunkerRelays, userPubkey,
+    //     name, domain, origin
+    // })
+    if (!bunkerRelays.length) {
       throw new Error('Bunker relay not provided');
     }
 
-    const relayParams = bunkerRelays.map(r => `relay=${encodeURIComponent(r)}`).join('&');
-
-    return `bunker://${userPubkey}?${relayParams}`;
+    return `bunker://${userPubkey}?relay=${bunkerRelays[0]}`;
   }
 
   throw new Error('Invalid user name or bunker url');
@@ -238,11 +195,6 @@ const upgradeInfo = (info: Info | RecentType) => {
   if (info.authMethod === 'connect' && !info.signerPubkey) {
     info.signerPubkey = info.pubkey;
   }
-
-  if (info.authMethod === ('amber' as any)) {
-    if (!info.signerPubkey) info.signerPubkey = '';
-    if (!(info as any).relays) (info as any).relays = [];
-  }
 };
 
 export const localStorageAddAccount = (info: Info) => {

package/tsconfig.json

@@ -11,5 +11,5 @@
     "outDir": "./dist",
   },
   "include": ["src/**/*.ts"],
-  "exclude": ["node_modules", "**/*.test.ts", "**/*.spec.ts"],
-}
+  "exclude": ["node_modules"],
+}

package/src/modules/AmberDirectSigner.ts

@@ -1,242 +0,0 @@
-import { AmberResponse } from '../types';
-import { Signer } from './Nostr';
-
-export class AmberDirectSigner implements Signer {
-  private _pubkey: string;
-  private static pendingResolves: Map<string, { resolve: (result: string) => void; timer: NodeJS.Timeout | null }> = new Map();
-
-  constructor(pubkey: string = '') {
-    this._pubkey = pubkey;
-  }
-
-  get pubkey() {
-    return this._pubkey;
-  }
-
-  set pubkey(v: string) {
-    this._pubkey = v;
-  }
-
-  public nip04 = {
-    encrypt: (pubkey: string, plaintext: string) => this.encrypt04(pubkey, plaintext),
-    decrypt: (pubkey: string, ciphertext: string) => this.decrypt04(pubkey, ciphertext),
-  };
-
-  public nip44 = {
-    encrypt: (pubkey: string, plaintext: string) => this.encrypt44(pubkey, plaintext),
-    decrypt: (pubkey: string, ciphertext: string) => this.decrypt44(pubkey, ciphertext),
-  };
-
-  public async getPublicKey(id?: string): Promise<string> {
-    id = id || Math.random().toString(36).substring(7);
-    const url = this.generateUrl('', 'get_public_key', id);
-    console.log('[AmberDirectSigner] Requesting public key, URL:', url.substring(0, 100) + '...');
-    window.open(url, '_blank', 'width=400,height=600');
-    return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        AmberDirectSigner.pendingResolves.delete(id!);
-        const error = new Error('[AmberDirectSigner] getPublicKey timeout after 20s');
-        console.error(error.message);
-        reject(error);
-      }, 20000);
-      AmberDirectSigner.pendingResolves.set(id!, { resolve, timer });
-    });
-  }
-
-  public async signEvent(event: any, id?: string): Promise<any> {
-    id = id || Math.random().toString(36).substring(7);
-    const url = this.generateUrl(JSON.stringify(event), 'sign_event', id);
-    console.log('Amber redirecting to:', url);
-    window.open(url, '_blank', 'width=400,height=600');
-    return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        AmberDirectSigner.pendingResolves.delete(id!);
-        reject(new Error('AmberDirectSigner timeout'));
-      }, 20000);
-      AmberDirectSigner.pendingResolves.set(id!, {
-        resolve: (result: string) => {
-          try {
-            resolve(JSON.parse(result));
-          } catch (e) {
-            resolve(result as any);
-          }
-        },
-        timer,
-      });
-    });
-  }
-
-  public async encrypt04(pubkey: string, plaintext: string, id?: string): Promise<string> {
-    id = id || Math.random().toString(36).substring(7);
-    const url = this.generateUrl(plaintext, 'nip04_encrypt', id, pubkey);
-    console.log('Amber redirecting to:', url);
-    window.open(url, '_blank', 'width=400,height=600');
-    return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        AmberDirectSigner.pendingResolves.delete(id!);
-        reject(new Error('AmberDirectSigner timeout'));
-      }, 20000);
-      AmberDirectSigner.pendingResolves.set(id!, { resolve, timer });
-    });
-  }
-
-  public async decrypt04(pubkey: string, ciphertext: string, id?: string): Promise<string> {
-    id = id || Math.random().toString(36).substring(7);
-    const url = this.generateUrl(ciphertext, 'nip04_decrypt', id, pubkey);
-    console.log('Amber redirecting to:', url);
-    window.open(url, '_blank', 'width=400,height=600');
-    return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        AmberDirectSigner.pendingResolves.delete(id!);
-        reject(new Error('AmberDirectSigner timeout'));
-      }, 20000);
-      AmberDirectSigner.pendingResolves.set(id!, { resolve, timer });
-    });
-  }
-
-  public async encrypt44(pubkey: string, plaintext: string, id?: string): Promise<string> {
-    id = id || Math.random().toString(36).substring(7);
-    const url = this.generateUrl(plaintext, 'nip44_encrypt', id, pubkey);
-    console.log('Amber redirecting to:', url);
-    window.open(url, '_blank', 'width=400,height=600');
-    return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        AmberDirectSigner.pendingResolves.delete(id!);
-        reject(new Error('AmberDirectSigner timeout'));
-      }, 20000);
-      AmberDirectSigner.pendingResolves.set(id!, { resolve, timer });
-    });
-  }
-
-  public async decrypt44(pubkey: string, ciphertext: string, id?: string): Promise<string> {
-    id = id || Math.random().toString(36).substring(7);
-    const url = this.generateUrl(ciphertext, 'nip44_decrypt', id, pubkey);
-    console.log('Amber redirecting to:', url);
-    window.open(url, '_blank', 'width=400,height=600');
-    return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        AmberDirectSigner.pendingResolves.delete(id!);
-        reject(new Error('AmberDirectSigner timeout'));
-      }, 20000);
-      AmberDirectSigner.pendingResolves.set(id!, { resolve, timer });
-    });
-  }
-
-  public generateUrl(content: string, type: string, id: string, pubkey?: string): string {
-    const baseUrl = window.location.href.split('#')[0].split('?')[0];
-    const encodedContent = encodeURIComponent(content || '');
-
-    // callbackUrl にはベースURLだけを渡す
-    // Amberが自動的に ?event=<result> を追加する (NIP-55)
-    const callbackUrl = baseUrl;
-
-    localStorage.setItem('amber_last_type', type);
-    localStorage.setItem('amber_last_id', id);
-    localStorage.setItem('amber_last_timestamp', Date.now().toString());
-
-    // NIP-55準拠: nostrsigner: スキーム
-    let url = `nostrsigner:${encodedContent}`;
-    const params = new URLSearchParams();
-    params.append('compressionType', 'none');
-    params.append('returnType', 'signature');
-    params.append('type', type);
-    params.append('callbackUrl', callbackUrl);
-
-    // 三重の冗長性でアプリ名を渡す
-    const appName = document.title || window.location.hostname;
-    params.append('name', appName);
-    params.append('appName', appName);
-    params.append('app', appName);
-
-    // NIP-46互換のmetadata形式も追加
-    const metadata = {
-      name: appName,
-      url: window.location.origin,
-      description: 'Nostr Login provided by nostr-login library',
-    };
-    params.append('metadata', JSON.stringify(metadata));
-
-    if (pubkey) params.append('pubkey', pubkey);
-    if (this._pubkey) params.append('current_user', this._pubkey);
-
-    return `${url}?${params.toString()}`;
-  }
-
-  // AmberDirectSigner.ts の parseResponse を拡張
-
-  static parseResponse(): AmberResponse | null {
-    const url = new URL(window.location.href);
-
-    // パターン1: NIP-55標準 (?event=...)
-    let result = url.searchParams.get('event');
-
-    // Amberが壊れた{result}プレースホルダーを返した場合のクリーンアップ
-    // 例: ?event=result}5650178... → 5650178...
-    if (result && result.includes('result}')) {
-      result = result.replace(/^result\}/, '');
-      console.log('[AmberDirectSigner] Cleaned up malformed result:', result);
-    }
-
-    // パターン2: パス末尾にhexId (/<hexId>)
-    if (!result) {
-      const pathParts = url.pathname.split('/').filter(Boolean);
-      if (pathParts.length > 0) {
-        const lastPart = pathParts[pathParts.length - 1];
-        // hexIdっぽい（64文字の16進数）
-        if (/^[0-9a-f]{64}$/i.test(lastPart)) {
-          result = lastPart;
-        }
-      }
-    }
-
-    if (result) {
-      console.log('Amber response detection:', {
-        href: window.location.href,
-        eventParam: url.searchParams.get('event'),
-        pathResult: result,
-        sessionId: localStorage.getItem('amber_last_id'),
-        sessionType: localStorage.getItem('amber_last_type'),
-      });
-    }
-
-    if (!result) return null;
-
-    const id = localStorage.getItem('amber_last_id');
-    const type = localStorage.getItem('amber_last_type');
-
-    localStorage.removeItem('amber_last_id');
-    localStorage.removeItem('amber_last_type');
-    localStorage.removeItem('amber_last_timestamp');
-
-    if (id && type) {
-      return { id, type, result };
-    }
-
-    return null;
-  }
-
-  static resolvePending(id: string, type: string, result: string): boolean {
-    const entry = this.pendingResolves.get(id);
-    if (entry) {
-      this.pendingResolves.delete(id);
-      if (entry.timer) clearTimeout(entry.timer);
-      console.log('[AmberDirectSigner] Resolving pending:', { id, type, resultLen: result.length });
-      entry.resolve(result);
-      return true;
-    }
-    console.warn('[AmberDirectSigner] No pending resolve found for:', id);
-    return false;
-  }
-
-  static cleanupPending() {
-    for (const [id, entry] of this.pendingResolves) {
-      try {
-        if (entry.timer) clearTimeout(entry.timer);
-        entry.resolve('');
-      } catch (e) {
-        // ignore
-      }
-    }
-    this.pendingResolves.clear();
-  }
-}

package/src/modules/Nip46.iframe.test.ts

@@ -1,124 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { IframeNostrRpc } from './Nip46';
-import { PrivateKeySigner } from './Signer';
-import { generatePrivateKey, validateEvent, verifySignature } from 'nostr-tools';
-
-describe('IframeNostrRpc integration', () => {
-  it('roundtrips request/response via MessagePort', async () => {
-    const localSk = generatePrivateKey();
-    const remoteSk = generatePrivateKey();
-    const localSigner = new PrivateKeySigner(localSk);
-    const remoteSigner = new PrivateKeySigner(remoteSk);
-
-    const rpc = new IframeNostrRpc(localSigner, 'https://example.com', ['wss://relay.example']);
-
-    // mock MessagePort
-    const port: any = {
-      onmessage: undefined as any,
-      postMessage: (msg: any) => {
-        // ignore ping messages from keepalive
-        if (typeof msg === 'string') return;
-        // log for debugging
-        console.log('[test] postMessage received', typeof msg, msg && typeof msg === 'object' && msg.pubkey);
-        console.log('[test] msg.id', msg && msg.id, 'kind', msg && msg.kind, 'contentType', typeof (msg && msg.content), 'contentLen', msg && msg.content && msg.content.length);
-        // simulate remote iframe processing (defer to avoid race with request setup)
-        setTimeout(() => {
-          (async () => {
-            try {
-              // remote decrypts request (sender pubkey is msg.pubkey)
-              const decrypted = await remoteSigner.decrypt(msg.pubkey, msg.content);
-              console.log('[test] decrypted raw', typeof decrypted, decrypted && decrypted.slice ? decrypted.slice(0, 120) : decrypted);
-              const req = JSON.parse(decrypted);
-              console.log('[test] parsed request id', req.id, 'method', req.method);
-
-              const response = { id: req.id, result: 'ack' };
-              const content = await remoteSigner.encrypt(msg.pubkey, JSON.stringify(response));
-              const event: any = {
-                kind: msg.kind,
-                content,
-                tags: [['p', msg.pubkey]],
-                pubkey: remoteSigner.pubkey,
-                created_at: Math.floor(Date.now() / 1000),
-              };
-
-              await remoteSigner.sign(event);
-
-              // debug: validate/verify locally to see why rpc might ignore it
-              console.log('[test] validateEvent', validateEvent(event), 'verifySignature', verifySignature(event));
-
-              // instead of posting back via port, directly parse with rpc to avoid EventEmitter timing issues
-              try {
-                const parsed = await (rpc as any).parseEvent(event);
-                console.log('[test] direct parsed result', parsed);
-                if (parsed && (parsed as any).result === 'ack') {
-                  // resolve the outer test promise via port._resolve
-                  try {
-                    (port as any)._resolve?.();
-                  } catch (e) {
-                    console.error('[test] resolve error', e);
-                  }
-                  return;
-                }
-              } catch (e) {
-                console.error('[test] parseEvent direct error', e);
-                throw e;
-              }
-            } catch (e) {
-              console.error('[test] postMessage handler error', e);
-              throw e;
-            }
-          })();
-        }, 0);
-      },
-    };
-
-    rpc.setWorkerIframePort(port as MessagePort);
-
-    // override getId so we can listen for the specific response event
-    const id = 'test-iframe-id';
-    (rpc as any).getId = () => id;
-
-    // instrument rpc.emit to see emitted events
-    const origEmit = (rpc as any).emit;
-    (rpc as any).emit = function (ev: any, payload: any) {
-      try {
-        console.log('[test] rpc.emit', ev, payload && payload.id, payload && JSON.stringify(payload));
-      } catch (e) {
-        console.log('[test] rpc.emit', ev, payload && payload.id);
-      }
-      return origEmit.apply(this, arguments as any);
-    };
-
-    // instrument parseEvent to see if the rpc handler runs
-    const origParse = (rpc as any).parseEvent;
-    (rpc as any).parseEvent = async function (event: any) {
-      console.log('[test] rpc.parseEvent called');
-      try {
-        const parsed = await origParse.apply(this, arguments as any);
-        console.log('[test] rpc.parseEvent result', parsed && parsed.id, parsed && (parsed as any).method);
-        return parsed;
-      } catch (e) {
-        console.error('[test] rpc.parseEvent error', e);
-        throw e;
-      }
-    };
-
-    await new Promise<void>((ok, err) => {
-      // attach resolve onto the port so deferred handler can call it
-      (port as any)._resolve = ok;
-
-      // use internal setResponseHandler directly to ensure we catch responses (optional)
-      (rpc as any).setResponseHandler(id, (res: any) => {
-        console.log('[test] setResponseHandler callback', res);
-        try {
-          expect(res.result).toBe('ack');
-          ok();
-        } catch (e) {
-          err(e);
-        }
-      });
-
-      rpc.sendRequest(remoteSigner.pubkey, 'connect', [localSigner.pubkey], 24133);
-    });
-  });
-});

package/src/modules/Nip46.test.ts

@@ -1,31 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { PrivateKeySigner } from './Signer';
-import { NostrRpc, IframeNostrRpc, Nip46Signer } from './Nip46';
-import { generatePrivateKey, getPublicKey } from 'nostr-tools';
-
-// basic smoke tests
-
-describe('NostrRpc basic', () => {
-  it('creates and signs event', async () => {
-    const sk = generatePrivateKey();
-    const signer = new PrivateKeySigner(sk);
-    const rpc = new NostrRpc(signer, ['wss://relay.nostr.example']);
-
-    const event = await rpc.createRequestEvent('id1', getPublicKey(sk), 'echo', ['hello']);
-    expect(event.kind).toBe(24133);
-    expect(event.pubkey).toBe(signer.pubkey);
-    expect(event.content).toBeTruthy();
-  });
-});
-
-describe('Nip46Signer basic', () => {
-  it('wraps signer and can sign', async () => {
-    const sk = generatePrivateKey();
-    const signer = new PrivateKeySigner(sk);
-    const nip = new Nip46Signer(signer, signer.pubkey);
-
-    const ev: any = { kind: 1, content: 'x', pubkey: signer.pubkey, tags: [] };
-    const sig = await nip.sign(ev);
-    expect(sig).toBeTruthy();
-  });
-});