@konemono/nostr-login 1.7.61 → 1.7.63

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@konemono/nostr-login",
-  "version": "1.7.61",
+  "version": "1.7.63",
   "description": "",
   "main": "./dist/index.esm.js",
   "types": "./dist/index.d.ts",

package/src/modules/AmberDirectSigner.ts

@@ -1,242 +1,162 @@
+import { AmberResponse } from '../types';
 import { Signer } from './Nostr';
 
-const PENDING_KEY = 'amber_pending_request';
-
 export class AmberDirectSigner implements Signer {
-  private _pubkey: string = '';
-  private static pendingResolves: Map<string, (result: any) => void> = new Map();
-
-  constructor(pubkey?: string) {
-    this._pubkey = pubkey || '';
-  }
-
-  get pubkey() {
-    return this._pubkey;
-  }
-
-  public set pubkey(v: string) {
-    this._pubkey = v;
-  }
-
-  nip04 = {
-    encrypt: (pubkey: string, plaintext: string) => this.encrypt04(pubkey, plaintext),
-    decrypt: (pubkey: string, ciphertext: string) => this.decrypt04(pubkey, ciphertext),
-  };
-
-  nip44 = {
-    encrypt: (pubkey: string, plaintext: string) => this.encrypt44(pubkey, plaintext),
-    decrypt: (pubkey: string, ciphertext: string) => this.decrypt44(pubkey, ciphertext),
-  };
-
-  private getHash(content: string): string {
-    let hash = 0;
-    for (let i = 0; i < content.length; i++) {
-        const char = content.charCodeAt(i);
-        hash = (hash << 5) - hash + char;
-        hash |= 0;
+    private _pubkey: string;
+    private static pendingResolves: Map<string, (result: string) => void> = new Map();
+
+    constructor(pubkey: string = '') {
+        this._pubkey = pubkey;
     }
-    return hash.toString(36);
-  }
-
-  private checkCache(content: string, type: string): string | null {
-    const hash = this.getHash(content);
-    const cacheKey = `amber_result_${type}_${hash}`;
-    const cached = sessionStorage.getItem(cacheKey);
-    if (cached) {
-        sessionStorage.removeItem(cacheKey);
-        return cached;
+
+    get pubkey() {
+        return this._pubkey;
     }
-    return null;
-  }
-
-  private setPending(id: string, content: string, type: string) {
-    const hash = this.getHash(content);
-    const data = JSON.stringify({ id, type, hash, timestamp: Date.now() });
-    sessionStorage.setItem(`amber_pending_${id}`, data);
-    localStorage.setItem(PENDING_KEY, data); // Backup for reloads
-  }
-
-  public static resolvePending(id: string, type: string, result: string) {
-    console.log('AmberDirectSigner: resolvePending', { id, type, pendingCount: this.pendingResolves.size });
-
-    let resolve = this.pendingResolves.get(id);
-    
-    // Fallback by type if only one pending of that type
-    if (!resolve) {
-        console.log('AmberDirectSigner: Falling back to resolve by type', type);
-        for (const [pendingId, pendingResolve] of this.pendingResolves.entries()) {
-            const pending = sessionStorage.getItem(`amber_pending_${pendingId}`) || localStorage.getItem(PENDING_KEY);
-            if (pending) {
-                try {
-                    const { type: pendingType } = JSON.parse(pending);
-                    if (pendingType === type || type.startsWith(pendingType)) {
-                        resolve = pendingResolve;
-                        id = pendingId;
-                        break;
-                    }
-                } catch (e) {}
-            }
-        }
+
+    set pubkey(v: string) {
+        this._pubkey = v;
     }
 
-    if (resolve) {
-        console.log('AmberDirectSigner: Promise resolved', id);
-        resolve(result);
-        this.pendingResolves.delete(id);
-        return true;
+    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(): Promise<string> {
+        const id = Math.random().toString(36).substring(7);
+        const url = this.generateUrl('', 'get_public_key', id);
+        window.location.href = url;
+        return new Promise((resolve) => {
+            AmberDirectSigner.pendingResolves.set(id, resolve);
+        });
     }
-    return false;
-  }
-
-  async signEvent(event: any): Promise<any> {
-    const content = JSON.stringify(event);
-    const cached = this.checkCache(content, 'sign_event');
-    if (cached) return JSON.parse(cached);
-
-    const id = Math.random().toString(36).substring(7);
-    this.setPending(id, content, 'sign_event');
-    const url = this.generateUrl(content, 'sign_event', id);
-    window.location.href = url;
-    return new Promise((resolve) => {
-        AmberDirectSigner.pendingResolves.set(id, (res) => resolve(JSON.parse(res)));
-    });
-  }
-
-  async getPublicKey(): Promise<string> {
-    const id = Math.random().toString(36).substring(7);
-    this.setPending(id, '', 'get_public_key');
-    const url = this.generateUrl('', 'get_public_key', id);
-    window.location.href = url;
-    return new Promise((resolve) => {
-        AmberDirectSigner.pendingResolves.set(id, resolve);
-    });
-  }
-
-  async encrypt04(pubkey: string, plaintext: string): Promise<string> {
-    const cached = this.checkCache(plaintext, 'nip04_encrypt');
-    if (cached) return cached;
-
-    const id = Math.random().toString(36).substring(7);
-    this.setPending(id, plaintext, 'nip04_encrypt');
-    const url = this.generateUrl(plaintext, 'nip04_encrypt', id, pubkey);
-    window.location.href = url;
-    return new Promise((resolve) => {
-        AmberDirectSigner.pendingResolves.set(id, resolve);
-    });
-  }
-
-  async decrypt04(pubkey: string, ciphertext: string): Promise<string> {
-    const cached = this.checkCache(ciphertext, 'nip04_decrypt');
-    if (cached) return cached;
-
-    const id = Math.random().toString(36).substring(7);
-    this.setPending(id, ciphertext, 'nip04_decrypt');
-    const url = this.generateUrl(ciphertext, 'nip04_decrypt', id, pubkey);
-    window.location.href = url;
-    return new Promise((resolve) => {
-        AmberDirectSigner.pendingResolves.set(id, resolve);
-    });
-  }
-
-  async encrypt44(pubkey: string, plaintext: string): Promise<string> {
-    const cached = this.checkCache(plaintext, 'nip44_encrypt');
-    if (cached) return cached;
-
-    const id = Math.random().toString(36).substring(7);
-    this.setPending(id, plaintext, 'nip44_encrypt');
-    const url = this.generateUrl(plaintext, 'nip44_encrypt', id, pubkey);
-    window.location.href = url;
-    return new Promise((resolve) => {
-        AmberDirectSigner.pendingResolves.set(id, resolve);
-    });
-  }
-
-  async decrypt44(pubkey: string, ciphertext: string): Promise<string> {
-    const cached = this.checkCache(ciphertext, 'nip44_decrypt');
-    if (cached) return cached;
-
-    const id = Math.random().toString(36).substring(7);
-    this.setPending(id, ciphertext, 'nip44_decrypt');
-    const url = this.generateUrl(ciphertext, 'nip44_decrypt', id, pubkey);
-    window.location.href = url;
-    return new Promise((resolve) => {
-        AmberDirectSigner.pendingResolves.set(id, resolve);
-    });
-  }
-
-  private generateUrl(content: string, type: string, id: string, recipient?: string): string {
-    const callbackUrl = new URL(window.location.origin + window.location.pathname);
-    
-    // Minimal parameters in callbackUrl to avoid conflicts
-    callbackUrl.searchParams.set('amberType', type);
-    callbackUrl.searchParams.set('amberId', id);
-
-    const name = document.title || window.location.hostname || 'Nostr Login';
-
-    const params: string[] = [];
-    params.push(`type=${encodeURIComponent(type)}`);
-    params.push(`id=${encodeURIComponent(id)}`);
-    params.push(`callbackUrl=${encodeURIComponent(callbackUrl.toString())}`);
-    params.push(`name=${encodeURIComponent(name)}`);
-    params.push(`app_name=${encodeURIComponent(name)}`);
-
-    if (recipient) {
-        params.push(`pubkey=${encodeURIComponent(recipient)}`);
-    } else if (this._pubkey) {
-        params.push(`pubkey=${encodeURIComponent(this._pubkey)}`);
+
+    public async signEvent(event: any): Promise<any> {
+        const id = Math.random().toString(36).substring(7);
+        const url = this.generateUrl(JSON.stringify(event), 'sign_event', id);
+        window.location.href = url;
+        return new Promise((resolve) => {
+            AmberDirectSigner.pendingResolves.set(id, (result: string) => {
+                resolve(JSON.parse(result));
+            });
+        });
     }
 
-    const dataPart = content ? encodeURIComponent(content) : 'get_public_key';
-    // Use nostrsigner: scheme as primary which is standard NIP-55
-    return `nostrsigner:${dataPart}?${params.join('&')}`;
-  }
-
-  public static parseResponse(): { type: string; id: string; result: string } | null {
-    const url = new URL(window.location.href);
-    const params = new URLSearchParams(url.search);
-    const hashParams = new URLSearchParams(url.hash.substring(1));
-
-    const getParam = (name: string) => params.get(name) || hashParams.get(name);
-
-    let type = getParam('amberType') || getParam('type');
-    let id = getParam('amberId') || getParam('id');
-    const result = getParam('signature') || getParam('result') || getParam('pubKey') || getParam('pubkey');
-
-    // Fallback to localStorage pending if params are missing/merged
-    if (result && (!type || !id)) {
-        const pending = localStorage.getItem(PENDING_KEY);
-        if (pending) {
-            try {
-                const { id: pId, type: pType } = JSON.parse(pending);
-                if (!type) type = pType;
-                if (!id) id = pId;
-                console.log('AmberDirectSigner: Recovered type/id from localStorage');
-            } catch (e) {}
-        }
+    public async encrypt04(pubkey: string, plaintext: string): Promise<string> {
+        const id = Math.random().toString(36).substring(7);
+        const url = this.generateUrl(plaintext, 'nip04_encrypt', id, pubkey);
+        window.location.href = url;
+        return new Promise((resolve) => {
+            AmberDirectSigner.pendingResolves.set(id, resolve);
+        });
+    }
+
+    public async decrypt04(pubkey: string, ciphertext: string): Promise<string> {
+        const id = Math.random().toString(36).substring(7);
+        const url = this.generateUrl(ciphertext, 'nip04_decrypt', id, pubkey);
+        window.location.href = url;
+        return new Promise((resolve) => {
+            AmberDirectSigner.pendingResolves.set(id, resolve);
+        });
+    }
+
+    public async encrypt44(pubkey: string, plaintext: string): Promise<string> {
+        const id = Math.random().toString(36).substring(7);
+        const url = this.generateUrl(plaintext, 'nip44_encrypt', id, pubkey);
+        window.location.href = url;
+        return new Promise((resolve) => {
+            AmberDirectSigner.pendingResolves.set(id, resolve);
+        });
+    }
+
+    public async decrypt44(pubkey: string, ciphertext: string): Promise<string> {
+        const id = Math.random().toString(36).substring(7);
+        const url = this.generateUrl(ciphertext, 'nip44_decrypt', id, pubkey);
+        window.location.href = url;
+        return new Promise((resolve) => {
+            AmberDirectSigner.pendingResolves.set(id, resolve);
+        });
+    }
+
+
+    private generateUrl(content: string, type: string, id: string, pubkey?: string): string {
+        const callbackUrl = window.location.href.split('#')[0].split('?')[0];
+        const encodedContent = encodeURIComponent(content || '');
+        const encodedCallback = encodeURIComponent(callbackUrl);
+
+        // ★ 追加: sessionStorageに保存（これが無い）
+        sessionStorage.setItem('amber_last_type', type);
+        sessionStorage.setItem('amber_last_id', id);
+        sessionStorage.setItem('amber_last_timestamp', Date.now().toString());
+
+        // NIP-55準拠: nostrsigner: スキーム
+        let url = `nostrsigner:${encodedContent}`;
+        url += `?compressionType=none`;
+        url += `&returnType=signature`;
+        url += `&type=${type}`;
+        url += `&callbackUrl=${encodedCallback}`;
+        if (pubkey) url += `&pubkey=${pubkey}`;
+        if (this._pubkey) url += `&current_user=${this._pubkey}`; // ★ 追加
+
+        return url;
     }
 
-    if (type && result) {
-        // Handle "ID stuck to type" or typo cases
-        let finalType = type.toLowerCase();
-        if (finalType.includes('get_pub')) finalType = 'get_public_key';
-        else if (finalType.includes('sign_event')) finalType = 'sign_event';
-        else if (finalType.includes('encrypt')) finalType = finalType.includes('44') ? 'nip44_encrypt' : 'nip04_encrypt';
-        else if (finalType.includes('decrypt')) finalType = finalType.includes('44') ? 'nip44_decrypt' : 'nip04_decrypt';
+    // AmberDirectSigner.ts の parseResponse を拡張
+
+    static parseResponse(): AmberResponse | null {
+        const url = new URL(window.location.href);
 
-        const finalId = id || '';
+        // パターン1: NIP-55標準 (?event=...)
+        let result = url.searchParams.get('event');
 
-        // Clean up URL
-        const newUrl = new URL(window.location.href);
-        ['amberType', 'amberId', 'signature', 'result', 'pubKey', 'pubkey', 'type', 'id'].forEach(p => {
-            newUrl.searchParams.delete(p);
+        // パターン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;
+                }
+            }
+        }
+
+        console.log('Amber response detection:', {
+            href: window.location.href,
+            eventParam: url.searchParams.get('event'),
+            pathResult: result,
+            sessionId: sessionStorage.getItem('amber_last_id'),
+            sessionType: sessionStorage.getItem('amber_last_type')
         });
-        newUrl.hash = ''; 
-        window.history.replaceState({}, '', newUrl.toString());
-        
-        localStorage.removeItem(PENDING_KEY); // Done
 
-        return { type: finalType, id: finalId, result };
+        if (!result) return null;
+
+        const id = sessionStorage.getItem('amber_last_id');
+        const type = sessionStorage.getItem('amber_last_type');
+
+        sessionStorage.removeItem('amber_last_id');
+        sessionStorage.removeItem('amber_last_type');
+        sessionStorage.removeItem('amber_last_timestamp');
+
+        if (id && type) {
+            return { id, type, result };
+        }
+
+        return null;
+    }
+
+    static resolvePending(id: string, type: string, result: string): boolean {
+        const resolve = this.pendingResolves.get(id);
+        if (resolve) {
+            this.pendingResolves.delete(id);
+            resolve(result);
+            return true;
+        }
+        return false;
     }
-    return null;
-  }
 }

package/src/modules/AuthNostrService.ts

@@ -12,6 +12,7 @@ import { PrivateKeySigner } from './Signer';
 import { AmberDirectSigner } from './AmberDirectSigner';
 
 
+
 const OUTBOX_RELAYS = ['wss://user.kindpag.es', 'wss://purplepag.es', 'wss://relay.nos.social'];
 const DEFAULT_NOSTRCONNECT_RELAYS = ['wss://relay.nsec.app/', 'wss://ephemeral.snowflare.cc/'];
 const CONNECT_TIMEOUT = 5000;
@@ -94,7 +95,7 @@ class AuthNostrService extends EventEmitter implements Signer {
 
     window.addEventListener('focus', check);
     window.addEventListener('visibilitychange', () => {
-        if (document.visibilityState === 'visible') check();
+      if (document.visibilityState === 'visible') check();
     });
     window.addEventListener('popstate', check);
     window.addEventListener('hashchange', check);
@@ -114,7 +115,7 @@ class AuthNostrService extends EventEmitter implements Signer {
       // Resolve pending promises if any (for non-reload cases)
       const resolved = AmberDirectSigner.resolvePending(response.id, response.type, response.result);
       if (resolved) {
-          console.log('Resolved pending Amber promise via resolvePending');
+        console.log('Resolved pending Amber promise via resolvePending');
       }
 
       if (response.type === 'get_public_key' || response.type.includes('pub')) {
@@ -125,18 +126,14 @@ class AuthNostrService extends EventEmitter implements Signer {
         console.log('Amber login success', info);
         this.onAuth('login', info);
       } else {
-        const pendingKey = `amber_pending_${response.id}`;
-        const pending = sessionStorage.getItem(pendingKey);
-        if (pending) {
-          const { hash, type } = JSON.parse(pending);
-          sessionStorage.removeItem(pendingKey);
-          if (type === response.type) {
-            const cacheKey = `amber_result_${type}_${hash}`;
-            sessionStorage.setItem(cacheKey, response.result);
-            console.log('Stored Amber result', cacheKey);
-          }
-        }
+        // ★ 不要: この部分は削除または簡略化
+        // NIP-55では直接resultを使用するため、追加のキャッシュは不要
       }
+
+      // ★ 追加: URLクエリパラメータをクリーンアップ
+      const url = new URL(window.location.href);
+      url.searchParams.delete('event');
+      window.history.replaceState({}, '', url.toString());
     }
   }
 

package/src/types.ts

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