applesauce-core 0.0.0-next-20250916134023 → 0.0.0-next-20250918142212

package/dist/event-store/async-event-store.d.ts

@@ -17,7 +17,7 @@ declare const AsyncEventStore_base: {
         addressable(pointer: AddressPointer): Observable<NostrEvent | undefined>;
         timeline(filters: Filter | Filter[], includeOldVersion?: boolean): Observable<NostrEvent[]>;
         profile(user: string | import("nostr-tools/nip19").ProfilePointer): Observable<import("../helpers/profile.js").ProfileContent | undefined>;
-        contacts(user: string | import("nostr-tools/nip19").ProfilePointer): Observable<import("nostr-tools/nip19").ProfilePointer[] | undefined>;
+        contacts(user: string | import("nostr-tools/nip19").ProfilePointer): Observable<import("nostr-tools/nip19").ProfilePointer[]>;
         mutes(user: string | import("nostr-tools/nip19").ProfilePointer): Observable<import("../helpers/mutes.js").Mutes | undefined>;
         mailboxes(user: string | import("nostr-tools/nip19").ProfilePointer): Observable<{
             inboxes: string[];

package/dist/event-store/async-event-store.js

@@ -214,7 +214,7 @@ export class AsyncEventStore extends EventStoreModelMixin(class {
         // remove all old version of the replaceable event
         if (!this.keepOldVersions && isReplaceable(event.kind)) {
             const existing = await this.database.getReplaceableHistory(event.kind, event.pubkey, identifier);
-            if (existing) {
+            if (existing && existing.length > 0) {
                 const older = Array.from(existing).filter((e) => e.created_at < event.created_at);
                 for (const old of older)
                     await this.remove(old);
@@ -231,16 +231,16 @@ export class AsyncEventStore extends EventStoreModelMixin(class {
     }
     /** Removes an event from the store and updates subscriptions */
     async remove(event) {
-        // Get the current instance from the database
-        const e = await this.database.getEvent(typeof event === "string" ? event : event.id);
-        if (!e)
-            return false;
+        let instance = this.memory?.getEvent(typeof event === "string" ? event : event.id);
         // Remove from memory if available
         if (this.memory)
-            this.memory.remove(typeof event === "string" ? event : event.id);
+            this.memory.remove(event);
+        // Remove the event from the database
         const removed = await this.database.remove(event);
-        if (removed && e)
-            this.remove$.next(e);
+        // If the event was removed, notify the subscriptions
+        if (removed && instance) {
+            this.remove$.next(instance);
+        }
         return removed;
     }
     /** Add an event to the store and notifies all subscribes it has updated */

package/dist/event-store/event-memory.d.ts

@@ -66,9 +66,9 @@ export declare class EventMemory implements IEventMemory {
     /** Iterates over all events by id */
     iterateIds(ids: Iterable<string>): Generator<NostrEvent>;
     /** Returns all events that match the filter */
-    getEventsForFilter(filter: Filter): Set<NostrEvent>;
+    protected getEventsForFilter(filter: Filter): Set<NostrEvent>;
     /** Returns all events that match the filters */
-    getEventsForFilters(filters: Filter[]): Set<NostrEvent>;
+    protected getEventsForFilters(filters: Filter[]): Set<NostrEvent>;
     /** Resets the event set */
     reset(): void;
 }

package/dist/event-store/event-memory.js

@@ -90,7 +90,7 @@ export class EventMemory {
     remove(eventOrId) {
         let event = typeof eventOrId === "string" ? this.events.get(eventOrId) : eventOrId;
         if (!event)
-            throw new Error("Missing event");
+            return false;
         const id = event.id;
         // only remove events that are known
         if (!this.events.has(id))
@@ -327,7 +327,7 @@ export class EventMemory {
     /** Returns all events that match the filters */
     getEventsForFilters(filters) {
         if (filters.length === 0)
-            throw new Error("No Filters");
+            return new Set();
         let events = new Set();
         for (const filter of filters) {
             const filtered = this.getEventsForFilter(filter);

package/dist/event-store/event-store.d.ts

@@ -17,7 +17,7 @@ declare const EventStore_base: {
         addressable(pointer: AddressPointer): Observable<NostrEvent | undefined>;
         timeline(filters: Filter | Filter[], includeOldVersion?: boolean): Observable<NostrEvent[]>;
         profile(user: string | import("nostr-tools/nip19").ProfilePointer): Observable<import("../helpers/profile.js").ProfileContent | undefined>;
-        contacts(user: string | import("nostr-tools/nip19").ProfilePointer): Observable<import("nostr-tools/nip19").ProfilePointer[] | undefined>;
+        contacts(user: string | import("nostr-tools/nip19").ProfilePointer): Observable<import("nostr-tools/nip19").ProfilePointer[]>;
         mutes(user: string | import("nostr-tools/nip19").ProfilePointer): Observable<import("../helpers/mutes.js").Mutes | undefined>;
         mailboxes(user: string | import("nostr-tools/nip19").ProfilePointer): Observable<{
             inboxes: string[];

package/dist/event-store/event-store.js

@@ -218,7 +218,7 @@ export class EventStore extends EventStoreModelMixin(class {
         // remove all old version of the replaceable event
         if (!this.keepOldVersions && isReplaceable(event.kind)) {
             const existing = this.database.getReplaceableHistory(event.kind, event.pubkey, identifier);
-            if (existing) {
+            if (existing && existing.length > 0) {
                 const older = Array.from(existing).filter((e) => e.created_at < event.created_at);
                 for (const old of older)
                     this.remove(old);
@@ -235,16 +235,16 @@ export class EventStore extends EventStoreModelMixin(class {
     }
     /** Removes an event from the store and updates subscriptions */
     remove(event) {
-        // Get the current instance from the database
-        const e = this.database.getEvent(typeof event === "string" ? event : event.id);
-        if (!e)
-            return false;
+        let instance = this.memory?.getEvent(typeof event === "string" ? event : event.id);
         // Remove from memory if available
         if (this.memory)
             this.memory.remove(event);
+        // Remove the event from the database
         const removed = this.database.remove(event);
-        if (removed && e)
-            this.remove$.next(e);
+        // If the event was removed, notify the subscriptions
+        if (removed && instance) {
+            this.remove$.next(instance);
+        }
         return removed;
     }
     /** Add an event to the store and notifies all subscribes it has updated */

package/dist/event-store/interface.d.ts

@@ -112,7 +112,7 @@ export interface IEventHelpfulSubscriptions {
     /** Subscribe to a users profile */
     profile(user: string | ProfilePointer): Observable<ProfileContent | undefined>;
     /** Subscribe to a users contacts */
-    contacts(user: string | ProfilePointer): Observable<ProfilePointer[] | undefined>;
+    contacts(user: string | ProfilePointer): Observable<ProfilePointer[]>;
     /** Subscribe to a users mutes */
     mutes(user: string | ProfilePointer): Observable<Mutes | undefined>;
     /** Subscribe to a users NIP-65 mailboxes */

package/dist/event-store/model-mixin.d.ts

@@ -31,7 +31,7 @@ export declare function EventStoreModelMixin<T extends new (...args: any[]) => a
         /** Subscribe to a users profile */
         profile(user: string | ProfilePointer): Observable<import("../helpers/profile.js").ProfileContent | undefined>;
         /** Subscribe to a users contacts */
-        contacts(user: string | ProfilePointer): Observable<ProfilePointer[] | undefined>;
+        contacts(user: string | ProfilePointer): Observable<ProfilePointer[]>;
         /** Subscribe to a users mutes */
         mutes(user: string | ProfilePointer): Observable<import("../helpers/mutes.js").Mutes | undefined>;
         /** Subscribe to a users NIP-65 mailboxes */

package/dist/helpers/index.d.ts

@@ -43,6 +43,7 @@ export * from "./pointers.js";
 export * from "./poll.js";
 export * from "./profile.js";
 export * from "./reactions.js";
+export * from "./relay-selection.js";
 export * from "./relays.js";
 export * from "./reports.js";
 export * from "./share.js";

package/dist/helpers/index.js

@@ -43,6 +43,7 @@ export * from "./pointers.js";
 export * from "./poll.js";
 export * from "./profile.js";
 export * from "./reactions.js";
+export * from "./relay-selection.js";
 export * from "./relays.js";
 export * from "./reports.js";
 export * from "./share.js";

package/dist/helpers/relay-selection.d.ts

@@ -0,0 +1,19 @@
+import { ProfilePointer } from "nostr-tools/nip19";
+export type SelectOptimalRelaysOptions = {
+    /** Maximum number of connections (relays) to select */
+    maxConnections: number;
+    /** Maximum coverage percentage a single relay can have (0-100 default 50) */
+    maxRelayCoverage?: number;
+    /** Maximum number of relays per user (default 8) */
+    maxRelaysPerUser?: number;
+    /** Minimum number of relays per user (default 2) */
+    minRelaysPerUser?: number;
+};
+/** Selects the optimal relays for a list of ProfilePointers */
+export declare function selectOptimalRelays(users: ProfilePointer[], { maxConnections, maxRelayCoverage, maxRelaysPerUser, minRelaysPerUser }: SelectOptimalRelaysOptions): ProfilePointer[];
+/** Sorts each ProfilePointer's relays by popularity */
+export declare function sortRelaysByPopularity(users: ProfilePointer[]): ProfilePointer[];
+/** A map of pubkeys by relay */
+export type OutboxMap = Record<string, string[]>;
+/** RxJS operator that aggregates contacts with outboxes into a relay -> pubkeys map */
+export declare function groupPubkeysByRelay(pointers: ProfilePointer[]): OutboxMap;

package/dist/helpers/relay-selection.js

@@ -0,0 +1,125 @@
+import { logger } from "../logger.js";
+const log = logger.extend("relay-selection");
+/** Selects the optimal relays for a list of ProfilePointers */
+export function selectOptimalRelays(users, { maxConnections, maxRelayCoverage = 50, maxRelaysPerUser, minRelaysPerUser }) {
+    if (!users.length)
+        return [];
+    // Initialize result array and tracking structures
+    const result = [];
+    const selectedRelays = new Set();
+    const relayUserCounts = new Map();
+    const totalUsers = users.length;
+    const maxUsersPerRelay = Math.ceil((totalUsers * maxRelayCoverage) / 100);
+    // Process each user to select optimal relays
+    for (const user of users) {
+        const userRelays = [];
+        const availableRelays = user.relays || [];
+        // If user has no relays, add them with empty relays
+        if (availableRelays.length === 0) {
+            result.push({ ...user, relays: [] });
+            continue;
+        }
+        // Try to select relays for this user, respecting priority order
+        let attempts = 0;
+        const maxAttempts = availableRelays.length * 2; // Prevent infinite loops
+        while (userRelays.length < (maxRelaysPerUser || availableRelays.length) &&
+            selectedRelays.size < maxConnections &&
+            attempts < maxAttempts) {
+            attempts++;
+            let foundRelay = false;
+            // Try each relay in priority order (first = highest priority)
+            for (const relay of availableRelays) {
+                // Skip if we already selected this relay for this user
+                if (userRelays.includes(relay))
+                    continue;
+                // Check if this relay would exceed coverage limit
+                const currentRelayUsers = relayUserCounts.get(relay) || 0;
+                if (currentRelayUsers >= maxUsersPerRelay)
+                    continue;
+                // Select this relay
+                userRelays.push(relay);
+                selectedRelays.add(relay);
+                relayUserCounts.set(relay, currentRelayUsers + 1);
+                foundRelay = true;
+                // Stop if we've reached maxRelaysPerUser for this user
+                if (maxRelaysPerUser && userRelays.length >= maxRelaysPerUser)
+                    break;
+                // Stop if we've reached maxConnections globally
+                if (selectedRelays.size >= maxConnections)
+                    break;
+            }
+            // If we couldn't find any more suitable relays, break
+            if (!foundRelay)
+                break;
+        }
+        // Ensure minimum relays per user if specified
+        if (minRelaysPerUser && userRelays.length < minRelaysPerUser) {
+            // Try to add more relays even if they exceed coverage limits
+            let minAttempts = 0;
+            const maxMinAttempts = availableRelays.length;
+            while (userRelays.length < minRelaysPerUser && minAttempts < maxMinAttempts) {
+                minAttempts++;
+                for (const relay of availableRelays) {
+                    if (userRelays.includes(relay))
+                        continue;
+                    if (selectedRelays.size >= maxConnections)
+                        break;
+                    userRelays.push(relay);
+                    selectedRelays.add(relay);
+                    relayUserCounts.set(relay, (relayUserCounts.get(relay) || 0) + 1);
+                    if (userRelays.length >= minRelaysPerUser)
+                        break;
+                }
+                if (selectedRelays.size >= maxConnections)
+                    break;
+            }
+        }
+        // Add user with selected relays (maintaining original relay order)
+        const finalRelays = availableRelays.filter((relay) => userRelays.includes(relay));
+        result.push({ ...user, relays: finalRelays });
+    }
+    log(`Selected ${selectedRelays.size} relays for ${result.length} users`);
+    log(`Relay distribution:`, Array.from(relayUserCounts.entries()));
+    return result;
+}
+/** Sorts each ProfilePointer's relays by popularity */
+export function sortRelaysByPopularity(users) {
+    const relayUsageCount = new Map();
+    // Count the times the relays are used
+    for (const user of users) {
+        if (!user.relays)
+            continue;
+        for (const relay of user.relays) {
+            relayUsageCount.set(relay, (relayUsageCount.get(relay) || 0) + 1);
+        }
+    }
+    return users.map((user) => {
+        if (!user.relays)
+            return user;
+        // Sort the user's relays by popularity
+        return {
+            ...user,
+            relays: user.relays.sort((a, b) => {
+                const countA = relayUsageCount.get(a) || 0;
+                const countB = relayUsageCount.get(b) || 0;
+                return countB - countA;
+            }),
+        };
+    });
+}
+/** RxJS operator that aggregates contacts with outboxes into a relay -> pubkeys map */
+export function groupPubkeysByRelay(pointers) {
+    const outbox = {};
+    for (const pointer of pointers) {
+        if (!pointer.relays)
+            continue;
+        for (const relay of pointer.relays) {
+            if (!outbox[relay])
+                outbox[relay] = [];
+            if (!outbox[relay].includes(pointer.pubkey)) {
+                outbox[relay].push(pointer.pubkey);
+            }
+        }
+    }
+    return outbox;
+}

package/dist/models/contacts.d.ts

@@ -1,7 +1,7 @@
 import { ProfilePointer } from "nostr-tools/nip19";
 import { Model } from "../event-store/interface.js";
 /** A model that returns all contacts for a user */
-export declare function ContactsModel(user: string | ProfilePointer): Model<ProfilePointer[] | undefined>;
+export declare function ContactsModel(user: string | ProfilePointer): Model<ProfilePointer[]>;
 /** A model that returns all public contacts for a user */
 export declare function PublicContactsModel(pubkey: string): Model<ProfilePointer[] | undefined>;
 /** A model that returns all hidden contacts for a user */

package/dist/models/contacts.js

@@ -10,7 +10,7 @@ export function ContactsModel(user) {
     // listen for event updates (hidden tags unlocked)
     watchEventUpdates(events), 
     // Get all contacts
-    map((e) => (e ? getContacts(e) : undefined)));
+    map((e) => (e ? getContacts(e) : [])));
 }
 /** A model that returns all public contacts for a user */
 export function PublicContactsModel(pubkey) {

package/dist/models/index.d.ts

@@ -17,3 +17,4 @@ export * from "./relays.js";
 export * from "./thread.js";
 export * from "./wrapped-messages.js";
 export * from "./zaps.js";
+export * from "./outbox.js";

package/dist/models/index.js

@@ -17,3 +17,4 @@ export * from "./relays.js";
 export * from "./thread.js";
 export * from "./wrapped-messages.js";
 export * from "./zaps.js";
+export * from "./outbox.js";

package/dist/models/outbox.d.ts

@@ -0,0 +1,13 @@
+import { ProfilePointer } from "nostr-tools/nip19";
+import { Model } from "../event-store/interface.js";
+import { ignoreBlacklistedRelays } from "../observable/relay-selection.js";
+import { SelectOptimalRelaysOptions } from "../helpers/relay-selection.js";
+export type OutboxModelOptions = SelectOptimalRelaysOptions & {
+    type?: "inbox" | "outbox";
+    blacklist?: Parameters<typeof ignoreBlacklistedRelays>[0];
+};
+/** A model that returns the users contacts with the relays to connect to */
+export declare function OutboxModel(user: string | ProfilePointer, opts: OutboxModelOptions): Model<ProfilePointer[]>;
+export declare namespace OutboxModel {
+    var getKey: (user: string | ProfilePointer, opts: OutboxModelOptions) => string;
+}

package/dist/models/outbox.js

@@ -0,0 +1,29 @@
+import { ignoreBlacklistedRelays, includeLegacyAppRelays, includeMailboxes } from "../observable/relay-selection.js";
+import { selectOptimalRelays, sortRelaysByPopularity } from "../helpers/relay-selection.js";
+import { identity, map } from "rxjs";
+import hash_sum from "hash-sum";
+/** A model that returns the users contacts with the relays to connect to */
+export function OutboxModel(user, opts) {
+    return (store) => store.contacts(user).pipe(
+    /** Ignore blacklisted relays */
+    opts?.blacklist ? ignoreBlacklistedRelays(opts.blacklist) : identity, 
+    /** Include mailboxes */
+    includeMailboxes(store, opts.type), 
+    /** Include legacy app relays */
+    includeLegacyAppRelays(store, opts.type), 
+    /** Sort the relays by popularity */
+    map(sortRelaysByPopularity), 
+    /** Select the optimal relays */
+    map((users) => selectOptimalRelays(users, opts)));
+}
+OutboxModel.getKey = (user, opts) => {
+    const p = typeof user === "string" ? user : user.pubkey;
+    return hash_sum([
+        p,
+        opts.type,
+        opts.maxConnections,
+        opts.maxRelayCoverage,
+        opts.maxRelaysPerUser,
+        opts.minRelaysPerUser,
+    ]);
+};

package/dist/observable/index.d.ts

@@ -1,4 +1,5 @@
-import { firstValueFrom, lastValueFrom } from "rxjs";
+export { firstValueFrom, lastValueFrom, combineLatest, merge } from "rxjs";
+export { Observable, Subject, BehaviorSubject, ReplaySubject } from "rxjs";
 export * from "./defined.js";
 export * from "./get-observable-value.js";
 export * from "./map-events-to-timeline.js";
@@ -6,4 +7,4 @@ export * from "./map-events-to-store.js";
 export * from "./simple-timeout.js";
 export * from "./watch-event-updates.js";
 export * from "./with-immediate-value.js";
-export { firstValueFrom, lastValueFrom };
+export * from "./relay-selection.js";

package/dist/observable/index.js

@@ -1,4 +1,6 @@
-import { firstValueFrom, lastValueFrom } from "rxjs";
+// Re-export some useful rxjs functions
+export { firstValueFrom, lastValueFrom, combineLatest, merge } from "rxjs";
+export { Observable, Subject, BehaviorSubject, ReplaySubject } from "rxjs";
 export * from "./defined.js";
 export * from "./get-observable-value.js";
 export * from "./map-events-to-timeline.js";
@@ -6,5 +8,4 @@ export * from "./map-events-to-store.js";
 export * from "./simple-timeout.js";
 export * from "./watch-event-updates.js";
 export * from "./with-immediate-value.js";
-// Re-export some useful rxjs functions
-export { firstValueFrom, lastValueFrom };
+export * from "./relay-selection.js";

package/dist/observable/map-events-to-store.d.ts

@@ -1,7 +1,7 @@
 import { NostrEvent } from "nostr-tools";
 import { MonoTypeOperatorFunction } from "rxjs";
-import { IEventStoreActions } from "../event-store/interface.js";
+import { IAsyncEventStoreActions, IEventStoreActions } from "../event-store/interface.js";
 /** Saves all events to an event store and filters out invalid events */
-export declare function mapEventsToStore(store: IEventStoreActions, removeDuplicates?: boolean): MonoTypeOperatorFunction<NostrEvent>;
+export declare function mapEventsToStore(store: IEventStoreActions | IAsyncEventStoreActions, removeDuplicates?: boolean): MonoTypeOperatorFunction<NostrEvent>;
 /** Alias for {@link mapEventsToStore} */
-export declare const filterDuplicateEvents: (store: IEventStoreActions) => MonoTypeOperatorFunction<import("nostr-tools").Event>;
+export declare const filterDuplicateEvents: (store: IEventStoreActions | IAsyncEventStoreActions) => MonoTypeOperatorFunction<import("nostr-tools").Event>;

package/dist/observable/map-events-to-store.js

@@ -1,10 +1,19 @@
-import { distinct, filter, identity, map } from "rxjs";
+import { catchError, distinct, filter, from, identity, mergeMap, of } from "rxjs";
 /** Saves all events to an event store and filters out invalid events */
 export function mapEventsToStore(store, removeDuplicates = true) {
     return (source) => source.pipe(
     // Map all events to the store
-    // NOTE: map is used here because we want to return the single instance of the event so that distinct() can be used later
-    map((event) => store.add(event)), 
+    // NOTE: mergeMap is used here because we want to return the single instance of the event so that distinct() can be used later
+    mergeMap((event) => {
+        const r = store.add(event);
+        // Unwrap the promise from the async store
+        if (r instanceof Promise)
+            return from(r);
+        else
+            return of(r);
+    }), 
+    // Ignore errors when inserting events into the store
+    catchError(() => of(null)), 
     // Ignore invalid events
     filter((e) => e !== null), 
     // Remove duplicates if requested

package/dist/observable/relay-selection.d.ts

@@ -0,0 +1,9 @@
+import { ProfilePointer } from "nostr-tools/nip19";
+import { type MonoTypeOperatorFunction, type Observable, type OperatorFunction } from "rxjs";
+import { IEventSubscriptions } from "../event-store/interface.js";
+/** RxJS operator that fetches outboxes for profile pointers from the event store */
+export declare function includeMailboxes(store: IEventSubscriptions, type?: "inbox" | "outbox"): OperatorFunction<ProfilePointer[], ProfilePointer[]>;
+/** An operator that reads and adds the legacy relays from the kind 3 event */
+export declare function includeLegacyAppRelays(store: IEventSubscriptions, type?: "inbox" | "outbox"): OperatorFunction<ProfilePointer[], ProfilePointer[]>;
+/** Removes blacklisted relays from the user's relays */
+export declare function ignoreBlacklistedRelays(blacklist: string[] | Observable<string[]>): MonoTypeOperatorFunction<ProfilePointer[]>;

package/dist/observable/relay-selection.js

@@ -0,0 +1,80 @@
+import { combineLatest, combineLatestWith, defaultIfEmpty, EMPTY, map, of, pipe, switchMap, timeout, } from "rxjs";
+import { getRelaysFromContactsEvent } from "../helpers/contacts.js";
+import { getInboxes, getOutboxes } from "../helpers/mailboxes.js";
+import { addRelayHintsToPointer } from "../helpers/pointers.js";
+import { defined } from "./defined.js";
+import { logger } from "../logger.js";
+const log = logger.extend("relay-selection");
+/** RxJS operator that fetches outboxes for profile pointers from the event store */
+export function includeMailboxes(store, type = "outbox") {
+    // Get the outboxes for all contacts
+    return switchMap((contacts) => combineLatest(contacts.map((contact) => 
+    // Get the outboxes for the contact
+    store
+        .replaceable({
+        kind: 10002,
+        pubkey: contact.pubkey,
+        relays: contact.relays,
+    })
+        .pipe(
+    // Wait for the event to be defined
+    defined(), 
+    // Merge the outboxes into the pointer
+    map((event) => {
+        const relays = type === "outbox" ? getOutboxes(event) : getInboxes(event);
+        if (!relays)
+            return contact;
+        return addRelayHintsToPointer(contact, relays);
+    }), 
+    // Timeout the request if it takes too long
+    timeout({ first: 5_000, with: () => EMPTY }), 
+    // If no event is found, return the contact
+    defaultIfEmpty(contact)))));
+}
+/** An operator that reads and adds the legacy relays from the kind 3 event */
+export function includeLegacyAppRelays(store, type = "outbox") {
+    return switchMap((users) => {
+        // Get the relays for all contacts
+        return combineLatest(users.map((contact) => {
+            // If the contact already has relays don't add any
+            if (contact.relays && contact.relays.length > 0)
+                return of(contact);
+            // Get the relays for the contact
+            return store
+                .replaceable({
+                kind: 1003,
+                pubkey: contact.pubkey,
+                relays: contact.relays,
+            })
+                .pipe(defined(), 
+            // Merge the relays into the pointer
+            map((event) => {
+                let relays = getRelaysFromContactsEvent(event);
+                if (!relays)
+                    return contact;
+                // Get the write relays
+                const urls = Array.from(relays.entries())
+                    .filter(([_, t]) => t === type || t === "all")
+                    .map(([relay]) => relay);
+                log(`Found ${urls.length} legacy ${type} relays for ${contact.pubkey}`);
+                return addRelayHintsToPointer(contact, urls);
+            }), 
+            // Timeout the request if it takes too long
+            timeout({ first: 5_000, with: () => EMPTY }), 
+            // If no event is found, return the contact
+            defaultIfEmpty(contact));
+        }));
+    });
+}
+/** Removes blacklisted relays from the user's relays */
+export function ignoreBlacklistedRelays(blacklist) {
+    return pipe(
+    // Combine with the observable so it re-emits when the blacklist changes
+    combineLatestWith(Array.isArray(blacklist) ? of(blacklist) : blacklist), 
+    // Filter the relays for the user
+    map(([users, blacklist]) => users.map((user) => {
+        if (!user.relays)
+            return user;
+        return { ...user, relays: user.relays.filter((relay) => !blacklist.includes(relay)) };
+    })));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-core",
-  "version": "0.0.0-next-20250916134023",
+  "version": "0.0.0-next-20250918142212",
   "description": "",
   "type": "module",
   "main": "dist/index.js",