applesauce-accounts 0.11.0 → 1.0.0

package/dist/{account.test.js → __tests__/account.test.js}

@@ -1,14 +1,14 @@
-import { describe, it, expect, beforeEach, vi } from "vitest";
-import { BaseAccount } from "./account.js";
+import { describe, it, expect, vi, beforeEach } from "vitest";
 import { SimpleSigner } from "applesauce-signers";
 import { finalizeEvent, generateSecretKey } from "nostr-tools";
-import { SimpleAccount } from "./accounts/simple-account.js";
+import { BaseAccount } from "../account.js";
+import { SimpleAccount } from "../accounts/simple-account.js";
 describe("BaseAccount", () => {
-    let signer;
-    beforeEach(() => {
-        signer = new SimpleSigner();
-    });
     describe("request queue", () => {
+        let signer;
+        beforeEach(() => {
+            signer = new SimpleSigner();
+        });
         it("should queue signing requests by default", async () => {
             const account = new BaseAccount(await signer.getPublicKey(), signer);
             let resolve = [];
@@ -63,4 +63,63 @@ describe("BaseAccount", () => {
             expect(account.type).toBe("nsec");
         });
     });
+    describe("nip04 and nip44", () => {
+        it("should return undefined when signer does not support nip04/nip44", () => {
+            const signer = {
+                getPublicKey: () => "test-pubkey",
+                signEvent: () => ({ id: "", pubkey: "test-pubkey", created_at: 0, kind: 1, tags: [], content: "", sig: "" }),
+            };
+            const account = new BaseAccount("test-pubkey", signer);
+            expect(account.nip04).toBeUndefined();
+            expect(account.nip44).toBeUndefined();
+        });
+        it("should return nip04/nip44 interface when signer supports them", async () => {
+            const signer = {
+                getPublicKey: () => "test-pubkey",
+                signEvent: () => ({ id: "", pubkey: "test-pubkey", created_at: 0, kind: 1, tags: [], content: "", sig: "" }),
+                nip04: {
+                    encrypt: async () => "encrypted",
+                    decrypt: async () => "decrypted",
+                },
+                nip44: {
+                    encrypt: async () => "encrypted",
+                    decrypt: async () => "decrypted",
+                },
+            };
+            const account = new BaseAccount("test-pubkey", signer);
+            expect(account.nip04).toBeDefined();
+            expect(account.nip44).toBeDefined();
+            const nip04Result = await account.nip04.encrypt("pubkey", "test");
+            expect(nip04Result).toBe("encrypted");
+            const nip44Result = await account.nip44.encrypt("pubkey", "test");
+            expect(nip44Result).toBe("encrypted");
+        });
+        it("should reflect changes in signer nip04/nip44 support", () => {
+            const signer = {
+                getPublicKey: () => "test-pubkey",
+                signEvent: () => ({ id: "", pubkey: "test-pubkey", created_at: 0, kind: 1, tags: [], content: "", sig: "" }),
+            };
+            const account = new BaseAccount("test-pubkey", signer);
+            expect(account.nip04).toBeUndefined();
+            expect(account.nip44).toBeUndefined();
+            // Add nip04 support
+            signer.nip04 = {
+                encrypt: async () => "encrypted",
+                decrypt: async () => "decrypted",
+            };
+            expect(account.nip04).toBeDefined();
+            expect(account.nip44).toBeUndefined();
+            // Add nip44 support
+            signer.nip44 = {
+                encrypt: async () => "encrypted",
+                decrypt: async () => "decrypted",
+            };
+            expect(account.nip04).toBeDefined();
+            expect(account.nip44).toBeDefined();
+            // Remove nip04 support
+            signer.nip04 = undefined;
+            expect(account.nip04).toBeUndefined();
+            expect(account.nip44).toBeDefined();
+        });
+    });
 });

package/dist/__tests__/manager.test.js

@@ -0,0 +1,65 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { AccountManager } from "../manager.js";
+import { SimpleAccount } from "../accounts/simple-account.js";
+import { generateSecretKey, getPublicKey } from "nostr-tools";
+import { bytesToHex } from "@noble/hashes/utils";
+let manager;
+beforeEach(() => {
+    manager = new AccountManager();
+});
+describe("toJSON", () => {
+    it("should return an array of serialized accounts", () => {
+        manager.addAccount(SimpleAccount.fromKey(generateSecretKey()));
+        manager.setAccountMetadata(manager.accounts[0], { name: "testing" });
+        expect(manager.toJSON()).toEqual([
+            {
+                id: expect.any(String),
+                type: "nsec",
+                pubkey: expect.any(String),
+                metadata: { name: "testing" },
+                signer: { key: expect.any(String) },
+            },
+        ]);
+    });
+});
+describe("fromJSON", () => {
+    it("should recreate accounts", () => {
+        const key = generateSecretKey();
+        const json = [
+            {
+                id: "custom-id",
+                type: "nsec",
+                pubkey: getPublicKey(key),
+                metadata: { name: "testing" },
+                signer: { key: bytesToHex(key) },
+            },
+        ];
+        manager.registerType(SimpleAccount);
+        manager.fromJSON(json);
+        expect(manager.getAccount("custom-id")).toBeInstanceOf(SimpleAccount);
+        expect(manager.getAccountForPubkey(getPublicKey(key))).toBeInstanceOf(SimpleAccount);
+        expect(manager.getAccountMetadata("custom-id")).toEqual({ name: "testing" });
+    });
+});
+describe("signer", () => {
+    it("should proxy active account", async () => {
+        const account = SimpleAccount.generateNew();
+        manager.addAccount(account);
+        manager.setActive(account);
+        expect(await manager.signer.getPublicKey()).toBe(getPublicKey(account.signer.key));
+    });
+    it("should throw if there is no active account", () => {
+        expect(() => {
+            manager.signer.getPublicKey();
+        }).toThrow("No active account");
+    });
+});
+describe("removeAccount", () => {
+    it("should clear active account if removed account was active", () => {
+        const account = SimpleAccount.generateNew();
+        manager.addAccount(account);
+        manager.setActive(account);
+        manager.removeAccount(account);
+        expect(manager.active).toBeUndefined();
+    });
+});

package/dist/account.d.ts

@@ -14,14 +14,8 @@ export declare class BaseAccount<Signer extends Nip07Interface, SignerData, Meta
     metadata$: BehaviorSubject<Metadata | undefined>;
     get metadata(): Metadata | undefined;
     set metadata(metadata: Metadata);
-    nip04?: {
-        encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
-        decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
-    } | undefined;
-    nip44?: {
-        encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
-        decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
-    } | undefined;
+    get nip04(): Nip07Interface["nip04"] | undefined;
+    get nip44(): Nip07Interface["nip44"] | undefined;
     constructor(pubkey: string, signer: Signer);
     toJSON(): SerializedAccount<SignerData, Metadata>;
     /** Adds the common fields to the serialized output of a toJSON method */

package/dist/account.js

@@ -40,33 +40,33 @@ export class BaseAccount {
     set metadata(metadata) {
         this.metadata$.next(metadata);
     }
-    // encryption interfaces
-    nip04;
-    nip44;
+    get nip04() {
+        if (!this.signer.nip04)
+            return undefined;
+        return {
+            encrypt: (pubkey, plaintext) => {
+                return this.waitForLock(() => this.signer.nip04.encrypt(pubkey, plaintext));
+            },
+            decrypt: (pubkey, plaintext) => {
+                return this.waitForLock(() => this.signer.nip04.decrypt(pubkey, plaintext));
+            },
+        };
+    }
+    get nip44() {
+        if (!this.signer.nip44)
+            return undefined;
+        return {
+            encrypt: (pubkey, plaintext) => {
+                return this.waitForLock(() => this.signer.nip44.encrypt(pubkey, plaintext));
+            },
+            decrypt: (pubkey, plaintext) => {
+                return this.waitForLock(() => this.signer.nip44.decrypt(pubkey, plaintext));
+            },
+        };
+    }
     constructor(pubkey, signer) {
         this.pubkey = pubkey;
         this.signer = signer;
-        // setup encryption interfaces to check if account is locked
-        if (this.signer.nip04) {
-            this.nip04 = {
-                encrypt: (pubkey, plaintext) => {
-                    return this.waitForLock(() => this.signer.nip04.encrypt(pubkey, plaintext));
-                },
-                decrypt: (pubkey, plaintext) => {
-                    return this.waitForLock(() => this.signer.nip04.decrypt(pubkey, plaintext));
-                },
-            };
-        }
-        if (this.signer.nip44) {
-            this.nip44 = {
-                encrypt: (pubkey, plaintext) => {
-                    return this.waitForLock(() => this.signer.nip44.encrypt(pubkey, plaintext));
-                },
-                decrypt: (pubkey, plaintext) => {
-                    return this.waitForLock(() => this.signer.nip44.decrypt(pubkey, plaintext));
-                },
-            };
-        }
     }
     // This should be overwritten by a sub class
     toJSON() {

package/dist/accounts/nostr-connect-account.d.ts

@@ -1,4 +1,4 @@
-import { NostrConnectConnectionMethods, NostrConnectSigner } from "applesauce-signers";
+import { NostrConnectSigner } from "applesauce-signers";
 import { BaseAccount } from "../account.js";
 import { SerializedAccount } from "../types.js";
 export type NostrConnectAccountSignerData = {
@@ -10,7 +10,5 @@ export type NostrConnectAccountSignerData = {
 export declare class NostrConnectAccount<Metadata extends unknown> extends BaseAccount<NostrConnectSigner, NostrConnectAccountSignerData, Metadata> {
     static readonly type = "nostr-connect";
     toJSON(): SerializedAccount<NostrConnectAccountSignerData, Metadata>;
-    /** This is called when NostrConnectAccount.fromJSON needs new connection methods for NostrConnectSigner */
-    static createConnectionMethods(): NostrConnectConnectionMethods;
-    static fromJSON<Metadata extends unknown>(json: SerializedAccount<NostrConnectAccountSignerData, Metadata>, connection?: NostrConnectConnectionMethods): NostrConnectAccount<Metadata>;
+    static fromJSON<Metadata extends unknown>(json: SerializedAccount<NostrConnectAccountSignerData, Metadata>): NostrConnectAccount<Metadata>;
 }

package/dist/accounts/nostr-connect-account.js

@@ -15,14 +15,8 @@ export class NostrConnectAccount extends BaseAccount {
             },
         });
     }
-    /** This is called when NostrConnectAccount.fromJSON needs new connection methods for NostrConnectSigner */
-    static createConnectionMethods() {
-        throw new Error("Cant create NostrConnectAccount without either passing in connection methods or setting NostrConnectAccount.createConnectionMethods");
-    }
-    static fromJSON(json, connection) {
-        connection = connection || NostrConnectAccount.createConnectionMethods();
+    static fromJSON(json) {
         const signer = new NostrConnectSigner({
-            ...connection,
             relays: json.signer.relays,
             pubkey: json.pubkey,
             remote: json.signer.remote,

package/dist/index.d.ts

@@ -2,3 +2,4 @@ export * as Accounts from "./accounts/index.js";
 export * from "./types.js";
 export * from "./account.js";
 export * from "./manager.js";
+export * from "./proxy-signer.js";

package/dist/index.js

@@ -2,3 +2,4 @@ export * as Accounts from "./accounts/index.js";
 export * from "./types.js";
 export * from "./account.js";
 export * from "./manager.js";
+export * from "./proxy-signer.js";

package/dist/manager.d.ts

@@ -8,7 +8,7 @@ export declare class AccountManager<Metadata extends unknown = any> {
     accounts$: BehaviorSubject<IAccount<any, any, Metadata>[]>;
     get accounts(): IAccount<any, any, Metadata>[];
     /** Proxy signer for currently active account */
-    signer: IAccount<any, any, Metadata>;
+    signer: Nip07Interface;
     /** Disable request queueing for any accounts added to this manager */
     disableQueue?: boolean;
     constructor();

package/dist/manager.js

@@ -1,4 +1,5 @@
 import { BehaviorSubject } from "rxjs";
+import { ProxySigner } from "./proxy-signer.js";
 export class AccountManager {
     types = new Map();
     active$ = new BehaviorSubject(undefined);
@@ -14,18 +15,7 @@ export class AccountManager {
     /** Disable request queueing for any accounts added to this manager */
     disableQueue;
     constructor() {
-        this.signer = new Proxy({}, {
-            get: (_, p) => {
-                if (!this.active)
-                    throw new Error("No active account");
-                return Reflect.get(this.active, p);
-            },
-            has: (_, p) => {
-                if (!this.active)
-                    throw new Error("No active account");
-                return Reflect.has(this.active, p);
-            },
-        });
+        this.signer = new ProxySigner(this.active$, "No active account");
     }
     // Account type CRUD
     /** Add account type class */
@@ -72,6 +62,9 @@ export class AccountManager {
     removeAccount(account) {
         const id = typeof account === "string" ? account : account.id;
         this.accounts$.next(this.accounts$.value.filter((a) => a.id !== id));
+        // if the removed account was active, clear the active account
+        if (this.active$.value?.id === id)
+            this.active$.next(undefined);
     }
     /** Replaces an account with another */
     replaceAccount(old, account) {

package/dist/proxy-signer.d.ts

@@ -0,0 +1,20 @@
+import { Nip07Interface } from "applesauce-signers";
+import { EventTemplate, NostrEvent } from "nostr-tools";
+import { Observable } from "rxjs";
+export declare class ProxySigner<T extends Nip07Interface> implements Nip07Interface {
+    protected upstream: Observable<T | undefined>;
+    protected error?: string | undefined;
+    private _signer;
+    protected get signer(): T;
+    get nip04(): {
+        encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
+        decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
+    };
+    get nip44(): {
+        encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
+        decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
+    };
+    constructor(upstream: Observable<T | undefined>, error?: string | undefined);
+    signEvent(template: EventTemplate): Promise<NostrEvent> | NostrEvent;
+    getPublicKey(): Promise<string> | string;
+}

package/dist/proxy-signer.js

@@ -0,0 +1,31 @@
+export class ProxySigner {
+    upstream;
+    error;
+    _signer;
+    get signer() {
+        if (!this._signer)
+            throw new Error(this.error || "Missing signer");
+        return this._signer;
+    }
+    get nip04() {
+        if (!this.signer.nip04)
+            throw new Error("Signer does not support nip04");
+        return this.signer.nip04;
+    }
+    get nip44() {
+        if (!this.signer.nip44)
+            throw new Error("Signer does not support nip44");
+        return this.signer.nip44;
+    }
+    constructor(upstream, error) {
+        this.upstream = upstream;
+        this.error = error;
+        this.upstream.subscribe((signer) => (this._signer = signer));
+    }
+    signEvent(template) {
+        return this.signer.signEvent(template);
+    }
+    getPublicKey() {
+        return this.signer.getPublicKey();
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-accounts",
-  "version": "0.11.0",
+  "version": "1.0.0",
   "description": "A simple nostr account management system",
   "type": "module",
   "main": "dist/index.js",
@@ -33,14 +33,14 @@
   },
   "dependencies": {
     "@noble/hashes": "^1.7.1",
-    "applesauce-signers": "^0.11.0",
-    "nanoid": "^5.0.9",
+    "applesauce-signers": "^1.0.0",
+    "nanoid": "^5.1.5",
     "nostr-tools": "^2.10.4",
     "rxjs": "^7.8.1"
   },
   "devDependencies": {
-    "typescript": "^5.7.3",
-    "vitest": "^3.0.5"
+    "typescript": "^5.8.3",
+    "vitest": "^3.1.1"
   },
   "funding": {
     "type": "lightning",

package/dist/manager.test.js

@@ -1,58 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import { AccountManager } from "./manager.js";
-import { SimpleAccount } from "./accounts/simple-account.js";
-import { generateSecretKey, getPublicKey } from "nostr-tools";
-import { bytesToHex } from "@noble/hashes/utils";
-describe("AccountManager", () => {
-    let manager;
-    beforeEach(() => {
-        manager = new AccountManager();
-    });
-    describe("toJSON", () => {
-        it("should return an array of serialized accounts", () => {
-            manager.addAccount(SimpleAccount.fromKey(generateSecretKey()));
-            manager.setAccountMetadata(manager.accounts[0], { name: "testing" });
-            expect(manager.toJSON()).toEqual([
-                {
-                    id: expect.any(String),
-                    type: "nsec",
-                    pubkey: expect.any(String),
-                    metadata: { name: "testing" },
-                    signer: { key: expect.any(String) },
-                },
-            ]);
-        });
-    });
-    describe("fromJSON", () => {
-        it("should recreate accounts", () => {
-            const key = generateSecretKey();
-            const json = [
-                {
-                    id: "custom-id",
-                    type: "nsec",
-                    pubkey: getPublicKey(key),
-                    metadata: { name: "testing" },
-                    signer: { key: bytesToHex(key) },
-                },
-            ];
-            manager.registerType(SimpleAccount);
-            manager.fromJSON(json);
-            expect(manager.getAccount("custom-id")).toBeInstanceOf(SimpleAccount);
-            expect(manager.getAccountForPubkey(getPublicKey(key))).toBeInstanceOf(SimpleAccount);
-            expect(manager.getAccountMetadata("custom-id")).toEqual({ name: "testing" });
-        });
-    });
-    describe("signer", () => {
-        it("should proxy active account", async () => {
-            const account = SimpleAccount.generateNew();
-            manager.addAccount(account);
-            manager.setActive(account);
-            expect(await manager.signer.getPublicKey()).toBe(getPublicKey(account.signer.key));
-        });
-        it("should throw if there is no active account", () => {
-            expect(() => {
-                manager.signer.getPublicKey();
-            }).toThrow("No active account");
-        });
-    });
-});