applesauce-accounts 0.0.0-next-20250124172415 → 0.0.0-next-20250124224517

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-signer](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,14 @@
 import { Nip07Interface } from "applesauce-signer";
-import { EventTemplate } from "nostr-tools";
-import { IAccount, SerializedAccount } from "./types.js";
+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;
+    metadata?: Metadata;
     nip04?: {
         encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
         decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
@@ -18,12 +17,8 @@ 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>;
     /** Gets the pubkey from the signer */
     getPublicKey(): Promise<string>;
     /** sign the event and make sure its signed with the correct pubkey */

package/dist/account.js

@@ -1,3 +1,4 @@
+import { nanoid } from "nanoid";
 // errors
 export class SignerMismatchError extends Error {
 }
@@ -6,8 +7,8 @@ export class AccountLockedError extends Error {
 export class BaseAccount {
     pubkey;
     signer;
-    name;
-    locked = true;
+    id = nanoid(8);
+    metadata;
     // encryption interfaces
     nip04;
     nip44;
@@ -18,11 +19,9 @@ export class BaseAccount {
         if (this.signer.nip04) {
             this.nip04 = {
                 encrypt: (pubkey, plaintext) => {
-                    this.checkLocked();
                     return this.signer.nip04.encrypt(pubkey, plaintext);
                 },
                 decrypt: (pubkey, plaintext) => {
-                    this.checkLocked();
                     return this.signer.nip04.decrypt(pubkey, plaintext);
                 },
             };
@@ -30,35 +29,21 @@ export class BaseAccount {
         if (this.signer.nip44) {
             this.nip44 = {
                 encrypt: (pubkey, plaintext) => {
-                    this.checkLocked();
                     return this.signer.nip44.encrypt(pubkey, plaintext);
                 },
                 decrypt: (pubkey, plaintext) => {
-                    this.checkLocked();
                     return 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");
-    }
     /** Gets the pubkey from the signer */
     async getPublicKey() {
-        this.checkLocked();
+        // this.checkLocked();
         const signerKey = await this.signer.getPublicKey();
         if (this.pubkey !== signerKey)
             throw new Error("Account signer mismatch");
@@ -66,7 +51,7 @@ export class BaseAccount {
     }
     /** sign the event and make sure its signed with the correct pubkey */
     async signEvent(template) {
-        this.checkLocked();
+        // this.checkLocked();
         if (!Reflect.has(template, "pubkey"))
             Reflect.set(template, "pubkey", this.pubkey);
         const signed = await this.signer.signEvent(template);

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

@@ -1,10 +1,9 @@
 import { AmberClipboardSigner } from "applesauce-signer/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 type: string;
+    toJSON(): SerializedAccount<void, Metadata>;
+    static fromJSON<MD extends unknown>(json: SerializedAccount<void, MD>): AmberClipboardAccount<MD>;
 }

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

@@ -2,13 +2,15 @@ import { AmberClipboardSigner } from "applesauce-signer/signers/amber-clipboard-
 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 {
+            type: AmberClipboardAccount.type,
+            id: this.id,
+            pubkey: this.pubkey,
+            metadata: this.metadata,
+            signer: undefined,
+        };
     }
     static fromJSON(json) {
         return new AmberClipboardAccount(json.pubkey, new AmberClipboardSigner());

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,11 @@
+import ExtensionAccount from "./extension-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);
+}

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

@@ -1,7 +1,16 @@
+import { ExtensionSigner } from "applesauce-signer/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 default class ExtensionAccount<Metadata extends unknown> extends BaseAccount<ExtensionSigner, void, Metadata> {
+    signer: ExtensionSigner;
+    static type: string;
+    constructor(pubkey: string, signer: ExtensionSigner);
+    toJSON(): {
+        type: string;
+        id: string;
+        pubkey: string;
+        metadata: Metadata | undefined;
+        signer: undefined;
+    };
+    static fromJSON<MD extends unknown>(json: SerializedAccount<void, MD>): ExtensionAccount<unknown>;
 }

package/dist/accounts/extension-account.js

@@ -1,13 +1,22 @@
 import { ExtensionSigner } from "applesauce-signer/signers/extension-signer";
 import { BaseAccount } from "../account.js";
 export default class ExtensionAccount extends BaseAccount {
-    constructor(pubkey) {
-        super(pubkey, new ExtensionSigner());
+    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 {
+            type: ExtensionAccount.type,
+            id: this.id,
+            pubkey: this.pubkey,
+            metadata: this.metadata,
+            signer: undefined,
+        };
     }
     static fromJSON(json) {
-        return new ExtensionAccount(json.pubkey);
+        return new ExtensionAccount(json.pubkey, new ExtensionSigner());
     }
 }

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,17 @@
+import { NostrConnectConnectionMethods, NostrConnectSigner } from "applesauce-signer";
+import { BaseAccount } from "../account.js";
+import { SerializedAccount } from "../types.js";
+type SignerData = {
+    clientKey: string;
+    remote: string;
+    relays: string[];
+};
+/** An account type for NIP-46 signers */
+export declare class NostrConnectAccount<Metadata extends unknown> extends BaseAccount<NostrConnectSigner, SignerData, Metadata> {
+    static type: string;
+    toJSON(): SerializedAccount<SignerData, Metadata>;
+    /** This is called when NostrConnectAccount.fromJSON needs new connection methods for NostrConnectSigner */
+    static createConnectionMethods(): NostrConnectConnectionMethods;
+    static fromJSON<Metadata extends unknown>(json: SerializedAccount<SignerData, Metadata>, connection?: NostrConnectConnectionMethods): NostrConnectAccount<Metadata>;
+}
+export {};

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

@@ -0,0 +1,32 @@
+import { NostrConnectSigner, SimpleSigner } from "applesauce-signer";
+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");
+        const signer = {
+            clientKey: bytesToHex(this.signer.signer.key),
+            remote: this.signer.remote,
+            relays: this.signer.relays,
+        };
+        return { type: NostrConnectAccount.type, id: this.id, pubkey: this.pubkey, metadata: this.metadata, signer };
+    }
+    /** 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)),
+        });
+        return new NostrConnectAccount(json.pubkey, signer);
+    }
+}

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

@@ -4,12 +4,19 @@ import { SerializedAccount } from "../types.js";
 type SignerData = {
     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 default class PasswordAccount<Metadata extends unknown> extends BaseAccount<PasswordSigner, SignerData, Metadata> {
+    static type: string;
+    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<SignerData, Metadata>;
+    static fromJSON<Metadata extends unknown>(json: SerializedAccount<SignerData, 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,39 @@
 import { PasswordSigner } from "applesauce-signer/signers/password-signer";
 import { BaseAccount } from "../account.js";
 export default class PasswordAccount extends BaseAccount {
-    signer;
-    constructor(pubkey, signer) {
-        super(pubkey, signer);
-        this.signer = signer;
+    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 {
+            type: PasswordAccount.type,
+            id: this.id,
+            pubkey: this.pubkey,
+            metadata: this.metadata,
+            signer: { ncryptsec: this.signer.ncryptsec },
+        };
     }
     static fromJSON(json) {
         const signer = new PasswordSigner();
         signer.ncryptsec = json.signer.ncryptsec;
         return new PasswordAccount(json.pubkey, signer);
     }
+    /** 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

@@ -2,8 +2,14 @@ import { ReadonlySigner } from "applesauce-signer/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 default class ReadonlyAccount<Metadata extends unknown> extends BaseAccount<ReadonlySigner, void, Metadata> {
+    static type: string;
+    toJSON(): {
+        type: string;
+        id: string;
+        pubkey: string;
+        metadata: Metadata | undefined;
+        signer: undefined;
+    };
+    static fromJSON<Metadata extends unknown>(json: SerializedAccount<void, Metadata>): ReadonlyAccount<Metadata>;
 }

package/dist/accounts/readonly-account.js

@@ -2,17 +2,17 @@ import { ReadonlySigner } from "applesauce-signer/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));
-    }
+    static type = "readonly";
     toJSON() {
         return {
-            type: "readonly",
+            type: ReadonlyAccount.type,
+            id: this.id,
             pubkey: this.pubkey,
+            metadata: this.metadata,
             signer: undefined,
         };
     }
     static fromJSON(json) {
-        return new ReadonlyAccount(json.pubkey);
+        return new ReadonlyAccount(json.pubkey, new ReadonlySigner(json.pubkey));
     }
 }

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

@@ -2,9 +2,9 @@ import { SerialPortSigner } from "applesauce-signer/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 default class SerialPortAccount<Metadata extends unknown> extends BaseAccount<SerialPortSigner, void, Metadata> {
+    static type: string;
     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

@@ -2,9 +2,7 @@ import { SerialPortSigner } from "applesauce-signer/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());
-    }
+    static type = "serial-port";
     async unlock() {
         try {
             const pubkey = await this.signer.getPublicKey();
@@ -17,9 +15,15 @@ export default class SerialPortAccount extends BaseAccount {
         }
     }
     toJSON() {
-        return { type: "serial-port", pubkey: this.pubkey, signer: undefined };
+        return {
+            type: SerialPortAccount.type,
+            id: this.id,
+            pubkey: this.pubkey,
+            metadata: this.metadata,
+            signer: undefined,
+        };
     }
     static fromJSON(json) {
-        return new SerialPortAccount(json.pubkey);
+        return new SerialPortAccount(json.pubkey, new SerialPortSigner());
     }
 }

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

@@ -4,11 +4,10 @@ import { SerializedAccount } from "../types.js";
 type SignerData = {
     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 default class SimpleAccount<Metadata extends unknown> extends BaseAccount<SimpleSigner, SignerData, Metadata> {
+    static type: string;
+    toJSON(): SerializedAccount<SignerData, Metadata>;
+    static fromJSON<Metadata extends unknown>(json: SerializedAccount<SignerData, Metadata>): SimpleAccount<Metadata>;
+    static fromKey<Metadata extends unknown>(key: Uint8Array | string): SimpleAccount<Metadata>;
 }
 export {};

package/dist/accounts/simple-account.js

@@ -3,10 +3,19 @@ import { SimpleSigner } from "applesauce-signer/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;
+    static type = "nsec";
+    toJSON() {
+        return {
+            type: SimpleAccount.type,
+            id: this.id,
+            pubkey: this.pubkey,
+            metadata: this.metadata,
+            signer: { key: bytesToHex(this.signer.key) },
+        };
+    }
+    static fromJSON(json) {
+        const key = hexToBytes(json.signer.key);
+        return new SimpleAccount(json.pubkey, new SimpleSigner(key));
     }
     static fromKey(key) {
         if (typeof key === "string")
@@ -14,11 +23,4 @@ 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));
-    }
 }

package/dist/manager.d.ts

@@ -1,2 +1,37 @@
-export declare class AccountManager {
+import { Nip07Interface } from "applesauce-signer";
+import { BehaviorSubject } from "rxjs";
+import { IAccount, IAccountConstructor, SerializedAccount } from "./types.js";
+export declare class AccountManager<Metadata extends unknown = any> {
+    active: BehaviorSubject<IAccount<any, any, Metadata> | null>;
+    accounts: BehaviorSubject<Record<string, IAccount<any, any, Metadata>>>;
+    types: Map<string, IAccountConstructor<any, any, Metadata>>;
+    /** 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<S extends Nip07Interface>(id: string | IAccount<S, any, Metadata>): IAccount<S, any, Metadata> | undefined;
+    /** 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> | null;
+    /** 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;
+    /** Removes all metadata on the account */
+    clearAccountMetadata(id: string | IAccount<any, any, Metadata>): void;
+    /** Returns an array of serialized accounts */
+    toJSON(): 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,115 @@
+import { BehaviorSubject } from "rxjs";
 export class AccountManager {
+    active = new BehaviorSubject(null);
+    accounts = new BehaviorSubject({});
+    types = new Map();
+    // 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[id];
+        else if (this.accounts.value[id.id])
+            return id;
+        else
+            return undefined;
+    }
+    /** adds an account to the manager */
+    addAccount(account) {
+        if (this.getAccount(account.id))
+            return;
+        this.accounts.next({
+            ...this.accounts.value,
+            [account.id]: account,
+        });
+    }
+    /** Removes an account from the manager */
+    removeAccount(account) {
+        const id = typeof account === "string" ? account : account.id;
+        const next = { ...this.accounts.value };
+        delete next[id];
+        this.accounts.next(next);
+    }
+    /** 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(null);
+    }
+    // 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;
+    }
+    /** 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() {
+        return Array.from(Object.values(this.accounts)).map((account) => account.toJSON());
+    }
+    /**
+     * 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;
+            }
+        }
+    }
 }

package/dist/types.d.ts

@@ -1,19 +1,34 @@
 import { Nip07Interface } from "applesauce-signer";
-export type SerializedAccount<T extends string, S> = {
-    type: T;
+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;
+    /** local name of the account */
     name?: 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, SignerData, Metadata extends unknown> extends Nip07Interface {
+    id: string;
     name?: string;
     pubkey: string;
-    locked: boolean;
-    unlock(): Promise<boolean>;
-    lock(): void;
-    toJSON(): SerializedAccount<T, S>;
+    metadata?: Metadata;
+    signer: Signer;
+    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> {
+    type: string;
+    new (pubkey: string, signer: Signer): IAccount<Signer, SignerData, Metadata>;
+    fromJSON(json: SerializedAccount<SignerData, Metadata>): IAccount<Signer, SignerData, Metadata>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-accounts",
-  "version": "0.0.0-next-20250124172415",
+  "version": "0.0.0-next-20250124224517",
   "description": "A simple nostr account management system",
   "type": "module",
   "main": "dist/index.js",
@@ -32,7 +32,7 @@
   },
   "dependencies": {
     "@noble/hashes": "^1.5.0",
-    "applesauce-signer": "0.0.0-next-20250124172415",
+    "applesauce-signer": "0.0.0-next-20250124224517",
     "nanoid": "^5.0.9",
     "nostr-tools": "^2.10.3",
     "rxjs": "^7.8.1"