Add request queue to base account class

Author: hzrd149

.changeset/spicy-parrots-fly.md

@@ -0,0 +1,5 @@
+---
+"applesauce-accounts": minor
+---
+
+Add request queue to base account class

packages/accounts/src/account.test.ts

@@ -0,0 +1,72 @@
+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: SimpleSigner;
+  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: (() => void)[] = [];
+      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(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()?.();
+    });
+
+    it("should not use queueing if its disabled", async () => {
+      const account = new BaseAccount(await signer.getPublicKey(), signer);
+      account.queueRequests = false;
+
+      let resolve: (() => void)[] = [];
+      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(signer.signEvent).toHaveBeenCalledTimes(2);
+      expect(signer.signEvent).toHaveBeenCalledWith(expect.objectContaining({ content: "first" }));
+      expect(signer.signEvent).toHaveBeenCalledWith(expect.objectContaining({ content: "second" }));
+
+      // resolve first
+      resolve.shift()?.();
+
+      // wait next tick
+      await new Promise((res) => setTimeout(res, 0));
+
+      // resolve second
+      resolve.shift()?.();
+    });
+  });
+});

packages/accounts/src/account.ts

@@ -2,16 +2,26 @@ import { Nip07Interface } from "applesauce-signer";
 import { nanoid } from "nanoid";
 
 import { EventTemplate, IAccount, SerializedAccount } from "./types.js";
+import { BehaviorSubject } from "rxjs";
+import { NostrEvent } from "nostr-tools";
 
-// errors
 export class SignerMismatchError extends Error {}
-export class AccountLockedError extends Error {}
 
 export class BaseAccount<Signer extends Nip07Interface, SignerData, Metadata extends unknown>
   implements IAccount<Signer, SignerData, Metadata>
 {
   id = nanoid(8);
-  metadata?: Metadata;
+
+  /** Use a queue for sign and encryption/decryption requests so that there is only one request at a time */
+  queueRequests = true;
+
+  metadata$ = new BehaviorSubject<Metadata | undefined>(undefined);
+  get metadata(): Metadata | undefined {
+    return this.metadata$.value;
+  }
+  set metadata(metadata: Metadata) {
+    this.metadata$.next(metadata);
+  }
 
   // encryption interfaces
   nip04?:
@@ -35,21 +45,21 @@ export class BaseAccount<Signer extends Nip07Interface, SignerData, Metadata ext
     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));
         },
       };
     }
@@ -61,21 +71,80 @@ export class BaseAccount<Signer extends Nip07Interface, SignerData, Metadata ext
   }
 
   /** 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(): string | Promise<string> {
+    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: EventTemplate) {
-    // this.checkLocked();
+  signEvent(template: EventTemplate): Promise<NostrEvent> | NostrEvent {
     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 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;
+      }
+    });
+  }
+
+  /** Resets the request queue */
+  resetQueue() {
+    this.lock = null;
+    this.queueLength = 0;
+  }
+
+  /** internal queue */
+  protected queueLength = 0;
+  protected lock: Promise<any> | null = null;
+  protected waitForLock<T>(fn: () => Promise<T> | T): Promise<T> | T {
+    if (!this.queueRequests) return fn();
+
+    // if there is already a pending request, wait for it
+    if (this.lock) {
+      // create a new promise that runs after the lock
+      const p = this.lock
+        .then(() => fn())
+        .finally(() => {
+          // shorten the queue
+          this.queueLength--;
+
+          // if this was the last request, remove the lock
+          if (this.queueLength === 0) this.lock = null;
+        });
 
-    return signed;
+      // set the lock the new promise
+      this.lock = p;
+      this.queueLength++;
+
+      return p;
+    } else {
+      const result = fn();
+
+      // if the result is async, set the new lock
+      if (result instanceof Promise) {
+        this.lock = result;
+        this.queueLength = 1;
+      }
+
+      return result;
+    }
   }
 }

packages/accounts/src/manager.ts

@@ -4,10 +4,18 @@ import { BehaviorSubject } from "rxjs";
 import { IAccount, IAccountConstructor, SerializedAccount } from "./types.js";
 
 export class AccountManager<Metadata extends unknown = any> {
-  active = new BehaviorSubject<IAccount<any, any, Metadata> | null>(null);
-  accounts = new BehaviorSubject<Record<string, IAccount<any, any, Metadata>>>({});
   types = new Map<string, IAccountConstructor<any, any, Metadata>>();
 
+  active$ = new BehaviorSubject<IAccount<any, any, Metadata> | null>(null);
+  get active() {
+    return this.active$.value;
+  }
+
+  accounts$ = new BehaviorSubject<IAccount<any, any, Metadata>[]>([]);
+  get accounts() {
+    return this.accounts$.value;
+  }
+
   // Account type CRUD
 
   /** Add account type class */
@@ -28,37 +36,35 @@ export class AccountManager<Metadata extends unknown = any> {
   getAccount<Signer extends Nip07Interface>(
     id: string | IAccount<Signer, any, Metadata>,
   ): IAccount<Signer, any, Metadata> | undefined {
-    if (typeof id === "string") return this.accounts.value[id];
-    else if (this.accounts.value[id.id]) return 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: string): IAccount<any, any, Metadata> | undefined {
-    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: string): IAccount<any, any, Metadata>[] {
-    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: IAccount<any, any, Metadata>) {
     if (this.getAccount(account.id)) return;
 
-    this.accounts.next({
-      ...this.accounts.value,
+    this.accounts$.next({
+      ...this.accounts$.value,
       [account.id]: account,
     });
   }
 
   /** Removes an account from the manager */
   removeAccount(account: string | IAccount<any, any, Metadata>) {
     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 */
@@ -67,7 +73,7 @@ export class AccountManager<Metadata extends unknown = any> {
 
     // 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);
+    if (this.active$.value?.id === id) this.setActive(account);
 
     this.removeAccount(old);
   }
@@ -76,20 +82,20 @@ export class AccountManager<Metadata extends unknown = any> {
 
   /** Returns the currently active account */
   getActive() {
-    return this.active.value;
+    return this.active$.value;
   }
   /** Sets the currently active account */
   setActive(id: string | IAccount<any, any, Metadata>) {
     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
@@ -112,7 +118,7 @@ export class AccountManager<Metadata extends unknown = any> {
 
   /** Returns an array of serialized accounts */
   toJSON(): SerializedAccount<any, Metadata>[] {
-    return Array.from(Object.values(this.accounts)).map((account) => account.toJSON());
+    return Array.from(Object.values(this.accounts$)).map((account) => account.toJSON());
   }
 
   /**

packages/docs/accounts/manager.md

@@ -31,7 +31,7 @@ const manager = new AccountManager();
 registerCommonAccountTypes(manager);
 
 // subscribe to the active account
-manager.active.subscribe((account) => {
+manager.active$.subscribe((account) => {
   if (account) console.log(`${account.id} is now active`);
   else console.log("no account is active");
 
@@ -69,7 +69,7 @@ const json = JSON.parse(localStorage.getItem("accounts") || "[]");
 await manager.fromJSON(json);
 
 // next, subscribe to any accounts added or removed
-manager.accounts.subscribe((accounts) => {
+manager.accounts$.subscribe((accounts) => {
   // save all the accounts into the "accounts" field
   localStorage.setItem("accounts", JSON.stringify(manager.toJSON()));
 });
@@ -80,7 +80,7 @@ if (localStorage.hasItem("active")) {
 }
 
 // subscribe to active changes
-manager.active.subscribe((account) => {
+manager.active$.subscribe((account) => {
   if (account) localStorage.setItem("active", account.id);
   else localStorage.clearItem("active");
 });