applesauce-accounts 0.0.0-next-20250124230519 → 0.0.0-next-20250125183855

package/dist/account.d.ts

@@ -1,14 +1,18 @@
 import { Nip07Interface } from "applesauce-signer";
+import { BehaviorSubject } from "rxjs";
+import { NostrEvent } from "nostr-tools";
 import { EventTemplate, IAccount, SerializedAccount } from "./types.js";
 export declare class SignerMismatchError extends Error {
 }
-export declare class AccountLockedError extends Error {
-}
 export declare class BaseAccount<Signer extends Nip07Interface, SignerData, Metadata extends unknown> implements IAccount<Signer, SignerData, Metadata> {
     pubkey: string;
     signer: Signer;
     id: string;
-    metadata?: Metadata;
+    /** Disable request queueing */
+    disableQueue?: boolean;
+    metadata$: BehaviorSubject<Metadata | undefined>;
+    get metadata(): Metadata | undefined;
+    set metadata(metadata: Metadata);
     nip04?: {
         encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
         decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
@@ -20,7 +24,15 @@ export declare class BaseAccount<Signer extends Nip07Interface, SignerData, Meta
     constructor(pubkey: string, signer: Signer);
     toJSON(): SerializedAccount<SignerData, Metadata>;
     /** Gets the pubkey from the signer */
-    getPublicKey(): Promise<string>;
+    getPublicKey(): string | Promise<string>;
     /** sign the event and make sure its signed with the correct pubkey */
-    signEvent(template: EventTemplate): Promise<import("nostr-tools").Event>;
+    signEvent(template: EventTemplate): Promise<NostrEvent> | NostrEvent;
+    /** Aborts all pending requests in the queue */
+    abortQueue(reason: Error): void;
+    /** internal queue */
+    protected queueLength: number;
+    protected lock: Promise<any> | null;
+    protected abort: AbortController | null;
+    protected reduceQueue(): void;
+    protected waitForLock<T>(fn: () => Promise<T> | T): Promise<T> | T;
 }

package/dist/account.js

@@ -1,14 +1,41 @@
 import { nanoid } from "nanoid";
-// errors
-export class SignerMismatchError extends Error {
+import { BehaviorSubject } from "rxjs";
+function wrapInSignal(promise, signal) {
+    return new Promise((res, rej) => {
+        signal.throwIfAborted();
+        let done = false;
+        // reject promise if abort signal is triggered
+        signal.addEventListener("abort", () => {
+            if (!done)
+                rej(signal.reason || undefined);
+            done = true;
+        });
+        return promise.then((v) => {
+            if (!done)
+                res(v);
+            done = true;
+        }, (err) => {
+            if (!done)
+                rej(err);
+            done = true;
+        });
+    });
 }
-export class AccountLockedError extends Error {
+export class SignerMismatchError extends Error {
 }
 export class BaseAccount {
     pubkey;
     signer;
     id = nanoid(8);
-    metadata;
+    /** Disable request queueing */
+    disableQueue;
+    metadata$ = new BehaviorSubject(undefined);
+    get metadata() {
+        return this.metadata$.value;
+    }
+    set metadata(metadata) {
+        this.metadata$.next(metadata);
+    }
     // encryption interfaces
     nip04;
     nip44;
@@ -19,20 +46,20 @@ export class BaseAccount {
         if (this.signer.nip04) {
             this.nip04 = {
                 encrypt: (pubkey, plaintext) => {
-                    return this.signer.nip04.encrypt(pubkey, plaintext);
+                    return this.waitForLock(() => this.signer.nip04.encrypt(pubkey, plaintext));
                 },
                 decrypt: (pubkey, plaintext) => {
-                    return this.signer.nip04.decrypt(pubkey, plaintext);
+                    return this.waitForLock(() => this.signer.nip04.decrypt(pubkey, plaintext));
                 },
             };
         }
         if (this.signer.nip44) {
             this.nip44 = {
                 encrypt: (pubkey, plaintext) => {
-                    return this.signer.nip44.encrypt(pubkey, plaintext);
+                    return this.waitForLock(() => this.signer.nip44.encrypt(pubkey, plaintext));
                 },
                 decrypt: (pubkey, plaintext) => {
-                    return this.signer.nip44.decrypt(pubkey, plaintext);
+                    return this.waitForLock(() => this.signer.nip44.decrypt(pubkey, plaintext));
                 },
             };
         }
@@ -42,21 +69,84 @@ export class BaseAccount {
         throw new Error("Not implemented");
     }
     /** Gets the pubkey from the signer */
-    async getPublicKey() {
-        // this.checkLocked();
-        const signerKey = await this.signer.getPublicKey();
-        if (this.pubkey !== signerKey)
-            throw new Error("Account signer mismatch");
-        return this.pubkey;
+    getPublicKey() {
+        const result = this.signer.getPublicKey();
+        if (result instanceof Promise)
+            return result.then((pubkey) => {
+                if (this.pubkey !== pubkey)
+                    throw new SignerMismatchError("Account signer mismatch");
+                return pubkey;
+            });
+        else {
+            if (this.pubkey !== result)
+                throw new SignerMismatchError("Account signer mismatch");
+            return result;
+        }
     }
     /** sign the event and make sure its signed with the correct pubkey */
-    async signEvent(template) {
-        // this.checkLocked();
+    signEvent(template) {
         if (!Reflect.has(template, "pubkey"))
             Reflect.set(template, "pubkey", this.pubkey);
-        const signed = await this.signer.signEvent(template);
-        if (signed.pubkey !== this.pubkey)
-            throw new SignerMismatchError("Signer signed with wrong pubkey");
-        return signed;
+        return this.waitForLock(() => {
+            const result = this.signer.signEvent(template);
+            if (result instanceof Promise)
+                return result.then((signed) => {
+                    if (signed.pubkey !== this.pubkey)
+                        throw new SignerMismatchError("Signer signed with wrong pubkey");
+                    return signed;
+                });
+            else {
+                if (result.pubkey !== this.pubkey)
+                    throw new SignerMismatchError("Signer signed with wrong pubkey");
+                return result;
+            }
+        });
+    }
+    /** Aborts all pending requests in the queue */
+    abortQueue(reason) {
+        if (this.abort)
+            this.abort.abort(reason);
+    }
+    /** internal queue */
+    queueLength = 0;
+    lock = null;
+    abort = null;
+    reduceQueue() {
+        // shorten the queue
+        this.queueLength--;
+        // if this was the last request, remove the lock
+        if (this.queueLength === 0) {
+            this.lock = null;
+            this.abort = null;
+        }
+    }
+    waitForLock(fn) {
+        if (this.disableQueue)
+            return fn();
+        // if there is already a pending request, wait for it
+        if (this.lock && this.abort) {
+            // create a new promise that runs after the lock
+            const p = wrapInSignal(this.lock.then(() => {
+                // if the abort signal is triggered, don't call the signer
+                this.abort?.signal.throwIfAborted();
+                return fn();
+            }), this.abort.signal);
+            // set the lock the new promise that ignores errors
+            this.lock = p.catch(() => { }).finally(this.reduceQueue.bind(this));
+            this.queueLength++;
+            return p;
+        }
+        else {
+            const result = fn();
+            // if the result is async, set the new lock
+            if (result instanceof Promise) {
+                this.abort = new AbortController();
+                const p = wrapInSignal(result, this.abort.signal);
+                // set the lock the new promise that ignores errors
+                this.lock = p.catch(() => { }).finally(this.reduceQueue.bind(this));
+                this.queueLength = 1;
+            }
+            return result;
+        }
     }
 }

package/dist/account.test.d.ts

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

package/dist/account.test.js

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

package/dist/manager.d.ts

@@ -2,9 +2,13 @@ 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>>;
+    active$: BehaviorSubject<IAccount<any, any, Metadata> | null>;
+    get active(): IAccount<any, any, Metadata> | null;
+    accounts$: BehaviorSubject<IAccount<any, any, Metadata>[]>;
+    get accounts(): IAccount<any, any, Metadata>[];
+    /** Disable request queueing for any accounts added to this manager */
+    disableQueue?: boolean;
     /** Add account type class */
     registerType<S extends Nip07Interface>(accountType: IAccountConstructor<S, any, Metadata>): void;
     /** Remove account type */

package/dist/manager.js

@@ -1,8 +1,16 @@
 import { BehaviorSubject } from "rxjs";
 export class AccountManager {
-    active = new BehaviorSubject(null);
-    accounts = new BehaviorSubject({});
     types = new Map();
+    active$ = new BehaviorSubject(null);
+    get active() {
+        return this.active$.value;
+    }
+    accounts$ = new BehaviorSubject([]);
+    get accounts() {
+        return this.accounts$.value;
+    }
+    /** Disable request queueing for any accounts added to this manager */
+    disableQueue;
     // Account type CRUD
     /** Add account type class */
     registerType(accountType) {
@@ -20,62 +28,64 @@ export class AccountManager {
     /** 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 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);
+        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);
+        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;
-        this.accounts.next({
-            ...this.accounts.value,
+        // 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.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);
+        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)
+        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;
+        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);
+        if (this.active$.value?.id !== account.id) {
+            this.active$.next(account);
         }
     }
     /** Clears the currently active account */
     clearActive() {
-        this.active.next(null);
+        this.active$.next(null);
     }
     // Metadata CRUD
     /** sets the metadata on an account */
@@ -95,7 +105,7 @@ export class AccountManager {
     // Serialize / Deserialize
     /** Returns an array of serialized accounts */
     toJSON() {
-        return Array.from(Object.values(this.accounts)).map((account) => account.toJSON());
+        return Array.from(Object.values(this.accounts$)).map((account) => account.toJSON());
     }
     /**
      * Restores all accounts from an array of serialized accounts

package/dist/types.d.ts

@@ -25,6 +25,7 @@ export interface IAccount<Signer extends Nip07Interface, SignerData, Metadata ex
     pubkey: string;
     metadata?: Metadata;
     signer: Signer;
+    disableQueue?: boolean;
     toJSON(): SerializedAccount<SignerData, Metadata>;
 }
 export interface IAccountConstructor<Signer extends Nip07Interface, SignerData, Metadata extends unknown> {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-accounts",
-  "version": "0.0.0-next-20250124230519",
+  "version": "0.0.0-next-20250125183855",
   "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-20250124230519",
+    "applesauce-signer": "0.0.0-next-20250125183855",
     "nanoid": "^5.0.9",
     "nostr-tools": "^2.10.3",
     "rxjs": "^7.8.1"