applesauce-signers 1.0.0 → 2.0.0

package/README.md

@@ -8,7 +8,7 @@ For detailed documentation and API reference, see:
 
 - [Signers Documentation](https://hzrd149.github.io/applesauce/signers/signers.html)
 - [Nostr Connect Documentation](https://hzrd149.github.io/applesauce/signers/nostr-connect.html)
-- [API Reference](https://hzrd149.github.io/applesauce/typedoc/modules/applesauce_signers.html)
+- [API Reference](https://hzrd149.github.io/applesauce/typedoc/modules/applesauce-signers.html)
 
 ## Available Signers
 

package/dist/helpers/encryption.d.ts

@@ -2,4 +2,4 @@
  * Checks if a string is encrypted with NIP-04 or NIP-44
  * @see https://github.com/nostr-protocol/nips/pull/1248#issuecomment-2437731316
  */
-export declare function isNIP04(ciphertext: string): boolean;
+export { isNIP04Encrypted as isNIP04 } from "applesauce-core/helpers/encryption";

package/dist/helpers/encryption.js

@@ -2,9 +2,4 @@
  * Checks if a string is encrypted with NIP-04 or NIP-44
  * @see https://github.com/nostr-protocol/nips/pull/1248#issuecomment-2437731316
  */
-export function isNIP04(ciphertext) {
-    const l = ciphertext.length;
-    if (l < 28)
-        return false;
-    return (ciphertext[l - 28] == "?" && ciphertext[l - 27] == "i" && ciphertext[l - 26] == "v" && ciphertext[l - 25] == "=");
-}
+export { isNIP04Encrypted as isNIP04 } from "applesauce-core/helpers/encryption";

package/dist/signers/nostr-connect-signer.d.ts

@@ -82,8 +82,10 @@ interface Observer<T> {
 type Subscribable<T extends unknown> = {
     subscribe: (observer: Partial<Observer<T>>) => Unsubscribable;
 };
-export type NostrSubscriptionMethod = (relays: string[], filters: Filter[]) => Subscribable<NostrEvent>;
-export type NostrPublishMethod = (relays: string[], event: NostrEvent) => void | Promise<void>;
+/** A method used to subscribe to events on a set of relays */
+export type NostrSubscriptionMethod = (relays: string[], filters: Filter[]) => Subscribable<NostrEvent | string>;
+/** A method used for publishing an event, can return a Promise that completes when published or an Observable that completes when published*/
+export type NostrPublishMethod = (relays: string[], event: NostrEvent) => Promise<any> | Subscribable<any>;
 export type NostrConnectAppMetadata = {
     name?: string;
     image?: string;
@@ -98,7 +100,8 @@ export declare class NostrConnectSigner implements Nip07Interface {
     protected log: import("debug").Debugger;
     /** The local client signer */
     signer: SimpleSigner;
-    protected subscriptionOpen: boolean;
+    /** Whether the signer is listening for events */
+    listening: boolean;
     /** Whether the signer is connected to the remote signer */
     isConnected: boolean;
     /** The users pubkey */
@@ -143,7 +146,7 @@ export declare class NostrConnectSigner implements Nip07Interface {
     connect(secret?: string | undefined, permissions?: string[]): Promise<"ack">;
     private waitingPromise;
     /** Wait for a remote signer to connect */
-    waitForSigner(): Promise<void>;
+    waitForSigner(abort?: AbortSignal): Promise<void>;
     /** Request to create an account on the remote signer */
     createAccount(username: string, domain: string, email?: string, permissions?: string[]): Promise<string>;
     /** Ensure the signer is connected to the remote signer */

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

@@ -40,7 +40,8 @@ export class NostrConnectSigner {
     log = logger.extend("NostrConnectSigner");
     /** The local client signer */
     signer;
-    subscriptionOpen = false;
+    /** Whether the signer is listening for events */
+    listening = false;
     /** Whether the signer is connected to the remote signer */
     isConnected = false;
     /** The users pubkey */
@@ -92,9 +93,9 @@ export class NostrConnectSigner {
     req;
     /** Open the connection */
     async open() {
-        if (this.subscriptionOpen)
+        if (this.listening)
             return;
-        this.subscriptionOpen = true;
+        this.listening = true;
         const pubkey = await this.signer.getPublicKey();
         // Setup subscription
         this.req = this.subscriptionMethod(this.relays, [
@@ -103,15 +104,24 @@ export class NostrConnectSigner {
                 "#p": [pubkey],
             },
         ]).subscribe({
-            next: (event) => this.handleEvent(event),
+            next: (event) => typeof event !== "string" && this.handleEvent(event),
         });
         this.log("Opened", this.relays);
     }
     /** Close the connection */
     async close() {
-        this.subscriptionOpen = false;
+        this.listening = false;
         this.isConnected = false;
-        this.req?.unsubscribe();
+        // Close the current subscription
+        if (this.req) {
+            this.req.unsubscribe();
+            this.req = undefined;
+        }
+        // Cancel waiting promise
+        if (this.waitingPromise) {
+            this.waitingPromise.reject(new Error("Closed"));
+            this.waitingPromise = null;
+        }
         this.log("Closed");
     }
     requests = new Map();
@@ -185,10 +195,16 @@ export class NostrConnectSigner {
         const request = { id, method, params };
         const encrypted = await this.signer.nip44.encrypt(this.remote, JSON.stringify(request));
         const event = await this.createRequestEvent(encrypted, this.remote, kind);
-        this.log(`Sending request ${id} (${method}) ${JSON.stringify(params)}`);
+        this.log(`Sending ${id} (${method}) ${JSON.stringify(params)}`);
         const p = createDefer();
         this.requests.set(id, p);
-        await this.publishMethod?.(this.relays, event);
+        const result = this.publishMethod?.(this.relays, event);
+        // Handle returned Promise or Observable
+        if (result instanceof Promise)
+            await result;
+        else if ("subscribe" in result)
+            await new Promise((res) => result.subscribe({ complete: res }));
+        this.log(`Sent ${id} (${method})`);
         return p;
     }
     /** Connect to remote signer */
@@ -216,11 +232,16 @@ export class NostrConnectSigner {
     }
     waitingPromise = null;
     /** Wait for a remote signer to connect */
-    waitForSigner() {
+    waitForSigner(abort) {
         if (this.isConnected)
             return Promise.resolve();
         this.open();
         this.waitingPromise = createDefer();
+        abort?.addEventListener("abort", () => {
+            this.waitingPromise?.reject(new Error("Aborted"));
+            this.waitingPromise = null;
+            this.close();
+        }, true);
         return this.waitingPromise;
     }
     /** Request to create an account on the remote signer */

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

@@ -17,13 +17,22 @@ export declare class PasswordSigner implements Nip07Interface {
     constructor();
     unlockPromise?: Deferred<void>;
     protected requestUnlock(): Deferred<void> | undefined;
+    /** Sets the ncryptsec from the key and password */
     setPassword(password: string): Promise<void>;
+    /** Tests if the provided password is correct by decrypting the ncryptsec */
     testPassword(password: string): Promise<void>;
+    /** Unlocks the signer by decrypting the ncryptsec using the provided password */
     unlock(password: string): Promise<void>;
+    /** Locks the signer by removing the unencrypted key from memory */
+    lock(): void;
     getPublicKey(): Promise<string>;
     signEvent(event: EventTemplate): Promise<import("nostr-tools").VerifiedEvent>;
     nip04Encrypt(pubkey: string, plaintext: string): Promise<string>;
     nip04Decrypt(pubkey: string, ciphertext: string): Promise<string>;
     nip44Encrypt(pubkey: string, plaintext: string): Promise<string>;
     nip44Decrypt(pubkey: string, ciphertext: string): Promise<string>;
+    /** Creates a PasswordSigner from a hex private key or NIP-19 nsec and password */
+    static fromPrivateKey(privateKey: Uint8Array | string, password: string): Promise<PasswordSigner>;
+    /** Creates a PasswordSigner from a ncryptsec and unlocks it with the provided password */
+    static fromNcryptsec(ncryptsec: string, password?: string): Promise<PasswordSigner>;
 }

package/dist/signers/password-signer.js

@@ -1,6 +1,7 @@
 import { finalizeEvent, getPublicKey, nip04, nip44 } from "nostr-tools";
 import { encrypt, decrypt } from "nostr-tools/nip49";
 import { createDefer } from "applesauce-core/promise";
+import { normalizeToSecretKey } from "applesauce-core/helpers";
 /** A NIP-49 (Private Key Encryption) signer */
 export class PasswordSigner {
     key = null;
@@ -30,11 +31,13 @@ export class PasswordSigner {
         this.unlockPromise = p;
         return p;
     }
+    /** Sets the ncryptsec from the key and password */
     async setPassword(password) {
         if (!this.key)
             throw new Error("Cant set password until unlocked");
         this.ncryptsec = encrypt(this.key, password);
     }
+    /** Tests if the provided password is correct by decrypting the ncryptsec */
     async testPassword(password) {
         if (this.ncryptsec) {
             const key = decrypt(this.ncryptsec, password);
@@ -44,6 +47,7 @@ export class PasswordSigner {
         else
             throw new Error("Missing ncryptsec");
     }
+    /** Unlocks the signer by decrypting the ncryptsec using the provided password */
     async unlock(password) {
         if (this.key)
             return;
@@ -55,6 +59,10 @@ export class PasswordSigner {
         else
             throw new Error("Missing ncryptsec");
     }
+    /** Locks the signer by removing the unencrypted key from memory */
+    lock() {
+        this.key = null;
+    }
     // public methods
     async getPublicKey() {
         await this.requestUnlock();
@@ -82,4 +90,19 @@ export class PasswordSigner {
         await this.requestUnlock();
         return nip44.v2.decrypt(ciphertext, nip44.v2.utils.getConversationKey(this.key, pubkey));
     }
+    /** Creates a PasswordSigner from a hex private key or NIP-19 nsec and password */
+    static async fromPrivateKey(privateKey, password) {
+        const signer = new PasswordSigner();
+        signer.key = normalizeToSecretKey(privateKey);
+        await signer.setPassword(password);
+        return signer;
+    }
+    /** Creates a PasswordSigner from a ncryptsec and unlocks it with the provided password */
+    static async fromNcryptsec(ncryptsec, password) {
+        const signer = new PasswordSigner();
+        signer.ncryptsec = ncryptsec;
+        if (password)
+            await signer.unlock(password);
+        return signer;
+    }
 }

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

@@ -19,4 +19,6 @@ export declare class ReadonlySigner implements Nip07Interface {
     nip04Decrypt(): string;
     nip44Encrypt(): string;
     nip44Decrypt(): string;
+    /** Creates a ReadonlySigner from a hex public key or NIP-19 npub */
+    static fromPubkey(pubkey: string): ReadonlySigner;
 }

package/dist/signers/readonly-signer.js

@@ -1,3 +1,4 @@
+import { isHexKey, normalizeToPubkey } from "applesauce-core/helpers";
 /** A signer that only implements getPublicKey and throws on ever other method */
 export class ReadonlySigner {
     pubkey;
@@ -5,6 +6,8 @@ export class ReadonlySigner {
     nip44;
     constructor(pubkey) {
         this.pubkey = pubkey;
+        if (!isHexKey(pubkey))
+            throw new Error("Invalid public key");
         this.nip04 = {
             encrypt: this.nip04Encrypt.bind(this),
             decrypt: this.nip04Decrypt.bind(this),
@@ -35,4 +38,8 @@ export class ReadonlySigner {
     nip44Decrypt() {
         throw new Error("Cant decrypt with readonly");
     }
+    /** Creates a ReadonlySigner from a hex public key or NIP-19 npub */
+    static fromPubkey(pubkey) {
+        return new ReadonlySigner(normalizeToPubkey(pubkey));
+    }
 }

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

@@ -1,5 +1,5 @@
-import { EventTemplate, verifyEvent } from "nostr-tools";
 import { Deferred } from "applesauce-core/promise";
+import { EventTemplate, verifyEvent } from "nostr-tools";
 import { Nip07Interface } from "../nip-07.js";
 type Callback = () => void;
 type DeviceOpts = {

package/dist/signers/serial-port-signer.js

@@ -1,10 +1,10 @@
 /// <reference types="@types/dom-serial" />
-import { getEventHash, verifyEvent } from "nostr-tools";
-import { base64 } from "@scure/base";
-import { randomBytes, hexToBytes, bytesToHex } from "@noble/hashes/utils";
+import { bytesToHex, hexToBytes, randomBytes } from "@noble/hashes/utils";
 import { Point } from "@noble/secp256k1";
+import { base64 } from "@scure/base";
+import { logger } from "applesauce-core";
 import { createDefer } from "applesauce-core/promise";
-import { logger } from "../logger.js";
+import { getEventHash, verifyEvent } from "nostr-tools";
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 function xOnlyToXY(p) {
     return Point.fromHex(p).toHex().substring(2);

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

@@ -13,4 +13,6 @@ export declare class SimpleSigner {
         encrypt: (pubkey: string, plaintext: string) => Promise<string>;
         decrypt: (pubkey: string, ciphertext: string) => Promise<string>;
     };
+    /** Creates a SimpleSigner from a hex private key or NIP-19 nsec */
+    static fromKey(privateKey: Uint8Array | string): SimpleSigner;
 }

package/dist/signers/simple-signer.js

@@ -1,3 +1,4 @@
+import { normalizeToSecretKey } from "applesauce-core/helpers";
 import { finalizeEvent, generateSecretKey, getPublicKey, nip04, nip44 } from "nostr-tools";
 /** A Simple NIP-07 signer class */
 export class SimpleSigner {
@@ -19,4 +20,8 @@ export class SimpleSigner {
         encrypt: async (pubkey, plaintext) => nip44.v2.encrypt(plaintext, nip44.v2.utils.getConversationKey(this.key, pubkey)),
         decrypt: async (pubkey, ciphertext) => nip44.v2.decrypt(ciphertext, nip44.v2.utils.getConversationKey(this.key, pubkey)),
     };
+    /** Creates a SimpleSigner from a hex private key or NIP-19 nsec */
+    static fromKey(privateKey) {
+        return new SimpleSigner(normalizeToSecretKey(privateKey));
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-signers",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "description": "Signer classes for applesauce",
   "type": "module",
   "main": "dist/index.js",
@@ -36,16 +36,16 @@
     "@noble/hashes": "^1.7.1",
     "@noble/secp256k1": "^1.7.1",
     "@scure/base": "^1.2.4",
-    "applesauce-core": "^1.0.0",
+    "applesauce-core": "^2.0.0",
     "debug": "^4.4.0",
     "nanoid": "^5.0.9",
-    "nostr-tools": "^2.10.4"
+    "nostr-tools": "^2.13"
   },
   "devDependencies": {
     "@types/debug": "^4.1.12",
     "@types/dom-serial": "^1.0.6",
     "typescript": "^5.8.3",
-    "vitest": "^3.1.1"
+    "vitest": "^3.1.3"
   },
   "funding": {
     "type": "lightning",

package/dist/logger.d.ts

@@ -1,2 +0,0 @@
-import debug from "debug";
-export declare const logger: debug.Debugger;

package/dist/logger.js

@@ -1,2 +0,0 @@
-import debug from "debug";
-export const logger = debug("applesauce:signer");

package/dist/signers/nostr-connect-signer.test.d.ts

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

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

@@ -1,23 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { NostrConnectSigner } from "./nostr-connect-signer.js";
-import { SimpleSigner } from "./simple-signer.js";
-describe("NostrConnectSigner", () => {
-    describe("connection", () => {
-        it("should call subscription method with filters", async () => {
-            const relays = ["wss://relay.signer.com"];
-            const subscription = vi.fn().mockReturnValue({ subscribe: vi.fn() });
-            const publish = vi.fn(async () => { });
-            const client = new SimpleSigner();
-            const remote = new SimpleSigner();
-            const signer = new NostrConnectSigner({
-                relays,
-                remote: await remote.getPublicKey(),
-                signer: client,
-                subscriptionMethod: subscription,
-                publishMethod: publish,
-            });
-            signer.connect();
-            expect(subscription).toHaveBeenCalledWith(relays, [{ "#p": [await client.getPublicKey()], kinds: [24133] }]);
-        });
-    });
-});