@konemono/nostr-login 1.7.52 → 1.7.54

package/package.json

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

package/src/modules/AmberDirectSigner.ts

@@ -26,37 +26,86 @@ export class AmberDirectSigner implements Signer {
     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);
+    sessionStorage.setItem(`amber_pending_${id}`, JSON.stringify({ hash, type }));
+  }
+
   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);
-    const url = this.generateUrl(JSON.stringify(event), 'sign_event', id);
+    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(() => {});
   }
 
   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(() => {});
   }
 
   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(() => {});
   }
 
   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(() => {});
   }
 
   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(() => {});
@@ -86,9 +135,17 @@ export class AmberDirectSigner implements Signer {
 
   public static parseResponse(): { type: string; id: string; result: string } | null {
     const params = new URLSearchParams(window.location.search);
-    const type = params.get('amberType');
-    const id = params.get('amberId');
-    const result = params.get('signature') || params.get('result'); // Amber uses signature for events, result for others?
+    let type = params.get('amberType');
+    let id = params.get('amberId');
+    let result = params.get('signature') || params.get('result'); // Amber uses signature for events, result for others?
+
+    // Also check hash
+    if (!type || !id || !result) {
+      const hashParams = new URLSearchParams(window.location.hash.substring(1));
+      type = type || hashParams.get('amberType');
+      id = id || hashParams.get('amberId');
+      result = result || hashParams.get('signature') || hashParams.get('result');
+    }
 
     if (type && id && result) {
       // Clean up URL
@@ -97,6 +154,7 @@ export class AmberDirectSigner implements Signer {
       newUrl.searchParams.delete('amberId');
       newUrl.searchParams.delete('signature');
       newUrl.searchParams.delete('result');
+      newUrl.hash = ''; // Clear hash too
       window.history.replaceState({}, '', newUrl.toString());
 
       return { type, id, result };

package/src/modules/AuthNostrService.ts

@@ -27,12 +27,6 @@ const NOSTRCONNECT_APPS: ConnectionString[] = [
   {
     name: 'Amber',
     img: 'https://raw.githubusercontent.com/greenart7c3/Amber/refs/heads/master/assets/android-icon.svg',
-    link: '<nostrconnect>',
-    relays: DEFAULT_NOSTRCONNECT_RELAYS,
-  },
-  {
-    name: 'Amber (Direct)',
-    img: 'https://raw.githubusercontent.com/greenart7c3/Amber/refs/heads/master/assets/android-icon.svg',
     link: 'amber',
     relays: DEFAULT_NOSTRCONNECT_RELAYS,
   },
@@ -92,7 +86,7 @@ class AuthNostrService extends EventEmitter implements Signer {
       decrypt: this.decrypt44.bind(this),
     };
 
-    this.checkAmberResponse();
+    setTimeout(() => this.checkAmberResponse(), 500);
   }
 
   private checkAmberResponse() {
@@ -105,14 +99,16 @@ class AuthNostrService extends EventEmitter implements Signer {
         };
         this.onAuth('login', info);
       } else {
-        // For other types, we might want to store the result in a way 
-        // that the next call to the same method can return it immediately
-        // but for now, we just log it.
-        console.log('Amber response', response);
-        if (response.type === 'sign_event') {
-            // If it's a signed event, we could potentially use it if someone asks for it.
-            // But usually the app will re-request signing.
-            // A better way would be to have a session-based cache.
+        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);
+          }
         }
       }
     }