@konemono/nostr-login 1.7.70 → 1.9.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,180 @@
+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;
+      console.log('[Nip46Adapter] User pubkey set from hint:', hintPubkey);
+      return;
+    }
+
+    console.log('[Nip46Adapter] Fetching user pubkey');
+    try {
+      const res = await this.client.sendRequest('get_public_key', []);
+      if (!res) throw new Error('No public key returned');
+      this.userPubkey = res;
+      console.log('[Nip46Adapter] User pubkey fetched:', res);
+    } catch (error: any) {
+      console.error('[Nip46Adapter] Failed to get user pubkey:', error.message);
+      throw error;
+    }
+  }
+
+  /**
+   * nostrconnect:// フロー - 受信待機
+   * サイナーからの接続を待つ
+   */
+  async listen(nostrConnectSecret: string, timeoutMs: number = 60000): Promise<string> {
+    console.log('[Nip46Adapter] Starting listen mode, timeout:', timeoutMs);
+
+    return new Promise<string>((resolve, reject) => {
+      const timer = setTimeout(() => {
+        cleanup();
+        const error = new Error(`Listen timeout after ${timeoutMs}ms`);
+        console.error('[Nip46Adapter]', error.message);
+        reject(error);
+      }, timeoutMs);
+
+      const cleanup = () => {
+        clearTimeout(timer);
+        this.client.off('response', onResponse);
+      };
+
+      const onResponse = ({ response, pubkey }: any) => {
+        if (!response) return;
+
+        // auth_urlは無視（別のハンドラが処理）
+        if (response.result === 'auth_url') return;
+
+        // 成功: ack または secret が返される
+        if (response.result === 'ack' || response.result === nostrConnectSecret) {
+          cleanup();
+          console.log('[Nip46Adapter] Listen succeeded, signer pubkey:', pubkey);
+          resolve(pubkey);
+        } else if (response.error) {
+          cleanup();
+          console.error('[Nip46Adapter] Listen failed:', response.error);
+          reject(new Error(response.error));
+        }
+      };
+
+      this.client.on('response', onResponse);
+    });
+  }
+
+  /**
+   * bunker:// フロー - 能動的接続
+   * サイナーに接続リクエストを送る
+   */
+  async connect(token?: string, perms?: string, timeoutMs: number = 30000): Promise<void> {
+    console.log('[Nip46Adapter] Connecting with token, timeout:', timeoutMs);
+
+    try {
+      const result = await this.client.sendRequest('connect', [this.localSigner.pubkey, token || '', perms || ''], timeoutMs);
+
+      if (result !== 'ack') {
+        throw new Error(`Connect failed: ${result || 'unknown error'}`);
+      }
+
+      console.log('[Nip46Adapter] Connected successfully');
+    } catch (error: any) {
+      console.error('[Nip46Adapter] Connect failed:', error.message);
+      throw error;
+    }
+  }
+
+  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];
+
+    console.log('[Nip46Adapter] Creating account:', { name, domain });
+    try {
+      const r = await this.client.sendRequest('create_account', params);
+      if (!r) throw new Error('create_account returned empty result');
+      if (r === 'error') throw new Error('create_account failed');
+      console.log('[Nip46Adapter] Account created successfully');
+      return r;
+    } catch (error: any) {
+      console.error('[Nip46Adapter] Failed to create account:', error.message);
+      throw error;
+    }
+  }
+
+  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) {
+    try {
+      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;
+    } catch (error: any) {
+      console.error('[Nip46Adapter] Failed to sign event:', error.message);
+      throw error;
+    }
+  }
+
+  // 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,356 @@
+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();
+  private iframeConfig?: { origin: string; port?: MessagePort };
+  private retryConfig: { maxRetries: number; retryDelayMs: number };
+  private iframeKeepaliveInterval?: NodeJS.Timeout;
+
+  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;
+    this.iframeConfig = options.iframeConfig;
+    this.retryConfig = options.retryConfig || { maxRetries: 3, retryDelayMs: 1000 };
+
+    // iframe用のメッセージハンドラを設定
+    if (this.iframeConfig?.port) {
+      this.setupIframePort(this.iframeConfig.port);
+    }
+  }
+
+  get localPubkey(): string {
+    return getPublicKey(this.localPrivateKey);
+  }
+
+  /**
+   * NIP-46リクエストを送信（リトライ機能付き）
+   */
+  async sendRequest(method: string, params: string[] = [], timeoutMs?: number): Promise<string> {
+    let lastError: Error | null = null;
+
+    for (let attempt = 0; attempt <= this.retryConfig.maxRetries; attempt++) {
+      try {
+        if (attempt > 0) {
+          const delay = this.retryConfig.retryDelayMs * attempt;
+          console.log(`[Nip46Client] Retry attempt ${attempt}/${this.retryConfig.maxRetries} for ${method} after ${delay}ms`);
+          await new Promise(resolve => setTimeout(resolve, delay));
+        }
+
+        return await this.sendRequestInternal(method, params, timeoutMs);
+      } catch (error: any) {
+        lastError = error;
+
+        // タイムアウトまたはネットワークエラーの場合のみリトライ
+        const shouldRetry = error.message.includes('timed out') || error.message.includes('network') || error.message.includes('publish');
+
+        if (!shouldRetry || attempt === this.retryConfig.maxRetries) {
+          console.error(`[Nip46Client] Request failed after ${attempt + 1} attempts:`, error.message);
+          throw error;
+        }
+      }
+    }
+
+    throw lastError || new Error('Request failed after retries');
+  }
+
+  /**
+   * NIP-46リクエストを送信（内部実装）
+   */
+  private async sendRequestInternal(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);
+
+    // iframeがある場合は優先的に使用
+    if (this.iframeConfig?.port) {
+      try {
+        this.iframeConfig.port.postMessage(event);
+        console.log('[Nip46Client] Request sent via iframe:', request.id);
+        return;
+      } catch (e) {
+        console.warn('[Nip46Client] Iframe send failed, falling back to relays:', e);
+      }
+    }
+
+    // リレーに送信
+    try {
+      await Promise.any(this.pool.publish(this.relays, event));
+      console.log('[Nip46Client] Request published to relays:', request.id);
+    } catch (e) {
+      console.error('[Nip46Client] Failed to publish to relays:', e);
+      throw new Error('Failed to publish request to relays');
+    }
+  }
+
+  /**
+   * レスポンスイベントを購読
+   */
+  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の特別処理: OAuth完了後に実際のレスポンスが来るまで待つ
+      if (response.result === 'auth_url') {
+        console.log('[Nip46Client] Auth URL received:', response.error);
+        this.emit('authUrl', response.error);
+        // 注意: pendingRequestsは削除しない
+        // OAuth完了後に同じIDで実際のレスポンスが返ってくる
+        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;
+    }
+
+    // iframeのkeepaliveをクリア
+    if (this.iframeKeepaliveInterval) {
+      clearInterval(this.iframeKeepaliveInterval);
+      this.iframeKeepaliveInterval = undefined;
+    }
+
+    // リレー接続を閉じる
+    this.pool.close(this.relays);
+
+    // イベントリスナーをクリア
+    this.removeAllListeners();
+  }
+
+  /**
+   * 接続状態を確認
+   */
+  isConnected(): boolean {
+    return this.isSubscribed;
+  }
+
+  /**
+   * iframeポートを設定
+   */
+  setIframePort(port: MessagePort): void {
+    if (!this.iframeConfig) {
+      throw new Error('Iframe config not set');
+    }
+    this.iframeConfig.port = port;
+    this.setupIframePort(port);
+  }
+
+  /**
+   * iframe用のメッセージハンドラを設定
+   */
+  private setupIframePort(port: MessagePort): void {
+    port.onmessage = async (ev: MessageEvent) => {
+      if (ev.data === 'ping') return;
+
+      try {
+        const event = ev.data;
+        // validate and handle event
+        if (!event || typeof event !== 'object') {
+          console.warn('[Nip46Client] Invalid message from iframe');
+          return;
+        }
+        await this.handleResponseEvent(event);
+      } catch (e) {
+        console.error('[Nip46Client] Iframe message error:', e);
+      }
+    };
+
+    // Keep alive
+    this.iframeKeepaliveInterval = setInterval(() => {
+      try {
+        port.postMessage('ping');
+      } catch (e) {
+        console.warn('[Nip46Client] Failed to send keepalive ping:', e);
+      }
+    }, 5000);
+
+    console.log('[Nip46Client] Iframe port setup complete');
+  }
+}

package/src/modules/nip46/types.ts

@@ -0,0 +1,34 @@
+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;
+  iframeConfig?: {
+    origin: string;
+    port?: MessagePort;
+  };
+  retryConfig?: {
+    maxRetries: number;
+    retryDelayMs: number;
+  };
+}