applesauce-signers 1.2.0 → 3.0.0

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

@@ -1,34 +1,11 @@
-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 } from "applesauce-signers";
 import { nanoid } from "nanoid";
+import { getPublicKey, kinds, verifyEvent } from "nostr-tools";
 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");
 }
@@ -37,10 +14,17 @@ export class NostrConnectSigner {
     publishMethod;
     /** The active nostr subscription */
     subscriptionMethod;
+    /** 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;
     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 */
@@ -57,25 +41,27 @@ 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;
+        this.secret = opts.secret || nanoid(12);
+        // Get the subscription and publish methods
+        const subscriptionMethod = opts.subscriptionMethod ||
+            opts.pool?.subscription ||
+            NostrConnectSigner.subscriptionMethod ||
+            NostrConnectSigner.pool?.subscription;
         if (!subscriptionMethod)
             throw new Error("Missing subscriptionMethod, either pass a method or set NostrConnectSigner.subscriptionMethod");
-        const publishMethod = opts.publishMethod || NostrConnectSigner.publishMethod;
+        const publishMethod = opts.publishMethod || opts.pool?.publish || NostrConnectSigner.publishMethod || NostrConnectSigner.pool?.publish;
         if (!publishMethod)
             throw new Error("Missing publishMethod, either pass a method or set NostrConnectSigner.publishMethod");
-        this.subscriptionMethod = subscriptionMethod;
-        this.publishMethod = publishMethod;
+        // 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 (opts.onAuth)
             this.onAuth = opts.onAuth;
         this.signer = opts?.signer || new SimpleSigner();
@@ -92,9 +78,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 +89,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();
@@ -124,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;
@@ -185,10 +183,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 +220,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 */
@@ -295,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,29 +1,38 @@
 import { EventTemplate } from "nostr-tools";
 import { Deferred } from "applesauce-core/promise";
-import { Nip07Interface } from "../nip-07.js";
+import { ISigner } from "../interface.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();
     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,17 +47,27 @@ 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;
         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");
     }
+    /** Locks the signer by removing the unencrypted key from memory */
+    lock() {
+        this.key = null;
+    }
     // public methods
     async getPublicKey() {
         await this.requestUnlock();
@@ -82,4 +95,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

@@ -1,22 +1,23 @@
 import { VerifiedEvent } from "nostr-tools";
-import { Nip07Interface } from "../nip-07.js";
+import { ISigner } from "../interface.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

@@ -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),
@@ -14,25 +17,26 @@ 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 */
+    static fromPubkey(pubkey) {
+        return new ReadonlySigner(normalizeToPubkey(pubkey));
+    }
 }

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 "../interface.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 "../interface.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>;
@@ -13,4 +14,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,12 +1,14 @@
 {
   "name": "applesauce-signers",
-  "version": "1.2.0",
+  "version": "3.0.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,17 @@
     "@noble/hashes": "^1.7.1",
     "@noble/secp256k1": "^1.7.1",
     "@scure/base": "^1.2.4",
-    "applesauce-core": "^1.2.0",
+    "applesauce-core": "^3.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",
+    "vitest-websocket-mock": "^0.5.0"
   },
   "funding": {
     "type": "lightning",

package/dist/__tests__/exports.test.js

@@ -1,22 +0,0 @@
-import { describe, expect, it } from "vitest";
-import * as exports from "../index.js";
-describe("exports", () => {
-    it("should export the expected functions", () => {
-        expect(Object.keys(exports).sort()).toMatchInlineSnapshot(`
-      [
-        "AmberClipboardSigner",
-        "ExtensionMissingError",
-        "ExtensionSigner",
-        "Helpers",
-        "NostrConnectMethod",
-        "NostrConnectSigner",
-        "PasswordSigner",
-        "Permission",
-        "ReadonlySigner",
-        "SerialPortSigner",
-        "SimpleSigner",
-        "isErrorResponse",
-      ]
-    `);
-    });
-});

package/dist/helpers/__tests__/exports.test.d.ts

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

package/dist/helpers/__tests__/exports.test.js

@@ -1,11 +0,0 @@
-import { describe, expect, it } from "vitest";
-import * as exports from "../index.js";
-describe("exports", () => {
-    it("should export the expected functions", () => {
-        expect(Object.keys(exports).sort()).toMatchInlineSnapshot(`
-      [
-        "isNIP04",
-      ]
-    `);
-    });
-});

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 {};

package/dist/signers/__tests__/exports.test.d.ts

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

package/dist/signers/__tests__/exports.test.js

@@ -1,21 +0,0 @@
-import { describe, expect, it } from "vitest";
-import * as exports from "../index.js";
-describe("exports", () => {
-    it("should export the expected functions", () => {
-        expect(Object.keys(exports).sort()).toMatchInlineSnapshot(`
-      [
-        "AmberClipboardSigner",
-        "ExtensionMissingError",
-        "ExtensionSigner",
-        "NostrConnectMethod",
-        "NostrConnectSigner",
-        "PasswordSigner",
-        "Permission",
-        "ReadonlySigner",
-        "SerialPortSigner",
-        "SimpleSigner",
-        "isErrorResponse",
-      ]
-    `);
-    });
-});

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

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

package/dist/signers/__tests__/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] }]);
-        });
-    });
-});