@konemono/nostr-login 1.7.61 → 1.7.62

package/package.json

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

package/src/modules/AmberDirectSigner.ts

@@ -1,242 +1,142 @@
+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();
+  private _pubkey: string;
+  private static pendingResolves: Map<string, (result: string) => void> = new Map();
 
-  constructor(pubkey?: string) {
-    this._pubkey = pubkey || '';
+  constructor(pubkey: string = '') {
+    this._pubkey = pubkey;
   }
 
   get pubkey() {
     return this._pubkey;
   }
 
-  public set pubkey(v: string) {
+  set pubkey(v: string) {
     this._pubkey = v;
   }
 
-  nip04 = {
+  public nip04 = {
     encrypt: (pubkey: string, plaintext: string) => this.encrypt04(pubkey, plaintext),
     decrypt: (pubkey: string, ciphertext: string) => this.decrypt04(pubkey, ciphertext),
   };
 
-  nip44 = {
+  public 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;
-    }
-    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;
-    }
-    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) {}
-            }
-        }
-    }
-
-    if (resolve) {
-        console.log('AmberDirectSigner: Promise resolved', id);
-        resolve(result);
-        this.pendingResolves.delete(id);
-        return true;
-    }
-    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);
-
+  public async getPublicKey(): Promise<string> {
     const id = Math.random().toString(36).substring(7);
-    this.setPending(id, content, 'sign_event');
-    const url = this.generateUrl(content, 'sign_event', id);
+    const url = this.generateUrl('', 'get_public_key', id);
     window.location.href = url;
     return new Promise((resolve) => {
-        AmberDirectSigner.pendingResolves.set(id, (res) => resolve(JSON.parse(res)));
+      AmberDirectSigner.pendingResolves.set(id, resolve);
     });
   }
 
-  async getPublicKey(): Promise<string> {
+  public async signEvent(event: any): Promise<any> {
     const id = Math.random().toString(36).substring(7);
-    this.setPending(id, '', 'get_public_key');
-    const url = this.generateUrl('', 'get_public_key', id);
+    const url = this.generateUrl(JSON.stringify(event), 'sign_event', id);
     window.location.href = url;
     return new Promise((resolve) => {
-        AmberDirectSigner.pendingResolves.set(id, resolve);
+      AmberDirectSigner.pendingResolves.set(id, (result: string) => {
+        resolve(JSON.parse(result));
+      });
     });
   }
 
-  async encrypt04(pubkey: string, plaintext: string): Promise<string> {
-    const cached = this.checkCache(plaintext, 'nip04_encrypt');
-    if (cached) return cached;
-
+  public async encrypt04(pubkey: string, plaintext: string): Promise<string> {
     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);
+      AmberDirectSigner.pendingResolves.set(id, resolve);
     });
   }
 
-  async decrypt04(pubkey: string, ciphertext: string): Promise<string> {
-    const cached = this.checkCache(ciphertext, 'nip04_decrypt');
-    if (cached) return cached;
-
+  public async decrypt04(pubkey: string, ciphertext: string): Promise<string> {
     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);
+      AmberDirectSigner.pendingResolves.set(id, resolve);
     });
   }
 
-  async encrypt44(pubkey: string, plaintext: string): Promise<string> {
-    const cached = this.checkCache(plaintext, 'nip44_encrypt');
-    if (cached) return cached;
-
+  public async encrypt44(pubkey: string, plaintext: string): Promise<string> {
     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);
+      AmberDirectSigner.pendingResolves.set(id, resolve);
     });
   }
 
-  async decrypt44(pubkey: string, ciphertext: string): Promise<string> {
-    const cached = this.checkCache(ciphertext, 'nip44_decrypt');
-    if (cached) return cached;
-
+  public async decrypt44(pubkey: string, ciphertext: string): Promise<string> {
     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);
+      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)}`);
-    }
 
-    const dataPart = content ? encodeURIComponent(content) : 'get_public_key';
-    // Use nostrsigner: scheme as primary which is standard NIP-55
-    return `nostrsigner:${dataPart}?${params.join('&')}`;
-  }
+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;
+}
 
-  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) {}
-        }
-    }
+static parseResponse(): AmberResponse | null  {
+  // NIP-55準拠: クエリパラメータから取得
+  const url = new URL(window.location.href);
+  const result = url.searchParams.get('event');
+  
+  if (!result) return null;
+  
+  // ★ sessionStorageから id と type を取得
+  const id = sessionStorage.getItem('amber_last_id');
+  const type = sessionStorage.getItem('amber_last_type');
+  
+  // ★ sessionStorage をクリーンアップ
+  sessionStorage.removeItem('amber_last_id');
+  sessionStorage.removeItem('amber_last_type');
+  sessionStorage.removeItem('amber_last_timestamp');
+  
+  // ★ id と type が存在する場合のみ返す
+  if (id && type) {
+    return { id, type, result };
+  }
+  
+  return null;
+}
 
-    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';
-
-        const finalId = id || '';
-
-        // Clean up URL
-        const newUrl = new URL(window.location.href);
-        ['amberType', 'amberId', 'signature', 'result', 'pubKey', 'pubkey', 'type', 'id'].forEach(p => {
-            newUrl.searchParams.delete(p);
-        });
-        newUrl.hash = ''; 
-        window.history.replaceState({}, '', newUrl.toString());
-        
-        localStorage.removeItem(PENDING_KEY); // Done
-
-        return { type: finalType, id: finalId, result };
+  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 null;
+    return false;
   }
 }

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;
+}