applesauce-accounts 2.0.0 → 3.0.0

package/dist/account.d.ts

@@ -1,4 +1,4 @@
-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";
@@ -6,7 +6,7 @@ import { EventTemplate, IAccount, SerializedAccount } from "./types.js";
 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> {
+export declare class BaseAccount<Signer extends ISigner, SignerData, Metadata extends unknown> implements IAccount<Signer, SignerData, Metadata> {
     pubkey: string;
     signer: Signer;
     id: string;
@@ -16,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 */
@@ -35,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,6 @@
 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) => {
@@ -47,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) {
@@ -75,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 };
@@ -89,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 */
@@ -139,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));
@@ -156,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.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 */
@@ -15,6 +16,6 @@ export class ReadonlyAccount extends BaseAccount {
     /** Creates a ReadonlyAccount from a hex public key or NIP-19 npub */
     static fromPubkey(pubkey) {
         const signer = ReadonlySigner.fromPubkey(pubkey);
-        return new ReadonlyAccount(signer.getPublicKey(), signer);
+        return new ReadonlyAccount(normalizeToPubkey(pubkey), signer);
     }
 }

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,21 +1,21 @@
-import { Nip07Interface } from "applesauce-signers";
+import { ISigner } 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 {
+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

@@ -23,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,4 +1,4 @@
-import { Nip07Interface } from "applesauce-signers";
+import { ISigner } from "applesauce-signers";
 import { NostrEvent } from "nostr-tools";
 export type EventTemplate = {
     kind: number;
@@ -20,7 +20,7 @@ export type SerializedAccount<SignerData, Metadata extends unknown> = {
     metadata?: Metadata;
 };
 /** An interface for an account */
-export interface IAccount<Signer extends Nip07Interface = Nip07Interface, SignerData = any, Metadata extends unknown = any> extends Nip07Interface {
+export interface IAccount<Signer extends ISigner = ISigner, SignerData = any, Metadata extends unknown = any> extends ISigner {
     id: string;
     name?: string;
     pubkey: string;
@@ -31,7 +31,7 @@ export interface IAccount<Signer extends Nip07Interface = Nip07Interface, Signer
     toJSON(): SerializedAccount<SignerData, Metadata>;
 }
 /** A constructor for an account */
-export interface IAccountConstructor<Signer extends Nip07Interface, SignerData, Metadata extends unknown> {
+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>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-accounts",
-  "version": "2.0.0",
+  "version": "3.0.0",
   "description": "A simple nostr account management system",
   "type": "module",
   "main": "dist/index.js",
@@ -33,7 +33,8 @@
   },
   "dependencies": {
     "@noble/hashes": "^1.7.1",
-    "applesauce-signers": "^2.0.0",
+    "applesauce-signers": "^3.0.0",
+    "applesauce-core": "^3.0.0",
     "nanoid": "^5.1.5",
     "nostr-tools": "^2.13",
     "rxjs": "^7.8.1"