applesauce-accounts 0.10.0 → 0.12.0

package/README.md

@@ -1,3 +1,5 @@
 # applesauce-accounts
 
-A simple nostr account management system
+A simple nostr account management system built on top of [applesauce-signers](https://hzrd149.github.io/applesauce/signers/installation.html)
+
+See [documentation](https://hzrd149.github.io/applesauce/signers/signers.html)

package/dist/__tests__/account.test.d.ts

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

package/dist/__tests__/account.test.js

@@ -0,0 +1,125 @@
+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/account.d.ts

@@ -1,31 +1,37 @@
-import { Nip07Interface } from "applesauce-signer";
-import { EventTemplate } from "nostr-tools";
-import { IAccount, SerializedAccount } from "./types.js";
+import { Nip07Interface } from "applesauce-signers";
+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<T extends string, S> implements IAccount<T, S> {
+export declare class BaseAccount<Signer extends Nip07Interface, SignerData, Metadata extends unknown> implements IAccount<Signer, SignerData, Metadata> {
     pubkey: string;
-    signer: Nip07Interface;
-    name?: string;
-    locked: boolean;
-    nip04?: {
-        encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
-        decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
-    } | undefined;
-    nip44?: {
-        encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
-        decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
-    } | undefined;
-    constructor(pubkey: string, signer: Nip07Interface);
-    unlock(): Promise<boolean>;
-    lock(): void;
-    toJSON(): SerializedAccount<T, S>;
-    /** throws if account is locked */
-    protected checkLocked(): void;
+    signer: Signer;
+    id: string;
+    get type(): string;
+    /** Disable request queueing */
+    disableQueue?: boolean;
+    metadata$: BehaviorSubject<Metadata | undefined>;
+    get metadata(): Metadata | undefined;
+    set metadata(metadata: Metadata);
+    get nip04(): Nip07Interface["nip04"] | undefined;
+    get nip44(): Nip07Interface["nip44"] | undefined;
+    constructor(pubkey: string, signer: Signer);
+    toJSON(): SerializedAccount<SignerData, Metadata>;
+    /** 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(): 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,77 +1,168 @@
-// errors
-export class SignerMismatchError extends Error {
+import { nanoid } from "nanoid";
+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;
-    name;
-    locked = true;
-    // encryption interfaces
-    nip04;
-    nip44;
+    id = nanoid(8);
+    get type() {
+        const cls = Reflect.getPrototypeOf(this).constructor;
+        return cls.type;
+    }
+    /** Disable request queueing */
+    disableQueue;
+    metadata$ = new BehaviorSubject(undefined);
+    get metadata() {
+        return this.metadata$.value;
+    }
+    set metadata(metadata) {
+        this.metadata$.next(metadata);
+    }
+    get nip04() {
+        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));
+            },
+        };
+    }
+    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));
+            },
+        };
+    }
     constructor(pubkey, signer) {
         this.pubkey = pubkey;
         this.signer = signer;
-        // setup encryption interfaces to check if account is locked
-        if (this.signer.nip04) {
-            this.nip04 = {
-                encrypt: (pubkey, plaintext) => {
-                    this.checkLocked();
-                    return this.signer.nip04.encrypt(pubkey, plaintext);
-                },
-                decrypt: (pubkey, plaintext) => {
-                    this.checkLocked();
-                    return this.signer.nip04.decrypt(pubkey, plaintext);
-                },
-            };
-        }
-        if (this.signer.nip44) {
-            this.nip44 = {
-                encrypt: (pubkey, plaintext) => {
-                    this.checkLocked();
-                    return this.signer.nip44.encrypt(pubkey, plaintext);
-                },
-                decrypt: (pubkey, plaintext) => {
-                    this.checkLocked();
-                    return this.signer.nip44.decrypt(pubkey, plaintext);
-                },
-            };
-        }
-    }
-    async unlock() {
-        this.locked = false;
-        return true;
-    }
-    lock() {
-        this.locked = true;
     }
     // This should be overwritten by a sub class
     toJSON() {
         throw new Error("Not implemented");
     }
-    /** throws if account is locked */
-    checkLocked() {
-        if (this.locked)
-            throw new AccountLockedError("Account is locked");
+    /** 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 };
+    }
+    /** Sets an accounts id and metadata. NOTE: This should only be used in fromJSON methods */
+    static loadCommonFields(account, json) {
+        if (json.id)
+            account.id = json.id;
+        if (json.metadata)
+            account.metadata = json.metadata;
+        return account;
     }
     /** 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/accounts/amber-clipboard-account.d.ts

@@ -1,10 +1,9 @@
-import { AmberClipboardSigner } from "applesauce-signer/signers/amber-clipboard-signer";
+import { AmberClipboardSigner } from "applesauce-signers/signers/amber-clipboard-signer";
 import { BaseAccount } from "../account.js";
-import { IAccount, SerializedAccount } from "../types.js";
+import { SerializedAccount } from "../types.js";
 /** An account for the amber clipboard api */
-export declare class AmberClipboardAccount extends BaseAccount<"amber-clipboard", void> {
-    signer: AmberClipboardSigner;
-    constructor(pubkey: string, signer: AmberClipboardSigner);
-    toJSON(): SerializedAccount<"amber-clipboard", void>;
-    static fromJSON(json: SerializedAccount<"amber-clipboard", void>): IAccount<"amber-clipboard", void>;
+export declare class AmberClipboardAccount<Metadata extends unknown> extends BaseAccount<AmberClipboardSigner, void, Metadata> {
+    static readonly type = "amber-clipboard";
+    toJSON(): SerializedAccount<void, Metadata>;
+    static fromJSON<Metadata extends unknown>(json: SerializedAccount<void, Metadata>): AmberClipboardAccount<Metadata>;
 }

package/dist/accounts/amber-clipboard-account.js

@@ -1,16 +1,15 @@
-import { AmberClipboardSigner } from "applesauce-signer/signers/amber-clipboard-signer";
+import { AmberClipboardSigner } from "applesauce-signers/signers/amber-clipboard-signer";
 import { BaseAccount } from "../account.js";
 /** An account for the amber clipboard api */
 export class AmberClipboardAccount extends BaseAccount {
-    signer;
-    constructor(pubkey, signer) {
-        super(pubkey, signer);
-        this.signer = signer;
-    }
+    static type = "amber-clipboard";
     toJSON() {
-        return { type: "amber-clipboard", pubkey: this.pubkey, name: this.name, signer: void 0 };
+        return super.saveCommonFields({
+            signer: undefined,
+        });
     }
     static fromJSON(json) {
-        return new AmberClipboardAccount(json.pubkey, new AmberClipboardSigner());
+        const account = new AmberClipboardAccount(json.pubkey, new AmberClipboardSigner());
+        return super.loadCommonFields(account, json);
     }
 }

package/dist/accounts/common.d.ts

@@ -0,0 +1,3 @@
+import { AccountManager } from "../manager.js";
+/** Registers the most common account types to a account manager */
+export declare function registerCommonAccountTypes(manager: AccountManager): void;

package/dist/accounts/common.js

@@ -0,0 +1,13 @@
+import { ExtensionAccount } from "./extension-account.js";
+import { NostrConnectAccount } from "./nostr-connect-account.js";
+import { PasswordAccount } from "./password-account.js";
+import { ReadonlyAccount } from "./readonly-account.js";
+import { SimpleAccount } from "./simple-account.js";
+/** Registers the most common account types to a account manager */
+export function registerCommonAccountTypes(manager) {
+    manager.registerType(ExtensionAccount);
+    manager.registerType(PasswordAccount);
+    manager.registerType(ReadonlyAccount);
+    manager.registerType(SimpleAccount);
+    manager.registerType(NostrConnectAccount);
+}

package/dist/accounts/extension-account.d.ts

@@ -1,7 +1,10 @@
+import { ExtensionSigner } from "applesauce-signers/signers/extension-signer";
 import { BaseAccount } from "../account.js";
 import { SerializedAccount } from "../types.js";
-export default class ExtensionAccount extends BaseAccount<"extension", void> {
-    constructor(pubkey: string);
-    toJSON(): SerializedAccount<"extension", void>;
-    static fromJSON(json: SerializedAccount<"extension", void>): ExtensionAccount;
+export declare class ExtensionAccount<Metadata extends unknown> extends BaseAccount<ExtensionSigner, void, Metadata> {
+    signer: ExtensionSigner;
+    static readonly type = "extension";
+    constructor(pubkey: string, signer: ExtensionSigner);
+    toJSON(): SerializedAccount<void, Metadata>;
+    static fromJSON<Metadata extends unknown>(json: SerializedAccount<void, Metadata>): ExtensionAccount<Metadata>;
 }

package/dist/accounts/extension-account.js

@@ -1,13 +1,19 @@
-import { ExtensionSigner } from "applesauce-signer/signers/extension-signer";
+import { ExtensionSigner } from "applesauce-signers/signers/extension-signer";
 import { BaseAccount } from "../account.js";
-export default class ExtensionAccount extends BaseAccount {
-    constructor(pubkey) {
-        super(pubkey, new ExtensionSigner());
+export class ExtensionAccount extends BaseAccount {
+    signer;
+    static type = "extension";
+    constructor(pubkey, signer) {
+        super(pubkey, signer || new ExtensionSigner());
+        this.signer = signer;
     }
     toJSON() {
-        return { type: "extension", pubkey: this.pubkey, signer: undefined };
+        return super.saveCommonFields({
+            signer: undefined,
+        });
     }
     static fromJSON(json) {
-        return new ExtensionAccount(json.pubkey);
+        const account = new ExtensionAccount(json.pubkey, new ExtensionSigner());
+        return super.loadCommonFields(account, json);
     }
 }

package/dist/accounts/index.d.ts

@@ -4,3 +4,5 @@ export * from "./password-account.js";
 export * from "./readonly-account.js";
 export * from "./serial-port-account.js";
 export * from "./simple-account.js";
+export * from "./nostr-connect-account.js";
+export * from "./common.js";

package/dist/accounts/index.js

@@ -4,3 +4,5 @@ export * from "./password-account.js";
 export * from "./readonly-account.js";
 export * from "./serial-port-account.js";
 export * from "./simple-account.js";
+export * from "./nostr-connect-account.js";
+export * from "./common.js";

package/dist/accounts/nostr-connect-account.d.ts

@@ -0,0 +1,16 @@
+import { NostrConnectConnectionMethods, NostrConnectSigner } from "applesauce-signers";
+import { BaseAccount } from "../account.js";
+import { SerializedAccount } from "../types.js";
+export type NostrConnectAccountSignerData = {
+    clientKey: string;
+    remote: string;
+    relays: string[];
+};
+/** An account type for NIP-46 signers */
+export declare class NostrConnectAccount<Metadata extends unknown> extends BaseAccount<NostrConnectSigner, NostrConnectAccountSignerData, Metadata> {
+    static readonly type = "nostr-connect";
+    toJSON(): SerializedAccount<NostrConnectAccountSignerData, Metadata>;
+    /** This is called when NostrConnectAccount.fromJSON needs new connection methods for NostrConnectSigner */
+    static createConnectionMethods(): NostrConnectConnectionMethods;
+    static fromJSON<Metadata extends unknown>(json: SerializedAccount<NostrConnectAccountSignerData, Metadata>, connection?: NostrConnectConnectionMethods): NostrConnectAccount<Metadata>;
+}

package/dist/accounts/nostr-connect-account.js

@@ -0,0 +1,34 @@
+import { NostrConnectSigner, SimpleSigner } from "applesauce-signers";
+import { bytesToHex, hexToBytes } from "@noble/hashes/utils";
+import { BaseAccount } from "../account.js";
+/** An account type for NIP-46 signers */
+export class NostrConnectAccount extends BaseAccount {
+    static type = "nostr-connect";
+    toJSON() {
+        if (!this.signer.remote)
+            throw new Error("Cant save NostrConnectAccount when not initialized");
+        return super.saveCommonFields({
+            signer: {
+                clientKey: bytesToHex(this.signer.signer.key),
+                remote: this.signer.remote,
+                relays: this.signer.relays,
+            },
+        });
+    }
+    /** This is called when NostrConnectAccount.fromJSON needs new connection methods for NostrConnectSigner */
+    static createConnectionMethods() {
+        throw new Error("Cant create NostrConnectAccount without either passing in connection methods or setting NostrConnectAccount.createConnectionMethods");
+    }
+    static fromJSON(json, connection) {
+        connection = connection || NostrConnectAccount.createConnectionMethods();
+        const signer = new NostrConnectSigner({
+            ...connection,
+            relays: json.signer.relays,
+            pubkey: json.pubkey,
+            remote: json.signer.remote,
+            signer: new SimpleSigner(hexToBytes(json.signer.clientKey)),
+        });
+        const account = new NostrConnectAccount(json.pubkey, signer);
+        return super.loadCommonFields(account, json);
+    }
+}

package/dist/accounts/password-account.d.ts

@@ -1,15 +1,21 @@
-import { PasswordSigner } from "applesauce-signer/signers/password-signer";
+import { PasswordSigner } from "applesauce-signers/signers/password-signer";
 import { BaseAccount } from "../account.js";
 import { SerializedAccount } from "../types.js";
-type SignerData = {
+export type PasswordAccountSignerData = {
     ncryptsec: string;
 };
-export default class PasswordAccount extends BaseAccount<"ncryptsec", SignerData> {
-    signer: PasswordSigner;
-    constructor(pubkey: string, signer: PasswordSigner);
-    unlock(): Promise<boolean>;
-    toJSON(): SerializedAccount<"ncryptsec", SignerData>;
-    static fromJSON(json: SerializedAccount<"ncryptsec", SignerData>): PasswordAccount;
-    static fromNcryptsec(pubkey: string, ncryptsec: string): PasswordAccount;
+export declare class PasswordAccount<Metadata extends 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>;
+    /**
+     * Attempt to unlock the signer with a password
+     * @throws
+     */
+    unlock(password?: string): Promise<void>;
+    toJSON(): SerializedAccount<PasswordAccountSignerData, Metadata>;
+    static fromJSON<Metadata extends unknown>(json: SerializedAccount<PasswordAccountSignerData, Metadata>): PasswordAccount<Metadata>;
+    /** Creates a new PasswordAccount from a ncryptsec string */
+    static fromNcryptsec<Metadata extends unknown>(pubkey: string, ncryptsec: string): PasswordAccount<Metadata>;
 }
-export {};