applesauce-core 3.0.1 → 4.0.0

package/dist/helpers/profile.d.ts

@@ -1,4 +1,5 @@
-import { NostrEvent } from "nostr-tools";
+import { kinds, NostrEvent } from "nostr-tools";
+import { KnownEvent } from "./index.js";
 export declare const ProfileContentSymbol: unique symbol;
 export type ProfileContent = {
     name?: string;
@@ -17,10 +18,13 @@ export type ProfileContent = {
     lud06?: string;
     nip05?: string;
 };
+/** Type for validated profile events */
+export type ProfileEvent = KnownEvent<kinds.Metadata>;
 /** Returns the parsed profile content for a kind 0 event */
-export declare function getProfileContent(event: NostrEvent): ProfileContent;
+export declare function getProfileContent(event: ProfileEvent): ProfileContent;
+export declare function getProfileContent(event: NostrEvent): ProfileContent | undefined;
 /** Checks if the content of the kind 0 event is valid JSON */
-export declare function isValidProfile(profile?: NostrEvent): boolean;
+export declare function isValidProfile(profile?: NostrEvent): profile is ProfileEvent;
 /** Gets the profile picture from a nostr event or profile content with fallback */
 export declare function getProfilePicture(metadata: ProfileContent | NostrEvent | undefined): string | undefined;
 export declare function getProfilePicture(metadata: ProfileContent | NostrEvent | undefined, fallback: string): string;

package/dist/helpers/profile.js

@@ -1,11 +1,13 @@
 import { kinds } from "nostr-tools";
 import { npubEncode } from "nostr-tools/nip19";
 import { getOrComputeCachedValue } from "./cache.js";
+import { safeParse } from "./index.js";
 export const ProfileContentSymbol = Symbol.for("profile-content");
-/** Returns the parsed profile content for a kind 0 event */
 export function getProfileContent(event) {
     return getOrComputeCachedValue(event, ProfileContentSymbol, () => {
-        const profile = JSON.parse(event.content);
+        const profile = safeParse(event.content);
+        if (!profile)
+            return undefined;
         // ensure nip05 is a string
         if (profile.nip05 && typeof profile.nip05 !== "string")
             profile.nip05 = String(profile.nip05);
@@ -22,13 +24,10 @@ export function isValidProfile(profile) {
         return false;
     if (profile.kind !== kinds.Metadata && profile.kind !== kinds.Handlerinformation)
         return false;
-    try {
-        getProfileContent(profile);
-        return true;
-    }
-    catch (error) {
+    // Check if the profile content is valid
+    if (!getProfileContent(profile))
         return false;
-    }
+    return true;
 }
 export function getProfilePicture(metadata, fallback) {
     if (!metadata)

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

@@ -0,0 +1,13 @@
+import { ProfilePointer } from "nostr-tools/nip19";
+export type SelectOptimalRelaysOptions = {
+    /** Maximum number of connections (relays) to select */
+    maxConnections: number;
+    /** Cap the number of relays a user can have */
+    maxRelaysPerUser?: number;
+};
+/** Selects the optimal relays for a list of ProfilePointers */
+export declare function selectOptimalRelays(users: ProfilePointer[], { maxConnections, maxRelaysPerUser }: SelectOptimalRelaysOptions): ProfilePointer[];
+/** A map of pubkeys by relay */
+export type OutboxMap = Record<string, ProfilePointer[]>;
+/** 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,84 @@
+/** Selects the optimal relays for a list of ProfilePointers */
+export function selectOptimalRelays(users, { maxConnections, maxRelaysPerUser }) {
+    const usersWithRelays = users.filter((user) => user.relays && user.relays.length > 0);
+    // create map of popular relays
+    const popular = new Map();
+    for (const user of usersWithRelays) {
+        if (!user.relays)
+            continue;
+        for (const relay of user.relays)
+            popular.set(relay, (popular.get(relay) || 0) + 1);
+    }
+    // sort users relays by popularity
+    for (const user of usersWithRelays) {
+        if (!user.relays)
+            continue;
+        user.relays = Array.from(user.relays).sort((a, b) => popular.get(b) - popular.get(a));
+    }
+    // Create a pool of users to calculate relay coverage from
+    let selectionPool = Array.from(usersWithRelays);
+    // Create map of times a users relay has been selected
+    const selectionCount = new Map();
+    let selection = new Set();
+    while (selectionPool.length > 0 && selection.size < maxConnections) {
+        // Create map of number of pool users per relay
+        const relayUserCount = new Map();
+        for (const user of selectionPool) {
+            if (!user.relays)
+                continue;
+            for (const relay of user.relays) {
+                // Skip relays that are already selected
+                if (selection.has(relay))
+                    continue;
+                // Increment relay user count
+                relayUserCount.set(relay, (relayUserCount.get(relay) || 0) + 1);
+            }
+        }
+        // Sort relays by coverage
+        const byCoverage = Array.from(relayUserCount.entries()).sort((a, b) => b[1] - a[1]);
+        // No more relays to select, exit loop
+        if (byCoverage.length === 0)
+            break;
+        // Pick the most popular relay
+        const relay = byCoverage[0][0];
+        // Add relay to selection
+        selection.add(relay);
+        // Increment user relay count and remove users over the limit
+        selectionPool = selectionPool.filter((user) => {
+            // Ignore users that don't have the relay
+            if (!user.relays || !user.relays.includes(relay))
+                return true;
+            // Increment user relay count
+            let count = selectionCount.get(relay) || 0;
+            selectionCount.set(relay, count++);
+            // Remove user if they their relay has been selected more than minRelaysPerUser times
+            if (count >= 1)
+                return false;
+            return true;
+        });
+    }
+    // Take the original users and only include relays that where selected
+    return users.map((user) => ({
+        ...user,
+        relays: maxRelaysPerUser
+            ? user.relays
+                ?.filter((relay) => selection.has(relay))
+                .sort((a, b) => (popular.get(a) ?? 0) - (popular.get(b) ?? 0))
+                .slice(0, maxRelaysPerUser)
+            : user.relays?.filter((relay) => selection.has(relay)),
+    }));
+}
+/** 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] = [];
+            outbox[relay].push(pointer);
+        }
+    }
+    return outbox;
+}

package/dist/helpers/relays.d.ts

@@ -12,4 +12,6 @@ export declare function getSeenRelays(event: NostrEvent): Set<string> | undefine
 /** A fast check to make sure relay hints are safe to connect to */
 export declare function isSafeRelayURL(relay: string): boolean;
 /** Merge multiple sets of relays and remove duplicates (ignores invalid URLs) */
-export declare function mergeRelaySets(...sources: (Iterable<string> | undefined)[]): string[];
+export declare function mergeRelaySets(...sources: (Iterable<string> | string | undefined)[]): string[];
+/** Alias for {@link mergeRelaySets} */
+export declare const relaySet: typeof mergeRelaySets;

package/dist/helpers/relays.js

@@ -23,9 +23,10 @@ export function mergeRelaySets(...sources) {
     for (const src of sources) {
         if (!src)
             continue;
-        for (const url of src) {
+        if (typeof src === "string") {
+            // Source is a string
             try {
-                const safe = normalizeURL(url).toString();
+                const safe = normalizeURL(src).toString();
                 if (safe)
                     set.add(safe);
             }
@@ -33,6 +34,21 @@ export function mergeRelaySets(...sources) {
                 // failed to parse URL, ignore
             }
         }
+        else {
+            // Source is iterable
+            for (const url of src) {
+                try {
+                    const safe = normalizeURL(url).toString();
+                    if (safe)
+                        set.add(safe);
+                }
+                catch (error) {
+                    // failed to parse URL, ignore
+                }
+            }
+        }
     }
     return Array.from(set);
 }
+/** Alias for {@link mergeRelaySets} */
+export const relaySet = mergeRelaySets;

package/dist/helpers/url.js

@@ -78,13 +78,13 @@ export function ensureHttpURL(url) {
  */
 export function normalizeURL(url) {
     let p = new URL(url);
-    // remove any double slashes
+    // Remove any double slashes
     p.pathname = p.pathname.replace(/\/+/g, "/");
-    // drop the port if its not needed
+    // Remove the port if its not needed
     if ((p.port === "80" && (p.protocol === "ws:" || p.protocol === "http:")) ||
         (p.port === "443" && (p.protocol === "wss:" || p.protocol === "https:")))
         p.port = "";
-    // return a string if a string was passed in
+    // Return a string if a string was passed in
     // @ts-expect-error
     return typeof url === "string" ? p.toString() : p;
 }

package/dist/helpers/wrapped-messages.d.ts

@@ -1,5 +1,14 @@
 import { Rumor } from "./gift-wraps.js";
-/** Returns the subject of a warpped direct message */
+/** Returns the subject of a wrapped direct message */
 export declare function getWrappedMessageSubject(message: Rumor): string | undefined;
 /** Returns the parent id of a wrapped direct message */
 export declare function getWrappedMessageParent(message: Rumor): string | undefined;
+/** Returns the sender of a wrapped direct message */
+export declare function getWrappedMessageSender(message: Rumor): string;
+/** @deprecated use {@link getWrappedMessageSender} instead */
+export declare const getWrappedMesssageSender: typeof getWrappedMessageSender;
+/**
+ * Returns the first participant in a conversation that is not the sender
+ * @see getConversationParticipants
+ */
+export declare function getWrappedMessageReceiver(message: Rumor): string;

package/dist/helpers/wrapped-messages.js

@@ -1,5 +1,5 @@
-import { getTagValue } from "./index.js";
-/** Returns the subject of a warpped direct message */
+import { getConversationParticipants, getTagValue } from "./index.js";
+/** Returns the subject of a wrapped direct message */
 export function getWrappedMessageSubject(message) {
     return getTagValue(message, "subject");
 }
@@ -7,3 +7,16 @@ export function getWrappedMessageSubject(message) {
 export function getWrappedMessageParent(message) {
     return getTagValue(message, "e");
 }
+/** Returns the sender of a wrapped direct message */
+export function getWrappedMessageSender(message) {
+    return message.pubkey;
+}
+/** @deprecated use {@link getWrappedMessageSender} instead */
+export const getWrappedMesssageSender = getWrappedMessageSender;
+/**
+ * Returns the first participant in a conversation that is not the sender
+ * @see getConversationParticipants
+ */
+export function getWrappedMessageReceiver(message) {
+    return getConversationParticipants(message).filter((p) => p !== message.pubkey)[0];
+}

package/dist/helpers/zap.d.ts

@@ -1,6 +1,7 @@
-import { NostrEvent } from "nostr-tools";
+import { kinds, NostrEvent } from "nostr-tools";
 import { AddressPointer, EventPointer } from "nostr-tools/nip19";
 import { ParsedInvoice } from "./bolt11.js";
+import { KnownEvent } from "./index.js";
 export declare const ZapRequestSymbol: unique symbol;
 export declare const ZapSenderSymbol: unique symbol;
 export declare const ZapReceiverSymbol: unique symbol;
@@ -8,30 +9,31 @@ export declare const ZapInvoiceSymbol: unique symbol;
 export declare const ZapEventPointerSymbol: unique symbol;
 export declare const ZapAddressPointerSymbol: unique symbol;
 /** Returns the senders pubkey */
-export declare function getZapSender(zap: NostrEvent): string;
-/**
- * Gets the receivers pubkey
- * @throws
- */
-export declare function getZapRecipient(zap: NostrEvent): string;
+export declare function getZapSender(zap: KnownEvent<kinds.Zap>): string;
+export declare function getZapSender(zap: NostrEvent): string | undefined;
+/** Gets the receivers pubkey */
+export declare function getZapRecipient(zap: KnownEvent<kinds.Zap>): string;
+export declare function getZapRecipient(zap: NostrEvent): string | undefined;
 /** Returns the parsed bolt11 invoice */
+export declare function getZapPayment(zap: KnownEvent<kinds.Zap>): ParsedInvoice;
 export declare function getZapPayment(zap: NostrEvent): ParsedInvoice | undefined;
+/** Returns the zap event amount in msats */
+export declare function getZapAmount(zap: KnownEvent<kinds.Zap>): number;
+export declare function getZapAmount(zap: NostrEvent): number | undefined;
 /** Gets the AddressPointer that was zapped */
 export declare function getZapAddressPointer(zap: NostrEvent): AddressPointer | null;
 /** Gets the EventPointer that was zapped */
 export declare function getZapEventPointer(zap: NostrEvent): EventPointer | null;
 /** Gets the preimage for the bolt11 invoice */
 export declare function getZapPreimage(zap: NostrEvent): string | undefined;
+/** Returns the zap request event inside the zap receipt */
+export declare function getZapRequest(zap: KnownEvent<kinds.Zap>): NostrEvent;
+export declare function getZapRequest(zap: NostrEvent): NostrEvent | undefined;
 /**
- * Returns the zap request event inside the zap receipt
- * @throws
- */
-export declare function getZapRequest(zap: NostrEvent): NostrEvent;
-/**
- * Checks if the zap is valid
+ * Checks if a zap event is valid (not missing fields)
  * DOES NOT validate LNURL address
  */
-export declare function isValidZap(zap?: NostrEvent): boolean;
+export declare function isValidZap(zap?: NostrEvent): zap is KnownEvent<kinds.Zap>;
 export type ZapSplit = {
     pubkey: string;
     percent: number;

package/dist/helpers/zap.js

@@ -10,31 +10,25 @@ export const ZapReceiverSymbol = Symbol.for("zap-receiver");
 export const ZapInvoiceSymbol = Symbol.for("zap-bolt11");
 export const ZapEventPointerSymbol = Symbol.for("zap-event-pointer");
 export const ZapAddressPointerSymbol = Symbol.for("zap-address-pointer");
-/** Returns the senders pubkey */
 export function getZapSender(zap) {
     return getOrComputeCachedValue(zap, ZapSenderSymbol, () => {
-        return getTagValue(zap, "P") || getZapRequest(zap).pubkey;
+        return getTagValue(zap, "P") || getZapRequest(zap)?.pubkey;
     });
 }
-/**
- * Gets the receivers pubkey
- * @throws
- */
 export function getZapRecipient(zap) {
     return getOrComputeCachedValue(zap, ZapReceiverSymbol, () => {
-        const recipient = getTagValue(zap, "p");
-        if (!recipient)
-            throw new Error("Missing recipient");
-        return recipient;
+        return getTagValue(zap, "p");
     });
 }
-/** Returns the parsed bolt11 invoice */
 export function getZapPayment(zap) {
     return getOrComputeCachedValue(zap, ZapInvoiceSymbol, () => {
         const bolt11 = getTagValue(zap, "bolt11");
         return bolt11 ? parseBolt11(bolt11) : undefined;
     });
 }
+export function getZapAmount(zap) {
+    return getZapPayment(zap)?.amount;
+}
 /** Gets the AddressPointer that was zapped */
 export function getZapAddressPointer(zap) {
     return getOrComputeCachedValue(zap, ZapAddressPointerSymbol, () => {
@@ -53,23 +47,25 @@ export function getZapEventPointer(zap) {
 export function getZapPreimage(zap) {
     return getTagValue(zap, "preimage");
 }
-/**
- * Returns the zap request event inside the zap receipt
- * @throws
- */
 export function getZapRequest(zap) {
     return getOrComputeCachedValue(zap, ZapRequestSymbol, () => {
         const description = getTagValue(zap, "description");
         if (!description)
-            throw new Error("Missing description tag");
-        const error = nip57.validateZapRequest(description);
-        if (error)
-            throw new Error(error);
-        return JSON.parse(description);
+            return;
+        // Attempt to parse the zap request
+        try {
+            const error = nip57.validateZapRequest(description);
+            if (error)
+                return;
+            return JSON.parse(description);
+        }
+        catch (error) {
+            return undefined;
+        }
     });
 }
 /**
- * Checks if the zap is valid
+ * Checks if a zap event is valid (not missing fields)
  * DOES NOT validate LNURL address
  */
 export function isValidZap(zap) {
@@ -77,14 +73,16 @@ export function isValidZap(zap) {
         return false;
     if (zap.kind !== kinds.Zap)
         return false;
-    try {
-        getZapRequest(zap);
-        getZapRecipient(zap);
-        return true;
-    }
-    catch (error) {
+    // Is not a valid zap kind if any of these is undefined
+    if (getZapPayment(zap) === undefined)
         return false;
-    }
+    if (getZapRequest(zap) === undefined)
+        return false;
+    if (getZapRecipient(zap) === undefined)
+        return false;
+    if (getZapSender(zap) === undefined)
+        return false;
+    return true;
 }
 /** Returns the zap splits for an event */
 export function getZapSplits(event) {

package/dist/models/common.d.ts

@@ -1,13 +1,13 @@
 import { Filter, NostrEvent } from "nostr-tools";
 import { AddressPointer, EventPointer } from "nostr-tools/nip19";
-import { Model } from "../event-store/interface.js";
+import { IAsyncEventStore, IEventStore, Model } from "../event-store/interface.js";
 import { AddressPointerWithoutD } from "../helpers/index.js";
 /** A model that returns a single event or undefined when its removed */
-export declare function EventModel(pointer: string | EventPointer): Model<NostrEvent | undefined>;
+export declare function EventModel(pointer: string | EventPointer): Model<NostrEvent | undefined, IEventStore | IAsyncEventStore>;
 /** A model that returns the latest version of a replaceable event or undefined if its removed */
-export declare function ReplaceableModel(pointer: AddressPointer | AddressPointerWithoutD): Model<NostrEvent | undefined>;
+export declare function ReplaceableModel(pointer: AddressPointer | AddressPointerWithoutD): Model<NostrEvent | undefined, IEventStore | IAsyncEventStore>;
 /** A model that returns an array of sorted events matching the filters */
-export declare function TimelineModel(filters: Filter | Filter[], includeOldVersion?: boolean): Model<NostrEvent[]>;
+export declare function TimelineModel(filters: Filter | Filter[], includeOldVersion?: boolean): Model<NostrEvent[], IEventStore | IAsyncEventStore>;
 /**
  * A model that returns a multiple events in a map
  * @deprecated use multiple {@link EventModel} instead

package/dist/models/common.js

@@ -1,30 +1,73 @@
-import { combineLatest, defer, distinctUntilChanged, EMPTY, endWith, filter, finalize, from, map, merge, mergeWith, of, repeat, scan, takeUntil, tap, } from "rxjs";
+import { combineLatest, defer, distinctUntilChanged, EMPTY, endWith, filter, finalize, from, ignoreElements, map, merge, mergeWith, of, repeat, scan, switchMap, take, takeUntil, tap, } from "rxjs";
 import { insertEventIntoDescendingList } from "nostr-tools/utils";
 import { createReplaceableAddress, getEventUID, getReplaceableIdentifier, isReplaceable, matchFilters, } from "../helpers/index.js";
 import { claimEvents } from "../observable/claim-events.js";
 import { claimLatest } from "../observable/claim-latest.js";
+import { defined } from "../observable/defined.js";
 import { withImmediateValueOrDefault } from "../observable/with-immediate-value.js";
+/** Gets a single event from both types of event stores and returns an observable that completes */
+function getEventFromStores(store, pointer) {
+    const r = store.getEvent(pointer.id);
+    if (r instanceof Promise)
+        return from(r);
+    else
+        return of(r);
+}
+/** Gets a single replaceable event from both types of event stores and returns an observable that completes */
+function getReplaceableFromStores(store, pointer) {
+    const r = store.getReplaceable(pointer.kind, pointer.pubkey, pointer.identifier);
+    if (r instanceof Promise)
+        return from(r);
+    else
+        return of(r);
+}
+/** If event is undefined, attempt to load using the fallback loader */
+function loadEventUsingFallback(store, pointer) {
+    return switchMap((event) => {
+        if (event)
+            return of(event);
+        // If event was not found, attempt to load
+        if (!store.eventLoader)
+            return EMPTY;
+        return from(store.eventLoader(pointer));
+    });
+}
+/** If replaceable event is undefined, attempt to load using the fallback loader */
+function loadReplaceableUsingFallback(store, pointer) {
+    return switchMap((event) => {
+        if (event)
+            return of(event);
+        else if (pointer.identifier !== undefined) {
+            if (!store.addressableLoader)
+                return EMPTY;
+            return from(store.addressableLoader(pointer)).pipe(filter((e) => !!e));
+        }
+        else {
+            if (!store.replaceableLoader)
+                return EMPTY;
+            return from(store.replaceableLoader(pointer)).pipe(filter((e) => !!e));
+        }
+    });
+}
 /** A model that returns a single event or undefined when its removed */
 export function EventModel(pointer) {
     if (typeof pointer === "string")
         pointer = { id: pointer };
-    return (events) => merge(
+    return (store) => merge(
     // get current event and ignore if there is none
-    defer(() => {
-        let event = events.getEvent(pointer.id);
-        if (event)
-            return of(event);
-        // If there is a loader, use it to get the event
-        if (!events.eventLoader)
-            return EMPTY;
-        return from(events.eventLoader(pointer)).pipe(filter((e) => !!e));
-    }), 
+    defer(() => getEventFromStores(store, pointer)).pipe(
+    // If the event isn't found, attempt to load using the fallback loader
+    loadEventUsingFallback(store, pointer), 
+    // Only emit found events
+    defined()), 
     // Listen for new events
-    events.insert$.pipe(filter((e) => e.id === pointer.id)), 
+    store.insert$.pipe(filter((e) => e.id === pointer.id)), 
     // emit undefined when deleted
-    events.removed(pointer.id).pipe(endWith(undefined))).pipe(
+    store.remove$.pipe(filter((e) => e.id === pointer.id), take(1), ignoreElements(), 
+    // Emit undefined when deleted
+    endWith(undefined))).pipe(
     // claim all events
-    claimLatest(events), 
+    claimLatest(store), 
     // ignore duplicate events
     distinctUntilChanged((a, b) => a?.id === b?.id), 
     // always emit undefined so the observable is synchronous
@@ -32,27 +75,17 @@ export function EventModel(pointer) {
 }
 /** A model that returns the latest version of a replaceable event or undefined if its removed */
 export function ReplaceableModel(pointer) {
-    return (events) => {
+    return (store) => {
         let current = undefined;
         return merge(
         // lazily get current event
-        defer(() => {
-            let event = events.getReplaceable(pointer.kind, pointer.pubkey, pointer.identifier);
-            if (event)
-                return of(event);
-            else if (pointer.identifier !== undefined) {
-                if (!events.addressableLoader)
-                    return EMPTY;
-                return from(events.addressableLoader(pointer)).pipe(filter((e) => !!e));
-            }
-            else {
-                if (!events.replaceableLoader)
-                    return EMPTY;
-                return from(events.replaceableLoader(pointer)).pipe(filter((e) => !!e));
-            }
-        }), 
-        // subscribe to new events
-        events.insert$.pipe(filter((e) => e.pubkey == pointer.pubkey &&
+        defer(() => getReplaceableFromStores(store, pointer)).pipe(
+        // If the event isn't found, attempt to load using the fallback loader
+        loadReplaceableUsingFallback(store, pointer), 
+        // Only emit found events
+        defined()), 
+        // Subscribe to new events that match the pointer
+        store.insert$.pipe(filter((e) => e.pubkey == pointer.pubkey &&
             e.kind === pointer.kind &&
             (pointer.identifier !== undefined ? getReplaceableIdentifier(e) === pointer.identifier : true)))).pipe(
         // only update if event is newer
@@ -63,13 +96,13 @@ export function ReplaceableModel(pointer) {
         // Hacky way to extract the current event so takeUntil can access it
         tap((event) => (current = event)), 
         // complete when event is removed
-        takeUntil(events.remove$.pipe(filter((e) => e.id === current?.id))), 
+        takeUntil(store.remove$.pipe(filter((e) => e.id === current?.id))), 
         // emit undefined when removed
         endWith(undefined), 
         // keep the observable hot
         repeat(), 
         // claim latest event
-        claimLatest(events), 
+        claimLatest(store), 
         // always emit undefined so the observable is synchronous
         withImmediateValueOrDefault(undefined));
     };
@@ -77,18 +110,24 @@ export function ReplaceableModel(pointer) {
 /** A model that returns an array of sorted events matching the filters */
 export function TimelineModel(filters, includeOldVersion) {
     filters = Array.isArray(filters) ? filters : [filters];
-    return (events) => {
+    return (store) => {
         const seen = new Map();
         // get current events
-        return defer(() => of(Array.from(events.getTimeline(filters)))).pipe(
+        return defer(() => {
+            const r = store.getTimeline(filters);
+            if (r instanceof Promise)
+                return from(r);
+            else
+                return of(r);
+        }).pipe(
         // claim existing events
-        claimEvents(events), 
+        claimEvents(store), 
         // subscribe to newer events
-        mergeWith(events.insert$.pipe(filter((e) => matchFilters(filters, e)), 
+        mergeWith(store.insert$.pipe(filter((e) => matchFilters(filters, e)), 
         // claim all new events
-        claimEvents(events))), 
+        claimEvents(store))), 
         // subscribe to delete events
-        mergeWith(events.remove$.pipe(filter((e) => matchFilters(filters, e)), map((e) => e.id))), 
+        mergeWith(store.remove$.pipe(filter((e) => matchFilters(filters, e)), map((e) => e.id))), 
         // build a timeline
         scan((timeline, event) => {
             // filter out removed events from timeline

package/dist/models/gift-wrap.d.ts

@@ -2,6 +2,6 @@ import { NostrEvent } from "nostr-tools";
 import { Model } from "../event-store/interface.js";
 import { Rumor } from "../helpers/gift-wraps.js";
 /** A model that returns all gift wrap events for a pubkey, optionally filtered by locked status */
-export declare function GiftWrapsModel(pubkey: string, locked?: boolean): Model<NostrEvent[]>;
+export declare function GiftWrapsModel(pubkey: string, unlocked?: boolean): Model<NostrEvent[]>;
 /** A model that returns the rumor event of a gift wrap event when its unlocked */
 export declare function GiftWrapRumorModel(gift: NostrEvent | string): Model<Rumor | undefined>;

package/dist/models/gift-wrap.js

@@ -1,14 +1,14 @@
 import { kinds } from "nostr-tools";
 import { identity, map, of } from "rxjs";
-import { getGiftWrapRumor, isGiftWrapLocked } from "../helpers/gift-wraps.js";
+import { getGiftWrapRumor, isGiftWrapUnlocked } from "../helpers/gift-wraps.js";
 import { watchEventsUpdates, watchEventUpdates } from "../observable/watch-event-updates.js";
 /** A model that returns all gift wrap events for a pubkey, optionally filtered by locked status */
-export function GiftWrapsModel(pubkey, locked) {
+export function GiftWrapsModel(pubkey, unlocked) {
     return (store) => store.timeline({ kinds: [kinds.GiftWrap], "#p": [pubkey] }).pipe(
     // Update the timeline when events are updated
     watchEventsUpdates(store), 
-    // If lock is specified filter on locked status
-    locked !== undefined ? map((events) => events.filter((e) => isGiftWrapLocked(e) === locked)) : identity);
+    // If unlock is specified filter on unlocked status
+    unlocked !== undefined ? map((events) => events.filter((e) => isGiftWrapUnlocked(e) === unlocked)) : identity);
 }
 /** A model that returns the rumor event of a gift wrap event when its unlocked */
 export function GiftWrapRumorModel(gift) {

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/legacy-messages.d.ts

@@ -7,8 +7,8 @@ export declare function LegacyMessagesGroups(self: string): Model<{
     lastMessage: NostrEvent;
 }[]>;
 /** Returns all legacy direct messages in a group */
-export declare function LegacyMessagesGroup(self: string, corraspondant: string): Model<NostrEvent[]>;
+export declare function LegacyMessagesGroup(self: string, correspondent: string): Model<NostrEvent[]>;
 /** Returns an array of legacy messages that have replies */
-export declare function LegacyMessageThreads(self: string, corraspondant: string): Model<NostrEvent[]>;
+export declare function LegacyMessageThreads(self: string, correspondent: string): Model<NostrEvent[]>;
 /** Returns all the legacy direct messages that are replies to a given message */
 export declare function LegacyMessageReplies(self: string, message: NostrEvent): Model<NostrEvent[]>;