applesauce-accounts 0.10.0 → 0.12.0

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: Nip07Interface;
+    /** 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,155 @@
+import { BehaviorSubject } from "rxjs";
+import { ProxySigner } from "./proxy-signer.js";
 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 ProxySigner(this.active$, "No active account");
+    }
+    // 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/proxy-signer.d.ts

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

package/dist/proxy-signer.js

@@ -0,0 +1,45 @@
+export class ProxySigner {
+    upstream;
+    error;
+    nip04;
+    nip44;
+    constructor(upstream, error) {
+        this.upstream = upstream;
+        this.error = error;
+        this.nip04 = {
+            encrypt: (pubkey, plaintext) => {
+                if (!this.signer.nip04)
+                    throw new Error("Signer does not support nip04");
+                return this.signer.nip04.encrypt(pubkey, plaintext);
+            },
+            decrypt: (pubkey, ciphertext) => {
+                if (!this.signer.nip04)
+                    throw new Error("Signer does not support nip04");
+                return this.signer.nip04.decrypt(pubkey, ciphertext);
+            },
+        };
+        this.nip44 = {
+            encrypt: (pubkey, plaintext) => {
+                if (!this.signer.nip44)
+                    throw new Error("Signer does not support nip44");
+                return this.signer.nip44.encrypt(pubkey, plaintext);
+            },
+            decrypt: (pubkey, ciphertext) => {
+                if (!this.signer.nip44)
+                    throw new Error("Signer does not support nip44");
+                return this.signer.nip44.decrypt(pubkey, ciphertext);
+            },
+        };
+    }
+    get signer() {
+        if (!this.upstream.value)
+            throw new Error(this.error || "Missing signer");
+        return this.upstream.value;
+    }
+    signEvent(template) {
+        return this.signer.signEvent(template);
+    }
+    getPublicKey() {
+        return this.signer.getPublicKey();
+    }
+}

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.12.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.12.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",