applesauce-signers 0.11.0 → 1.0.0

package/README.md

@@ -1,5 +1,101 @@
 # applesauce-signer
 
-A collection of signer classes for applesauce
+A collection of signer classes for applesauce that are compatible with the [NIP-07](https://github.com/nostr-protocol/nips/blob/master/07.md) API.
 
-See [documentation](https://hzrd149.github.io/applesauce/signers/signers.html)
+## Documentation
+
+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)
+
+## Available Signers
+
+### Password Signer (NIP-49)
+
+A secure signer that encrypts private keys using [NIP-49](https://github.com/nostr-protocol/nips/blob/master/49.md).
+
+```ts
+// Create a new password signer
+const signer = new PasswordSigner();
+
+// Set up with a new key and password
+const randomBytes = new Uint8Array(64);
+window.crypto.getRandomValues(randomBytes);
+
+signer.key = randomBytes;
+signer.setPassword("your-password");
+
+// Unlock the signer when needed
+await signer.unlock("your-password");
+```
+
+### Simple Signer
+
+A basic signer that holds the secret key in memory with NIP-04 and NIP-44 encryption support.
+
+```ts
+// Create new signer with random key
+const signer = new SimpleSigner();
+
+// Or import existing key
+const key = new Uint8Array(32);
+window.crypto.getRandomValues(key);
+const signer = new SimpleSigner(key);
+```
+
+### Nostr Connect Signer (NIP-46)
+
+A client-side implementation for remote signing using [NIP-46](https://github.com/nostr-protocol/nips/blob/master/46.md).
+
+```ts
+// First, set up the required relay communication methods
+import { Observable } from "rxjs";
+
+// Define subscription method for receiving events
+const subscriptionMethod = (filters, relays) => {
+  return new Observable((observer) => {
+    // Create subscription to relays
+    const cleanup = subscribeToRelays(relays, filters, (event) => {
+      observer.next(event);
+    });
+    return () => cleanup();
+  });
+};
+
+// Define publish method for sending events
+const publishMethod = async (event, relays) => {
+  for (const relay of relays) await publishToRelay(relay, event);
+};
+
+// You can set these methods globally at app initialization
+NostrConnectSigner.subscriptionMethod = subscriptionMethod;
+NostrConnectSigner.publishMethod = publishMethod;
+
+// Now create and use the signer
+const signer = new NostrConnectSigner({
+  remote: "<remote signer pubkey>",
+  relays: ["wss://relay.example.com"],
+  // Or pass methods directly to the constructor
+  subscriptionMethod,
+  publishMethod,
+});
+
+// Create a connection URI for your app
+const uri = signer.getNostrConnectURI({
+  name: "My App",
+  url: "https://example.com",
+  permissions: NostrConnectSigner.buildSigningPermissions([0, 1, 3]),
+});
+
+// Connect using bunker URI
+const bunkerSigner = await NostrConnectSigner.fromBunkerURI("bunker://...your-uri-here...", {
+  permissions: NostrConnectSigner.buildSigningPermissions([0, 1, 3]),
+});
+```
+
+### Other Signers
+
+- **Serial Port Signer**: For hardware signing devices (Chrome browsers only)
+- **Amber Clipboard Signer**: Integration with Amber wallet's web API

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

@@ -13,6 +13,7 @@ export declare class ExtensionSigner implements Nip07Interface {
         encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
         decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
     } | undefined;
+    protected pubkey: string | undefined;
     getPublicKey(): string | Promise<string>;
     getRelays(): Record<string, {
         read: boolean;

package/dist/signers/extension-signer.js

@@ -9,10 +9,22 @@ export class ExtensionSigner {
     get nip44() {
         return window.nostr?.nip44;
     }
+    pubkey = undefined;
     getPublicKey() {
         if (!window.nostr)
             throw new ExtensionMissingError("Signer extension missing");
-        return window.nostr.getPublicKey();
+        if (this.pubkey)
+            return this.pubkey;
+        const p = window.nostr.getPublicKey();
+        if (p instanceof Promise)
+            return p.then((pubkey) => {
+                this.pubkey = pubkey;
+                return pubkey;
+            });
+        else {
+            this.pubkey = p;
+            return p;
+        }
     }
     getRelays() {
         if (!window.nostr)

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

@@ -64,17 +64,26 @@ export type NostrConnectSignerOptions = {
     remote?: string;
     /** Users pubkey */
     pubkey?: string;
-};
-export type NostrConnectConnectionMethods = {
-    /** A method that is called when the subscription needs to be updated */
-    onSubOpen: (filters: Filter[], relays: string[], onEvent: (event: NostrEvent) => void) => Promise<void>;
-    /** A method called when the subscription should be closed */
-    onSubClose: () => Promise<void>;
-    /** A method that is called when an event needs to be published */
-    onPublishEvent: (event: NostrEvent, relays: string[]) => Promise<void>;
     /** A method for handling "auth" requests */
     onAuth?: (url: string) => Promise<void>;
+    /** A method for subscribing to relays */
+    subscriptionMethod?: NostrSubscriptionMethod;
+    /** A method for publishing events */
+    publishMethod?: NostrPublishMethod;
+};
+interface Unsubscribable {
+    unsubscribe(): void;
+}
+interface Observer<T> {
+    next: (value: T) => void;
+    error: (err: any) => void;
+    complete: () => void;
+}
+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>;
 export type NostrConnectAppMetadata = {
     name?: string;
     image?: string;
@@ -82,12 +91,10 @@ export type NostrConnectAppMetadata = {
     permissions?: string[];
 };
 export declare class NostrConnectSigner implements Nip07Interface {
-    /** A method that is called when the subscription needs to be updated */
-    onSubOpen?: (filters: Filter[], relays: string[], onEvent: (event: NostrEvent) => void) => Promise<void>;
-    /** A method called when the subscription should be closed */
-    onSubClose?: () => Promise<void>;
     /** A method that is called when an event needs to be published */
-    onPublishEvent?: (event: NostrEvent, relays: string[]) => Promise<void>;
+    protected publishMethod: NostrPublishMethod;
+    /** The active nostr subscription */
+    protected subscriptionMethod: NostrSubscriptionMethod;
     protected log: import("debug").Debugger;
     /** The local client signer */
     signer: SimpleSigner;
@@ -102,6 +109,7 @@ export declare class NostrConnectSigner implements Nip07Interface {
     remote?: string;
     /** Client pubkey */
     get clientPubkey(): string;
+    /** A method for handling "auth" requests */
     onAuth: (url: string) => Promise<void>;
     verifyEvent: typeof verifyEvent;
     /** A secret used when initiating a connection from the client side */
@@ -114,7 +122,13 @@ export declare class NostrConnectSigner implements Nip07Interface {
         encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
         decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
     } | undefined;
-    constructor(opts: NostrConnectConnectionMethods & NostrConnectSignerOptions);
+    /** A fallback method to use for subscriptionMethod if none is pass in when creating the signer */
+    static subscriptionMethod: NostrSubscriptionMethod | undefined;
+    /** A fallback method to use for publishMethod if none is pass in when creating the signer */
+    static publishMethod: NostrPublishMethod | undefined;
+    constructor(opts: NostrConnectSignerOptions);
+    /** The currently active REQ subscription */
+    protected req?: Unsubscribable;
     /** Open the connection */
     open(): Promise<void>;
     /** Close the connection */
@@ -155,7 +169,7 @@ export declare class NostrConnectSigner implements Nip07Interface {
     /** Builds an array of signing permissions for event kinds */
     static buildSigningPermissions(kinds: number[]): string[];
     /** Create a {@link NostrConnectSigner} from a bunker:// URI */
-    static fromBunkerURI(uri: string, options: NostrConnectConnectionMethods & {
+    static fromBunkerURI(uri: string, options?: Omit<NostrConnectSignerOptions, "relays"> & {
         permissions?: string[];
         signer?: SimpleSigner;
     }): Promise<NostrConnectSigner>;

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

@@ -33,14 +33,10 @@ 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 method that is called when the subscription needs to be updated */
-    onSubOpen;
-    /** A method called when the subscription should be closed */
-    onSubClose;
     /** A method that is called when an event needs to be published */
-    onPublishEvent;
-    // protected pool: IConnectionPool;
-    // protected sub: MultiSubscription;
+    publishMethod;
+    /** The active nostr subscription */
+    subscriptionMethod;
     log = logger.extend("NostrConnectSigner");
     /** The local client signer */
     signer;
@@ -57,19 +53,29 @@ export class NostrConnectSigner {
     get clientPubkey() {
         return getPublicKey(this.signer.key);
     }
+    /** A method for handling "auth" requests */
     onAuth = defaultHandleAuth;
     verifyEvent = verifyEvent;
     /** A secret used when initiating a connection from the client side */
     clientSecret = nanoid(12);
     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;
-        this.onSubOpen = opts.onSubOpen;
-        this.onSubClose = opts.onSubClose;
-        this.onPublishEvent = opts.onPublishEvent;
+        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();
@@ -82,6 +88,8 @@ export class NostrConnectSigner {
             decrypt: this.nip44Decrypt.bind(this),
         };
     }
+    /** The currently active REQ subscription */
+    req;
     /** Open the connection */
     async open() {
         if (this.subscriptionOpen)
@@ -89,19 +97,21 @@ export class NostrConnectSigner {
         this.subscriptionOpen = true;
         const pubkey = await this.signer.getPublicKey();
         // Setup subscription
-        await this.onSubOpen?.([
+        this.req = this.subscriptionMethod(this.relays, [
             {
                 kinds: [kinds.NostrConnect],
                 "#p": [pubkey],
             },
-        ], this.relays, this.handleEvent.bind(this));
+        ]).subscribe({
+            next: (event) => this.handleEvent(event),
+        });
         this.log("Opened", this.relays);
     }
     /** Close the connection */
     async close() {
         this.subscriptionOpen = false;
         this.isConnected = false;
-        await this.onSubClose?.();
+        this.req?.unsubscribe();
         this.log("Closed");
     }
     requests = new Map();
@@ -147,7 +157,7 @@ export class NostrConnectSigner {
                         }
                     }
                     else
-                        p.reject(response);
+                        p.reject(new Error(response.error));
                 }
                 else if (response.result) {
                     this.log("Got Response", response.id, response.result);
@@ -178,7 +188,7 @@ export class NostrConnectSigner {
         this.log(`Sending request ${id} (${method}) ${JSON.stringify(params)}`);
         const p = createDefer();
         this.requests.set(id, p);
-        await this.onPublishEvent?.(event, this.relays);
+        await this.publishMethod?.(this.relays, event);
         return p;
     }
     /** Connect to remote signer */
@@ -321,7 +331,7 @@ export class NostrConnectSigner {
     static async fromBunkerURI(uri, options) {
         const { remote, relays, secret } = NostrConnectSigner.parseBunkerURI(uri);
         const client = new NostrConnectSigner({ relays, remote, ...options });
-        await client.connect(secret, options.permissions);
+        await client.connect(secret, options?.permissions);
         return client;
     }
 }

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

@@ -3,23 +3,21 @@ import { NostrConnectSigner } from "./nostr-connect-signer.js";
 import { SimpleSigner } from "./simple-signer.js";
 describe("NostrConnectSigner", () => {
     describe("connection", () => {
-        it("should call onSubOpen with filters", async () => {
+        it("should call subscription method with filters", async () => {
             const relays = ["wss://relay.signer.com"];
-            const onSubOpen = vi.fn(async () => { });
-            const onSubClose = vi.fn(async () => { });
-            const onPublishEvent = vi.fn(async () => { });
+            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({
-                onSubOpen,
-                onSubClose,
-                onPublishEvent,
                 relays,
                 remote: await remote.getPublicKey(),
                 signer: client,
+                subscriptionMethod: subscription,
+                publishMethod: publish,
             });
             signer.connect();
-            expect(onSubOpen).toHaveBeenCalledWith([{ "#p": [await client.getPublicKey()], kinds: [24133] }], relays, expect.any(Function));
+            expect(subscription).toHaveBeenCalledWith(relays, [{ "#p": [await client.getPublicKey()], kinds: [24133] }]);
         });
     });
 });

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "applesauce-signers",
-  "version": "0.11.0",
+  "version": "1.0.0",
   "description": "Signer classes for applesauce",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "keywords": [
-    "nostr"
+    "nostr",
+    "applesauce"
   ],
   "author": "hzrd149",
   "license": "MIT",
@@ -35,7 +36,7 @@
     "@noble/hashes": "^1.7.1",
     "@noble/secp256k1": "^1.7.1",
     "@scure/base": "^1.2.4",
-    "applesauce-core": "^0.11.0",
+    "applesauce-core": "^1.0.0",
     "debug": "^4.4.0",
     "nanoid": "^5.0.9",
     "nostr-tools": "^2.10.4"
@@ -43,8 +44,8 @@
   "devDependencies": {
     "@types/debug": "^4.1.12",
     "@types/dom-serial": "^1.0.6",
-    "typescript": "^5.7.3",
-    "vitest": "^3.0.5"
+    "typescript": "^5.8.3",
+    "vitest": "^3.1.1"
   },
   "funding": {
     "type": "lightning",