applesauce-core 5.1.0 → 6.0.0

package/dist/casts/cast.d.ts

@@ -0,0 +1,31 @@
+import { Observable } from "rxjs";
+import { EventModels, IEventStoreStreams, IEventSubscriptions } from "../event-store/index.js";
+import { NostrEvent } from "../helpers/event.js";
+import { ChainableObservable } from "../observable/chainable.js";
+import { User } from "./user.js";
+/** The type of event store that is passed to cast references */
+export type CastRefEventStore = IEventSubscriptions & EventModels & IEventStoreStreams;
+/** A symbol used to store all the cast instances for a given event */
+export declare const CAST_REF_SYMBOL: unique symbol;
+/** A symbol used to store all the casts for an event */
+export declare const CASTS_SYMBOL: unique symbol;
+/** A class that can be used to cast a Nostr event */
+export type CastConstructor<C extends EventCast<NostrEvent>> = new (event: NostrEvent, store: CastRefEventStore) => C;
+/** Cast a Nostr event to a specific class */
+export declare function castEvent<C extends EventCast<NostrEvent>>(event: NostrEvent, cls: CastConstructor<C>, store?: CastRefEventStore): C;
+/** The base class for all casts */
+export declare class EventCast<T extends NostrEvent = NostrEvent> {
+    #private;
+    readonly event: T;
+    readonly store: CastRefEventStore;
+    get id(): string;
+    get uid(): string;
+    get createdAt(): Date;
+    /** Get the {@link User} that authored this event */
+    get author(): User;
+    /** Return the set of relays this event was seen on */
+    get seen(): Set<string> | undefined;
+    constructor(event: T, store: CastRefEventStore);
+    /** Internal method for creating a reference */
+    protected $$ref<Return extends unknown>(key: string, builder: (store: CastRefEventStore) => Observable<Return>): ChainableObservable<Return>;
+}

package/dist/casts/cast.js

@@ -0,0 +1,67 @@
+import { getEventUID, getParentEventStore } from "../helpers/event.js";
+import { getSeenRelays } from "../helpers/relays.js";
+import { chainable } from "../observable/chainable.js";
+import { castUser } from "./user.js";
+/** A symbol used to store all the cast instances for a given event */
+export const CAST_REF_SYMBOL = Symbol.for("cast-ref");
+/** A symbol used to store all the casts for an event */
+export const CASTS_SYMBOL = Symbol.for("casts");
+/** Cast a Nostr event to a specific class */
+export function castEvent(event, cls, store) {
+    const casts = Reflect.get(event, CASTS_SYMBOL);
+    // If the event has already been cast to this class, return the existing cast
+    const existing = casts?.get(cls);
+    if (existing)
+        return existing;
+    if (!store) {
+        store = getParentEventStore(event);
+        if (!store)
+            throw new Error("Event is not attached to an event store, an event store must be provided");
+    }
+    // Create a new instance of the class
+    const cast = new cls(event, store);
+    if (!casts)
+        Reflect.set(event, CASTS_SYMBOL, new Map([[cls, cast]]));
+    else
+        casts.set(cls, cast);
+    return cast;
+}
+/** The base class for all casts */
+export class EventCast {
+    event;
+    store;
+    get id() {
+        return this.event.id;
+    }
+    get uid() {
+        return getEventUID(this.event);
+    }
+    get createdAt() {
+        return new Date(this.event.created_at * 1000);
+    }
+    /** Get the {@link User} that authored this event */
+    get author() {
+        return castUser(this.event, this.store);
+    }
+    /** Return the set of relays this event was seen on */
+    get seen() {
+        return getSeenRelays(this.event);
+    }
+    // Enfore kind check in constructor. this will force child classes to verify the event before calling super()
+    constructor(event, store) {
+        this.event = event;
+        this.store = store;
+    }
+    /** A cache of observable references */
+    #refs = {};
+    /** Internal method for creating a reference */
+    $$ref(key, builder) {
+        // Return cached observable
+        if (this.#refs[key])
+            return this.#refs[key];
+        // Build a new observable and cache it
+        const observable = chainable(builder(this.store));
+        this.#refs[key] = observable;
+        return observable;
+    }
+}

package/dist/casts/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./cast.js";
+export * from "./pubkey.js";
+export * from "./user.js";

package/dist/casts/index.js

@@ -0,0 +1,3 @@
+export * from "./cast.js";
+export * from "./pubkey.js";
+export * from "./user.js";

package/dist/casts/pubkey.d.ts

@@ -0,0 +1,27 @@
+/** A constructor type for {@link PubkeyCast} subclasses */
+import { Observable } from "rxjs";
+import { NostrEvent } from "../helpers/event.js";
+import type { ProfilePointer } from "../helpers/pointers.js";
+import { ChainableObservable } from "../observable/chainable.js";
+import { CastRefEventStore } from "./cast.js";
+export type PubkeyCastConstructor<C extends PubkeyCast> = (new (pointer: ProfilePointer, store: CastRefEventStore) => C) & {
+    cache: Map<string, C>;
+};
+/**
+ * Cast a pubkey to a specific class instance.
+ * Works like {@link castUser} - returns a cached singleton per pubkey+relay-hints combination.
+ */
+export declare function castPubkey<C extends PubkeyCast>(pubkey: string | NostrEvent | ProfilePointer, cls: PubkeyCastConstructor<C>, store: CastRefEventStore): C;
+/** Base class for pubkey-based casts (analogous to {@link EventCast} for events) */
+export declare class PubkeyCast {
+    #private;
+    readonly pointer: ProfilePointer;
+    readonly store: CastRefEventStore;
+    /** A global cache of pubkey -> instance, populated by {@link castPubkey} */
+    static cache: Map<string, PubkeyCast>;
+    constructor(pointer: ProfilePointer, store: CastRefEventStore);
+    /** The hex pubkey represented by this cast */
+    get pubkey(): string;
+    /** Internal method for creating a cached observable reference */
+    protected $$ref<Return extends unknown>(key: string, builder: (store: CastRefEventStore) => Observable<Return>): ChainableObservable<Return>;
+}

package/dist/casts/pubkey.js

@@ -0,0 +1,49 @@
+/** A constructor type for {@link PubkeyCast} subclasses */
+import { isEvent } from "../helpers/event.js";
+import { isHexKey } from "../helpers/string.js";
+import { chainable } from "../observable/chainable.js";
+/**
+ * Cast a pubkey to a specific class instance.
+ * Works like {@link castUser} - returns a cached singleton per pubkey+relay-hints combination.
+ */
+export function castPubkey(pubkey, cls, store) {
+    if (isEvent(pubkey))
+        return castPubkey(pubkey.pubkey, cls, store);
+    const pointer = typeof pubkey === "string" ? { pubkey } : pubkey;
+    if (!isHexKey(pointer.pubkey))
+        throw new Error("Invalid pubkey");
+    const cacheKey = pointer.relays?.length ? `${pointer.pubkey}:${JSON.stringify(pointer.relays)}` : pointer.pubkey;
+    if (!cls.cache)
+        cls.cache = new Map();
+    const existing = cls.cache.get(cacheKey);
+    if (existing)
+        return existing;
+    const instance = new cls(pointer, store);
+    cls.cache.set(cacheKey, instance);
+    return instance;
+}
+/** Base class for pubkey-based casts (analogous to {@link EventCast} for events) */
+export class PubkeyCast {
+    pointer;
+    store;
+    /** A global cache of pubkey -> instance, populated by {@link castPubkey} */
+    static cache = new Map();
+    constructor(pointer, store) {
+        this.pointer = pointer;
+        this.store = store;
+    }
+    /** The hex pubkey represented by this cast */
+    get pubkey() {
+        return this.pointer.pubkey;
+    }
+    /** A cache of observable references */
+    #refs = {};
+    /** Internal method for creating a cached observable reference */
+    $$ref(key, builder) {
+        if (this.#refs[key])
+            return this.#refs[key];
+        const observable = chainable(builder(this.store));
+        this.#refs[key] = observable;
+        return observable;
+    }
+}

package/dist/casts/user.d.ts

@@ -0,0 +1,19 @@
+import { NostrEvent } from "../helpers/event.js";
+import { ProfilePointer } from "../helpers/pointers.js";
+import { ChainableObservable } from "../observable/chainable.js";
+import type { CastRefEventStore } from "./cast.js";
+import { PubkeyCast } from "./pubkey.js";
+/** Cast a Nostr event or pointer into a {@link User} */
+export declare function castUser(event: NostrEvent, store: CastRefEventStore): User;
+export declare function castUser(user: string | ProfilePointer, store: CastRefEventStore): User;
+/** A class representing a Nostr user */
+export declare class User extends PubkeyCast {
+    /** A global cache of pubkey -> {@link User} */
+    static cache: Map<string, User>;
+    get npub(): `npub1${string}`;
+    get nprofile(): `nprofile1${string}`;
+    /** Subscribe to a replaceable event for this user */
+    replaceable(kind: number, identifier?: string, relays?: string[]): ChainableObservable<NostrEvent | undefined>;
+    /** Subscribe to an addressable event for this user */
+    addressable(kind: number, identifier: string, relays?: string[]): ChainableObservable<NostrEvent | undefined>;
+}

package/dist/casts/user.js

@@ -0,0 +1,25 @@
+import { nprofileEncode, npubEncode } from "../helpers/pointers.js";
+import { chainable } from "../observable/chainable.js";
+import { castPubkey, PubkeyCast } from "./pubkey.js";
+export function castUser(user, store) {
+    return castPubkey(user, User, store);
+}
+/** A class representing a Nostr user */
+export class User extends PubkeyCast {
+    /** A global cache of pubkey -> {@link User} */
+    static cache = new Map();
+    get npub() {
+        return npubEncode(this.pubkey);
+    }
+    get nprofile() {
+        return nprofileEncode(this.pointer);
+    }
+    /** Subscribe to a replaceable event for this user */
+    replaceable(kind, identifier, relays) {
+        return chainable(this.store.replaceable({ kind, pubkey: this.pointer.pubkey, identifier, relays }));
+    }
+    /** Subscribe to an addressable event for this user */
+    addressable(kind, identifier, relays) {
+        return chainable(this.store.addressable({ kind, pubkey: this.pointer.pubkey, identifier, relays }));
+    }
+}

package/dist/factories/delete.d.ts

@@ -0,0 +1,18 @@
+import { kinds, NostrEvent } from "nostr-tools";
+import { KnownEventTemplate } from "../helpers/event.js";
+import { EventFactory } from "./event.js";
+export type DeleteTemplate = KnownEventTemplate<kinds.EventDeletion>;
+/** A factory class for building delete events */
+export declare class DeleteFactory extends EventFactory<kinds.EventDeletion, DeleteTemplate> {
+    /**
+     * Creates a new delete factory from a list of event ids
+     * @param events - The list of event ids to delete
+     * @param reason - The reason for the deletion
+     * @returns A new delete factory
+     */
+    static fromEvents(events: (string | NostrEvent)[], reason?: string): DeleteFactory;
+    /** Sets the reason for the deletion */
+    reason(reason: string): this;
+    /** Sets the events to delete */
+    events(events: (string | NostrEvent)[]): this;
+}

package/dist/factories/delete.js

@@ -0,0 +1,23 @@
+import { kinds } from "nostr-tools";
+import { blankEventTemplate, EventFactory } from "./event.js";
+import { setDeleteEvents } from "../operations/delete.js";
+/** A factory class for building delete events */
+export class DeleteFactory extends EventFactory {
+    /**
+     * Creates a new delete factory from a list of event ids
+     * @param events - The list of event ids to delete
+     * @param reason - The reason for the deletion
+     * @returns A new delete factory
+     */
+    static fromEvents(events, reason = "") {
+        return new DeleteFactory((res) => res(blankEventTemplate(kinds.EventDeletion))).events(events).reason(reason);
+    }
+    /** Sets the reason for the deletion */
+    reason(reason) {
+        return this.content(reason);
+    }
+    /** Sets the events to delete */
+    events(events) {
+        return this.chain(setDeleteEvents(events));
+    }
+}

package/dist/factories/event.d.ts

@@ -0,0 +1,61 @@
+import { EventSigner } from "./types.js";
+import type { EventOperation } from "./types.js";
+import { EncryptionMethod } from "../helpers/encrypted-content.js";
+import { KnownEvent, KnownEventTemplate, KnownUnsignedEvent } from "../helpers/event.js";
+import { MetaTagOptions } from "../operations/event.js";
+import { modifyHiddenTags, modifyPublicTags, modifyTags } from "../operations/tags.js";
+/** Creates a blank event template with the given kind and random "d" tag if addressable */
+export declare function blankEventTemplate<K extends number = number>(kind: K): KnownEventTemplate<K>;
+/** Converts a nostr event to an event template and updates the created_at timestamp */
+export declare function toEventTemplate<K extends number>(event: KnownEvent<K>): KnownEventTemplate<K>;
+/** Shared mutable signer container passed through the factory chain */
+type SignerRef = {
+    signer?: EventSigner;
+};
+/** The base class for building or modifying events */
+export declare class EventFactory<K extends number = number, T extends KnownEventTemplate<K> = KnownEventTemplate<K>> extends Promise<T> {
+    /** Create a new event factory from a kind */
+    static fromKind<K extends number>(kind: K): EventFactory<K>;
+    /** Create a new event factory from a nostr event */
+    static fromEvent<K extends number = number>(event: KnownEvent<K>): EventFactory<K, KnownEventTemplate<K>>;
+    /** Shared mutable reference to the signer, propagated through all chain links */
+    protected _signerRef: SignerRef;
+    /** The signer used to sign the event (reads from shared ref) */
+    protected get signer(): EventSigner | undefined;
+    protected set signer(value: EventSigner | undefined);
+    /** Custom .then method that wraps the resulting promise in a new event factory */
+    protected chain(operation: EventOperation<T>): this;
+    /** Sets the event signer to use when building this event */
+    as(signer: EventSigner): this;
+    /** Strips the pubkey, sig, and id from the event */
+    strip(): EventFactory<K>;
+    /** Stamps the pubkey onto the event template */
+    stamp(signer?: EventSigner | undefined): EventFactory<K, KnownUnsignedEvent<K>>;
+    /** Signs the event using a signer interface and returns a Promise */
+    sign(signer?: EventSigner | undefined): Promise<KnownEvent<K>>;
+    /** Sets the event kind and casts the result to a {@link KnownEventTemplate<Kind>} */
+    kind<Kind extends number>(kind: Kind): EventFactory<Kind, KnownEventTemplate<Kind>>;
+    /** Sets the event content */
+    content(content: string): this;
+    /** Set the event created_at timestamp in seconds. if no value is provided, the current unix timestamp will be used */
+    created(created?: number | Date): this;
+    /** Sets the meta tags for the event */
+    meta(options: MetaTagOptions): this;
+    /** Sets the NIP-31 alt tag for the event */
+    alt(alt: string): this;
+    /** Sets the NIP-40 expiration timestamp for the event */
+    expiration(timestamp: number): this;
+    /** Sets the NIP-36 content-warning tag for the event */
+    contentWarning(warning: string | boolean): this;
+    /** Sets the NIP-70 "-" tag for the event */
+    protected(isProtected: boolean): this;
+    /** Modifies the events public and optional hidden tags */
+    modifyTags(...args: Parameters<typeof modifyTags>): this;
+    /** Modifies the events public tags array */
+    modifyPublicTags(...args: Parameters<typeof modifyPublicTags>): this;
+    /** Modifies the events hidden tags array */
+    modifyHiddenTags(...args: Exclude<Parameters<typeof modifyHiddenTags>[1], undefined>[]): this;
+    /** Sets the encrypted content of the event */
+    encryptedContent(target: string, content: string, override?: EncryptionMethod): this;
+}
+export {};

package/dist/factories/event.js

@@ -0,0 +1,164 @@
+import { isAddressableKind, isKind } from "nostr-tools/kinds";
+import { PRESERVE_EVENT_SYMBOLS } from "../helpers/pipeline.js";
+import { unixNow } from "../helpers/time.js";
+import { setEncryptedContent } from "../operations/encrypted-content.js";
+import { includeAltTag, setExpirationTimestamp, setMetaTags, setProtected, sign, stamp, } from "../operations/event.js";
+import { modifyHiddenTags, modifyPublicTags, modifyTags } from "../operations/tags.js";
+import { setContentWarning } from "../operations/content.js";
+import { nanoid } from "nanoid";
+/** Creates a blank event template with the given kind and random "d" tag if addressable */
+export function blankEventTemplate(kind) {
+    const tags = isAddressableKind(kind) ? [["d", nanoid()]] : [];
+    return { kind, created_at: unixNow(), tags, content: "" };
+}
+/** Converts a nostr event to an event template and updates the created_at timestamp */
+export function toEventTemplate(event) {
+    return {
+        kind: event.kind,
+        created_at: unixNow(),
+        tags: Array.from(event.tags),
+        content: event.content,
+    };
+}
+/** The base class for building or modifying events */
+export class EventFactory extends Promise {
+    /** Create a new event factory from a kind */
+    static fromKind(kind) {
+        return new EventFactory((res) => res({ kind, created_at: unixNow(), tags: [], content: "" }));
+    }
+    /** Create a new event factory from a nostr event */
+    static fromEvent(event) {
+        return new EventFactory((res) => res(toEventTemplate(event)));
+    }
+    /** Shared mutable reference to the signer, propagated through all chain links */
+    _signerRef = {};
+    /** The signer used to sign the event (reads from shared ref) */
+    get signer() {
+        return this._signerRef.signer;
+    }
+    set signer(value) {
+        this._signerRef.signer = value;
+    }
+    /** Custom .then method that wraps the resulting promise in a new event factory */
+    chain(operation) {
+        const Constructor = this.constructor;
+        const next = new Constructor((res) => res(this.then(async (draft) => {
+            const result = await operation(draft);
+            // Strip any symbols that are not in the preserve list, matching the
+            // behaviour of eventPipe / pipeFromAsyncArray so stale caches (e.g.
+            // HiddenTagsSymbol set by a previous modifyHiddenTags step) never
+            // leak into subsequent chain operations.
+            for (const key of Reflect.ownKeys(result)) {
+                if (typeof key === "symbol" && !PRESERVE_EVENT_SYMBOLS.has(key)) {
+                    Reflect.deleteProperty(result, key);
+                }
+            }
+            return result;
+        })));
+        // Share the same signer reference so setting .as() on any link propagates to all
+        next._signerRef = this._signerRef;
+        return next;
+    }
+    /** Sets the event signer to use when building this event */
+    as(signer) {
+        this._signerRef.signer = signer;
+        return this;
+    }
+    /** Strips the pubkey, sig, and id from the event */
+    strip() {
+        return new EventFactory((res) => res(this.then((v) => ({
+            content: v.content,
+            tags: v.tags,
+            created_at: v.created_at,
+            kind: v.kind,
+        }))));
+    }
+    /** Stamps the pubkey onto the event template */
+    stamp(signer = this.signer) {
+        return new EventFactory((res, rej) => {
+            if (!signer)
+                return rej(new Error("Signer required for stamping"));
+            else
+                res(this.then((template) => stamp(signer)(template)));
+        });
+    }
+    /** Signs the event using a signer interface and returns a Promise */
+    async sign(signer = this.signer) {
+        if (!signer)
+            throw new Error("Missing signer");
+        // Ensure the signer is available to chain operations during resolution
+        if (!this.signer)
+            this.signer = signer;
+        const template = await this;
+        const signed = await sign(signer)(template);
+        // Verify the pubkey has not changed
+        if (Reflect.has(template, "pubkey") && Reflect.get(template, "pubkey") !== signed.pubkey)
+            throw new Error("Signer modified pubkey");
+        // If its the same kind, return the signed event
+        if (isKind(signed, template.kind))
+            return signed;
+        else
+            throw new Error("Signer modified event kind");
+    }
+    /** Sets the event kind and casts the result to a {@link KnownEventTemplate<Kind>} */
+    kind(kind) {
+        return new EventFactory((e) => ({ ...e, kind }));
+    }
+    /** Sets the event content */
+    content(content) {
+        return this.chain((e) => ({ ...e, content }));
+    }
+    /** Set the event created_at timestamp in seconds. if no value is provided, the current unix timestamp will be used */
+    created(created = unixNow()) {
+        if (created instanceof Date)
+            created = Math.floor(created.getTime() / 1000);
+        return this.chain((e) => ({ ...e, created_at: created }));
+    }
+    /** Sets the meta tags for the event */
+    meta(options) {
+        return this.chain(setMetaTags(options));
+    }
+    /** Sets the NIP-31 alt tag for the event */
+    alt(alt) {
+        return this.chain(includeAltTag(alt));
+    }
+    /** Sets the NIP-40 expiration timestamp for the event */
+    expiration(timestamp) {
+        return this.chain(setExpirationTimestamp(timestamp));
+    }
+    /** Sets the NIP-36 content-warning tag for the event */
+    contentWarning(warning) {
+        return this.chain(setContentWarning(warning));
+    }
+    /** Sets the NIP-70 "-" tag for the event */
+    protected(isProtected) {
+        return this.chain(setProtected(isProtected));
+    }
+    /** Modifies the events public and optional hidden tags */
+    modifyTags(...args) {
+        let result;
+        result = this.chain((e) => modifyTags(args[0], result.signer)(e));
+        return result;
+    }
+    /** Modifies the events public tags array */
+    modifyPublicTags(...args) {
+        return this.chain(modifyPublicTags(...args));
+    }
+    /** Modifies the events hidden tags array */
+    modifyHiddenTags(...args) {
+        let result;
+        result = this.chain((e) => modifyHiddenTags(result.signer, ...args)(e));
+        return result;
+    }
+    /** Sets the encrypted content of the event */
+    encryptedContent(target, content, override) {
+        let result;
+        result = this.chain((draft) => {
+            const signer = result.signer;
+            if (!signer)
+                throw new Error("Signer required for encrypted content");
+            return setEncryptedContent(target, content, signer, override)(draft);
+        });
+        return result;
+    }
+}

package/dist/factories/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./types.js";
+export * from "./event.js";
+export * from "./delete.js";
+export * from "./mailboxes.js";
+export * from "./profile.js";

package/dist/factories/index.js

@@ -0,0 +1,5 @@
+export * from "./types.js";
+export * from "./event.js";
+export * from "./delete.js";
+export * from "./mailboxes.js";
+export * from "./profile.js";

package/dist/factories/mailboxes.d.ts

@@ -0,0 +1,33 @@
+import { kinds, KnownEvent, KnownEventTemplate } from "../helpers/event.js";
+import { EventFactory } from "./event.js";
+export type MailboxesTemplate = KnownEventTemplate<kinds.RelayList>;
+export type MailboxesOptions = {
+    inboxes?: string[];
+    outboxes?: string[];
+};
+/** A factory class for building NIP-65 relay list (mailboxes) events */
+export declare class MailboxesFactory extends EventFactory<kinds.RelayList, MailboxesTemplate> {
+    /**
+     * Creates a new mailboxes factory
+     * @returns A new mailboxes factory
+     */
+    static create(opts?: MailboxesOptions): MailboxesFactory;
+    /** Creates a new mailboxes factory from an existing relay list event with validation */
+    static modify(event: KnownEvent<kinds.RelayList>): MailboxesFactory;
+    /** Adds an outbox relay (write) */
+    addOutbox(url: string | URL): this;
+    /** Removes an outbox relay (write) */
+    removeOutbox(url: string | URL): this;
+    /** Adds an inbox relay (read) */
+    addInbox(url: string | URL): this;
+    /** Removes an inbox relay (read) */
+    removeInbox(url: string | URL): this;
+    /** Adds a relay as both inbox and outbox */
+    addRelay(url: string | URL): this;
+    /** Completely removes a relay from mailboxes */
+    removeRelay(url: string | URL): this;
+    /** Sets all inbox relays (read), replacing existing ones */
+    inboxes(urls: (string | URL)[]): this;
+    /** Sets all outbox relays (write), replacing existing ones */
+    outboxes(urls: (string | URL)[]): this;
+}

package/dist/factories/mailboxes.js

@@ -0,0 +1,57 @@
+import { kinds } from "../helpers/event.js";
+import { isMailboxesEvent } from "../helpers/mailboxes.js";
+import { addInboxRelay, addMailboxRelay, addOutboxRelay, removeInboxRelay, removeMailboxRelay, removeOutboxRelay, setInboxRelays, setOutboxRelays, } from "../operations/mailboxes.js";
+import { blankEventTemplate, EventFactory, toEventTemplate } from "./event.js";
+/** A factory class for building NIP-65 relay list (mailboxes) events */
+export class MailboxesFactory extends EventFactory {
+    /**
+     * Creates a new mailboxes factory
+     * @returns A new mailboxes factory
+     */
+    static create(opts) {
+        let factory = new MailboxesFactory((res) => res(blankEventTemplate(kinds.RelayList)));
+        if (opts?.inboxes)
+            factory = factory.inboxes(opts.inboxes);
+        if (opts?.outboxes)
+            factory = factory.outboxes(opts.outboxes);
+        return factory;
+    }
+    /** Creates a new mailboxes factory from an existing relay list event with validation */
+    static modify(event) {
+        if (!isMailboxesEvent(event))
+            throw new Error("Event is not a relay list");
+        return new MailboxesFactory((res) => res(toEventTemplate(event)));
+    }
+    /** Adds an outbox relay (write) */
+    addOutbox(url) {
+        return this.chain(addOutboxRelay(url));
+    }
+    /** Removes an outbox relay (write) */
+    removeOutbox(url) {
+        return this.chain(removeOutboxRelay(url));
+    }
+    /** Adds an inbox relay (read) */
+    addInbox(url) {
+        return this.chain(addInboxRelay(url));
+    }
+    /** Removes an inbox relay (read) */
+    removeInbox(url) {
+        return this.chain(removeInboxRelay(url));
+    }
+    /** Adds a relay as both inbox and outbox */
+    addRelay(url) {
+        return this.chain(addMailboxRelay(url));
+    }
+    /** Completely removes a relay from mailboxes */
+    removeRelay(url) {
+        return this.chain(removeMailboxRelay(url));
+    }
+    /** Sets all inbox relays (read), replacing existing ones */
+    inboxes(urls) {
+        return this.chain(setInboxRelays(urls));
+    }
+    /** Sets all outbox relays (write), replacing existing ones */
+    outboxes(urls) {
+        return this.chain(setOutboxRelays(urls));
+    }
+}

package/dist/factories/profile.d.ts

@@ -0,0 +1,46 @@
+import { kinds, KnownEvent, KnownEventTemplate } from "../helpers/event.js";
+import { ProfileContent } from "../helpers/index.js";
+import { EventFactory } from "./event.js";
+export type ProfileTemplate = KnownEventTemplate<kinds.Metadata>;
+/** A factory class for building kind 0 profile/metadata events */
+export declare class ProfileFactory<T extends ProfileTemplate = ProfileTemplate> extends EventFactory<kinds.Metadata, T> {
+    /**
+     * Creates a new profile factory
+     * @returns A new profile factory
+     */
+    static create(): ProfileFactory;
+    /**
+     * Creates a new profile factory from an existing metadata event with validation
+     * @param event - The existing metadata event
+     * @returns A new profile factory
+     */
+    static modify(event: KnownEvent<kinds.Metadata>): ProfileFactory;
+    /** Sets the entire profile content, replacing any existing content */
+    override(content: ProfileContent): this;
+    /** Updates specific fields in the profile content, merging with existing content */
+    update(content: Partial<ProfileContent>): this;
+    /** Sets the display name */
+    name(name: string): this;
+    /** Sets the username */
+    username(username: string): this;
+    /** Sets the display name (alias for name) */
+    displayName(displayName: string): this;
+    /** Sets the about/bio text */
+    about(about: string): this;
+    /** Sets the profile picture URL */
+    picture(picture: string): this;
+    /** Sets the banner image URL */
+    banner(banner: string): this;
+    /** Sets the website URL */
+    website(website: string): this;
+    /** Sets the NIP-05 identifier */
+    nip05(nip05: string): this;
+    /** Sets the Lightning Network address */
+    lnurlp(lnurlp: string): this;
+    /** Sets the Lightning Network address (LNURL) */
+    lightningAddress(address: string): this;
+    /** Sets the bot flag */
+    bot(bot: boolean): this;
+    /** Sets the languages */
+    languages(languages: string[]): this;
+}