@konemono/nostr-login 1.7.57 → 1.7.59

package/package.json

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

package/src/modules/AmberDirectSigner.ts

@@ -1,8 +1,8 @@
-import { NDKUser } from '@nostr-dev-kit/ndk';
 import { Signer } from './Nostr';
 
 export class AmberDirectSigner implements Signer {
   private _pubkey: string = '';
+  private static pendingResolves: Map<string, (result: any) => void> = new Map();
 
   constructor(pubkey?: string) {
     this._pubkey = pubkey || '';
@@ -29,9 +29,9 @@ export class AmberDirectSigner implements Signer {
   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;
+        const char = content.charCodeAt(i);
+        hash = (hash << 5) - hash + char;
+        hash |= 0;
     }
     return hash.toString(36);
   }
@@ -41,8 +41,8 @@ export class AmberDirectSigner implements Signer {
     const cacheKey = `amber_result_${type}_${hash}`;
     const cached = sessionStorage.getItem(cacheKey);
     if (cached) {
-      sessionStorage.removeItem(cacheKey);
-      return cached;
+        sessionStorage.removeItem(cacheKey);
+        return cached;
     }
     return null;
   }
@@ -52,19 +52,58 @@ export class AmberDirectSigner implements Signer {
     sessionStorage.setItem(`amber_pending_${id}`, JSON.stringify({ hash, type }));
   }
 
+  public static resolvePending(id: string, type: string, result: string) {
+    // Try resolving by ID first
+    let resolve = this.pendingResolves.get(id);
+    
+    // Fallback: If no ID match, try resolving by type if only one is pending of that type
+    if (!resolve) {
+        console.log('No direct ID match for Amber resolve, searching by type', { id, type });
+        for (const [pendingId, pendingResolve] of this.pendingResolves.entries()) {
+            const pending = sessionStorage.getItem(`amber_pending_${pendingId}`);
+            if (pending) {
+                const { type: pendingType } = JSON.parse(pending);
+                if (pendingType === type) {
+                    resolve = pendingResolve;
+                    id = pendingId;
+                    break;
+                }
+            }
+        }
+    }
+
+    if (resolve) {
+        console.log('Resolving pending Amber promise', { id, type });
+        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);
+        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;
-    // This will never resolve because of page reload
-    return new Promise(() => {});
+    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);
+    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> {
@@ -75,7 +114,9 @@ export class AmberDirectSigner implements Signer {
     this.setPending(id, plaintext, 'nip04_encrypt');
     const url = this.generateUrl(plaintext, 'nip04_encrypt', id, pubkey);
     window.location.href = url;
-    return new Promise(() => {});
+    return new Promise((resolve) => {
+        AmberDirectSigner.pendingResolves.set(id, resolve);
+    });
   }
 
   async decrypt04(pubkey: string, ciphertext: string): Promise<string> {
@@ -86,7 +127,9 @@ export class AmberDirectSigner implements Signer {
     this.setPending(id, ciphertext, 'nip04_decrypt');
     const url = this.generateUrl(ciphertext, 'nip04_decrypt', id, pubkey);
     window.location.href = url;
-    return new Promise(() => {});
+    return new Promise((resolve) => {
+        AmberDirectSigner.pendingResolves.set(id, resolve);
+    });
   }
 
   async encrypt44(pubkey: string, plaintext: string): Promise<string> {
@@ -97,7 +140,9 @@ export class AmberDirectSigner implements Signer {
     this.setPending(id, plaintext, 'nip44_encrypt');
     const url = this.generateUrl(plaintext, 'nip44_encrypt', id, pubkey);
     window.location.href = url;
-    return new Promise(() => {});
+    return new Promise((resolve) => {
+        AmberDirectSigner.pendingResolves.set(id, resolve);
+    });
   }
 
   async decrypt44(pubkey: string, ciphertext: string): Promise<string> {
@@ -108,30 +153,40 @@ export class AmberDirectSigner implements Signer {
     this.setPending(id, ciphertext, 'nip44_decrypt');
     const url = this.generateUrl(ciphertext, 'nip44_decrypt', id, pubkey);
     window.location.href = url;
-    return new Promise(() => {});
-  }
-
-  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(() => {});
+    return new Promise((resolve) => {
+        AmberDirectSigner.pendingResolves.set(id, resolve);
+    });
   }
 
   private generateUrl(content: string, type: string, id: string, recipient?: string): string {
-    const url = new URL(window.location.origin + window.location.pathname);
-    url.searchParams.set('amberType', type);
-    url.searchParams.set('amberId', id);
+    const callbackUrl = new URL(window.location.origin + window.location.pathname);
+    
+    // Preserve other relevant current URL params if necessary, but avoid amber internal ones
+    const currentParams = new URLSearchParams(window.location.search);
+    currentParams.forEach((value, key) => {
+        if (!['amberType', 'amberId', 'signature', 'result', 'pubKey', 'pubkey'].includes(key)) {
+            callbackUrl.searchParams.set(key, value);
+        }
+    });
+
+    callbackUrl.searchParams.set('amberType', type);
+    callbackUrl.searchParams.set('amberId', id);
+
+    const name = document.title || window.location.hostname || 'Nostr Login';
 
     const params = new URLSearchParams();
     params.set('type', type);
     params.set('id', id);
-    params.set('callbackUrl', url.toString());
-    params.set('name', document.title || window.location.hostname || 'Nostr Login');
+    params.set('callbackUrl', callbackUrl.toString());
+    params.set('name', name);
+    params.set('app_name', name); // Alias just in case
+
     if (recipient) {
-      params.set('pubkey', recipient);
+        params.set('pubkey', recipient);
+        params.set('pubKey', recipient); // Alias
     } else if (this._pubkey) {
-      params.set('pubkey', this._pubkey);
+        params.set('pubkey', this._pubkey);
+        params.set('pubKey', this._pubkey); // Alias
     }
 
     const dataPart = content ? encodeURIComponent(content) : '/';
@@ -143,19 +198,25 @@ export class AmberDirectSigner implements Signer {
     const params = new URLSearchParams(url.search);
     const hashParams = new URLSearchParams(url.hash.substring(1));
 
-    let type = params.get('amberType') || hashParams.get('amberType');
-    let id = params.get('amberId') || hashParams.get('amberId');
-    let result = params.get('signature') || params.get('result') || params.get('pubKey') ||
-                 hashParams.get('signature') || hashParams.get('result') || hashParams.get('pubKey');
+    const getParam = (name: string) => params.get(name) || hashParams.get(name);
+
+    const type = getParam('amberType') || getParam('type');
+    const id = getParam('amberId') || getParam('id');
+    const result = getParam('signature') || getParam('result') || getParam('pubKey') || getParam('pubkey');
+
+    if (type && result) {
+        // ID might be missing in some older redirect cases, but we need it for precise resolution
+        const finalId = id || '';
 
-    if (type && id && result) {
-      // Clean up URL
-      const newUrl = new URL(window.location.href);
-      ['amberType', 'amberId', 'signature', 'result', 'pubKey'].forEach(p => newUrl.searchParams.delete(p));
-      newUrl.hash = ''; 
-      window.history.replaceState({}, '', newUrl.toString());
+        // 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());
 
-      return { type, id, result };
+        return { type, id: finalId, result };
     }
     return null;
   }

package/src/modules/AuthNostrService.ts

@@ -98,6 +98,10 @@ class AuthNostrService extends EventEmitter implements Signer {
     const response = AmberDirectSigner.parseResponse();
     if (response) {
       console.log('Amber response detected', response);
+
+      // Resolve pending promises if any (for non-reload cases)
+      AmberDirectSigner.resolvePending(response.id, response.type, response.result);
+
       if (response.type === 'get_public_key') {
         const info: Info = {
           pubkey: response.result,