applesauce-accounts 0.0.0-next-20241218172722

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 hzrd149
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# applesauce-accounts
+
+A simple nostr account management system

package/dist/account.d.ts

@@ -0,0 +1,31 @@
+import { Nip07Interface } from "applesauce-signer";
+import { EventTemplate } from "nostr-tools";
+import { 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> {
+    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;
+    /** Gets the pubkey from the signer */
+    getPublicKey(): Promise<string>;
+    /** sign the event and make sure its signed with the correct pubkey */
+    signEvent(template: EventTemplate): Promise<import("nostr-tools").Event>;
+}

package/dist/account.js

@@ -0,0 +1,77 @@
+// errors
+export class SignerMismatchError extends Error {
+}
+export class AccountLockedError extends Error {
+}
+export class BaseAccount {
+    pubkey;
+    signer;
+    name;
+    locked = true;
+    // encryption interfaces
+    nip04;
+    nip44;
+    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");
+    }
+    /** 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;
+    }
+    /** sign the event and make sure its signed with the correct pubkey */
+    async signEvent(template) {
+        this.checkLocked();
+        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;
+    }
+}

package/dist/accounts/amber-clipboard-account.d.ts

@@ -0,0 +1,10 @@
+import { AmberClipboardSigner } from "applesauce-signer/signers/amber-clipboard-signer";
+import { BaseAccount } from "../account.js";
+import { IAccount, 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>;
+}

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

@@ -0,0 +1,16 @@
+import { AmberClipboardSigner } from "applesauce-signer/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;
+    }
+    toJSON() {
+        return { type: "amber-clipboard", pubkey: this.pubkey, name: this.name, signer: void 0 };
+    }
+    static fromJSON(json) {
+        return new AmberClipboardAccount(json.pubkey, new AmberClipboardSigner());
+    }
+}

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

@@ -0,0 +1,7 @@
+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;
+}

package/dist/accounts/extension-account.js

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

package/dist/accounts/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./amber-clipboard-account.js";
+export * from "./extension-account.js";
+export * from "./password-account.js";
+export * from "./readonly-account.js";
+export * from "./serial-port-account.js";
+export * from "./simple-account.js";

package/dist/accounts/index.js

@@ -0,0 +1,6 @@
+export * from "./amber-clipboard-account.js";
+export * from "./extension-account.js";
+export * from "./password-account.js";
+export * from "./readonly-account.js";
+export * from "./serial-port-account.js";
+export * from "./simple-account.js";

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

@@ -0,0 +1,11 @@
+import { NostrConnectSigner } from "applesauce-signer/signers";
+import { Account } from "./account";
+export default class NostrConnectAccount extends Account {
+    readonly type = "nostr-connect";
+    protected _signer: NostrConnectSigner;
+    get signer(): NostrConnectSigner;
+    set signer(value: NostrConnectSigner);
+    constructor(pubkey: string, signer?: NostrConnectSigner);
+    toJSON(): any;
+    fromJSON(data: any): this;
+}

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

@@ -0,0 +1,36 @@
+import { NostrConnectSigner, SimpleSigner } from "applesauce-signer/signers";
+import { hexToBytes } from "@noble/hashes/utils";
+import { DEFAULT_NOSTR_CONNECT_RELAYS } from "../../const";
+import { Account } from "./account";
+import relayPoolService from "../../services/relay-pool";
+function createSigner(pubkey, relays, secretKey, provider) {
+    const signer = secretKey ? new SimpleSigner(hexToBytes(secretKey)) : undefined;
+    const client = new NostrConnectSigner({ pool: relayPoolService, pubkey, relays, signer, remote: provider });
+    return client;
+}
+export default class NostrConnectAccount extends Account {
+    type = "nostr-connect";
+    get signer() {
+        return this._signer;
+    }
+    set signer(value) {
+        this._signer = value;
+    }
+    constructor(pubkey, signer) {
+        super(pubkey);
+        this.signer = signer || createSigner(pubkey, DEFAULT_NOSTR_CONNECT_RELAYS);
+    }
+    toJSON() {
+        const json = this.signer.toJSON();
+        return {
+            ...super.toJSON(),
+            signerRelays: this.signer.relays,
+            clientSecretKey: json.client,
+        };
+    }
+    fromJSON(data) {
+        super.fromJSON(data);
+        this.signer = createSigner(data.pubkey, data.signerRelays, data.clientSecretKey);
+        return this;
+    }
+}

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

@@ -0,0 +1,13 @@
+import { SimpleSigner } from "applesauce-signer/signers/simple-signer";
+import { Account } from "./account";
+export default class NsecAccount extends Account {
+    readonly type = "nsec";
+    protected _signer?: SimpleSigner | undefined;
+    get signer(): SimpleSigner | undefined;
+    set signer(value: SimpleSigner | undefined);
+    constructor(pubkey: string);
+    static newKey(): NsecAccount;
+    static fromKey(key: Uint8Array): NsecAccount;
+    toJSON(): any;
+    fromJSON(data: any): this;
+}

package/dist/accounts/nsec-account.js

@@ -0,0 +1,39 @@
+import { generateSecretKey, getPublicKey, nip19 } from "nostr-tools";
+import { SimpleSigner } from "applesauce-signer/signers/simple-signer";
+import { Account } from "./account";
+export default class NsecAccount extends Account {
+    type = "nsec";
+    get signer() {
+        return this._signer;
+    }
+    set signer(value) {
+        this._signer = value;
+    }
+    constructor(pubkey) {
+        super(pubkey);
+    }
+    static newKey() {
+        const key = generateSecretKey();
+        const account = new NsecAccount(getPublicKey(key));
+        account.signer = new SimpleSigner(key);
+        return account;
+    }
+    static fromKey(key) {
+        const account = new NsecAccount(getPublicKey(key));
+        account.signer = new SimpleSigner(key);
+        return account;
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            nsec: this.signer && nip19.nsecEncode(this.signer.key),
+        };
+    }
+    fromJSON(data) {
+        const parse = nip19.decode(data.nsec);
+        if (parse.type !== "nsec")
+            throw new Error("Unknown nsec type");
+        this.signer = new SimpleSigner(parse.data);
+        return this;
+    }
+}

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

@@ -0,0 +1,15 @@
+import { PasswordSigner } from "applesauce-signer/signers/password-signer";
+import { BaseAccount } from "../account.js";
+import { SerializedAccount } from "../types.js";
+type SignerData = {
+    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 {};

package/dist/accounts/password-account.js

@@ -0,0 +1,36 @@
+import { PasswordSigner } from "applesauce-signer/signers/password-signer";
+import { BaseAccount } from "../account.js";
+export default class PasswordAccount extends BaseAccount {
+    signer;
+    constructor(pubkey, signer) {
+        super(pubkey, signer);
+        this.signer = signer;
+    }
+    async unlock() {
+        try {
+            const password = prompt("Unlock password");
+            if (password === null)
+                return false;
+            await this.signer.unlock(password);
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    toJSON() {
+        if (!this.signer.ncryptsec)
+            throw new Error("Cant save account without ncryptsec");
+        return { type: "ncryptsec", pubkey: this.pubkey, signer: { ncryptsec: this.signer.ncryptsec } };
+    }
+    static fromJSON(json) {
+        const signer = new PasswordSigner();
+        signer.ncryptsec = json.signer.ncryptsec;
+        return new PasswordAccount(json.pubkey, signer);
+    }
+    static fromNcryptsec(pubkey, ncryptsec) {
+        const signer = new PasswordSigner();
+        signer.ncryptsec = ncryptsec;
+        return new PasswordAccount(pubkey, signer);
+    }
+}

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

@@ -0,0 +1,5 @@
+import { Account } from "./account";
+export default class PubkeyAccount extends Account {
+    readonly type = "pubkey";
+    constructor(pubkey: string);
+}

package/dist/accounts/pubkey-account.js

@@ -0,0 +1,7 @@
+import { Account } from "./account";
+export default class PubkeyAccount extends Account {
+    type = "pubkey";
+    constructor(pubkey) {
+        super(pubkey);
+    }
+}

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

@@ -0,0 +1,9 @@
+import { ReadonlySigner } from "applesauce-signer/signers/readonly-signer";
+import { BaseAccount } from "../account.js";
+import { SerializedAccount } from "../types.js";
+/** An account that cannot sign or encrypt anything */
+export default class ReadonlyAccount extends BaseAccount<"readonly", void> {
+    constructor(pubkey: string, signer?: ReadonlySigner);
+    toJSON(): SerializedAccount<"readonly", void>;
+    static fromJSON(json: SerializedAccount<"readonly", void>): ReadonlyAccount;
+}

package/dist/accounts/readonly-account.js

@@ -0,0 +1,18 @@
+import { ReadonlySigner } from "applesauce-signer/signers/readonly-signer";
+import { BaseAccount } from "../account.js";
+/** An account that cannot sign or encrypt anything */
+export default class ReadonlyAccount extends BaseAccount {
+    constructor(pubkey, signer) {
+        super(pubkey, signer || new ReadonlySigner(pubkey));
+    }
+    toJSON() {
+        return {
+            type: "readonly",
+            pubkey: this.pubkey,
+            signer: undefined,
+        };
+    }
+    static fromJSON(json) {
+        return new ReadonlyAccount(json.pubkey);
+    }
+}

package/dist/accounts/serial-port-account.d.ts

@@ -0,0 +1,10 @@
+import { SerialPortSigner } from "applesauce-signer/signers/serial-port-signer";
+import { BaseAccount } from "../account.js";
+import { SerializedAccount } from "../types.js";
+/** An account for SerialPortSigner */
+export default class SerialPortAccount extends BaseAccount<"serial-port", void> {
+    constructor(pubkey: string, signer?: SerialPortSigner);
+    unlock(): Promise<boolean>;
+    toJSON(): SerializedAccount<"serial-port", void>;
+    static fromJSON(json: SerializedAccount<"serial-port", void>): SerialPortAccount;
+}

package/dist/accounts/serial-port-account.js

@@ -0,0 +1,25 @@
+import { SerialPortSigner } from "applesauce-signer/signers/serial-port-signer";
+import { BaseAccount } from "../account.js";
+/** An account for SerialPortSigner */
+export default class SerialPortAccount extends BaseAccount {
+    constructor(pubkey, signer) {
+        super(pubkey, signer || new SerialPortSigner());
+    }
+    async unlock() {
+        try {
+            const pubkey = await this.signer.getPublicKey();
+            if (pubkey !== this.pubkey)
+                throw new Error("Signer returned incorrect pubkey");
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    toJSON() {
+        return { type: "serial-port", pubkey: this.pubkey, signer: undefined };
+    }
+    static fromJSON(json) {
+        return new SerialPortAccount(json.pubkey);
+    }
+}

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

@@ -0,0 +1,14 @@
+import { SimpleSigner } from "applesauce-signer/signers/simple-signer";
+import { BaseAccount } from "../account.js";
+import { SerializedAccount } from "../types.js";
+type SignerData = {
+    key: string;
+};
+export default class SimpleAccount extends BaseAccount<"nsec", SignerData> {
+    signer: SimpleSigner;
+    constructor(pubkey: string, signer: SimpleSigner);
+    static fromKey(key: Uint8Array | string): SimpleAccount;
+    toJSON(): SerializedAccount<"nsec", SignerData>;
+    static fromJSON(json: SerializedAccount<"nsec", SignerData>): SimpleAccount;
+}
+export {};

package/dist/accounts/simple-account.js

@@ -0,0 +1,24 @@
+import { getPublicKey } from "nostr-tools";
+import { SimpleSigner } from "applesauce-signer/signers/simple-signer";
+import { bytesToHex, hexToBytes } from "@noble/hashes/utils";
+import { BaseAccount } from "../account.js";
+export default class SimpleAccount extends BaseAccount {
+    signer;
+    constructor(pubkey, signer) {
+        super(pubkey, signer);
+        this.signer = signer;
+    }
+    static fromKey(key) {
+        if (typeof key === "string")
+            key = hexToBytes(key);
+        const pubkey = getPublicKey(key);
+        return new SimpleAccount(pubkey, new SimpleSigner(key));
+    }
+    toJSON() {
+        return { type: "nsec", pubkey: this.pubkey, signer: { key: bytesToHex(this.signer.key) } };
+    }
+    static fromJSON(json) {
+        const key = hexToBytes(json.signer.key);
+        return new SimpleAccount(json.pubkey, new SimpleSigner(key));
+    }
+}

package/dist/helpers/address-pointer.d.ts

@@ -0,0 +1,16 @@
+import { AddressPointerWithoutD } from "applesauce-core/helpers";
+import { Filter } from "nostr-tools";
+/** Converts an array of address pointers to a filter */
+export declare function createFilterFromAddressPointers(pointers: AddressPointerWithoutD[]): Filter;
+/** Takes a set of address pointers, groups them, then returns filters for the groups */
+export declare function createFiltersFromAddressPointers(pointers: AddressPointerWithoutD[]): Filter[];
+/** Checks if a relay will understand an address pointer */
+export declare function isLoadableAddressPointer<T extends AddressPointerWithoutD>(pointer: T): boolean;
+/** Group an array of address pointers by kind */
+export declare function groupAddressPointersByKind(pointers: AddressPointerWithoutD[]): Map<number, AddressPointerWithoutD[]>;
+/** Group an array of address pointers by pubkey */
+export declare function groupAddressPointersByPubkey(pointers: AddressPointerWithoutD[]): Map<string, AddressPointerWithoutD[]>;
+/** Groups address pointers by kind or pubkey depending on which is most optimal */
+export declare function groupAddressPointersByPubkeyOrKind(pointers: AddressPointerWithoutD[]): Map<number, AddressPointerWithoutD[]> | Map<string, AddressPointerWithoutD[]>;
+export declare function getRelaysFromPointers(pointers: AddressPointerWithoutD[]): Set<string>;
+export declare function getAddressPointerId<T extends AddressPointerWithoutD>(pointer: T): string;

package/dist/helpers/address-pointer.js

@@ -0,0 +1,67 @@
+import { getReplaceableUID } from "applesauce-core/helpers";
+import { isParameterizedReplaceableKind, isReplaceableKind } from "nostr-tools/kinds";
+import { unique } from "./array.js";
+/** Converts an array of address pointers to a filter */
+export function createFilterFromAddressPointers(pointers) {
+    const filter = {};
+    filter.kinds = unique(pointers.map((p) => p.kind));
+    filter.authors = unique(pointers.map((p) => p.pubkey));
+    const identifiers = unique(pointers.map((p) => p.identifier).filter((d) => !!d));
+    if (identifiers.length > 0)
+        filter["#d"] = identifiers;
+    return filter;
+}
+/** Takes a set of address pointers, groups them, then returns filters for the groups */
+export function createFiltersFromAddressPointers(pointers) {
+    const groups = groupAddressPointersByPubkeyOrKind(pointers);
+    return Array.from(groups.values()).map((pointers) => createFilterFromAddressPointers(pointers));
+}
+/** Checks if a relay will understand an address pointer */
+export function isLoadableAddressPointer(pointer) {
+    if (isParameterizedReplaceableKind(pointer.kind))
+        return !!pointer.identifier;
+    else
+        return isReplaceableKind(pointer.kind);
+}
+/** Group an array of address pointers by kind */
+export function groupAddressPointersByKind(pointers) {
+    const byKind = new Map();
+    for (const pointer of pointers) {
+        if (byKind.has(pointer.kind))
+            byKind.get(pointer.kind).push(pointer);
+        else
+            byKind.set(pointer.kind, [pointer]);
+    }
+    return byKind;
+}
+/** Group an array of address pointers by pubkey */
+export function groupAddressPointersByPubkey(pointers) {
+    const byPubkey = new Map();
+    for (const pointer of pointers) {
+        if (byPubkey.has(pointer.pubkey))
+            byPubkey.get(pointer.pubkey).push(pointer);
+        else
+            byPubkey.set(pointer.pubkey, [pointer]);
+    }
+    return byPubkey;
+}
+/** Groups address pointers by kind or pubkey depending on which is most optimal */
+export function groupAddressPointersByPubkeyOrKind(pointers) {
+    const kinds = new Set(pointers.map((p) => p.kind));
+    const pubkeys = new Set(pointers.map((p) => p.pubkey));
+    return pubkeys.size > kinds.size ? groupAddressPointersByKind(pointers) : groupAddressPointersByPubkey(pointers);
+}
+export function getRelaysFromPointers(pointers) {
+    const relays = new Set();
+    for (const pointer of pointers) {
+        if (!pointer.relays)
+            continue;
+        for (const relay of pointer.relays) {
+            relays.add(relay);
+        }
+    }
+    return relays;
+}
+export function getAddressPointerId(pointer) {
+    return getReplaceableUID(pointer.kind, pointer.pubkey, pointer.identifier);
+}

package/dist/helpers/array.d.ts

@@ -0,0 +1,4 @@
+/** Does not preserve order */
+export declare function unique<T>(arr: T[]): T[];
+/** split array into a set of arrays no larger than batchSize */
+export declare function reduceToBatches<T>(arr: T[], batchSize: number): T[][];

package/dist/helpers/array.js

@@ -0,0 +1,21 @@
+/** Does not preserve order */
+export function unique(arr) {
+    return Array.from(new Set(arr));
+}
+/** split array into a set of arrays no larger than batchSize */
+export function reduceToBatches(arr, batchSize) {
+    const batches = [];
+    for (const value of arr) {
+        if (batches.length === 0) {
+            batches.push([value]);
+            continue;
+        }
+        const current = batches[batches.length - 1];
+        if (current.length <= batchSize) {
+            current.push(value);
+        }
+        else
+            batches.push([value]);
+    }
+    return batches;
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * as Accounts from "./accounts/index.js";
+export * from "./types.js";
+export * from "./account.js";
+export * from "./manager.js";

package/dist/index.js

@@ -0,0 +1,4 @@
+export * as Accounts from "./accounts/index.js";
+export * from "./types.js";
+export * from "./account.js";
+export * from "./manager.js";

package/dist/loaders/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./loader.js";
+export * from "./replaceable-loader.js";
+export * from "./single-relay-replaceable-loader.js";

package/dist/loaders/index.js

@@ -0,0 +1,3 @@
+export * from "./loader.js";
+export * from "./replaceable-loader.js";
+export * from "./single-relay-replaceable-loader.js";

package/dist/loaders/loader.d.ts

@@ -0,0 +1,14 @@
+import { Observable, OperatorFunction, Subject, Subscribable } from "rxjs";
+export interface ILoader<T, R> extends Subscribable<R> {
+    next: (value: T) => void;
+    pipe: Observable<R>["pipe"];
+}
+/** Base loader class */
+export declare class Loader<T, R> implements ILoader<T, R> {
+    protected subject: Subject<T>;
+    protected observable: Observable<R>;
+    pipe: Observable<R>["pipe"];
+    subscribe: Observable<R>["subscribe"];
+    constructor(transform: OperatorFunction<T, R>);
+    next(value: T): void;
+}

package/dist/loaders/loader.js

@@ -0,0 +1,17 @@
+import { Subject } from "rxjs";
+/** Base loader class */
+export class Loader {
+    subject = new Subject();
+    observable;
+    pipe;
+    subscribe;
+    constructor(transform) {
+        this.observable = this.subject.pipe(transform);
+        // copy pipe function
+        this.pipe = this.observable.pipe.bind(this.observable);
+        this.subscribe = this.observable.subscribe.bind(this.observable);
+    }
+    next(value) {
+        this.subject.next(value);
+    }
+}

package/dist/loaders/replaceable-loader.d.ts

@@ -0,0 +1,31 @@
+import { Observable } from "rxjs";
+import { EventPacket, RxNostr } from "rx-nostr";
+import { Filter, NostrEvent } from "nostr-tools";
+import { logger } from "applesauce-core";
+import { Loader } from "./loader.js";
+export type LoadableAddressPointer = {
+    kind: number;
+    pubkey: string;
+    /** Optional "d" tag for paramaritized replaceable */
+    identifier?: string;
+    /** Relays to load from */
+    relays?: string[];
+    /** Load this address pointer even if it has already been loaded */
+    force?: boolean;
+};
+export type CacheRequest = (filters: Filter[]) => Observable<NostrEvent>;
+export type ReplaceableLoaderOptions = {
+    /**
+     * Time interval to buffer requests in ms
+     * @default 1000
+     */
+    bufferTime?: number;
+    /** Request events from the cache first */
+    cacheRequest?: CacheRequest;
+    /** Fallback lookup relays to check when event cant be found */
+    lookupRelays?: string[];
+};
+export declare class ReplaceableLoader extends Loader<LoadableAddressPointer, EventPacket> {
+    log: typeof logger;
+    constructor(rxNostr: RxNostr, opts?: ReplaceableLoaderOptions);
+}

package/dist/loaders/replaceable-loader.js

@@ -0,0 +1,163 @@
+import { share, tap, from, filter, bufferTime, map, mergeMap } from "rxjs";
+import { getEventUID, getReplaceableUID, markFromCache } from "applesauce-core/helpers";
+import { logger } from "applesauce-core";
+import { nanoid } from "nanoid";
+import { Loader } from "./loader.js";
+import { generatorSequence } from "../operators/generator-sequence.js";
+import { replaceableRequest } from "../operators/address-pointers-request.js";
+import { createFiltersFromAddressPointers, getAddressPointerId, getRelaysFromPointers, isLoadableAddressPointer, } from "../helpers/address-pointer.js";
+import { unique } from "../helpers/array.js";
+/** deep clone a loadable pointer to ensure its safe to modify */
+function cloneLoadablePointer(pointer) {
+    const clone = { ...pointer };
+    if (pointer.relays)
+        clone.relays = [...pointer.relays];
+    return clone;
+}
+/** A generator that tries to load the address pointers from the cache first, then tries the relays */
+function* cacheFirstSequence(rxNostr, pointers, log, opts) {
+    const id = nanoid(8);
+    log = log.extend(id);
+    let remaining = Array.from(pointers);
+    const pointerRelays = Array.from(getRelaysFromPointers(pointers));
+    // handle previous step results and decide if to exit
+    const handleResults = (results) => {
+        if (results.length) {
+            const coordinates = new Set(results.map((p) => getEventUID(p.event)));
+            // if there where results, filter out any pointers that where found
+            remaining = remaining.filter((pointer) => {
+                const found = coordinates.has(getReplaceableUID(pointer.kind, pointer.pubkey, pointer.identifier));
+                if (found && pointer.force !== true)
+                    return false;
+                else
+                    return true;
+            });
+            if (remaining.length === 0)
+                return true;
+        }
+        return false;
+    };
+    // first attempt, load from cache relays
+    if (opts?.cacheRequest) {
+        log(`Checking cache`, remaining);
+        const results = yield from([remaining]).pipe(
+        // convert pointers to filters
+        map(createFiltersFromAddressPointers), 
+        // make requests
+        mergeMap((filters) => opts.cacheRequest(filters)), 
+        // mark the event as from the cache
+        tap((event) => markFromCache(event)), 
+        // convert to event packets
+        map((e) => ({ event: e, from: "cache", subId: "cache", type: "EVENT" })));
+        if (handleResults(results))
+            return;
+    }
+    // load from pointer relays and default relays
+    const defaultRelays = Object.entries(rxNostr.getDefaultRelays())
+        .filter(([_relay, config]) => config.read)
+        .map(([relay]) => relay);
+    const remoteRelays = [...pointerRelays, ...defaultRelays];
+    if (remoteRelays.length > 0) {
+        log(`Requesting`, remoteRelays, remaining);
+        const results = yield from([remaining]).pipe(replaceableRequest(rxNostr, id, remoteRelays));
+        if (handleResults(results))
+            return;
+    }
+    // finally load from lookup relays
+    if (opts?.lookupRelays) {
+        // make sure we aren't asking a relay twice
+        const relays = opts.lookupRelays.filter((r) => !pointerRelays.includes(r));
+        if (relays.length > 0) {
+            log(`Request from lookup`, relays, remaining);
+            const results = yield from([remaining]).pipe(replaceableRequest(rxNostr, id, relays));
+            if (handleResults(results))
+                return;
+        }
+    }
+}
+/** Batches address pointers and consolidates them */
+function multiRelayBatcher(buffer) {
+    const requestedFrom = new Map();
+    const requestedDefault = new Set();
+    return (source) => source.pipe(
+    // buffer on time
+    bufferTime(buffer), 
+    // ignore empty buffers
+    filter((buffer) => buffer.length > 0), 
+    // consolidate buffered pointers
+    map((pointers) => {
+        const byId = new Map();
+        for (const pointer of pointers) {
+            const id = getAddressPointerId(pointer);
+            if (byId.has(id)) {
+                // duplicate, merge pointers
+                const current = byId.get(id);
+                // merge relays
+                if (pointer.relays) {
+                    if (current.relays)
+                        current.relays = unique([...current.relays, ...pointer.relays]);
+                    else
+                        current.relays = pointer.relays;
+                }
+                // merge force flag
+                if (pointer.force !== undefined) {
+                    current.force = current.force || pointer.force;
+                }
+            }
+            else
+                byId.set(id, cloneLoadablePointer(pointer));
+        }
+        // return consolidated pointers
+        return Array.from(byId.values());
+    }), 
+    // ignore empty buffer
+    filter((buffer) => buffer.length > 0), 
+    // ensure pointers are only requested from each relay once
+    map((pointers) => {
+        return pointers.filter((pointer) => {
+            const id = getAddressPointerId(pointer);
+            // skip if forced
+            if (pointer.force)
+                return true;
+            // skip if already requested from default relays
+            if (!pointer.relays) {
+                if (requestedDefault.has(id))
+                    return false;
+                else {
+                    requestedDefault.add(id);
+                    return true;
+                }
+            }
+            let set = requestedFrom.get(id);
+            if (!set) {
+                set = new Set();
+                requestedFrom.set(id, set);
+            }
+            // remove any relays that have already been used
+            pointer.relays = pointer.relays.filter((relay) => !set.has(relay));
+            // remember used relays
+            for (const relay of pointer.relays)
+                set.add(relay);
+            // if there are no new relays, ignore pointer
+            return pointer.relays.length > 0;
+        });
+    }), 
+    // ignore empty buffer
+    filter((buffer) => buffer.length > 0));
+}
+export class ReplaceableLoader extends Loader {
+    log = logger.extend("ReplaceableLoader");
+    constructor(rxNostr, opts) {
+        super((source) => {
+            return source.pipe(
+            // filter out invalid pointers
+            filter(isLoadableAddressPointer), 
+            // batch and filter
+            multiRelayBatcher(opts?.bufferTime ?? 1000), 
+            // check cache, relays, lookup relays in that order
+            generatorSequence((pointers) => cacheFirstSequence(rxNostr, pointers, this.log, opts)), 
+            // share the response with all subscribers
+            share());
+        });
+    }
+}

package/dist/loaders/single-relay-replaceable-loader.d.ts

@@ -0,0 +1,14 @@
+import { EventPacket, RxNostr } from "rx-nostr";
+import { Loader } from "./loader.js";
+import { LoadableAddressPointer } from "./replaceable-loader.js";
+export type SingleRelayReplaceableOptions = Partial<{
+    /**
+     * Wait X ms before making a request
+     * @default 1000
+     */
+    bufferTime: number;
+}>;
+/** A wrapper class around {@link singleRelayBatcher'}, {@link replaceableRequest}, and share */
+export declare class SingleRelayReplaceableLoader extends Loader<LoadableAddressPointer, EventPacket> {
+    constructor(rxNostr: RxNostr, relay: string, opts?: SingleRelayReplaceableOptions);
+}

package/dist/loaders/single-relay-replaceable-loader.js

@@ -0,0 +1,51 @@
+import { bufferTime, filter, from, map, mergeMap, share } from "rxjs";
+import { getReplaceableUID } from "applesauce-core/helpers";
+import { nanoid } from "nanoid";
+import { Loader } from "./loader.js";
+import { isLoadableAddressPointer } from "../helpers/address-pointer.js";
+import { replaceableRequest } from "../operators/address-pointers-request.js";
+const defaultRelayReplaceableLoaderOptions = {
+    bufferTime: 1000,
+};
+/** Ensures an address pointer is only loaded once from a relay */
+function singleRelayBatcher(opts) {
+    return (source) => {
+        const loaded = new Set();
+        const options = opts ? { ...defaultRelayReplaceableLoaderOptions, ...opts } : defaultRelayReplaceableLoaderOptions;
+        return source.pipe(
+        // buffer the requests, so we only send requests every second
+        bufferTime(options.bufferTime), 
+        // ignore empty batches
+        filter((batch) => batch.length > 0), 
+        // filter out duplicates
+        map((batch) => {
+            const filtered = [];
+            for (const pointer of batch) {
+                const uid = getReplaceableUID(pointer.kind, pointer.pubkey, pointer.identifier);
+                if (!loaded.has(uid)) {
+                    filtered.push(pointer);
+                    loaded.add(uid);
+                }
+                else if (pointer.force)
+                    filtered.push(pointer);
+            }
+            return filtered;
+        }), 
+        // ignore empty batches
+        filter((batch) => batch.length > 0));
+    };
+}
+/** A wrapper class around {@link singleRelayBatcher'}, {@link replaceableRequest}, and share */
+export class SingleRelayReplaceableLoader extends Loader {
+    constructor(rxNostr, relay, opts) {
+        super((source) => source.pipe(
+        // ignore invalid address pointers
+        filter(isLoadableAddressPointer), 
+        // batch and filter
+        singleRelayBatcher(opts), 
+        // breakout the batches so they can complete
+        mergeMap((pointers) => from([pointers]).pipe(replaceableRequest(rxNostr, nanoid(8), [relay]))), 
+        // share the response with all subscribers
+        share()));
+    }
+}

package/dist/manager.d.ts

@@ -0,0 +1,2 @@
+export declare class AccountManager {
+}

package/dist/manager.js

@@ -0,0 +1,2 @@
+export class AccountManager {
+}

package/dist/operators/address-pointers-request.d.ts

@@ -0,0 +1,5 @@
+import { EventPacket, RxNostr } from "rx-nostr";
+import { OperatorFunction } from "rxjs";
+import { AddressPointerWithoutD } from "applesauce-core/helpers";
+/** Makes a request to relays for every set of address pointers */
+export declare function replaceableRequest<T extends AddressPointerWithoutD>(rxNostr: RxNostr, id: string, relays?: string[]): OperatorFunction<T[], EventPacket>;

package/dist/operators/address-pointers-request.js

@@ -0,0 +1,25 @@
+import { map, tap } from "rxjs";
+import { logger } from "applesauce-core";
+import { relaysRequest } from "./relay-request.js";
+import { createFiltersFromAddressPointers } from "../helpers/address-pointer.js";
+/** Makes a request to relays for every set of address pointers */
+export function replaceableRequest(rxNostr, id, relays) {
+    return (source) => {
+        const log = logger.extend(`replaceableRequest:${id}`);
+        return source.pipe(
+        // convert pointers to filters
+        map(createFiltersFromAddressPointers), 
+        // make requests
+        tap((filters) => {
+            log(`Requesting`, relays, filters);
+        }), 
+        // make requests
+        relaysRequest(rxNostr, id, relays), 
+        // log when complete
+        tap({
+            complete: () => {
+                log(`Complete`);
+            },
+        }));
+    };
+}

package/dist/operators/generator-sequence.d.ts

@@ -0,0 +1,3 @@
+import { Observable, OperatorFunction } from "rxjs";
+/** Keeps retrying a value until the generator returns */
+export declare function generatorSequence<T, R>(createGenerator: (value: T) => Generator<Observable<R>, undefined, R[] | undefined>): OperatorFunction<T, R>;

package/dist/operators/generator-sequence.js

@@ -0,0 +1,45 @@
+import { Observable } from "rxjs";
+/** Keeps retrying a value until the generator returns */
+export function generatorSequence(createGenerator) {
+    return (source) => {
+        return new Observable((observer) => {
+            let complete = false;
+            const sub = source.subscribe({
+                next: (value) => {
+                    const generator = createGenerator(value);
+                    const next = (prevResults) => {
+                        const result = generator.next(prevResults);
+                        // generator complete, exit
+                        if (result.done)
+                            return;
+                        const results = [];
+                        result.value.subscribe({
+                            next: (v) => {
+                                // track results and pass along values
+                                results.push(v);
+                                observer.next(v);
+                            },
+                            error: (err) => {
+                                observer.error(err);
+                            },
+                            complete: () => {
+                                // if the upstream observable was complete. exit
+                                if (complete)
+                                    return observer.complete();
+                                // run next step
+                                next(results);
+                            },
+                        });
+                    };
+                    // start running steps
+                    next();
+                },
+                complete: () => {
+                    // source is complete
+                    complete = true;
+                },
+            });
+            return () => sub.unsubscribe();
+        });
+    };
+}

package/dist/operators/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./generator-sequence.js";
+export * from "./relay-request.js";
+export * from "./max-filters.js";
+export * from "./address-pointers-request.js";

package/dist/operators/index.js

@@ -0,0 +1,4 @@
+export * from "./generator-sequence.js";
+export * from "./relay-request.js";
+export * from "./max-filters.js";
+export * from "./address-pointers-request.js";

package/dist/operators/max-filters.d.ts

@@ -0,0 +1,4 @@
+import { LazyFilter } from "rx-nostr";
+import { OperatorFunction } from "rxjs";
+/** Splits a batch of filters into multiple requests if necessary */
+export declare function splitMaxFiltersPerRequest(maxFiltersPerRequest: number): OperatorFunction<LazyFilter[], LazyFilter[]>;

package/dist/operators/max-filters.js

@@ -0,0 +1,8 @@
+import { mergeMap } from "rxjs";
+import { reduceToBatches } from "../helpers/array.js";
+/** Splits a batch of filters into multiple requests if necessary */
+export function splitMaxFiltersPerRequest(maxFiltersPerRequest) {
+    return (source) => source.pipe(
+    // batch the filters into sets no larger than maxFiltersPerRequest
+    mergeMap((filters) => reduceToBatches(filters, maxFiltersPerRequest)));
+}

package/dist/operators/relay-request.d.ts

@@ -0,0 +1,4 @@
+import { EventPacket, LazyFilter, RxNostr } from "rx-nostr";
+import { OperatorFunction } from "rxjs";
+/** Makes a request to relays for every set of filters */
+export declare function relaysRequest(rxNostr: RxNostr, id: string, relays?: string[]): OperatorFunction<LazyFilter | LazyFilter[], EventPacket>;

package/dist/operators/relay-request.js

@@ -0,0 +1,9 @@
+import { createRxOneshotReq } from "rx-nostr";
+import { map, mergeAll } from "rxjs";
+/** Makes a request to relays for every set of filters */
+export function relaysRequest(rxNostr, id, relays) {
+    return (source) => source.pipe(map((filters) => {
+        const req = createRxOneshotReq({ filters, rxReqId: id });
+        return rxNostr.use(req, { on: { relays } });
+    }), mergeAll());
+}

package/dist/types.d.ts

@@ -0,0 +1,19 @@
+import { Nip07Interface } from "applesauce-signer";
+export type SerializedAccount<T extends string, S> = {
+    type: T;
+    name?: string;
+    pubkey: string;
+    signer: S;
+};
+export interface IAccount<T extends string, S> extends Nip07Interface {
+    name?: string;
+    pubkey: string;
+    locked: boolean;
+    unlock(): Promise<boolean>;
+    lock(): void;
+    toJSON(): SerializedAccount<T, S>;
+}
+export interface IAccountConstructor<T extends string, S> {
+    new (pubkey: string, signer: Nip07Interface): IAccount<T, S>;
+    fromJSON(json: SerializedAccount<T, S>): IAccount<T, S>;
+}

package/dist/types.js

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

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "applesauce-accounts",
+  "version": "0.0.0-next-20241218172722",
+  "description": "A simple nostr account management system",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "keywords": [
+    "nostr"
+  ],
+  "author": "hzrd149",
+  "license": "MIT",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./accounts": {
+      "import": "./dist/accounts/index.js",
+      "types": "./dist/accounts/index.d.ts"
+    },
+    "./accounts/*": {
+      "import": "./dist/accounts/*.js",
+      "types": "./dist/accounts/*.d.ts"
+    }
+  },
+  "dependencies": {
+    "@noble/hashes": "^1.5.0",
+    "applesauce-signer": "0.0.0-next-20241218172722",
+    "nanoid": "^5.0.9",
+    "nostr-tools": "^2.10.3",
+    "rxjs": "^7.8.1"
+  },
+  "devDependencies": {
+    "typescript": "^5.6.3",
+    "vitest": "^2.1.8"
+  },
+  "funding": {
+    "type": "lightning",
+    "url": "lightning:nostrudel@geyser.fund"
+  },
+  "scripts": {
+    "build": "tsc",
+    "watch:build": "tsc --watch > /dev/null",
+    "test": "vitest run --passWithNoTests",
+    "watch:test": "vitest"
+  }
+}