applesauce-signers 2.0.0 → 3.1.0

package/dist/signers/nostr-connect-signer.js

@@ -1,38 +1,22 @@
-import { kinds, verifyEvent } from "nostr-tools";
-import { SimpleSigner } from "applesauce-signers";
-import { createDefer } from "applesauce-core/promise";
-import { isHexKey, unixNow } from "applesauce-core/helpers";
 import { logger } from "applesauce-core";
-import { getPublicKey } from "nostr-tools";
+import { getHiddenContent, unixNow } from "applesauce-core/helpers";
+import { createDefer } from "applesauce-core/promise";
+import { SimpleSigner, getConnectionMethods, } from "applesauce-signers";
 import { nanoid } from "nanoid";
+import { getPublicKey, kinds, verifyEvent } from "nostr-tools";
+import { filter, from, repeat, retry } from "rxjs";
 import { isNIP04 } from "../helpers/encryption.js";
-export function isErrorResponse(response) {
-    return !!response.error;
-}
-export var Permission;
-(function (Permission) {
-    Permission["GetPublicKey"] = "get_pubic_key";
-    Permission["SignEvent"] = "sign_event";
-    Permission["Nip04Encrypt"] = "nip04_encrypt";
-    Permission["Nip04Decrypt"] = "nip04_decrypt";
-    Permission["Nip44Encrypt"] = "nip44_encrypt";
-    Permission["Nip44Decrypt"] = "nip44_decrypt";
-})(Permission || (Permission = {}));
-export var NostrConnectMethod;
-(function (NostrConnectMethod) {
-    NostrConnectMethod["Connect"] = "connect";
-    NostrConnectMethod["CreateAccount"] = "create_account";
-    NostrConnectMethod["GetPublicKey"] = "get_public_key";
-    NostrConnectMethod["SignEvent"] = "sign_event";
-    NostrConnectMethod["Nip04Encrypt"] = "nip04_encrypt";
-    NostrConnectMethod["Nip04Decrypt"] = "nip04_decrypt";
-    NostrConnectMethod["Nip44Encrypt"] = "nip44_encrypt";
-    NostrConnectMethod["Nip44Decrypt"] = "nip44_decrypt";
-})(NostrConnectMethod || (NostrConnectMethod = {}));
+import { NostrConnectMethod, buildSigningPermissions, createNostrConnectURI, parseBunkerURI, } from "../helpers/nostr-connect.js";
 async function defaultHandleAuth(url) {
     window.open(url, "auth", "width=400,height=600,resizable=no,status=no,location=no,toolbar=no,menubar=no");
 }
 export class NostrConnectSigner {
+    /** A fallback method to use for subscriptionMethod if none is pass in when creating the signer */
+    static subscriptionMethod = undefined;
+    /** A fallback method to use for publishMethod if none is pass in when creating the signer */
+    static publishMethod = undefined;
+    /** A fallback pool to use if none is pass in when creating the signer */
+    static pool = undefined;
     /** A method that is called when an event needs to be published */
     publishMethod;
     /** The active nostr subscription */
@@ -58,28 +42,23 @@ export class NostrConnectSigner {
     onAuth = defaultHandleAuth;
     verifyEvent = verifyEvent;
     /** A secret used when initiating a connection from the client side */
-    clientSecret = nanoid(12);
+    secret;
     nip04;
     nip44;
-    /** A fallback method to use for subscriptionMethod if none is pass in when creating the signer */
-    static subscriptionMethod = undefined;
-    /** A fallback method to use for publishMethod if none is pass in when creating the signer */
-    static publishMethod = undefined;
-    constructor(opts) {
-        this.relays = opts.relays;
-        this.pubkey = opts.pubkey;
-        this.remote = opts.remote;
-        const subscriptionMethod = opts.subscriptionMethod || NostrConnectSigner.subscriptionMethod;
-        if (!subscriptionMethod)
-            throw new Error("Missing subscriptionMethod, either pass a method or set NostrConnectSigner.subscriptionMethod");
-        const publishMethod = opts.publishMethod || NostrConnectSigner.publishMethod;
-        if (!publishMethod)
-            throw new Error("Missing publishMethod, either pass a method or set NostrConnectSigner.publishMethod");
-        this.subscriptionMethod = subscriptionMethod;
-        this.publishMethod = publishMethod;
-        if (opts.onAuth)
-            this.onAuth = opts.onAuth;
-        this.signer = opts?.signer || new SimpleSigner();
+    constructor(options) {
+        this.relays = options.relays;
+        this.pubkey = options.pubkey;
+        this.remote = options.remote;
+        this.secret = options.secret || nanoid(12);
+        // Get the subscription and publish methods
+        const { subscriptionMethod, publishMethod } = getConnectionMethods(options, NostrConnectSigner);
+        // Use arrow functions so "this" isn't bound to the signer
+        this.subscriptionMethod = (relays, filters) => subscriptionMethod(relays, filters);
+        this.publishMethod = (relays, event) => publishMethod(relays, event);
+        if (options.onAuth)
+            this.onAuth = options.onAuth;
+        // Get or create the local signer
+        this.signer = options?.signer || new SimpleSigner();
         this.nip04 = {
             encrypt: this.nip04Encrypt.bind(this),
             decrypt: this.nip04Decrypt.bind(this),
@@ -98,14 +77,20 @@ export class NostrConnectSigner {
         this.listening = true;
         const pubkey = await this.signer.getPublicKey();
         // Setup subscription
-        this.req = this.subscriptionMethod(this.relays, [
+        this.req = from(this.subscriptionMethod(this.relays, [
             {
                 kinds: [kinds.NostrConnect],
                 "#p": [pubkey],
             },
-        ]).subscribe({
-            next: (event) => typeof event !== "string" && this.handleEvent(event),
-        });
+        ]))
+            .pipe(
+        // Keep the connection open indefinitely
+        repeat(), 
+        // Retry on connection failure
+        retry(), 
+        // Ignore strings (support for applesauce-relay)
+        filter((event) => typeof event !== "string"))
+            .subscribe(this.handleEvent.bind(this));
         this.log("Opened", this.relays);
     }
     /** Close the connection */
@@ -134,12 +119,15 @@ export class NostrConnectSigner {
         if (this.remote && event.pubkey !== this.remote)
             return;
         try {
-            const responseStr = isNIP04(event.content)
-                ? await this.signer.nip04.decrypt(event.pubkey, event.content)
-                : await this.signer.nip44.decrypt(event.pubkey, event.content);
+            const responseStr = getHiddenContent(event) ??
+                (isNIP04(event.content)
+                    ? await this.signer.nip04.decrypt(event.pubkey, event.content)
+                    : await this.signer.nip44.decrypt(event.pubkey, event.content));
+            if (!responseStr)
+                return;
             const response = JSON.parse(responseStr);
             // handle remote signer connection
-            if (!this.remote && (response.result === "ack" || (this.clientSecret && response.result === this.clientSecret))) {
+            if (!this.remote && (response.result === "ack" || (this.secret && response.result === this.secret))) {
                 this.log("Got ack response from", event.pubkey, response.result);
                 this.isConnected = true;
                 this.remote = event.pubkey;
@@ -316,37 +304,20 @@ export class NostrConnectSigner {
     }
     /** Returns the nostrconnect:// URI for this signer */
     getNostrConnectURI(metadata) {
-        const params = new URLSearchParams();
-        params.set("secret", this.clientSecret);
-        if (metadata?.name)
-            params.set("name", metadata.name);
-        if (metadata?.url)
-            params.set("url", String(metadata.url));
-        if (metadata?.image)
-            params.set("image", metadata.image);
-        if (metadata?.permissions)
-            params.set("perms", metadata.permissions.join(","));
-        for (const relay of this.relays)
-            params.append("relay", relay);
-        const client = getPublicKey(this.signer.key);
-        return `nostrconnect://${client}?` + params.toString();
+        return createNostrConnectURI({
+            client: getPublicKey(this.signer.key),
+            secret: this.secret,
+            relays: this.relays,
+            metadata,
+        });
     }
     /** Parses a bunker:// URI */
     static parseBunkerURI(uri) {
-        const url = new URL(uri);
-        // firefox puts pubkey part in host, chrome puts pubkey in pathname
-        const remote = url.host || url.pathname.replace("//", "");
-        if (!isHexKey(remote))
-            throw new Error("Invalid connection URI");
-        const relays = url.searchParams.getAll("relay");
-        if (relays.length === 0)
-            throw new Error("Missing relays");
-        const secret = url.searchParams.get("secret") ?? undefined;
-        return { remote, relays, secret };
+        return parseBunkerURI(uri);
     }
     /** Builds an array of signing permissions for event kinds */
     static buildSigningPermissions(kinds) {
-        return [Permission.GetPublicKey, ...kinds.map((k) => `${Permission.SignEvent}:${k}`)];
+        return buildSigningPermissions(kinds);
     }
     /** Create a {@link NostrConnectSigner} from a bunker:// URI */
     static async fromBunkerURI(uri, options) {

package/dist/signers/password-signer.d.ts

@@ -1,17 +1,17 @@
 import { EventTemplate } from "nostr-tools";
 import { Deferred } from "applesauce-core/promise";
-import { Nip07Interface } from "../nip-07.js";
+import { ISigner } from "../interop.js";
 /** A NIP-49 (Private Key Encryption) signer */
-export declare class PasswordSigner implements Nip07Interface {
+export declare class PasswordSigner implements ISigner {
     key: Uint8Array | null;
     ncryptsec?: string;
     nip04: {
-        encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
-        decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
+        encrypt: (pubkey: string, plaintext: string) => Promise<string>;
+        decrypt: (pubkey: string, ciphertext: string) => Promise<string>;
     };
     nip44: {
-        encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
-        decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
+        encrypt: (pubkey: string, plaintext: string) => Promise<string>;
+        decrypt: (pubkey: string, ciphertext: string) => Promise<string>;
     };
     get unlocked(): boolean;
     constructor();

package/dist/signers/password-signer.js

@@ -52,9 +52,14 @@ export class PasswordSigner {
         if (this.key)
             return;
         if (this.ncryptsec) {
-            this.key = decrypt(this.ncryptsec, password);
-            if (!this.key)
-                throw new Error("Failed to decrypt key");
+            try {
+                this.key = decrypt(this.ncryptsec, password);
+                if (!this.key)
+                    throw new Error("Failed to decrypt key");
+            }
+            catch (error) {
+                throw new Error("failed to decrypt key: " + (error instanceof Error ? error.message : String(error)));
+            }
         }
         else
             throw new Error("Missing ncryptsec");

package/dist/signers/readonly-signer.d.ts

@@ -1,24 +1,23 @@
 import { VerifiedEvent } from "nostr-tools";
-import { Nip07Interface } from "../nip-07.js";
+import { ISigner } from "../interop.js";
 /** A signer that only implements getPublicKey and throws on ever other method */
-export declare class ReadonlySigner implements Nip07Interface {
+export declare class ReadonlySigner implements ISigner {
     private pubkey;
     nip04: {
-        encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
-        decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
+        encrypt: (pubkey: string, plaintext: string) => Promise<string>;
+        decrypt: (pubkey: string, ciphertext: string) => Promise<string>;
     };
     nip44: {
-        encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
-        decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
+        encrypt: (pubkey: string, plaintext: string) => Promise<string>;
+        decrypt: (pubkey: string, ciphertext: string) => Promise<string>;
     };
     constructor(pubkey: string);
-    getPublicKey(): string;
-    getRelays(): {};
-    signEvent(): VerifiedEvent;
-    nip04Encrypt(): string;
-    nip04Decrypt(): string;
-    nip44Encrypt(): string;
-    nip44Decrypt(): string;
+    getPublicKey(): Promise<string>;
+    signEvent(): Promise<VerifiedEvent>;
+    nip04Encrypt(): Promise<string>;
+    nip04Decrypt(): Promise<string>;
+    nip44Encrypt(): Promise<string>;
+    nip44Decrypt(): Promise<string>;
     /** Creates a ReadonlySigner from a hex public key or NIP-19 npub */
     static fromPubkey(pubkey: string): ReadonlySigner;
 }

package/dist/signers/readonly-signer.js

@@ -17,25 +17,22 @@ export class ReadonlySigner {
             decrypt: this.nip44Decrypt.bind(this),
         };
     }
-    getPublicKey() {
+    async getPublicKey() {
         return this.pubkey;
     }
-    getRelays() {
-        return {};
-    }
-    signEvent() {
+    async signEvent() {
         throw new Error("Cant sign events with readonly");
     }
-    nip04Encrypt() {
+    async nip04Encrypt() {
         throw new Error("Cant encrypt with readonly");
     }
-    nip04Decrypt() {
+    async nip04Decrypt() {
         throw new Error("Cant decrypt with readonly");
     }
-    nip44Encrypt() {
+    async nip44Encrypt() {
         throw new Error("Cant encrypt with readonly");
     }
-    nip44Decrypt() {
+    async nip44Decrypt() {
         throw new Error("Cant decrypt with readonly");
     }
     /** Creates a ReadonlySigner from a hex public key or NIP-19 npub */

package/dist/signers/serial-port-signer.d.ts

@@ -1,6 +1,6 @@
 import { Deferred } from "applesauce-core/promise";
 import { EventTemplate, verifyEvent } from "nostr-tools";
-import { Nip07Interface } from "../nip-07.js";
+import { ISigner } from "../interop.js";
 type Callback = () => void;
 type DeviceOpts = {
     onConnect?: Callback;
@@ -9,15 +9,15 @@ type DeviceOpts = {
     onDone?: Callback;
 };
 /** A signer that works with [nostr-signing-device](https://github.com/lnbits/nostr-signing-device) */
-export declare class SerialPortSigner implements Nip07Interface {
+export declare class SerialPortSigner implements ISigner {
     protected log: import("debug").Debugger;
     protected writer: WritableStreamDefaultWriter<string> | null;
     pubkey?: string;
     get isConnected(): boolean;
     verifyEvent: typeof verifyEvent;
     nip04: {
-        encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
-        decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
+        encrypt: (pubkey: string, plaintext: string) => Promise<string>;
+        decrypt: (pubkey: string, ciphertext: string) => Promise<string>;
     };
     constructor();
     protected lastCommand: Deferred<string> | null;

package/dist/signers/simple-signer.d.ts

@@ -1,6 +1,7 @@
 import { EventTemplate } from "nostr-tools";
+import { ISigner } from "../interop.js";
 /** A Simple NIP-07 signer class */
-export declare class SimpleSigner {
+export declare class SimpleSigner implements ISigner {
     key: Uint8Array;
     constructor(key?: Uint8Array);
     getPublicKey(): Promise<string>;

package/package.json

@@ -1,12 +1,14 @@
 {
   "name": "applesauce-signers",
-  "version": "2.0.0",
+  "version": "3.1.0",
   "description": "Signer classes for applesauce",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "keywords": [
     "nostr",
+    "signer",
+    "nostr-connect",
     "applesauce"
   ],
   "author": "hzrd149",
@@ -36,16 +38,18 @@
     "@noble/hashes": "^1.7.1",
     "@noble/secp256k1": "^1.7.1",
     "@scure/base": "^1.2.4",
-    "applesauce-core": "^2.0.0",
+    "applesauce-core": "^3.1.0",
     "debug": "^4.4.0",
     "nanoid": "^5.0.9",
-    "nostr-tools": "^2.13"
+    "nostr-tools": "~2.15",
+    "rxjs": "^7.8.2"
   },
   "devDependencies": {
     "@types/debug": "^4.1.12",
     "@types/dom-serial": "^1.0.6",
     "typescript": "^5.8.3",
-    "vitest": "^3.1.3"
+    "vitest": "^3.1.3",
+    "vitest-websocket-mock": "^0.5.0"
   },
   "funding": {
     "type": "lightning",

package/dist/nip-07.d.ts

@@ -1,20 +0,0 @@
-import { EventTemplate, NostrEvent } from "nostr-tools";
-export type Nip07Interface = {
-    getPublicKey: () => Promise<string> | string;
-    signEvent: (template: EventTemplate) => Promise<NostrEvent> | NostrEvent;
-    getRelays?: () => Record<string, {
-        read: boolean;
-        write: boolean;
-    }> | Promise<Record<string, {
-        read: boolean;
-        write: boolean;
-    }>>;
-    nip04?: {
-        encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
-        decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
-    };
-    nip44?: {
-        encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
-        decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
-    };
-};

package/dist/nip-07.js

@@ -1 +0,0 @@
-export {};