@konemono/nostr-login 1.7.70 → 1.8.0

package/src/modules/Signer.ts

@@ -1,13 +1,13 @@
-import { NDKPrivateKeySigner, NDKUser } from '@nostr-dev-kit/ndk';
 import { Nip44 } from '../utils/nip44';
-import { getPublicKey } from 'nostr-tools';
+import { getPublicKey, getEventHash, getSignature, nip04 } from 'nostr-tools';
 
-export class PrivateKeySigner extends NDKPrivateKeySigner {
+export class PrivateKeySigner {
   private nip44: Nip44 = new Nip44();
   private _pubkey: string;
+  public privateKey: string;
 
   constructor(privateKey: string) {
-    super(privateKey);
+    this.privateKey = privateKey;
     this._pubkey = getPublicKey(privateKey);
   }
 
@@ -15,11 +15,42 @@ export class PrivateKeySigner extends NDKPrivateKeySigner {
     return this._pubkey;
   }
 
-  encryptNip44(recipient: NDKUser, value: string): Promise<string> {
-    return Promise.resolve(this.nip44.encrypt(this.privateKey!, recipient.pubkey, value));
+  async blockUntilReady() {
+    return Promise.resolve();
   }
 
-  decryptNip44(sender: NDKUser, value: string): Promise<string> {
-    return Promise.resolve(this.nip44.decrypt(this.privateKey!, sender.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));
   }
 }

package/src/modules/nip46/Nip46Adapter.ts

@@ -0,0 +1,123 @@
+import { EventEmitter } from 'tseep';
+import { Nip46Client } from './Nip46Client';
+import { PrivateKeySigner } from '../Signer';
+
+export class Nip46Adapter extends EventEmitter {
+  private client: Nip46Client;
+  private localSigner: PrivateKeySigner;
+  public userPubkey: string = '';
+  public remotePubkey: string;
+
+  constructor(client: Nip46Client, localSigner: PrivateKeySigner) {
+    super();
+    this.client = client;
+    this.localSigner = localSigner;
+    this.remotePubkey = (client as any).remotePubkey || '';
+
+    // forward events
+    this.client.on('authUrl', (url: string) => {
+      this.emit('authUrl', url);
+    });
+    this.client.on('response', ({ response, pubkey }: any) => {
+      this.emit('response', response, pubkey);
+    });
+  }
+
+  async initUserPubkey(hintPubkey?: string) {
+    if (this.userPubkey) throw new Error('Already called initUserPubkey');
+    if (hintPubkey) {
+      this.userPubkey = hintPubkey;
+      return;
+    }
+
+    const res = await this.client.sendRequest('get_public_key', []);
+    if (!res) throw new Error('No public key returned');
+    this.userPubkey = res;
+  }
+
+  async listen(nostrConnectSecret: string): Promise<string> {
+    return new Promise<string>((ok, err) => {
+      const onResponse = ({ response, pubkey }: any) => {
+        if (!response) return;
+        if (response.result === 'auth_url') return;
+        if (response.result === 'ack' || response.result === nostrConnectSecret) {
+          this.client.off('response', onResponse);
+          ok(pubkey);
+        }
+      };
+
+      this.client.on('response', onResponse);
+
+      // also add a timeout
+      setTimeout(() => {
+        this.client.off('response', onResponse);
+        err(new Error('Listen timeout'));
+      }, 30000);
+    });
+  }
+
+  async connect(token?: string, perms?: string) {
+    const result = await this.client.sendRequest('connect', [this.localSigner.pubkey, token || '', perms || '']);
+    if (result !== 'ack') throw new Error(result || 'connect failed');
+  }
+
+  async setListenReply(reply: any, nostrConnectSecret: string) {
+    // reply is expected to be a raw event object; we'll try to parse its content
+    // Attempt to decrypt via the client flow by treating it as a response
+    try {
+      const decoded = reply && reply.content ? JSON.parse(reply.content) : null;
+      if (!decoded) throw new Error('Bad reply');
+      if (decoded.result === nostrConnectSecret) {
+        this.userPubkey = reply.pubkey;
+      } else {
+        throw new Error('Bad reply');
+      }
+    } catch (e) {
+      throw new Error('Failed to set listen reply');
+    }
+  }
+
+  async createAccount2({ bunkerPubkey, name, domain, perms = '' }: { bunkerPubkey: string; name: string; domain: string; perms?: string }) {
+    const params = [name, domain, '', perms];
+
+    const r = await this.client.sendRequest('create_account', params);
+    if (!r) throw new Error('create_account failed');
+    if (r === 'error') throw new Error('create_account error');
+    return r;
+  }
+
+  async encrypt(recipientPubkey: string, plaintext: string) {
+    const r = await this.client.sendRequest('nip04_encrypt', [recipientPubkey, plaintext]);
+    return r;
+  }
+
+  async decrypt(recipientPubkey: string, ciphertext: string) {
+    const r = await this.client.sendRequest('nip04_decrypt', [recipientPubkey, ciphertext]);
+    return r;
+  }
+
+  async sign(event: any) {
+    const r = await this.client.sendRequest('sign_event', [JSON.stringify(event)]);
+    try {
+      const parsed = typeof r === 'string' ? JSON.parse(r) : r;
+      if (parsed && parsed.sig) return parsed.sig;
+    } catch (e) {
+      // not JSON
+    }
+    return r;
+  }
+
+  // provide rpc compatibility
+  get rpc() {
+    return {
+      sendRequest: async (remotePubkey: string, method: string, params: string[], kind: number, cb: (res: any) => void) => {
+        try {
+          const res = await this.client.sendRequest(method, params);
+          cb({ result: res });
+        } catch (err: any) {
+          cb({ error: err.message });
+        }
+      },
+    };
+  }
+}

package/src/modules/nip46/Nip46Client.ts

@@ -0,0 +1,248 @@
+import { SimplePool, Event as NostrEvent, getPublicKey, nip04 } from 'nostr-tools';
+import { Nip44 } from '../../utils/nip44';
+import { EventEmitter } from 'tseep';
+import { Nip46Request, Nip46Response, PendingRequest, Nip46ClientOptions } from './types';
+import { getEventHash, getSignature } from 'nostr-tools';
+
+export class Nip46Client extends EventEmitter {
+  private pool: SimplePool;
+  private localPrivateKey: string;
+  private remotePubkey: string;
+  private relays: string[];
+  private pendingRequests: Map<string, PendingRequest> = new Map();
+  private defaultTimeoutMs: number;
+  private useNip44: boolean;
+  private subscription: any = null;
+  private isSubscribed: boolean = false;
+  private nip44Codec: Nip44 = new Nip44();
+
+  constructor(options: Nip46ClientOptions) {
+    super();
+    this.pool = new SimplePool();
+    this.localPrivateKey = options.localPrivateKey;
+    this.remotePubkey = options.remotePubkey;
+    this.relays = options.relays;
+    this.defaultTimeoutMs = options.timeoutMs || 30000;
+    this.useNip44 = options.useNip44 || false;
+  }
+
+  get localPubkey(): string {
+    return getPublicKey(this.localPrivateKey);
+  }
+
+  /**
+   * NIP-46リクエストを送信
+   */
+  async sendRequest(method: string, params: string[] = [], timeoutMs?: number): Promise<string> {
+    const timeout = timeoutMs || this.defaultTimeoutMs;
+    const id = this.generateId();
+    const request: Nip46Request = { id, method, params };
+
+    console.log('[Nip46Client] Sending request:', { id, method, params });
+
+    // レスポンス購読を開始（まだの場合）
+    if (!this.isSubscribed) {
+      this.subscribeToResponses();
+    }
+
+    // リクエストイベントを作成・送信
+    await this.publishRequest(request);
+
+    // レスポンスを待つPromise
+    return new Promise<string>((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingRequests.delete(id);
+        const error = new Error(`Request ${id} (${method}) timed out after ${timeout}ms`);
+        console.error('[Nip46Client]', error.message);
+        reject(error);
+      }, timeout);
+
+      this.pendingRequests.set(id, {
+        resolve,
+        reject,
+        timer,
+        method,
+      });
+    });
+  }
+
+  /**
+   * リクエストイベントを作成して送信
+   */
+  private async publishRequest(request: Nip46Request): Promise<void> {
+    const content = JSON.stringify(request);
+
+    // 暗号化
+    const encrypted = this.useNip44
+      ? await this.nip44Codec.encrypt(this.localPrivateKey, this.remotePubkey, content)
+      : await nip04.encrypt(this.localPrivateKey, this.remotePubkey, content);
+
+    // イベント作成
+    const event: NostrEvent = {
+      kind: 24133,
+      pubkey: this.localPubkey,
+      created_at: Math.floor(Date.now() / 1000),
+      tags: [['p', this.remotePubkey]],
+      content: encrypted,
+      id: '',
+      sig: '',
+    };
+
+    // ID計算
+    event.id = getEventHash(event);
+
+    // 署名
+    event.sig = getSignature(event, this.localPrivateKey);
+
+    // リレーに送信
+    await Promise.any(this.pool.publish(this.relays, event));
+    console.log('[Nip46Client] Request published:', request.id);
+  }
+
+  /**
+   * レスポンスイベントを購読
+   */
+  private subscribeToResponses(): void {
+    if (this.isSubscribed) return;
+
+    const filter = {
+      'kinds': [24133],
+      '#p': [this.localPubkey],
+      'since': Math.floor(Date.now() / 1000) - 60,
+    };
+
+    console.log('[Nip46Client] Subscribing to responses');
+
+    // SimplePool subscription
+    this.subscription = this.pool.sub(this.relays, [filter]);
+    this.subscription.on('event', async (event: NostrEvent) => {
+      await this.handleResponseEvent(event);
+    });
+    this.subscription.on('eose', () => {
+      console.log('[Nip46Client] EOSE received');
+    });
+
+    this.isSubscribed = true;
+  }
+
+  /**
+   * レスポンスイベントを処理
+   */
+  private async handleResponseEvent(event: NostrEvent): Promise<void> {
+    try {
+      // 復号化
+      const decrypted = this.isNip04(event.content)
+        ? await nip04.decrypt(this.localPrivateKey, event.pubkey, event.content)
+        : await this.nip44Codec.decrypt(this.localPrivateKey, event.pubkey, event.content);
+
+      const response: Nip46Response = JSON.parse(decrypted);
+
+      console.log('[Nip46Client] Response received:', {
+        id: response.id,
+        hasResult: !!response.result,
+        hasError: !!response.error,
+      });
+
+      // Emit response event for consumers (include sender pubkey)
+      this.emit('response', { response, pubkey: event.pubkey });
+
+      // auth_urlの特別処理
+      if (response.result === 'auth_url') {
+        console.log('[Nip46Client] Auth URL received:', response.error);
+        this.emit('authUrl', response.error);
+        return;
+      }
+
+      // 保留中のリクエストを解決
+      const pending = this.pendingRequests.get(response.id);
+      if (pending) {
+        clearTimeout(pending.timer);
+        this.pendingRequests.delete(response.id);
+
+        if (response.error) {
+          console.error('[Nip46Client] Request failed:', {
+            id: response.id,
+            method: pending.method,
+            error: response.error,
+          });
+          pending.reject(new Error(response.error));
+        } else if (response.result !== undefined) {
+          console.log('[Nip46Client] Request succeeded:', {
+            id: response.id,
+            method: pending.method,
+          });
+          pending.resolve(response.result);
+        } else {
+          pending.reject(new Error('Invalid response: no result or error'));
+        }
+      } else {
+        console.warn('[Nip46Client] Received response for unknown request:', response.id);
+      }
+    } catch (error) {
+      console.error('[Nip46Client] Failed to parse response event:', error);
+    }
+  }
+
+  /**
+   * NIP-04かNIP-44かを判定
+   */
+  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] === '=';
+  }
+
+  /**
+   * ランダムIDを生成
+   */
+  private generateId(): string {
+    return Math.random().toString(36).substring(2, 15);
+  }
+
+  /**
+   * NIP-44を使用するかどうかを設定
+   */
+  setUseNip44(useNip44: boolean): void {
+    this.useNip44 = useNip44;
+  }
+
+  /**
+   * クリーンアップ
+   */
+  cleanup(): void {
+    console.log('[Nip46Client] Cleaning up');
+
+    // すべての保留中リクエストをキャンセル
+    for (const [id, pending] of this.pendingRequests) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error('Client cleanup'));
+    }
+    this.pendingRequests.clear();
+
+    // 購読を停止
+    if (this.subscription) {
+      // SimplePool subscriptions may use `unsub` or `close`
+      try {
+        if (typeof this.subscription.unsub === 'function') this.subscription.unsub();
+        if (typeof this.subscription.close === 'function') this.subscription.close();
+      } catch (e) {
+        // ignore
+      }
+      this.subscription = null;
+      this.isSubscribed = false;
+    }
+
+    // リレー接続を閉じる
+    this.pool.close(this.relays);
+
+    // イベントリスナーをクリア
+    this.removeAllListeners();
+  }
+
+  /**
+   * 接続状態を確認
+   */
+  isConnected(): boolean {
+    return this.isSubscribed;
+  }
+}

package/src/modules/nip46/types.ts

@@ -0,0 +1,26 @@
+export interface Nip46Request {
+    id: string;
+    method: string;
+    params: string[];
+}
+
+export interface Nip46Response {
+    id: string;
+    result?: string;
+    error?: string;
+}
+
+export interface PendingRequest {
+    resolve: (result: string) => void;
+    reject: (error: Error) => void;
+    timer: NodeJS.Timeout;
+    method: string;
+}
+
+export interface Nip46ClientOptions {
+    localPrivateKey: string;
+    remotePubkey: string;
+    relays: string[];
+    timeoutMs?: number;
+    useNip44?: boolean;
+}

package/src/utils/index.ts

@@ -1,6 +1,5 @@
 import { Info, RecentType } from 'nostr-login-components/dist/types/types';
-import NDK, { NDKEvent, NDKRelaySet, NDKSigner, NDKUser } from '@nostr-dev-kit/ndk';
-import { generatePrivateKey } from 'nostr-tools';
+import { generatePrivateKey, SimplePool, getEventHash } from 'nostr-tools';
 import { NostrLoginOptions } from '../types';
 
 const LOCAL_STORE_KEY = '__nostrlogin_nip46';
@@ -19,7 +18,7 @@ export const localStorageGetItem = (key: string) => {
   if (value) {
     try {
       return JSON.parse(value);
-    } catch { }
+    } catch {}
   }
 
   return null;
@@ -29,12 +28,53 @@ export const localStorageRemoveItem = (key: string) => {
   localStorage.removeItem(key);
 };
 
-export const fetchProfile = async (info: Info, profileNdk: NDK) => {
-  const user = new NDKUser({ pubkey: info.pubkey });
-
-  user.ndk = profileNdk;
+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
+    }
+  }
 
-  return await user.fetchProfile();
+  // 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);
+    });
+  });
 };
 
 export const prepareSignupRelays = (signupRelays?: string) => {
@@ -46,43 +86,46 @@ export const prepareSignupRelays = (signupRelays?: string) => {
   return relays;
 };
 
-export const createProfile = async (info: Info, profileNdk: NDK, signer: NDKSigner, signupRelays?: string, outboxRelays?: string[]) => {
+export const createProfile = async (info: Info, signer: any, signupRelays?: string, outboxRelays?: string[]) => {
   const meta = {
     name: info.name,
   };
 
-  const profileEvent = new NDKEvent(profileNdk, {
+  const profileEvent: any = {
     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 = new NDKEvent(profileNdk, {
+  const relaysEvent: any = {
     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]);
   }
 
-  await profileEvent.sign(signer);
+  // signer is expected to implement sign(event)
+  await signer.sign(profileEvent);
   console.log('signed profile', profileEvent);
-  await relaysEvent.sign(signer);
+  await signer.sign(relaysEvent);
   console.log('signed relays', relaysEvent);
 
   const outboxRelaysFinal = outboxRelays && outboxRelays.length ? outboxRelays : OUTBOX_RELAYS;
 
-  await profileEvent.publish(NDKRelaySet.fromRelayUrls(outboxRelaysFinal, profileNdk));
+  // publish using SimplePool
+  const pool = new SimplePool();
+  await Promise.any(pool.publish(outboxRelaysFinal, profileEvent));
   console.log('published profile', profileEvent);
-  await relaysEvent.publish(NDKRelaySet.fromRelayUrls(outboxRelaysFinal, profileNdk));
+  await Promise.any(pool.publish(outboxRelaysFinal, relaysEvent));
   console.log('published relays', relaysEvent);
 };
 
@@ -128,9 +171,7 @@ export const getBunkerUrl = async (value: string, optionsModal: NostrLoginOption
       throw new Error('Bunker relay not provided');
     }
 
-    const relayParams = bunkerRelays
-      .map(r => `relay=${encodeURIComponent(r)}`)
-      .join('&');
+    const relayParams = bunkerRelays.map(r => `relay=${encodeURIComponent(r)}`).join('&');
 
     return `bunker://${userPubkey}?${relayParams}`;
   }
@@ -167,7 +208,7 @@ export const checkNip05 = async (nip05: string) => {
         pubkey = d.names[name];
         return;
       }
-    } catch { }
+    } catch {}
 
     available = true;
   })();

package/tsconfig.json

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

package/vitest.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['src/**/*.test.ts'],
+  },
+});