applesauce-accounts 1.0.0 → 3.0.0

package/dist/account.d.ts

@@ -1,10 +1,12 @@
-import { Nip07Interface } from "applesauce-signers";
+import { ISigner } from "applesauce-signers";
 import { BehaviorSubject } from "rxjs";
 import { NostrEvent } from "nostr-tools";
 import { EventTemplate, IAccount, SerializedAccount } from "./types.js";
+/** An error thrown when a signer is used with the wrong pubkey */
 export declare class SignerMismatchError extends Error {
 }
-export declare class BaseAccount<Signer extends Nip07Interface, SignerData, Metadata extends unknown> implements IAccount<Signer, SignerData, Metadata> {
+/** A base class for all accounts */
+export declare class BaseAccount<Signer extends ISigner, SignerData, Metadata extends unknown> implements IAccount<Signer, SignerData, Metadata> {
     pubkey: string;
     signer: Signer;
     id: string;
@@ -14,18 +16,20 @@ export declare class BaseAccount<Signer extends Nip07Interface, SignerData, Meta
     metadata$: BehaviorSubject<Metadata | undefined>;
     get metadata(): Metadata | undefined;
     set metadata(metadata: Metadata);
-    get nip04(): Nip07Interface["nip04"] | undefined;
-    get nip44(): Nip07Interface["nip44"] | undefined;
+    get nip04(): ISigner["nip04"] | undefined;
+    get nip44(): ISigner["nip44"] | undefined;
     constructor(pubkey: string, signer: Signer);
     toJSON(): SerializedAccount<SignerData, Metadata>;
+    /** A method that wraps any signer interaction, this allows the account to wait for unlock or queue requests */
+    protected operation<T extends unknown>(operation: () => Promise<T>): Promise<T>;
     /** 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(): string | Promise<string>;
+    getPublicKey(): Promise<string>;
     /** sign the event and make sure its signed with the correct pubkey */
-    signEvent(template: EventTemplate): Promise<NostrEvent> | NostrEvent;
+    signEvent(template: EventTemplate): Promise<NostrEvent>;
     /** Aborts all pending requests in the queue */
     abortQueue(reason: Error): void;
     /** internal queue */
@@ -33,5 +37,5 @@ export declare class BaseAccount<Signer extends Nip07Interface, SignerData, Meta
     protected lock: Promise<any> | null;
     protected abort: AbortController | null;
     protected reduceQueue(): void;
-    protected waitForLock<T>(fn: () => Promise<T> | T): Promise<T> | T;
+    protected waitForQueue<T extends unknown>(operation: () => Promise<T>): Promise<T>;
 }

package/dist/account.js

@@ -1,5 +1,7 @@
 import { nanoid } from "nanoid";
 import { BehaviorSubject } from "rxjs";
+import { getEventHash } from "nostr-tools";
+/** Wraps a promise in an abort signal */
 function wrapInSignal(promise, signal) {
     return new Promise((res, rej) => {
         signal.throwIfAborted();
@@ -21,8 +23,10 @@ function wrapInSignal(promise, signal) {
         });
     });
 }
+/** An error thrown when a signer is used with the wrong pubkey */
 export class SignerMismatchError extends Error {
 }
+/** A base class for all accounts */
 export class BaseAccount {
     pubkey;
     signer;
@@ -44,24 +48,16 @@ export class BaseAccount {
         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));
-            },
+            encrypt: async (pubkey, plaintext) => this.operation(() => this.signer.nip04.encrypt(pubkey, plaintext)),
+            decrypt: async (pubkey, plaintext) => this.operation(() => 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));
-            },
+            encrypt: async (pubkey, plaintext) => this.operation(() => this.signer.nip44.encrypt(pubkey, plaintext)),
+            decrypt: async (pubkey, plaintext) => this.operation(() => this.signer.nip44.decrypt(pubkey, plaintext)),
         };
     }
     constructor(pubkey, signer) {
@@ -72,6 +68,11 @@ export class BaseAccount {
     toJSON() {
         throw new Error("Not implemented");
     }
+    /** A method that wraps any signer interaction, this allows the account to wait for unlock or queue requests */
+    operation(operation) {
+        // If the queue is enabled, wait our turn in the queue
+        return this.waitForQueue(operation);
+    }
     /** 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 };
@@ -86,36 +87,26 @@ export class BaseAccount {
     }
     /** Gets the pubkey from the signer */
     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 {
+        return this.operation(async () => {
+            const result = await this.signer.getPublicKey();
             if (this.pubkey !== result)
                 throw new SignerMismatchError("Account signer mismatch");
             return result;
-        }
+        });
     }
     /** sign the event and make sure its signed with the correct pubkey */
     signEvent(template) {
+        // If the template does not have a pubkey, set it to the accounts pubkey
         if (!Reflect.has(template, "pubkey"))
             Reflect.set(template, "pubkey", this.pubkey);
-        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;
-            }
+        return this.operation(async () => {
+            const id = getEventHash(template);
+            const result = await this.signer.signEvent(template);
+            if (result.pubkey !== this.pubkey)
+                throw new SignerMismatchError("Signer signed with wrong pubkey");
+            if (result.id !== id)
+                throw new SignerMismatchError("Signer modified event");
+            return result;
         });
     }
     /** Aborts all pending requests in the queue */
@@ -136,16 +127,16 @@ export class BaseAccount {
             this.abort = null;
         }
     }
-    waitForLock(fn) {
+    waitForQueue(operation) {
         if (this.disableQueue)
-            return fn();
+            return operation();
         // 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();
+                return operation();
             }), this.abort.signal);
             // set the lock the new promise that ignores errors
             this.lock = p.catch(() => { }).finally(this.reduceQueue.bind(this));
@@ -153,7 +144,7 @@ export class BaseAccount {
             return p;
         }
         else {
-            const result = fn();
+            const result = operation();
             // if the result is async, set the new lock
             if (result instanceof Promise) {
                 this.abort = new AbortController();

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

@@ -7,4 +7,9 @@ export declare class ExtensionAccount<Metadata extends unknown> extends BaseAcco
     constructor(pubkey: string, signer: ExtensionSigner);
     toJSON(): SerializedAccount<void, Metadata>;
     static fromJSON<Metadata extends unknown>(json: SerializedAccount<void, Metadata>): ExtensionAccount<Metadata>;
+    /**
+     * Creates a new account from the NIP-07 extension
+     * @throws {ExtensionMissingError} if the extension is not installed
+     */
+    static fromExtension(): Promise<ExtensionAccount<void>>;
 }

package/dist/accounts/extension-account.js

@@ -16,4 +16,13 @@ export class ExtensionAccount extends BaseAccount {
         const account = new ExtensionAccount(json.pubkey, new ExtensionSigner());
         return super.loadCommonFields(account, json);
     }
+    /**
+     * Creates a new account from the NIP-07 extension
+     * @throws {ExtensionMissingError} if the extension is not installed
+     */
+    static async fromExtension() {
+        const signer = new ExtensionSigner();
+        const pubkey = await signer.getPublicKey();
+        return new ExtensionAccount(pubkey, signer);
+    }
 }

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

@@ -4,16 +4,17 @@ import { SerializedAccount } from "../types.js";
 export type PasswordAccountSignerData = {
     ncryptsec: string;
 };
-export declare class PasswordAccount<Metadata extends unknown> extends BaseAccount<PasswordSigner, PasswordAccountSignerData, Metadata> {
+export declare class PasswordAccount<Metadata extends unknown = 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>;
+    static requestUnlockPassword?: (account: PasswordAccount<any>) => Promise<string>;
     /**
      * Attempt to unlock the signer with a password
      * @throws
      */
     unlock(password?: string): Promise<void>;
+    protected operation<T extends unknown>(operation: () => Promise<T>): Promise<T>;
     toJSON(): SerializedAccount<PasswordAccountSignerData, Metadata>;
     static fromJSON<Metadata extends unknown>(json: SerializedAccount<PasswordAccountSignerData, Metadata>): PasswordAccount<Metadata>;
     /** Creates a new PasswordAccount from a ncryptsec string */

package/dist/accounts/password-account.js

@@ -6,17 +6,29 @@ export class PasswordAccount extends BaseAccount {
         return this.signer.unlocked;
     }
     /** 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");
-    }
+    static requestUnlockPassword;
     /**
      * Attempt to unlock the signer with a password
      * @throws
      */
     async unlock(password) {
-        password = password || (await PasswordAccount.requestUnlockPassword(this));
+        if (!password) {
+            if (!PasswordAccount.requestUnlockPassword)
+                throw new Error("Cant unlock PasswordAccount without a password. either pass one in or set PasswordAccount.requestUnlockPassword");
+            password = await PasswordAccount.requestUnlockPassword(this);
+        }
         await this.signer.unlock(password);
     }
+    operation(operation) {
+        // If the account is not unlocked, wait for the unlock password to be provided
+        if (!this.unlocked) {
+            if (!PasswordAccount.requestUnlockPassword)
+                throw new Error("Account is locked and there is no requestUnlockPassword method");
+            return this.unlock().then(() => super.operation(operation));
+        }
+        else
+            return super.operation(operation);
+    }
     toJSON() {
         if (!this.signer.ncryptsec)
             throw new Error("Cant save account without ncryptsec");

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

@@ -6,5 +6,6 @@ export declare class ReadonlyAccount<Metadata extends unknown> extends BaseAccou
     static readonly type = "readonly";
     toJSON(): SerializedAccount<void, Metadata>;
     static fromJSON<Metadata extends unknown>(json: SerializedAccount<void, Metadata>): ReadonlyAccount<Metadata>;
+    /** Creates a ReadonlyAccount from a hex public key or NIP-19 npub */
     static fromPubkey(pubkey: string): ReadonlyAccount<unknown>;
 }

package/dist/accounts/readonly-account.js

@@ -1,3 +1,4 @@
+import { normalizeToPubkey } from "applesauce-core/helpers/pointers";
 import { ReadonlySigner } from "applesauce-signers/signers/readonly-signer";
 import { BaseAccount } from "../account.js";
 /** An account that cannot sign or encrypt anything */
@@ -12,7 +13,9 @@ export class ReadonlyAccount extends BaseAccount {
         const account = new ReadonlyAccount(json.pubkey, new ReadonlySigner(json.pubkey));
         return super.loadCommonFields(account, json);
     }
+    /** Creates a ReadonlyAccount from a hex public key or NIP-19 npub */
     static fromPubkey(pubkey) {
-        return new ReadonlyAccount(pubkey, new ReadonlySigner(pubkey));
+        const signer = ReadonlySigner.fromPubkey(pubkey);
+        return new ReadonlyAccount(normalizeToPubkey(pubkey), signer);
     }
 }

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

@@ -8,6 +8,8 @@ export declare class SimpleAccount<Metadata extends unknown> extends BaseAccount
     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>;
+    /** Creates a SimpleAccount from a hex private key or NIP-19 nsec */
+    static fromKey<Metadata extends unknown>(privateKey: Uint8Array | string): SimpleAccount<Metadata>;
+    /** Creates a new SimpleAccount with a random private key */
     static generateNew<Metadata extends unknown>(): SimpleAccount<Metadata>;
 }

package/dist/accounts/simple-account.js

@@ -14,12 +14,13 @@ export class SimpleAccount extends BaseAccount {
         const account = new SimpleAccount(json.pubkey, new SimpleSigner(key));
         return super.loadCommonFields(account, json);
     }
-    static fromKey(key) {
-        if (typeof key === "string")
-            key = hexToBytes(key);
-        const pubkey = getPublicKey(key);
-        return new SimpleAccount(pubkey, new SimpleSigner(key));
+    /** Creates a SimpleAccount from a hex private key or NIP-19 nsec */
+    static fromKey(privateKey) {
+        const signer = SimpleSigner.fromKey(privateKey);
+        const pubkey = getPublicKey(signer.key);
+        return new SimpleAccount(pubkey, signer);
     }
+    /** Creates a new SimpleAccount with a random private key */
     static generateNew() {
         const key = generateSecretKey();
         return SimpleAccount.fromKey(key);

package/dist/manager.d.ts

@@ -1,4 +1,4 @@
-import { Nip07Interface } from "applesauce-signers";
+import { ISigner } from "applesauce-signers";
 import { BehaviorSubject } from "rxjs";
 import { IAccount, IAccountConstructor, SerializedAccount } from "./types.js";
 export declare class AccountManager<Metadata extends unknown = any> {
@@ -8,16 +8,16 @@ 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: Nip07Interface;
+    signer: ISigner;
     /** 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;
+    registerType<S extends ISigner>(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;
+    getAccount<Signer extends ISigner>(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 */

package/dist/proxy-signer.d.ts

@@ -1,20 +1,21 @@
-import { Nip07Interface } from "applesauce-signers";
+import { ISigner } from "applesauce-signers";
 import { EventTemplate, NostrEvent } from "nostr-tools";
 import { Observable } from "rxjs";
-export declare class ProxySigner<T extends Nip07Interface> implements Nip07Interface {
+/** A signer class that proxies requests to another signer that isn't created yet */
+export declare class ProxySigner<T extends ISigner> implements ISigner {
     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;
+        encrypt: (pubkey: string, plaintext: string) => Promise<string>;
+        decrypt: (pubkey: string, ciphertext: string) => Promise<string>;
     };
     get nip44(): {
-        encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
-        decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
+        encrypt: (pubkey: string, plaintext: string) => Promise<string>;
+        decrypt: (pubkey: string, ciphertext: string) => Promise<string>;
     };
     constructor(upstream: Observable<T | undefined>, error?: string | undefined);
-    signEvent(template: EventTemplate): Promise<NostrEvent> | NostrEvent;
-    getPublicKey(): Promise<string> | string;
+    signEvent(template: EventTemplate): Promise<NostrEvent>;
+    getPublicKey(): Promise<string>;
 }

package/dist/proxy-signer.js

@@ -1,3 +1,4 @@
+/** A signer class that proxies requests to another signer that isn't created yet */
 export class ProxySigner {
     upstream;
     error;
@@ -22,10 +23,10 @@ export class ProxySigner {
         this.error = error;
         this.upstream.subscribe((signer) => (this._signer = signer));
     }
-    signEvent(template) {
+    async signEvent(template) {
         return this.signer.signEvent(template);
     }
-    getPublicKey() {
+    async getPublicKey() {
         return this.signer.getPublicKey();
     }
 }

package/dist/types.d.ts

@@ -1,10 +1,12 @@
-import { Nip07Interface } from "applesauce-signers";
+import { ISigner } from "applesauce-signers";
+import { NostrEvent } from "nostr-tools";
 export type EventTemplate = {
     kind: number;
     content: string;
     tags: string[][];
     created_at: number;
 };
+/** A type for serializing an account */
 export type SerializedAccount<SignerData, Metadata extends unknown> = {
     /** Internal account ID */
     id: string;
@@ -17,7 +19,8 @@ export type SerializedAccount<SignerData, Metadata extends unknown> = {
     /** Extra application specific account metadata */
     metadata?: Metadata;
 };
-export interface IAccount<Signer extends Nip07Interface = Nip07Interface, SignerData = any, Metadata extends unknown = any> extends Nip07Interface {
+/** An interface for an account */
+export interface IAccount<Signer extends ISigner = ISigner, SignerData = any, Metadata extends unknown = any> extends ISigner {
     id: string;
     name?: string;
     pubkey: string;
@@ -27,8 +30,14 @@ export interface IAccount<Signer extends Nip07Interface = Nip07Interface, Signer
     disableQueue?: boolean;
     toJSON(): SerializedAccount<SignerData, Metadata>;
 }
-export interface IAccountConstructor<Signer extends Nip07Interface, SignerData, Metadata extends unknown> {
+/** A constructor for an account */
+export interface IAccountConstructor<Signer extends ISigner, 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>;
 }
+/** An interface for caching decrypted content of events */
+export interface DecryptionCache {
+    getContent(event: NostrEvent): Promise<string>;
+    setContent(event: NostrEvent, content: string): Promise<void>;
+}

package/package.json

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

package/dist/__tests__/account.test.d.ts

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

package/dist/__tests__/account.test.js

@@ -1,125 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { SimpleSigner } from "applesauce-signers";
-import { finalizeEvent, generateSecretKey } from "nostr-tools";
-import { BaseAccount } from "../account.js";
-import { SimpleAccount } from "../accounts/simple-account.js";
-describe("BaseAccount", () => {
-    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 = [];
-            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");
-        });
-    });
-    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.d.ts

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

package/dist/__tests__/manager.test.js

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