applesauce-accounts 1.0.0 → 2.0.0

package/dist/account.d.ts

@@ -2,8 +2,10 @@ import { Nip07Interface } 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 {
 }
+/** A base class for all accounts */
 export declare class BaseAccount<Signer extends Nip07Interface, SignerData, Metadata extends unknown> implements IAccount<Signer, SignerData, Metadata> {
     pubkey: string;
     signer: Signer;

package/dist/account.js

@@ -1,5 +1,6 @@
 import { nanoid } from "nanoid";
 import { BehaviorSubject } from "rxjs";
+/** Wraps a promise in an abort signal */
 function wrapInSignal(promise, signal) {
     return new Promise((res, rej) => {
         signal.throwIfAborted();
@@ -21,8 +22,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;

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

@@ -12,7 +12,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(signer.getPublicKey(), 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/proxy-signer.d.ts

@@ -1,6 +1,7 @@
 import { Nip07Interface } from "applesauce-signers";
 import { EventTemplate, NostrEvent } from "nostr-tools";
 import { Observable } from "rxjs";
+/** A signer class that proxies requests to another signer that isn't created yet */
 export declare class ProxySigner<T extends Nip07Interface> implements Nip07Interface {
     protected upstream: Observable<T | undefined>;
     protected error?: string | undefined;

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;

package/dist/types.d.ts

@@ -1,10 +1,12 @@
 import { Nip07Interface } 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,6 +19,7 @@ export type SerializedAccount<SignerData, Metadata extends unknown> = {
     /** Extra application specific account metadata */
     metadata?: Metadata;
 };
+/** An interface for an account */
 export interface IAccount<Signer extends Nip07Interface = Nip07Interface, SignerData = any, Metadata extends unknown = any> extends Nip07Interface {
     id: string;
     name?: string;
@@ -27,8 +30,14 @@ export interface IAccount<Signer extends Nip07Interface = Nip07Interface, Signer
     disableQueue?: boolean;
     toJSON(): SerializedAccount<SignerData, Metadata>;
 }
+/** A constructor for an account */
 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>;
 }
+/** 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": "2.0.0",
   "description": "A simple nostr account management system",
   "type": "module",
   "main": "dist/index.js",
@@ -33,14 +33,14 @@
   },
   "dependencies": {
     "@noble/hashes": "^1.7.1",
-    "applesauce-signers": "^1.0.0",
+    "applesauce-signers": "^2.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();
-    });
-});