applesauce-accounts 0.10.0 → 0.11.0

package/README.md

@@ -1,3 +1,5 @@
 # applesauce-accounts
 
-A simple nostr account management system
+A simple nostr account management system built on top of [applesauce-signers](https://hzrd149.github.io/applesauce/signers/installation.html)
+
+See [documentation](https://hzrd149.github.io/applesauce/signers/signers.html)

package/dist/account.d.ts

@@ -1,15 +1,19 @@
-import { Nip07Interface } from "applesauce-signer";
-import { EventTemplate } from "nostr-tools";
-import { IAccount, SerializedAccount } from "./types.js";
+import { Nip07Interface } from "applesauce-signers";
+import { BehaviorSubject } from "rxjs";
+import { NostrEvent } from "nostr-tools";
+import { EventTemplate, IAccount, SerializedAccount } from "./types.js";
 export declare class SignerMismatchError extends Error {
 }
-export declare class AccountLockedError extends Error {
-}
-export declare class BaseAccount<T extends string, S> implements IAccount<T, S> {
+export declare class BaseAccount<Signer extends Nip07Interface, SignerData, Metadata extends unknown> implements IAccount<Signer, SignerData, Metadata> {
     pubkey: string;
-    signer: Nip07Interface;
-    name?: string;
-    locked: boolean;
+    signer: Signer;
+    id: string;
+    get type(): string;
+    /** Disable request queueing */
+    disableQueue?: boolean;
+    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;
@@ -18,14 +22,22 @@ export declare class BaseAccount<T extends string, S> implements IAccount<T, S>
         encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
         decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
     } | undefined;
-    constructor(pubkey: string, signer: Nip07Interface);
-    unlock(): Promise<boolean>;
-    lock(): void;
-    toJSON(): SerializedAccount<T, S>;
-    /** throws if account is locked */
-    protected checkLocked(): void;
+    constructor(pubkey: string, signer: Signer);
+    toJSON(): SerializedAccount<SignerData, Metadata>;
+    /** Adds the common fields to the serialized output of a toJSON method */
+    protected saveCommonFields(json: Omit<SerializedAccount<SignerData, Metadata>, "id" | "type" | "metadata" | "pubkey">): SerializedAccount<SignerData, Metadata>;
+    /** Sets an accounts id and metadata. NOTE: This should only be used in fromJSON methods */
+    static loadCommonFields<T extends IAccount>(account: T, json: SerializedAccount<any, any>): T;
     /** Gets the pubkey from the signer */
-    getPublicKey(): Promise<string>;
+    getPublicKey(): string | Promise<string>;
     /** sign the event and make sure its signed with the correct pubkey */
-    signEvent(template: EventTemplate): Promise<import("nostr-tools").Event>;
+    signEvent(template: EventTemplate): Promise<NostrEvent> | NostrEvent;
+    /** Aborts all pending requests in the queue */
+    abortQueue(reason: Error): void;
+    /** internal queue */
+    protected queueLength: number;
+    protected lock: Promise<any> | null;
+    protected abort: AbortController | null;
+    protected reduceQueue(): void;
+    protected waitForLock<T>(fn: () => Promise<T> | T): Promise<T> | T;
 }

package/dist/account.js

@@ -1,13 +1,45 @@
-// errors
-export class SignerMismatchError extends Error {
+import { nanoid } from "nanoid";
+import { BehaviorSubject } from "rxjs";
+function wrapInSignal(promise, signal) {
+    return new Promise((res, rej) => {
+        signal.throwIfAborted();
+        let done = false;
+        // reject promise if abort signal is triggered
+        signal.addEventListener("abort", () => {
+            if (!done)
+                rej(signal.reason || undefined);
+            done = true;
+        });
+        return promise.then((v) => {
+            if (!done)
+                res(v);
+            done = true;
+        }, (err) => {
+            if (!done)
+                rej(err);
+            done = true;
+        });
+    });
 }
-export class AccountLockedError extends Error {
+export class SignerMismatchError extends Error {
 }
 export class BaseAccount {
     pubkey;
     signer;
-    name;
-    locked = true;
+    id = nanoid(8);
+    get type() {
+        const cls = Reflect.getPrototypeOf(this).constructor;
+        return cls.type;
+    }
+    /** Disable request queueing */
+    disableQueue;
+    metadata$ = new BehaviorSubject(undefined);
+    get metadata() {
+        return this.metadata$.value;
+    }
+    set metadata(metadata) {
+        this.metadata$.next(metadata);
+    }
     // encryption interfaces
     nip04;
     nip44;
@@ -18,60 +50,119 @@ export class BaseAccount {
         if (this.signer.nip04) {
             this.nip04 = {
                 encrypt: (pubkey, plaintext) => {
-                    this.checkLocked();
-                    return this.signer.nip04.encrypt(pubkey, plaintext);
+                    return this.waitForLock(() => this.signer.nip04.encrypt(pubkey, plaintext));
                 },
                 decrypt: (pubkey, plaintext) => {
-                    this.checkLocked();
-                    return this.signer.nip04.decrypt(pubkey, plaintext);
+                    return this.waitForLock(() => this.signer.nip04.decrypt(pubkey, plaintext));
                 },
             };
         }
         if (this.signer.nip44) {
             this.nip44 = {
                 encrypt: (pubkey, plaintext) => {
-                    this.checkLocked();
-                    return this.signer.nip44.encrypt(pubkey, plaintext);
+                    return this.waitForLock(() => this.signer.nip44.encrypt(pubkey, plaintext));
                 },
                 decrypt: (pubkey, plaintext) => {
-                    this.checkLocked();
-                    return this.signer.nip44.decrypt(pubkey, plaintext);
+                    return this.waitForLock(() => this.signer.nip44.decrypt(pubkey, plaintext));
                 },
             };
         }
     }
-    async unlock() {
-        this.locked = false;
-        return true;
-    }
-    lock() {
-        this.locked = true;
-    }
     // This should be overwritten by a sub class
     toJSON() {
         throw new Error("Not implemented");
     }
-    /** throws if account is locked */
-    checkLocked() {
-        if (this.locked)
-            throw new AccountLockedError("Account is locked");
+    /** Adds the common fields to the serialized output of a toJSON method */
+    saveCommonFields(json) {
+        return { ...json, id: this.id, pubkey: this.pubkey, metadata: this.metadata, type: this.type };
+    }
+    /** Sets an accounts id and metadata. NOTE: This should only be used in fromJSON methods */
+    static loadCommonFields(account, json) {
+        if (json.id)
+            account.id = json.id;
+        if (json.metadata)
+            account.metadata = json.metadata;
+        return account;
     }
     /** Gets the pubkey from the signer */
-    async getPublicKey() {
-        this.checkLocked();
-        const signerKey = await this.signer.getPublicKey();
-        if (this.pubkey !== signerKey)
-            throw new Error("Account signer mismatch");
-        return this.pubkey;
+    getPublicKey() {
+        const result = this.signer.getPublicKey();
+        if (result instanceof Promise)
+            return result.then((pubkey) => {
+                if (this.pubkey !== pubkey)
+                    throw new SignerMismatchError("Account signer mismatch");
+                return pubkey;
+            });
+        else {
+            if (this.pubkey !== result)
+                throw new SignerMismatchError("Account signer mismatch");
+            return result;
+        }
     }
     /** sign the event and make sure its signed with the correct pubkey */
-    async signEvent(template) {
-        this.checkLocked();
+    signEvent(template) {
         if (!Reflect.has(template, "pubkey"))
             Reflect.set(template, "pubkey", this.pubkey);
-        const signed = await this.signer.signEvent(template);
-        if (signed.pubkey !== this.pubkey)
-            throw new SignerMismatchError("Signer signed with wrong pubkey");
-        return signed;
+        return this.waitForLock(() => {
+            const result = this.signer.signEvent(template);
+            if (result instanceof Promise)
+                return result.then((signed) => {
+                    if (signed.pubkey !== this.pubkey)
+                        throw new SignerMismatchError("Signer signed with wrong pubkey");
+                    return signed;
+                });
+            else {
+                if (result.pubkey !== this.pubkey)
+                    throw new SignerMismatchError("Signer signed with wrong pubkey");
+                return result;
+            }
+        });
+    }
+    /** Aborts all pending requests in the queue */
+    abortQueue(reason) {
+        if (this.abort)
+            this.abort.abort(reason);
+    }
+    /** internal queue */
+    queueLength = 0;
+    lock = null;
+    abort = null;
+    reduceQueue() {
+        // shorten the queue
+        this.queueLength--;
+        // if this was the last request, remove the lock
+        if (this.queueLength === 0) {
+            this.lock = null;
+            this.abort = null;
+        }
+    }
+    waitForLock(fn) {
+        if (this.disableQueue)
+            return fn();
+        // if there is already a pending request, wait for it
+        if (this.lock && this.abort) {
+            // create a new promise that runs after the lock
+            const p = wrapInSignal(this.lock.then(() => {
+                // if the abort signal is triggered, don't call the signer
+                this.abort?.signal.throwIfAborted();
+                return fn();
+            }), this.abort.signal);
+            // set the lock the new promise that ignores errors
+            this.lock = p.catch(() => { }).finally(this.reduceQueue.bind(this));
+            this.queueLength++;
+            return p;
+        }
+        else {
+            const result = fn();
+            // if the result is async, set the new lock
+            if (result instanceof Promise) {
+                this.abort = new AbortController();
+                const p = wrapInSignal(result, this.abort.signal);
+                // set the lock the new promise that ignores errors
+                this.lock = p.catch(() => { }).finally(this.reduceQueue.bind(this));
+                this.queueLength = 1;
+            }
+            return result;
+        }
     }
 }

package/dist/account.test.d.ts

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

package/dist/account.test.js

@@ -0,0 +1,66 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { BaseAccount } from "./account.js";
+import { SimpleSigner } from "applesauce-signers";
+import { finalizeEvent, generateSecretKey } from "nostr-tools";
+import { SimpleAccount } from "./accounts/simple-account.js";
+describe("BaseAccount", () => {
+    let signer;
+    beforeEach(() => {
+        signer = new SimpleSigner();
+    });
+    describe("request queue", () => {
+        it("should queue signing requests by default", async () => {
+            const account = new BaseAccount(await signer.getPublicKey(), signer);
+            let resolve = [];
+            vi.spyOn(signer, "signEvent").mockImplementation(() => {
+                return new Promise((res) => {
+                    resolve.push(() => res(finalizeEvent({ kind: 1, content: "mock", created_at: 0, tags: [] }, signer.key)));
+                });
+            });
+            // make two signing requests
+            expect(account.signEvent({ kind: 1, content: "first", created_at: 0, tags: [] })).toEqual(expect.any(Promise));
+            expect(account.signEvent({ kind: 1, content: "second", created_at: 0, tags: [] })).toEqual(expect.any(Promise));
+            expect(signer.signEvent).toHaveBeenCalledOnce();
+            expect(signer.signEvent).toHaveBeenCalledWith(expect.objectContaining({ content: "first" }));
+            // resolve first
+            resolve.shift()?.();
+            // wait next tick
+            await new Promise((res) => setTimeout(res, 0));
+            expect(signer.signEvent).toHaveBeenCalledTimes(2);
+            expect(signer.signEvent).toHaveBeenCalledWith(expect.objectContaining({ content: "second" }));
+            // resolve second
+            resolve.shift()?.();
+            // wait next tick
+            await new Promise((res) => setTimeout(res, 0));
+            expect(Reflect.get(account, "queueLength")).toBe(0);
+            expect(Reflect.get(account, "lock")).toBeNull();
+        });
+        it("should cancel queue if request throws", () => { });
+        it("should not use queueing if its disabled", async () => {
+            const account = new BaseAccount(await signer.getPublicKey(), signer);
+            account.disableQueue = true;
+            let resolve = [];
+            vi.spyOn(signer, "signEvent").mockImplementation(() => {
+                return new Promise((res) => {
+                    resolve.push(() => res(finalizeEvent({ kind: 1, content: "mock", created_at: 0, tags: [] }, signer.key)));
+                });
+            });
+            // make two signing requests
+            account.signEvent({ kind: 1, content: "first", created_at: 0, tags: [] });
+            account.signEvent({ kind: 1, content: "second", created_at: 0, tags: [] });
+            expect(Reflect.get(account, "lock")).toBeNull();
+            expect(signer.signEvent).toHaveBeenCalledTimes(2);
+            expect(signer.signEvent).toHaveBeenCalledWith(expect.objectContaining({ content: "first" }));
+            expect(signer.signEvent).toHaveBeenCalledWith(expect.objectContaining({ content: "second" }));
+            // resolve both
+            resolve.shift()?.();
+            resolve.shift()?.();
+        });
+    });
+    describe("type", () => {
+        it("should return static account type", () => {
+            const account = SimpleAccount.fromKey(generateSecretKey());
+            expect(account.type).toBe("nsec");
+        });
+    });
+});

package/dist/accounts/amber-clipboard-account.d.ts

@@ -1,10 +1,9 @@
-import { AmberClipboardSigner } from "applesauce-signer/signers/amber-clipboard-signer";
+import { AmberClipboardSigner } from "applesauce-signers/signers/amber-clipboard-signer";
 import { BaseAccount } from "../account.js";
-import { IAccount, SerializedAccount } from "../types.js";
+import { SerializedAccount } from "../types.js";
 /** An account for the amber clipboard api */
-export declare class AmberClipboardAccount extends BaseAccount<"amber-clipboard", void> {
-    signer: AmberClipboardSigner;
-    constructor(pubkey: string, signer: AmberClipboardSigner);
-    toJSON(): SerializedAccount<"amber-clipboard", void>;
-    static fromJSON(json: SerializedAccount<"amber-clipboard", void>): IAccount<"amber-clipboard", void>;
+export declare class AmberClipboardAccount<Metadata extends unknown> extends BaseAccount<AmberClipboardSigner, void, Metadata> {
+    static readonly type = "amber-clipboard";
+    toJSON(): SerializedAccount<void, Metadata>;
+    static fromJSON<Metadata extends unknown>(json: SerializedAccount<void, Metadata>): AmberClipboardAccount<Metadata>;
 }

package/dist/accounts/amber-clipboard-account.js

@@ -1,16 +1,15 @@
-import { AmberClipboardSigner } from "applesauce-signer/signers/amber-clipboard-signer";
+import { AmberClipboardSigner } from "applesauce-signers/signers/amber-clipboard-signer";
 import { BaseAccount } from "../account.js";
 /** An account for the amber clipboard api */
 export class AmberClipboardAccount extends BaseAccount {
-    signer;
-    constructor(pubkey, signer) {
-        super(pubkey, signer);
-        this.signer = signer;
-    }
+    static type = "amber-clipboard";
     toJSON() {
-        return { type: "amber-clipboard", pubkey: this.pubkey, name: this.name, signer: void 0 };
+        return super.saveCommonFields({
+            signer: undefined,
+        });
     }
     static fromJSON(json) {
-        return new AmberClipboardAccount(json.pubkey, new AmberClipboardSigner());
+        const account = new AmberClipboardAccount(json.pubkey, new AmberClipboardSigner());
+        return super.loadCommonFields(account, json);
     }
 }

package/dist/accounts/common.d.ts

@@ -0,0 +1,3 @@
+import { AccountManager } from "../manager.js";
+/** Registers the most common account types to a account manager */
+export declare function registerCommonAccountTypes(manager: AccountManager): void;

package/dist/accounts/common.js

@@ -0,0 +1,13 @@
+import { ExtensionAccount } from "./extension-account.js";
+import { NostrConnectAccount } from "./nostr-connect-account.js";
+import { PasswordAccount } from "./password-account.js";
+import { ReadonlyAccount } from "./readonly-account.js";
+import { SimpleAccount } from "./simple-account.js";
+/** Registers the most common account types to a account manager */
+export function registerCommonAccountTypes(manager) {
+    manager.registerType(ExtensionAccount);
+    manager.registerType(PasswordAccount);
+    manager.registerType(ReadonlyAccount);
+    manager.registerType(SimpleAccount);
+    manager.registerType(NostrConnectAccount);
+}

package/dist/accounts/extension-account.d.ts

@@ -1,7 +1,10 @@
+import { ExtensionSigner } from "applesauce-signers/signers/extension-signer";
 import { BaseAccount } from "../account.js";
 import { SerializedAccount } from "../types.js";
-export default class ExtensionAccount extends BaseAccount<"extension", void> {
-    constructor(pubkey: string);
-    toJSON(): SerializedAccount<"extension", void>;
-    static fromJSON(json: SerializedAccount<"extension", void>): ExtensionAccount;
+export declare class ExtensionAccount<Metadata extends unknown> extends BaseAccount<ExtensionSigner, void, Metadata> {
+    signer: ExtensionSigner;
+    static readonly type = "extension";
+    constructor(pubkey: string, signer: ExtensionSigner);
+    toJSON(): SerializedAccount<void, Metadata>;
+    static fromJSON<Metadata extends unknown>(json: SerializedAccount<void, Metadata>): ExtensionAccount<Metadata>;
 }

package/dist/accounts/extension-account.js

@@ -1,13 +1,19 @@
-import { ExtensionSigner } from "applesauce-signer/signers/extension-signer";
+import { ExtensionSigner } from "applesauce-signers/signers/extension-signer";
 import { BaseAccount } from "../account.js";
-export default class ExtensionAccount extends BaseAccount {
-    constructor(pubkey) {
-        super(pubkey, new ExtensionSigner());
+export class ExtensionAccount extends BaseAccount {
+    signer;
+    static type = "extension";
+    constructor(pubkey, signer) {
+        super(pubkey, signer || new ExtensionSigner());
+        this.signer = signer;
     }
     toJSON() {
-        return { type: "extension", pubkey: this.pubkey, signer: undefined };
+        return super.saveCommonFields({
+            signer: undefined,
+        });
     }
     static fromJSON(json) {
-        return new ExtensionAccount(json.pubkey);
+        const account = new ExtensionAccount(json.pubkey, new ExtensionSigner());
+        return super.loadCommonFields(account, json);
     }
 }

package/dist/accounts/index.d.ts

@@ -4,3 +4,5 @@ export * from "./password-account.js";
 export * from "./readonly-account.js";
 export * from "./serial-port-account.js";
 export * from "./simple-account.js";
+export * from "./nostr-connect-account.js";
+export * from "./common.js";

package/dist/accounts/index.js

@@ -4,3 +4,5 @@ export * from "./password-account.js";
 export * from "./readonly-account.js";
 export * from "./serial-port-account.js";
 export * from "./simple-account.js";
+export * from "./nostr-connect-account.js";
+export * from "./common.js";

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

@@ -0,0 +1,16 @@
+import { NostrConnectConnectionMethods, NostrConnectSigner } from "applesauce-signers";
+import { BaseAccount } from "../account.js";
+import { SerializedAccount } from "../types.js";
+export type NostrConnectAccountSignerData = {
+    clientKey: string;
+    remote: string;
+    relays: string[];
+};
+/** An account type for NIP-46 signers */
+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>;
+}

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

@@ -0,0 +1,34 @@
+import { NostrConnectSigner, SimpleSigner } from "applesauce-signers";
+import { bytesToHex, hexToBytes } from "@noble/hashes/utils";
+import { BaseAccount } from "../account.js";
+/** An account type for NIP-46 signers */
+export class NostrConnectAccount extends BaseAccount {
+    static type = "nostr-connect";
+    toJSON() {
+        if (!this.signer.remote)
+            throw new Error("Cant save NostrConnectAccount when not initialized");
+        return super.saveCommonFields({
+            signer: {
+                clientKey: bytesToHex(this.signer.signer.key),
+                remote: this.signer.remote,
+                relays: this.signer.relays,
+            },
+        });
+    }
+    /** 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();
+        const signer = new NostrConnectSigner({
+            ...connection,
+            relays: json.signer.relays,
+            pubkey: json.pubkey,
+            remote: json.signer.remote,
+            signer: new SimpleSigner(hexToBytes(json.signer.clientKey)),
+        });
+        const account = new NostrConnectAccount(json.pubkey, signer);
+        return super.loadCommonFields(account, json);
+    }
+}

package/dist/accounts/password-account.d.ts

@@ -1,15 +1,21 @@
-import { PasswordSigner } from "applesauce-signer/signers/password-signer";
+import { PasswordSigner } from "applesauce-signers/signers/password-signer";
 import { BaseAccount } from "../account.js";
 import { SerializedAccount } from "../types.js";
-type SignerData = {
+export type PasswordAccountSignerData = {
     ncryptsec: string;
 };
-export default class PasswordAccount extends BaseAccount<"ncryptsec", SignerData> {
-    signer: PasswordSigner;
-    constructor(pubkey: string, signer: PasswordSigner);
-    unlock(): Promise<boolean>;
-    toJSON(): SerializedAccount<"ncryptsec", SignerData>;
-    static fromJSON(json: SerializedAccount<"ncryptsec", SignerData>): PasswordAccount;
-    static fromNcryptsec(pubkey: string, ncryptsec: string): PasswordAccount;
+export declare class PasswordAccount<Metadata extends unknown> extends BaseAccount<PasswordSigner, PasswordAccountSignerData, Metadata> {
+    static readonly type = "ncryptsec";
+    get unlocked(): boolean;
+    /** called when PasswordAccount.unlock is called without a password */
+    static requestUnlockPassword(_account: PasswordAccount<any>): Promise<string>;
+    /**
+     * Attempt to unlock the signer with a password
+     * @throws
+     */
+    unlock(password?: string): Promise<void>;
+    toJSON(): SerializedAccount<PasswordAccountSignerData, Metadata>;
+    static fromJSON<Metadata extends unknown>(json: SerializedAccount<PasswordAccountSignerData, Metadata>): PasswordAccount<Metadata>;
+    /** Creates a new PasswordAccount from a ncryptsec string */
+    static fromNcryptsec<Metadata extends unknown>(pubkey: string, ncryptsec: string): PasswordAccount<Metadata>;
 }
-export {};

package/dist/accounts/password-account.js

@@ -1,33 +1,36 @@
-import { PasswordSigner } from "applesauce-signer/signers/password-signer";
+import { PasswordSigner } from "applesauce-signers/signers/password-signer";
 import { BaseAccount } from "../account.js";
-export default class PasswordAccount extends BaseAccount {
-    signer;
-    constructor(pubkey, signer) {
-        super(pubkey, signer);
-        this.signer = signer;
+export class PasswordAccount extends BaseAccount {
+    static type = "ncryptsec";
+    get unlocked() {
+        return this.signer.unlocked;
     }
-    async unlock() {
-        try {
-            const password = prompt("Unlock password");
-            if (password === null)
-                return false;
-            await this.signer.unlock(password);
-            return true;
-        }
-        catch (error) {
-            return false;
-        }
+    /** called when PasswordAccount.unlock is called without a password */
+    static async requestUnlockPassword(_account) {
+        throw new Error("Cant unlock PasswordAccount without a password. either pass one in or set PasswordAccount.requestUnlockPassword");
+    }
+    /**
+     * Attempt to unlock the signer with a password
+     * @throws
+     */
+    async unlock(password) {
+        password = password || (await PasswordAccount.requestUnlockPassword(this));
+        await this.signer.unlock(password);
     }
     toJSON() {
         if (!this.signer.ncryptsec)
             throw new Error("Cant save account without ncryptsec");
-        return { type: "ncryptsec", pubkey: this.pubkey, signer: { ncryptsec: this.signer.ncryptsec } };
+        return super.saveCommonFields({
+            signer: { ncryptsec: this.signer.ncryptsec },
+        });
     }
     static fromJSON(json) {
         const signer = new PasswordSigner();
         signer.ncryptsec = json.signer.ncryptsec;
-        return new PasswordAccount(json.pubkey, signer);
+        const account = new PasswordAccount(json.pubkey, signer);
+        return super.loadCommonFields(account, json);
     }
+    /** Creates a new PasswordAccount from a ncryptsec string */
     static fromNcryptsec(pubkey, ncryptsec) {
         const signer = new PasswordSigner();
         signer.ncryptsec = ncryptsec;

package/dist/accounts/readonly-account.d.ts

@@ -1,9 +1,10 @@
-import { ReadonlySigner } from "applesauce-signer/signers/readonly-signer";
+import { ReadonlySigner } from "applesauce-signers/signers/readonly-signer";
 import { BaseAccount } from "../account.js";
 import { SerializedAccount } from "../types.js";
 /** An account that cannot sign or encrypt anything */
-export default class ReadonlyAccount extends BaseAccount<"readonly", void> {
-    constructor(pubkey: string, signer?: ReadonlySigner);
-    toJSON(): SerializedAccount<"readonly", void>;
-    static fromJSON(json: SerializedAccount<"readonly", void>): ReadonlyAccount;
+export declare class ReadonlyAccount<Metadata extends unknown> extends BaseAccount<ReadonlySigner, void, Metadata> {
+    static readonly type = "readonly";
+    toJSON(): SerializedAccount<void, Metadata>;
+    static fromJSON<Metadata extends unknown>(json: SerializedAccount<void, Metadata>): ReadonlyAccount<Metadata>;
+    static fromPubkey(pubkey: string): ReadonlyAccount<unknown>;
 }

package/dist/accounts/readonly-account.js

@@ -1,18 +1,18 @@
-import { ReadonlySigner } from "applesauce-signer/signers/readonly-signer";
+import { ReadonlySigner } from "applesauce-signers/signers/readonly-signer";
 import { BaseAccount } from "../account.js";
 /** An account that cannot sign or encrypt anything */
-export default class ReadonlyAccount extends BaseAccount {
-    constructor(pubkey, signer) {
-        super(pubkey, signer || new ReadonlySigner(pubkey));
-    }
+export class ReadonlyAccount extends BaseAccount {
+    static type = "readonly";
     toJSON() {
-        return {
-            type: "readonly",
-            pubkey: this.pubkey,
+        return super.saveCommonFields({
             signer: undefined,
-        };
+        });
     }
     static fromJSON(json) {
-        return new ReadonlyAccount(json.pubkey);
+        const account = new ReadonlyAccount(json.pubkey, new ReadonlySigner(json.pubkey));
+        return super.loadCommonFields(account, json);
+    }
+    static fromPubkey(pubkey) {
+        return new ReadonlyAccount(pubkey, new ReadonlySigner(pubkey));
     }
 }

package/dist/accounts/serial-port-account.d.ts

@@ -1,10 +1,10 @@
-import { SerialPortSigner } from "applesauce-signer/signers/serial-port-signer";
+import { SerialPortSigner } from "applesauce-signers/signers/serial-port-signer";
 import { BaseAccount } from "../account.js";
 import { SerializedAccount } from "../types.js";
 /** An account for SerialPortSigner */
-export default class SerialPortAccount extends BaseAccount<"serial-port", void> {
-    constructor(pubkey: string, signer?: SerialPortSigner);
+export declare class SerialPortAccount<Metadata extends unknown> extends BaseAccount<SerialPortSigner, void, Metadata> {
+    static readonly type = "serial-port";
     unlock(): Promise<boolean>;
-    toJSON(): SerializedAccount<"serial-port", void>;
-    static fromJSON(json: SerializedAccount<"serial-port", void>): SerialPortAccount;
+    toJSON(): SerializedAccount<void, Metadata>;
+    static fromJSON<Metadata extends unknown>(json: SerializedAccount<void, Metadata>): SerialPortAccount<Metadata>;
 }

package/dist/accounts/serial-port-account.js

@@ -1,10 +1,8 @@
-import { SerialPortSigner } from "applesauce-signer/signers/serial-port-signer";
+import { SerialPortSigner } from "applesauce-signers/signers/serial-port-signer";
 import { BaseAccount } from "../account.js";
 /** An account for SerialPortSigner */
-export default class SerialPortAccount extends BaseAccount {
-    constructor(pubkey, signer) {
-        super(pubkey, signer || new SerialPortSigner());
-    }
+export class SerialPortAccount extends BaseAccount {
+    static type = "serial-port";
     async unlock() {
         try {
             const pubkey = await this.signer.getPublicKey();
@@ -17,9 +15,11 @@ export default class SerialPortAccount extends BaseAccount {
         }
     }
     toJSON() {
-        return { type: "serial-port", pubkey: this.pubkey, signer: undefined };
+        return super.saveCommonFields({ signer: undefined });
     }
     static fromJSON(json) {
-        return new SerialPortAccount(json.pubkey);
+        const signer = new SerialPortSigner();
+        const account = new SerialPortAccount(json.pubkey, signer);
+        return super.loadCommonFields(account, json);
     }
 }

package/dist/accounts/simple-account.d.ts

@@ -1,14 +1,13 @@
-import { SimpleSigner } from "applesauce-signer/signers/simple-signer";
+import { SimpleSigner } from "applesauce-signers/signers/simple-signer";
 import { BaseAccount } from "../account.js";
 import { SerializedAccount } from "../types.js";
-type SignerData = {
+export type SimpleAccountSignerData = {
     key: string;
 };
-export default class SimpleAccount extends BaseAccount<"nsec", SignerData> {
-    signer: SimpleSigner;
-    constructor(pubkey: string, signer: SimpleSigner);
-    static fromKey(key: Uint8Array | string): SimpleAccount;
-    toJSON(): SerializedAccount<"nsec", SignerData>;
-    static fromJSON(json: SerializedAccount<"nsec", SignerData>): SimpleAccount;
+export declare class SimpleAccount<Metadata extends unknown> extends BaseAccount<SimpleSigner, SimpleAccountSignerData, Metadata> {
+    static readonly type = "nsec";
+    toJSON(): SerializedAccount<SimpleAccountSignerData, Metadata>;
+    static fromJSON<Metadata extends unknown>(json: SerializedAccount<SimpleAccountSignerData, Metadata>): SimpleAccount<Metadata>;
+    static fromKey<Metadata extends unknown>(key: Uint8Array | string): SimpleAccount<Metadata>;
+    static generateNew<Metadata extends unknown>(): SimpleAccount<Metadata>;
 }
-export {};

package/dist/accounts/simple-account.js

@@ -1,12 +1,18 @@
-import { getPublicKey } from "nostr-tools";
-import { SimpleSigner } from "applesauce-signer/signers/simple-signer";
+import { generateSecretKey, getPublicKey } from "nostr-tools";
+import { SimpleSigner } from "applesauce-signers/signers/simple-signer";
 import { bytesToHex, hexToBytes } from "@noble/hashes/utils";
 import { BaseAccount } from "../account.js";
-export default class SimpleAccount extends BaseAccount {
-    signer;
-    constructor(pubkey, signer) {
-        super(pubkey, signer);
-        this.signer = signer;
+export class SimpleAccount extends BaseAccount {
+    static type = "nsec";
+    toJSON() {
+        return super.saveCommonFields({
+            signer: { key: bytesToHex(this.signer.key) },
+        });
+    }
+    static fromJSON(json) {
+        const key = hexToBytes(json.signer.key);
+        const account = new SimpleAccount(json.pubkey, new SimpleSigner(key));
+        return super.loadCommonFields(account, json);
     }
     static fromKey(key) {
         if (typeof key === "string")
@@ -14,11 +20,8 @@ export default class SimpleAccount extends BaseAccount {
         const pubkey = getPublicKey(key);
         return new SimpleAccount(pubkey, new SimpleSigner(key));
     }
-    toJSON() {
-        return { type: "nsec", pubkey: this.pubkey, signer: { key: bytesToHex(this.signer.key) } };
-    }
-    static fromJSON(json) {
-        const key = hexToBytes(json.signer.key);
-        return new SimpleAccount(json.pubkey, new SimpleSigner(key));
+    static generateNew() {
+        const key = generateSecretKey();
+        return SimpleAccount.fromKey(key);
     }
 }

package/dist/manager.d.ts

@@ -1,2 +1,50 @@
-export declare class AccountManager {
+import { Nip07Interface } from "applesauce-signers";
+import { BehaviorSubject } from "rxjs";
+import { IAccount, IAccountConstructor, SerializedAccount } from "./types.js";
+export declare class AccountManager<Metadata extends unknown = any> {
+    types: Map<string, IAccountConstructor<any, any, Metadata>>;
+    active$: BehaviorSubject<IAccount<any, any, Metadata> | undefined>;
+    get active(): IAccount<any, any, Metadata> | undefined;
+    accounts$: BehaviorSubject<IAccount<any, any, Metadata>[]>;
+    get accounts(): IAccount<any, any, Metadata>[];
+    /** Proxy signer for currently active account */
+    signer: IAccount<any, any, Metadata>;
+    /** Disable request queueing for any accounts added to this manager */
+    disableQueue?: boolean;
+    constructor();
+    /** Add account type class */
+    registerType<S extends Nip07Interface>(accountType: IAccountConstructor<S, any, Metadata>): void;
+    /** Remove account type */
+    unregisterType(type: string): void;
+    /** gets an account in the manager */
+    getAccount<Signer extends Nip07Interface>(id: string | IAccount<Signer, any, Metadata>): IAccount<Signer, any, Metadata> | undefined;
+    /** Return the first account for a pubkey */
+    getAccountForPubkey(pubkey: string): IAccount<any, any, Metadata> | undefined;
+    /** Returns all accounts for a pubkey */
+    getAccountsForPubkey(pubkey: string): IAccount<any, any, Metadata>[];
+    /** adds an account to the manager */
+    addAccount(account: IAccount<any, any, Metadata>): void;
+    /** Removes an account from the manager */
+    removeAccount(account: string | IAccount<any, any, Metadata>): void;
+    /** Replaces an account with another */
+    replaceAccount(old: string | IAccount<any, any, Metadata>, account: IAccount<any, any, Metadata>): void;
+    /** Returns the currently active account */
+    getActive(): IAccount<any, any, Metadata> | undefined;
+    /** Sets the currently active account */
+    setActive(id: string | IAccount<any, any, Metadata>): void;
+    /** Clears the currently active account */
+    clearActive(): void;
+    /** sets the metadata on an account */
+    setAccountMetadata(id: string | IAccount<any, any, Metadata>, metadata: Metadata): void;
+    /** sets the metadata on an account */
+    getAccountMetadata(id: string | IAccount<any, any, Metadata>): Metadata | undefined;
+    /** Removes all metadata on the account */
+    clearAccountMetadata(id: string | IAccount<any, any, Metadata>): void;
+    /** Returns an array of serialized accounts */
+    toJSON(quite?: boolean): SerializedAccount<any, Metadata>[];
+    /**
+     * Restores all accounts from an array of serialized accounts
+     * NOTE: this will clear all existing accounts
+     */
+    fromJSON(accounts: SerializedAccount<any, Metadata>[], quite?: boolean): void;
 }

package/dist/manager.js

@@ -1,2 +1,165 @@
+import { BehaviorSubject } from "rxjs";
 export class AccountManager {
+    types = new Map();
+    active$ = new BehaviorSubject(undefined);
+    get active() {
+        return this.active$.value;
+    }
+    accounts$ = new BehaviorSubject([]);
+    get accounts() {
+        return this.accounts$.value;
+    }
+    /** Proxy signer for currently active account */
+    signer;
+    /** 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);
+            },
+        });
+    }
+    // Account type CRUD
+    /** Add account type class */
+    registerType(accountType) {
+        if (!accountType.type)
+            throw new Error(`Account class missing static "type" field`);
+        if (this.types.has(accountType.type))
+            throw new Error(`An account type of ${accountType.type} already exists`);
+        this.types.set(accountType.type, accountType);
+    }
+    /** Remove account type */
+    unregisterType(type) {
+        this.types.delete(type);
+    }
+    // Accounts CRUD
+    /** gets an account in the manager */
+    getAccount(id) {
+        if (typeof id === "string")
+            return this.accounts$.value.find((a) => a.id === id);
+        else if (this.accounts$.value.includes(id))
+            return id;
+        else
+            return undefined;
+    }
+    /** Return the first account for a pubkey */
+    getAccountForPubkey(pubkey) {
+        return Object.values(this.accounts$.value).find((account) => account.pubkey === pubkey);
+    }
+    /** Returns all accounts for a pubkey */
+    getAccountsForPubkey(pubkey) {
+        return Object.values(this.accounts$.value).filter((account) => account.pubkey === pubkey);
+    }
+    /** adds an account to the manager */
+    addAccount(account) {
+        if (this.getAccount(account.id))
+            return;
+        // copy the disableQueue flag only if its set
+        if (this.disableQueue !== undefined && account.disableQueue !== undefined) {
+            account.disableQueue = this.disableQueue;
+        }
+        this.accounts$.next([...this.accounts$.value, account]);
+    }
+    /** Removes an account from the manager */
+    removeAccount(account) {
+        const id = typeof account === "string" ? account : account.id;
+        this.accounts$.next(this.accounts$.value.filter((a) => a.id !== id));
+    }
+    /** Replaces an account with another */
+    replaceAccount(old, account) {
+        this.addAccount(account);
+        // if the old account was active, switch to the new one
+        const id = typeof account === "string" ? account : account.id;
+        if (this.active$.value?.id === id)
+            this.setActive(account);
+        this.removeAccount(old);
+    }
+    // Active account methods
+    /** Returns the currently active account */
+    getActive() {
+        return this.active$.value;
+    }
+    /** Sets the currently active account */
+    setActive(id) {
+        const account = this.getAccount(id);
+        if (!account)
+            throw new Error("Cant find account with that ID");
+        if (this.active$.value?.id !== account.id) {
+            this.active$.next(account);
+        }
+    }
+    /** Clears the currently active account */
+    clearActive() {
+        this.active$.next(undefined);
+    }
+    // Metadata CRUD
+    /** sets the metadata on an account */
+    setAccountMetadata(id, metadata) {
+        const account = this.getAccount(id);
+        if (!account)
+            throw new Error("Cant find account with that ID");
+        account.metadata = metadata;
+    }
+    /** sets the metadata on an account */
+    getAccountMetadata(id) {
+        const account = this.getAccount(id);
+        if (!account)
+            throw new Error("Cant find account with that ID");
+        return account.metadata;
+    }
+    /** Removes all metadata on the account */
+    clearAccountMetadata(id) {
+        const account = this.getAccount(id);
+        if (!account)
+            throw new Error("Cant find account with that ID");
+        account.metadata = undefined;
+    }
+    // Serialize / Deserialize
+    /** Returns an array of serialized accounts */
+    toJSON(quite = false) {
+        const accounts = [];
+        for (const account of this.accounts) {
+            try {
+                accounts.push(account.toJSON());
+            }
+            catch (error) {
+                if (!quite)
+                    throw error;
+            }
+        }
+        return accounts;
+    }
+    /**
+     * Restores all accounts from an array of serialized accounts
+     * NOTE: this will clear all existing accounts
+     */
+    fromJSON(accounts, quite = false) {
+        for (const json of accounts) {
+            try {
+                const AccountType = this.types.get(json.type);
+                if (!AccountType) {
+                    if (!quite)
+                        throw new Error(`Missing account type ${json.type}`);
+                    else
+                        continue;
+                }
+                const account = AccountType.fromJSON(json);
+                this.addAccount(account);
+            }
+            catch (error) {
+                if (!quite)
+                    throw error;
+                else
+                    console.log(`Failed to load account`, error);
+            }
+        }
+    }
 }

package/dist/manager.test.d.ts

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

package/dist/manager.test.js

@@ -0,0 +1,58 @@
+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");
+        });
+    });
+});

package/dist/types.d.ts

@@ -1,19 +1,34 @@
-import { Nip07Interface } from "applesauce-signer";
-export type SerializedAccount<T extends string, S> = {
-    type: T;
-    name?: string;
+import { Nip07Interface } from "applesauce-signers";
+export type EventTemplate = {
+    kind: number;
+    content: string;
+    tags: string[][];
+    created_at: number;
+};
+export type SerializedAccount<SignerData, Metadata extends unknown> = {
+    /** Internal account ID */
+    id: string;
+    /** account type */
+    type: string;
+    /** pubkey of the account */
     pubkey: string;
-    signer: S;
+    /** Signer data */
+    signer: SignerData;
+    /** Extra application specific account metadata */
+    metadata?: Metadata;
 };
-export interface IAccount<T extends string, S> extends Nip07Interface {
+export interface IAccount<Signer extends Nip07Interface = Nip07Interface, SignerData = any, Metadata extends unknown = any> extends Nip07Interface {
+    id: string;
     name?: string;
     pubkey: string;
-    locked: boolean;
-    unlock(): Promise<boolean>;
-    lock(): void;
-    toJSON(): SerializedAccount<T, S>;
+    metadata?: Metadata;
+    signer: Signer;
+    type: string;
+    disableQueue?: boolean;
+    toJSON(): SerializedAccount<SignerData, Metadata>;
 }
-export interface IAccountConstructor<T extends string, S> {
-    new (pubkey: string, signer: Nip07Interface): IAccount<T, S>;
-    fromJSON(json: SerializedAccount<T, S>): IAccount<T, S>;
+export interface IAccountConstructor<Signer extends Nip07Interface, SignerData, Metadata extends unknown> {
+    readonly type: string;
+    new (pubkey: string, signer: Signer): IAccount<Signer, SignerData, Metadata>;
+    fromJSON(json: SerializedAccount<SignerData, Metadata>): IAccount<Signer, SignerData, Metadata>;
 }

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "applesauce-accounts",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "A simple nostr account management system",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "keywords": [
-    "nostr"
+    "nostr",
+    "applesauce"
   ],
   "author": "hzrd149",
   "license": "MIT",
@@ -16,27 +17,30 @@
   "exports": {
     ".": {
       "import": "./dist/index.js",
+      "require": "./dist/index.js",
       "types": "./dist/index.d.ts"
     },
     "./accounts": {
       "import": "./dist/accounts/index.js",
+      "require": "./dist/accounts/index.js",
       "types": "./dist/accounts/index.d.ts"
     },
     "./accounts/*": {
       "import": "./dist/accounts/*.js",
+      "require": "./dist/accounts/*.js",
       "types": "./dist/accounts/*.d.ts"
     }
   },
   "dependencies": {
-    "@noble/hashes": "^1.5.0",
-    "applesauce-signer": "^0.10.0",
+    "@noble/hashes": "^1.7.1",
+    "applesauce-signers": "^0.11.0",
     "nanoid": "^5.0.9",
-    "nostr-tools": "^2.10.3",
+    "nostr-tools": "^2.10.4",
     "rxjs": "^7.8.1"
   },
   "devDependencies": {
-    "typescript": "^5.6.3",
-    "vitest": "^2.1.8"
+    "typescript": "^5.7.3",
+    "vitest": "^3.0.5"
   },
   "funding": {
     "type": "lightning",