applesauce-core 0.0.0-next-20250913205403 → 0.0.0-next-20250916120818

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

@@ -2,6 +2,7 @@ import { Filter, NostrEvent } from "nostr-tools";
 import { AddressPointer, EventPointer } from "nostr-tools/nip19";
 import { Observable, Subject } from "rxjs";
 import { AddressPointerWithoutD } from "../helpers/pointers.js";
+import { EventMemory } from "./event-memory.js";
 import { IAsyncEventDatabase, IAsyncEventStore } from "./interface.js";
 declare const AsyncEventStore_base: {
     new (...args: any[]): {
@@ -39,6 +40,8 @@ declare const AsyncEventStore_base: {
 /** An async wrapper around an async event database that handles replaceable events, deletes, and models */
 export declare class AsyncEventStore extends AsyncEventStore_base implements IAsyncEventStore {
     database: IAsyncEventDatabase;
+    /** Optional memory database for ensuring single event instances */
+    memory?: EventMemory;
     /** Enable this to keep old versions of replaceable events */
     keepOldVersions: boolean;
     /** Enable this to keep expired events */
@@ -70,6 +73,8 @@ export declare class AsyncEventStore extends AsyncEventStore_base implements IAs
      */
     addressableLoader?: (pointer: AddressPointer) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
     constructor(database: IAsyncEventDatabase);
+    /** A method to add all events to memory to ensure there is only ever a single instance of an event */
+    private mapToMemory;
     protected deletedIds: Set<string>;
     protected deletedCoords: Map<string, number>;
     protected checkDeleted(event: string | NostrEvent): boolean;
@@ -93,12 +98,6 @@ export declare class AsyncEventStore extends AsyncEventStore_base implements IAs
     remove(event: string | NostrEvent): Promise<boolean>;
     /** Add an event to the store and notifies all subscribes it has updated */
     update(event: NostrEvent): Promise<void>;
-    /** Passthrough method for the database.touch */
-    touch(event: NostrEvent): Promise<void>;
-    /** Pass through method for the database.unclaimed */
-    unclaimed(): AsyncGenerator<NostrEvent>;
-    /** Removes any event that is not being used by a subscription */
-    prune(limit?: number): Promise<number>;
     /** Check if the store has an event by id */
     hasEvent(id: string): Promise<boolean>;
     /** Get an event by id from the store */
@@ -110,17 +109,23 @@ export declare class AsyncEventStore extends AsyncEventStore_base implements IAs
     /** Returns all versions of a replaceable event */
     getReplaceableHistory(kind: number, pubkey: string, identifier?: string): Promise<NostrEvent[] | undefined>;
     /** Get all events matching a filter */
-    getByFilters(filters: Filter | Filter[]): Promise<Set<NostrEvent>>;
+    getByFilters(filters: Filter | Filter[]): Promise<NostrEvent[]>;
     /** Returns a timeline of events that match filters */
     getTimeline(filters: Filter | Filter[]): Promise<NostrEvent[]>;
+    /** Passthrough method for the database.touch */
+    touch(event: NostrEvent): void | undefined;
     /** Sets the claim on the event and touches it */
-    claim(event: NostrEvent, claim: any): Promise<void>;
+    claim(event: NostrEvent, claim: any): void;
     /** Checks if an event is claimed by anything */
-    isClaimed(event: NostrEvent): Promise<boolean>;
+    isClaimed(event: NostrEvent): boolean;
     /** Removes a claim from an event */
-    removeClaim(event: NostrEvent, claim: any): Promise<void>;
+    removeClaim(event: NostrEvent, claim: any): void;
     /** Removes all claims on an event */
-    clearClaim(event: NostrEvent): Promise<void>;
+    clearClaim(event: NostrEvent): void;
+    /** Pass through method for the database.unclaimed */
+    unclaimed(): Generator<NostrEvent>;
+    /** Removes any event that is not being used by a subscription */
+    prune(limit?: number): number;
     /** Returns an observable that completes when an event is removed */
     removed(id: string): Observable<never>;
     /** Creates an observable that emits when event is updated */

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

@@ -7,12 +7,14 @@ import { getExpirationTimestamp } from "../helpers/expiration.js";
 import { parseCoordinate } from "../helpers/pointers.js";
 import { addSeenRelay, getSeenRelays } from "../helpers/relays.js";
 import { unixNow } from "../helpers/time.js";
-// Import common models
+import { EventMemory } from "./event-memory.js";
 import { EventStoreModelMixin } from "./model-mixin.js";
 /** An async wrapper around an async event database that handles replaceable events, deletes, and models */
 export class AsyncEventStore extends EventStoreModelMixin(class {
 }) {
     database;
+    /** Optional memory database for ensuring single event instances */
+    memory;
     /** Enable this to keep old versions of replaceable events */
     keepOldVersions = false;
     /** Enable this to keep expired events */
@@ -46,6 +48,7 @@ export class AsyncEventStore extends EventStoreModelMixin(class {
     constructor(database) {
         super();
         this.database = database;
+        this.memory = new EventMemory();
         // when events are added to the database, add the symbol
         this.insert$.subscribe((event) => {
             Reflect.set(event, EventStoreSymbol, this);
@@ -55,6 +58,13 @@ export class AsyncEventStore extends EventStoreModelMixin(class {
             Reflect.deleteProperty(event, EventStoreSymbol);
         });
     }
+    mapToMemory(event) {
+        if (event === undefined)
+            return undefined;
+        if (!this.memory)
+            return event;
+        return this.memory.add(event);
+    }
     // delete state
     deletedIds = new Set();
     deletedCoords = new Map();
@@ -176,22 +186,22 @@ export class AsyncEventStore extends EventStoreModelMixin(class {
                 return existing[0];
             }
         }
-        else if (await this.database.hasEvent(event.id)) {
-            // Duplicate event, copy symbols and return existing event
-            const existing = await this.database.getEvent(event.id);
-            if (existing) {
-                AsyncEventStore.mergeDuplicateEvent(event, existing);
-                return existing;
-            }
-        }
         // Verify event before inserting into the database
         if (this.verifyEvent && this.verifyEvent(event) === false)
             return null;
+        // Always add event to memory
+        const existing = this.memory?.add(event);
+        // If the memory returned a different instance, this is a duplicate event
+        if (existing && existing !== event) {
+            // Copy cached symbols and return existing event
+            AsyncEventStore.mergeDuplicateEvent(event, existing);
+            // attach relay this event was from
+            if (fromRelay)
+                addSeenRelay(existing, fromRelay);
+            return existing;
+        }
         // Insert event into database
-        const inserted = await this.database.add(event);
-        // If the event was ignored, return null
-        if (inserted === null)
-            return null;
+        const inserted = this.mapToMemory(await this.database.add(event));
         // Copy cached data if its a duplicate event
         if (event !== inserted)
             AsyncEventStore.mergeDuplicateEvent(event, inserted);
@@ -225,6 +235,9 @@ export class AsyncEventStore extends EventStoreModelMixin(class {
         const e = await this.database.getEvent(typeof event === "string" ? event : event.id);
         if (!e)
             return false;
+        // Remove from memory if available
+        if (this.memory)
+            this.memory.remove(typeof event === "string" ? event : event.id);
         const removed = await this.database.remove(event);
         if (removed && e)
             this.remove$.next(e);
@@ -236,72 +249,85 @@ export class AsyncEventStore extends EventStoreModelMixin(class {
         const e = await this.database.add(event);
         if (!e)
             return;
-        await this.database.update(event);
+        // Notify the database that the event has updated
+        this.database.update?.(event);
         this.update$.next(event);
     }
-    /** Passthrough method for the database.touch */
-    async touch(event) {
-        return await this.database.touch(event);
-    }
-    /** Pass through method for the database.unclaimed */
-    unclaimed() {
-        return this.database.unclaimed();
-    }
-    /** Removes any event that is not being used by a subscription */
-    async prune(limit) {
-        let removed = 0;
-        const generator = this.database.unclaimed();
-        for await (const event of generator) {
-            await this.remove(event);
-            removed++;
-            if (limit && removed >= limit)
-                break;
-        }
-        return removed;
-    }
     /** Check if the store has an event by id */
     async hasEvent(id) {
-        return await this.database.hasEvent(id);
+        // Check if the event exists in memory first, then in the database
+        return (this.memory?.hasEvent(id) ?? false) || (await this.database.hasEvent(id));
     }
     /** Get an event by id from the store */
     async getEvent(id) {
-        return await this.database.getEvent(id);
+        // Get the event from memory first, then from the database
+        return this.memory?.getEvent(id) ?? this.mapToMemory(await this.database.getEvent(id));
     }
     /** Check if the store has a replaceable event */
     async hasReplaceable(kind, pubkey, d) {
-        return await this.database.hasReplaceable(kind, pubkey, d);
+        // Check if the event exists in memory first, then in the database
+        return ((this.memory?.hasReplaceable(kind, pubkey, d) ?? false) || (await this.database.hasReplaceable(kind, pubkey, d)));
     }
     /** Gets the latest version of a replaceable event */
     async getReplaceable(kind, pubkey, identifier) {
-        return await this.database.getReplaceable(kind, pubkey, identifier);
+        // Get the event from memory first, then from the database
+        return (this.memory?.getReplaceable(kind, pubkey, identifier) ??
+            this.mapToMemory(await this.database.getReplaceable(kind, pubkey, identifier)));
     }
     /** Returns all versions of a replaceable event */
     async getReplaceableHistory(kind, pubkey, identifier) {
-        return await this.database.getReplaceableHistory(kind, pubkey, identifier);
+        // Get the events from memory first, then from the database
+        const memoryEvents = this.memory?.getReplaceableHistory(kind, pubkey, identifier);
+        if (memoryEvents)
+            return memoryEvents;
+        const dbEvents = await this.database.getReplaceableHistory(kind, pubkey, identifier);
+        return dbEvents?.map((e) => this.mapToMemory(e) ?? e);
     }
     /** Get all events matching a filter */
     async getByFilters(filters) {
-        return await this.database.getByFilters(filters);
+        // NOTE: no way to read from memory since memory won't have the full set of events
+        const events = await this.database.getByFilters(filters);
+        // Map events to memory if available for better performance
+        if (this.memory)
+            return events.map((e) => this.mapToMemory(e) ?? e);
+        else
+            return events;
     }
     /** Returns a timeline of events that match filters */
     async getTimeline(filters) {
-        return await this.database.getTimeline(filters);
+        const events = await this.database.getTimeline(filters);
+        if (this.memory)
+            return events.map((e) => this.mapToMemory(e));
+        else
+            return events;
+    }
+    /** Passthrough method for the database.touch */
+    touch(event) {
+        return this.memory?.touch(event);
     }
     /** Sets the claim on the event and touches it */
-    async claim(event, claim) {
-        return await this.database.claim(event, claim);
+    claim(event, claim) {
+        return this.memory?.claim(event, claim);
     }
     /** Checks if an event is claimed by anything */
-    async isClaimed(event) {
-        return await this.database.isClaimed(event);
+    isClaimed(event) {
+        return this.memory?.isClaimed(event) ?? false;
     }
     /** Removes a claim from an event */
-    async removeClaim(event, claim) {
-        return await this.database.removeClaim(event, claim);
+    removeClaim(event, claim) {
+        return this.memory?.removeClaim(event, claim);
     }
     /** Removes all claims on an event */
-    async clearClaim(event) {
-        return await this.database.clearClaim(event);
+    clearClaim(event) {
+        return this.memory?.clearClaim(event);
+    }
+    /** Pass through method for the database.unclaimed */
+    unclaimed() {
+        return this.memory?.unclaimed() || (function* () { })();
+    }
+    /** Removes any event that is not being used by a subscription */
+    prune(limit) {
+        return this.memory?.prune(limit) ?? 0;
     }
     /** Returns an observable that completes when an event is removed */
     removed(id) {

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

@@ -0,0 +1,74 @@
+import { Filter, NostrEvent } from "nostr-tools";
+import { LRU } from "../helpers/lru.js";
+import { IEventMemory } from "./interface.js";
+/** An in-memory database of events */
+export declare class EventMemory implements IEventMemory {
+    protected log: import("debug").Debugger;
+    /** Indexes */
+    protected kinds: Map<number, Set<import("nostr-tools").Event>>;
+    protected authors: Map<string, Set<import("nostr-tools").Event>>;
+    protected tags: LRU<Set<import("nostr-tools").Event>>;
+    protected created_at: NostrEvent[];
+    /** LRU cache of last events touched */
+    events: LRU<import("nostr-tools").Event>;
+    /** A sorted array of replaceable events by address */
+    protected replaceable: Map<string, import("nostr-tools").Event[]>;
+    /** The number of events in the event set */
+    get size(): number;
+    /** Checks if the database contains an event without touching it */
+    hasEvent(id: string): boolean;
+    /** Gets a single event based on id */
+    getEvent(id: string): NostrEvent | undefined;
+    /** Checks if the event set has a replaceable event */
+    hasReplaceable(kind: number, pubkey: string, identifier?: string): boolean;
+    /** Gets the latest replaceable event */
+    getReplaceable(kind: number, pubkey: string, identifier?: string): NostrEvent | undefined;
+    /** Gets the history of a replaceable event */
+    getReplaceableHistory(kind: number, pubkey: string, identifier?: string): NostrEvent[] | undefined;
+    /** Gets all events that match the filters */
+    getByFilters(filters: Filter | Filter[]): NostrEvent[];
+    /** Gets a timeline of events that match the filters */
+    getTimeline(filters: Filter | Filter[]): NostrEvent[];
+    /** Inserts an event into the database and notifies all subscriptions */
+    add(event: NostrEvent): NostrEvent;
+    /** Removes an event from the database and notifies all subscriptions */
+    remove(eventOrId: string | NostrEvent): boolean;
+    /** Notify the database that an event has updated */
+    update(_event: NostrEvent): void;
+    /** A weak map of events that are claimed by other things */
+    protected claims: WeakMap<import("nostr-tools").Event, any>;
+    /** Moves an event to the top of the LRU cache */
+    touch(event: NostrEvent): void;
+    /** Sets the claim on the event and touches it */
+    claim(event: NostrEvent, claim: any): void;
+    /** Checks if an event is claimed by anything */
+    isClaimed(event: NostrEvent): boolean;
+    /** Removes a claim from an event */
+    removeClaim(event: NostrEvent, claim: any): void;
+    /** Removes all claims on an event */
+    clearClaim(event: NostrEvent): void;
+    /** Returns a generator of unclaimed events in order of least used */
+    unclaimed(): Generator<NostrEvent>;
+    /** Removes events that are not claimed (free up memory) */
+    prune(limit?: number): number;
+    /** Index helper methods */
+    protected getKindIndex(kind: number): Set<import("nostr-tools").Event>;
+    protected getAuthorsIndex(author: string): Set<import("nostr-tools").Event>;
+    protected getTagIndex(tagAndValue: string): Set<import("nostr-tools").Event>;
+    /** Iterates over all events by author */
+    iterateAuthors(authors: Iterable<string>): Generator<NostrEvent>;
+    /** Iterates over all events by indexable tag and value */
+    iterateTag(tag: string, values: Iterable<string>): Generator<NostrEvent>;
+    /** Iterates over all events by kind */
+    iterateKinds(kinds: Iterable<number>): Generator<NostrEvent>;
+    /** Iterates over all events by time */
+    iterateTime(since: number | undefined, until: number | undefined): Generator<NostrEvent>;
+    /** Iterates over all events by id */
+    iterateIds(ids: Iterable<string>): Generator<NostrEvent>;
+    /** Returns all events that match the filter */
+    getEventsForFilter(filter: Filter): Set<NostrEvent>;
+    /** Returns all events that match the filters */
+    getEventsForFilters(filters: Filter[]): Set<NostrEvent>;
+    /** Resets the event set */
+    reset(): void;
+}

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

@@ -0,0 +1,349 @@
+import { binarySearch, insertEventIntoDescendingList } from "nostr-tools/utils";
+import { getIndexableTags, INDEXABLE_TAGS } from "../helpers/event-tags.js";
+import { createReplaceableAddress, isReplaceable } from "../helpers/event.js";
+import { LRU } from "../helpers/lru.js";
+import { logger } from "../logger.js";
+/** An in-memory database of events */
+export class EventMemory {
+    log = logger.extend("EventMemory");
+    /** Indexes */
+    kinds = new Map();
+    authors = new Map();
+    tags = new LRU();
+    created_at = [];
+    /** LRU cache of last events touched */
+    events = new LRU();
+    /** A sorted array of replaceable events by address */
+    replaceable = new Map();
+    /** The number of events in the event set */
+    get size() {
+        return this.events.size;
+    }
+    /** Checks if the database contains an event without touching it */
+    hasEvent(id) {
+        return this.events.has(id);
+    }
+    /** Gets a single event based on id */
+    getEvent(id) {
+        return this.events.get(id);
+    }
+    /** Checks if the event set has a replaceable event */
+    hasReplaceable(kind, pubkey, identifier) {
+        const events = this.replaceable.get(createReplaceableAddress(kind, pubkey, identifier));
+        return !!events && events.length > 0;
+    }
+    /** Gets the latest replaceable event */
+    getReplaceable(kind, pubkey, identifier) {
+        const address = createReplaceableAddress(kind, pubkey, identifier);
+        const events = this.replaceable.get(address);
+        return events?.[0];
+    }
+    /** Gets the history of a replaceable event */
+    getReplaceableHistory(kind, pubkey, identifier) {
+        const address = createReplaceableAddress(kind, pubkey, identifier);
+        return this.replaceable.get(address);
+    }
+    /** Gets all events that match the filters */
+    getByFilters(filters) {
+        return Array.from(this.getEventsForFilters(Array.isArray(filters) ? filters : [filters]));
+    }
+    /** Gets a timeline of events that match the filters */
+    getTimeline(filters) {
+        const timeline = [];
+        const events = this.getByFilters(filters);
+        for (const event of events)
+            insertEventIntoDescendingList(timeline, event);
+        return timeline;
+    }
+    /** Inserts an event into the database and notifies all subscriptions */
+    add(event) {
+        const id = event.id;
+        const current = this.events.get(id);
+        if (current)
+            return current;
+        this.events.set(id, event);
+        this.getKindIndex(event.kind).add(event);
+        this.getAuthorsIndex(event.pubkey).add(event);
+        // Add the event to the tag indexes if they exist
+        for (const tag of getIndexableTags(event)) {
+            if (this.tags.has(tag))
+                this.getTagIndex(tag).add(event);
+        }
+        // Insert into time index
+        insertEventIntoDescendingList(this.created_at, event);
+        // Insert into replaceable index
+        if (isReplaceable(event.kind)) {
+            const identifier = event.tags.find((t) => t[0] === "d")?.[1];
+            const address = createReplaceableAddress(event.kind, event.pubkey, identifier);
+            let array = this.replaceable.get(address);
+            if (!this.replaceable.has(address)) {
+                // add an empty array if there is no array
+                array = [];
+                this.replaceable.set(address, array);
+            }
+            // insert the event into the sorted array
+            insertEventIntoDescendingList(array, event);
+        }
+        return event;
+    }
+    /** Removes an event from the database and notifies all subscriptions */
+    remove(eventOrId) {
+        let event = typeof eventOrId === "string" ? this.events.get(eventOrId) : eventOrId;
+        if (!event)
+            throw new Error("Missing event");
+        const id = event.id;
+        // only remove events that are known
+        if (!this.events.has(id))
+            return false;
+        this.getAuthorsIndex(event.pubkey).delete(event);
+        this.getKindIndex(event.kind).delete(event);
+        for (const tag of getIndexableTags(event)) {
+            if (this.tags.has(tag)) {
+                this.getTagIndex(tag).delete(event);
+            }
+        }
+        // remove from created_at index
+        const i = this.created_at.indexOf(event);
+        this.created_at.splice(i, 1);
+        this.events.delete(id);
+        // remove from replaceable index
+        if (isReplaceable(event.kind)) {
+            const identifier = event.tags.find((t) => t[0] === "d")?.[1];
+            const address = createReplaceableAddress(event.kind, event.pubkey, identifier);
+            const array = this.replaceable.get(address);
+            if (array && array.includes(event)) {
+                const idx = array.indexOf(event);
+                array.splice(idx, 1);
+            }
+        }
+        // remove any claims this event has
+        this.claims.delete(event);
+        return true;
+    }
+    /** Notify the database that an event has updated */
+    update(_event) {
+        // Do nothing
+    }
+    /** A weak map of events that are claimed by other things */
+    claims = new WeakMap();
+    /** Moves an event to the top of the LRU cache */
+    touch(event) {
+        // Make sure the event is in the database before adding it to the LRU
+        if (!this.events.has(event.id))
+            return;
+        // Move to the top of the LRU
+        this.events.set(event.id, event);
+    }
+    /** Sets the claim on the event and touches it */
+    claim(event, claim) {
+        if (!this.claims.has(event)) {
+            this.claims.set(event, claim);
+        }
+        // always touch event
+        this.touch(event);
+    }
+    /** Checks if an event is claimed by anything */
+    isClaimed(event) {
+        return this.claims.has(event);
+    }
+    /** Removes a claim from an event */
+    removeClaim(event, claim) {
+        const current = this.claims.get(event);
+        if (current === claim)
+            this.claims.delete(event);
+    }
+    /** Removes all claims on an event */
+    clearClaim(event) {
+        this.claims.delete(event);
+    }
+    /** Returns a generator of unclaimed events in order of least used */
+    *unclaimed() {
+        let removed = 0;
+        let cursor = this.events.first;
+        while (cursor) {
+            const event = cursor.value;
+            if (!this.isClaimed(event))
+                yield event;
+            cursor = cursor.next;
+        }
+        return removed;
+    }
+    /** Removes events that are not claimed (free up memory) */
+    prune(limit) {
+        let removed = 0;
+        const unclaimed = this.unclaimed();
+        for (const event of unclaimed) {
+            this.remove(event);
+            removed++;
+            if (limit && removed >= limit)
+                break;
+        }
+        return removed;
+    }
+    /** Index helper methods */
+    getKindIndex(kind) {
+        if (!this.kinds.has(kind))
+            this.kinds.set(kind, new Set());
+        return this.kinds.get(kind);
+    }
+    getAuthorsIndex(author) {
+        if (!this.authors.has(author))
+            this.authors.set(author, new Set());
+        return this.authors.get(author);
+    }
+    getTagIndex(tagAndValue) {
+        if (!this.tags.has(tagAndValue)) {
+            // build new tag index from existing events
+            const events = new Set();
+            const ts = Date.now();
+            for (const event of this.events.values()) {
+                if (getIndexableTags(event).has(tagAndValue)) {
+                    events.add(event);
+                }
+            }
+            const took = Date.now() - ts;
+            if (took > 100)
+                this.log(`Built index ${tagAndValue} took ${took}ms`);
+            this.tags.set(tagAndValue, events);
+        }
+        return this.tags.get(tagAndValue);
+    }
+    /** Iterates over all events by author */
+    *iterateAuthors(authors) {
+        for (const author of authors) {
+            const events = this.authors.get(author);
+            if (events) {
+                for (const event of events)
+                    yield event;
+            }
+        }
+    }
+    /** Iterates over all events by indexable tag and value */
+    *iterateTag(tag, values) {
+        for (const value of values) {
+            const events = this.getTagIndex(tag + ":" + value);
+            if (events) {
+                for (const event of events)
+                    yield event;
+            }
+        }
+    }
+    /** Iterates over all events by kind */
+    *iterateKinds(kinds) {
+        for (const kind of kinds) {
+            const events = this.kinds.get(kind);
+            if (events) {
+                for (const event of events)
+                    yield event;
+            }
+        }
+    }
+    /** Iterates over all events by time */
+    *iterateTime(since, until) {
+        let untilIndex = 0;
+        let sinceIndex = this.created_at.length - 1;
+        let start = until
+            ? binarySearch(this.created_at, (mid) => {
+                return mid.created_at - until;
+            })
+            : undefined;
+        if (start)
+            untilIndex = start[0];
+        const end = since
+            ? binarySearch(this.created_at, (mid) => {
+                return mid.created_at - since;
+            })
+            : undefined;
+        if (end)
+            sinceIndex = end[0];
+        for (let i = untilIndex; i < sinceIndex; i++) {
+            yield this.created_at[i];
+        }
+    }
+    /** Iterates over all events by id */
+    *iterateIds(ids) {
+        for (const id of ids) {
+            if (this.events.has(id))
+                yield this.events.get(id);
+        }
+    }
+    /** Returns all events that match the filter */
+    getEventsForFilter(filter) {
+        // search is not supported, return an empty set
+        if (filter.search)
+            return new Set();
+        let first = true;
+        let events = new Set();
+        const and = (iterable) => {
+            const set = iterable instanceof Set ? iterable : new Set(iterable);
+            if (first) {
+                events = set;
+                first = false;
+            }
+            else {
+                for (const event of events) {
+                    if (!set.has(event))
+                        events.delete(event);
+                }
+            }
+            return events;
+        };
+        if (filter.ids)
+            and(this.iterateIds(filter.ids));
+        let time = null;
+        // query for time first if since is set
+        if (filter.since !== undefined) {
+            time = Array.from(this.iterateTime(filter.since, filter.until));
+            and(time);
+        }
+        for (const t of INDEXABLE_TAGS) {
+            const key = `#${t}`;
+            const values = filter[key];
+            if (values?.length)
+                and(this.iterateTag(t, values));
+        }
+        if (filter.authors)
+            and(this.iterateAuthors(filter.authors));
+        if (filter.kinds)
+            and(this.iterateKinds(filter.kinds));
+        // query for time last if only until is set
+        if (filter.since === undefined && filter.until !== undefined) {
+            time = Array.from(this.iterateTime(filter.since, filter.until));
+            and(time);
+        }
+        // if the filter queried on time and has a limit. truncate the events now
+        if (filter.limit && time) {
+            const limited = new Set();
+            for (const event of time) {
+                if (limited.size >= filter.limit)
+                    break;
+                if (events.has(event))
+                    limited.add(event);
+            }
+            return limited;
+        }
+        return events;
+    }
+    /** Returns all events that match the filters */
+    getEventsForFilters(filters) {
+        if (filters.length === 0)
+            throw new Error("No Filters");
+        let events = new Set();
+        for (const filter of filters) {
+            const filtered = this.getEventsForFilter(filter);
+            for (const event of filtered)
+                events.add(event);
+        }
+        return events;
+    }
+    /** Resets the event set */
+    reset() {
+        this.events.clear();
+        this.kinds.clear();
+        this.authors.clear();
+        this.tags.clear();
+        this.created_at = [];
+        this.replaceable.clear();
+        this.claims = new WeakMap();
+    }
+}

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

@@ -2,6 +2,7 @@ import { Filter, NostrEvent } from "nostr-tools";
 import { AddressPointer, EventPointer } from "nostr-tools/nip19";
 import { Observable, Subject } from "rxjs";
 import { AddressPointerWithoutD } from "../helpers/pointers.js";
+import { EventMemory } from "./event-memory.js";
 import { IEventDatabase, IEventStore } from "./interface.js";
 declare const EventStore_base: {
     new (...args: any[]): {
@@ -39,6 +40,8 @@ declare const EventStore_base: {
 /** A wrapper around an event database that handles replaceable events, deletes, and models */
 export declare class EventStore extends EventStore_base implements IEventStore {
     database: IEventDatabase;
+    /** Optional memory database for ensuring single event instances */
+    memory?: EventMemory;
     /** Enable this to keep old versions of replaceable events */
     keepOldVersions: boolean;
     /** Enable this to keep expired events */
@@ -70,6 +73,8 @@ export declare class EventStore extends EventStore_base implements IEventStore {
      */
     addressableLoader?: (pointer: AddressPointer) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
     constructor(database?: IEventDatabase);
+    /** A method to add all events to memory to ensure there is only ever a single instance of an event */
+    private mapToMemory;
     protected deletedIds: Set<string>;
     protected deletedCoords: Map<string, number>;
     protected checkDeleted(event: string | NostrEvent): boolean;
@@ -93,12 +98,6 @@ export declare class EventStore extends EventStore_base implements IEventStore {
     remove(event: string | NostrEvent): boolean;
     /** Add an event to the store and notifies all subscribes it has updated */
     update(event: NostrEvent): boolean;
-    /** Passthrough method for the database.touch */
-    touch(event: NostrEvent): void;
-    /** Pass through method for the database.unclaimed */
-    unclaimed(): Generator<NostrEvent>;
-    /** Removes any event that is not being used by a subscription */
-    prune(limit?: number): number;
     /** Check if the store has an event by id */
     hasEvent(id: string): boolean;
     /** Get an event by id from the store */
@@ -110,9 +109,11 @@ export declare class EventStore extends EventStore_base implements IEventStore {
     /** Returns all versions of a replaceable event */
     getReplaceableHistory(kind: number, pubkey: string, identifier?: string): NostrEvent[] | undefined;
     /** Get all events matching a filter */
-    getByFilters(filters: Filter | Filter[]): Set<NostrEvent>;
+    getByFilters(filters: Filter | Filter[]): NostrEvent[];
     /** Returns a timeline of events that match filters */
     getTimeline(filters: Filter | Filter[]): NostrEvent[];
+    /** Passthrough method for the database.touch */
+    touch(event: NostrEvent): void | undefined;
     /** Sets the claim on the event and touches it */
     claim(event: NostrEvent, claim: any): void;
     /** Checks if an event is claimed by anything */
@@ -121,6 +122,10 @@ export declare class EventStore extends EventStore_base implements IEventStore {
     removeClaim(event: NostrEvent, claim: any): void;
     /** Removes all claims on an event */
     clearClaim(event: NostrEvent): void;
+    /** Pass through method for the database.unclaimed */
+    unclaimed(): Generator<NostrEvent>;
+    /** Removes any event that is not being used by a subscription */
+    prune(limit?: number): number;
     /** Returns an observable that completes when an event is removed */
     removed(id: string): Observable<never>;
     /** Creates an observable that emits when event is updated */

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

@@ -7,13 +7,14 @@ import { getExpirationTimestamp } from "../helpers/expiration.js";
 import { parseCoordinate } from "../helpers/pointers.js";
 import { addSeenRelay, getSeenRelays } from "../helpers/relays.js";
 import { unixNow } from "../helpers/time.js";
-// Import common models
-import { InMemoryEventDatabase } from "./event-database.js";
+import { EventMemory } from "./event-memory.js";
 import { EventStoreModelMixin } from "./model-mixin.js";
 /** A wrapper around an event database that handles replaceable events, deletes, and models */
 export class EventStore extends EventStoreModelMixin(class {
 }) {
     database;
+    /** Optional memory database for ensuring single event instances */
+    memory;
     /** Enable this to keep old versions of replaceable events */
     keepOldVersions = false;
     /** Enable this to keep expired events */
@@ -44,9 +45,16 @@ export class EventStore extends EventStoreModelMixin(class {
      * @experimental
      */
     addressableLoader;
-    constructor(database = new InMemoryEventDatabase()) {
+    constructor(database = new EventMemory()) {
         super();
-        this.database = database;
+        if (database) {
+            this.database = database;
+            this.memory = new EventMemory();
+        }
+        else {
+            // If no database is provided, its the same as having a memory database
+            this.database = this.memory = new EventMemory();
+        }
         // when events are added to the database, add the symbol
         this.insert$.subscribe((event) => {
             Reflect.set(event, EventStoreSymbol, this);
@@ -56,6 +64,13 @@ export class EventStore extends EventStoreModelMixin(class {
             Reflect.deleteProperty(event, EventStoreSymbol);
         });
     }
+    mapToMemory(event) {
+        if (event === undefined)
+            return undefined;
+        if (!this.memory)
+            return event;
+        return this.memory.add(event);
+    }
     // delete state
     deletedIds = new Set();
     deletedCoords = new Map();
@@ -175,22 +190,22 @@ export class EventStore extends EventStoreModelMixin(class {
                 return existing[0];
             }
         }
-        else if (this.database.hasEvent(event.id)) {
-            // Duplicate event, copy symbols and return existing event
-            const existing = this.database.getEvent(event.id);
-            if (existing) {
-                EventStore.mergeDuplicateEvent(event, existing);
-                return existing;
-            }
-        }
         // Verify event before inserting into the database
         if (this.verifyEvent && this.verifyEvent(event) === false)
             return null;
+        // Always add event to memory
+        const existing = this.memory?.add(event);
+        // If the memory returned a different instance, this is a duplicate event
+        if (existing && existing !== event) {
+            // Copy cached symbols and return existing event
+            EventStore.mergeDuplicateEvent(event, existing);
+            // attach relay this event was from
+            if (fromRelay)
+                addSeenRelay(existing, fromRelay);
+            return existing;
+        }
         // Insert event into database
-        const inserted = this.database.add(event);
-        // If the event was ignored, return null
-        if (inserted === null)
-            return null;
+        const inserted = this.mapToMemory(this.database.add(event));
         // Copy cached data if its a duplicate event
         if (event !== inserted)
             EventStore.mergeDuplicateEvent(event, inserted);
@@ -224,6 +239,9 @@ export class EventStore extends EventStoreModelMixin(class {
         const e = this.database.getEvent(typeof event === "string" ? event : event.id);
         if (!e)
             return false;
+        // Remove from memory if available
+        if (this.memory)
+            this.memory.remove(event);
         const removed = this.database.remove(event);
         if (removed && e)
             this.remove$.next(e);
@@ -235,73 +253,83 @@ export class EventStore extends EventStoreModelMixin(class {
         const e = this.database.add(event);
         if (!e)
             return false;
-        this.database.update(event);
+        // Notify the database that the event has updated
+        this.database.update?.(event);
         this.update$.next(event);
         return true;
     }
-    /** Passthrough method for the database.touch */
-    touch(event) {
-        this.database.touch(event);
-    }
-    /** Pass through method for the database.unclaimed */
-    unclaimed() {
-        return this.database.unclaimed();
-    }
-    /** Removes any event that is not being used by a subscription */
-    prune(limit) {
-        let removed = 0;
-        const unclaimed = this.database.unclaimed();
-        for (const event of unclaimed) {
-            this.remove(event);
-            removed++;
-            if (limit && removed >= limit)
-                break;
-        }
-        return removed;
-    }
     /** Check if the store has an event by id */
     hasEvent(id) {
-        return this.database.hasEvent(id);
+        // Check if the event exists in memory first, then in the database
+        return this.memory?.hasEvent(id) || this.database.hasEvent(id);
     }
     /** Get an event by id from the store */
     getEvent(id) {
-        return this.database.getEvent(id);
+        // Get the event from memory first, then from the database
+        return this.memory?.getEvent(id) ?? this.mapToMemory(this.database.getEvent(id));
     }
     /** Check if the store has a replaceable event */
     hasReplaceable(kind, pubkey, d) {
-        return this.database.hasReplaceable(kind, pubkey, d);
+        // Check if the event exists in memory first, then in the database
+        return this.memory?.hasReplaceable(kind, pubkey, d) || this.database.hasReplaceable(kind, pubkey, d);
     }
     /** Gets the latest version of a replaceable event */
     getReplaceable(kind, pubkey, identifier) {
-        return this.database.getReplaceable(kind, pubkey, identifier);
+        // Get the event from memory first, then from the database
+        return (this.memory?.getReplaceable(kind, pubkey, identifier) ??
+            this.mapToMemory(this.database.getReplaceable(kind, pubkey, identifier)));
     }
     /** Returns all versions of a replaceable event */
     getReplaceableHistory(kind, pubkey, identifier) {
-        return this.database.getReplaceableHistory(kind, pubkey, identifier);
+        // Get the events from memory first, then from the database
+        return (this.memory?.getReplaceableHistory(kind, pubkey, identifier) ??
+            this.database.getReplaceableHistory(kind, pubkey, identifier)?.map((e) => this.mapToMemory(e) ?? e));
     }
     /** Get all events matching a filter */
     getByFilters(filters) {
-        return this.database.getByFilters(filters);
+        // NOTE: no way to read from memory since memory won't have the full set of events
+        const events = this.database.getByFilters(filters);
+        // Map events to memory if available for better performance
+        if (this.memory)
+            return events.map((e) => this.mapToMemory(e));
+        else
+            return events;
     }
     /** Returns a timeline of events that match filters */
     getTimeline(filters) {
-        return this.database.getTimeline(filters);
+        const events = this.database.getTimeline(filters);
+        if (this.memory)
+            return events.map((e) => this.mapToMemory(e));
+        else
+            return events;
+    }
+    /** Passthrough method for the database.touch */
+    touch(event) {
+        return this.memory?.touch(event);
     }
     /** Sets the claim on the event and touches it */
     claim(event, claim) {
-        return this.database.claim(event, claim);
+        return this.memory?.claim(event, claim);
     }
     /** Checks if an event is claimed by anything */
     isClaimed(event) {
-        return this.database.isClaimed(event);
+        return this.memory?.isClaimed(event) ?? false;
     }
     /** Removes a claim from an event */
     removeClaim(event, claim) {
-        return this.database.removeClaim(event, claim);
+        return this.memory?.removeClaim(event, claim);
     }
     /** Removes all claims on an event */
     clearClaim(event) {
-        return this.database.clearClaim(event);
+        return this.memory?.clearClaim(event);
+    }
+    /** Pass through method for the database.unclaimed */
+    unclaimed() {
+        return this.memory?.unclaimed() || (function* () { })();
+    }
+    /** Removes any event that is not being used by a subscription */
+    prune(limit) {
+        return this.memory?.prune(limit) ?? 0;
     }
     /** Returns an observable that completes when an event is removed */
     removed(id) {

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

@@ -1,4 +1,4 @@
 export * from "./async-event-store.js";
-export * from "./event-database.js";
+export * from "./event-memory.js";
 export * from "./event-store.js";
 export * from "./interface.js";

package/dist/event-store/index.js

@@ -1,4 +1,4 @@
 export * from "./async-event-store.js";
-export * from "./event-database.js";
+export * from "./event-memory.js";
 export * from "./event-store.js";
 export * from "./interface.js";

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

@@ -18,7 +18,7 @@ export interface IEventStoreRead {
     /** Get the history of a replaceable event */
     getReplaceableHistory(kind: number, pubkey: string, identifier?: string): NostrEvent[] | undefined;
     /** Get all events that match the filters */
-    getByFilters(filters: Filter | Filter[]): Set<NostrEvent>;
+    getByFilters(filters: Filter | Filter[]): NostrEvent[];
     /** Get a timeline of events that match the filters */
     getTimeline(filters: Filter | Filter[]): NostrEvent[];
 }
@@ -35,7 +35,7 @@ export interface IAsyncEventStoreRead {
     /** Get the history of a replaceable event */
     getReplaceableHistory(kind: number, pubkey: string, identifier?: string): Promise<NostrEvent[] | undefined>;
     /** Get all events that match the filters */
-    getByFilters(filters: Filter | Filter[]): Promise<Set<NostrEvent>>;
+    getByFilters(filters: Filter | Filter[]): Promise<NostrEvent[]>;
     /** Get a timeline of events that match the filters */
     getTimeline(filters: Filter | Filter[]): Promise<NostrEvent[]>;
 }
@@ -81,21 +81,6 @@ export interface IEventClaims {
     /** Returns a generator of unclaimed events in order of least used */
     unclaimed(): Generator<NostrEvent>;
 }
-/** The async claim interface for an event store */
-export interface IAsyncEventClaims {
-    /** Tell the store that this event was used */
-    touch(event: NostrEvent): Promise<void>;
-    /** Sets the claim on the event and touches it */
-    claim(event: NostrEvent, claim: any): Promise<void>;
-    /** Checks if an event is claimed by anything */
-    isClaimed(event: NostrEvent): Promise<boolean>;
-    /** Removes a claim from an event */
-    removeClaim(event: NostrEvent, claim: any): Promise<void>;
-    /** Removes all claims on an event */
-    clearClaim(event: NostrEvent): Promise<void>;
-    /** Returns a generator of unclaimed events in order of least used */
-    unclaimed(): AsyncGenerator<NostrEvent>;
-}
 /** An event store that can be subscribed to */
 export interface IEventSubscriptions {
     /** Subscribe to an event by id */
@@ -155,14 +140,30 @@ export type Model<T extends unknown, TStore extends IEventStore | IAsyncEventSto
 export type ModelConstructor<T extends unknown, Args extends Array<any>, TStore extends IEventStore | IAsyncEventStore = IEventStore> = ((...args: Args) => Model<T, TStore>) & {
     getKey?: (...args: Args) => string;
 };
-/** The base interface for a set of events */
-export interface IEventDatabase extends IEventStoreRead, IEventStoreActions, IEventClaims {
+/** The base interface for a database of events */
+export interface IEventDatabase extends IEventStoreRead {
+    /** Add an event to the database */
+    add(event: NostrEvent): NostrEvent;
+    /** Remove an event from the database */
+    remove(event: string | NostrEvent): boolean;
+    /** Notifies the database that an event has updated */
+    update?: (event: NostrEvent) => void;
 }
 /** The async base interface for a set of events */
-export interface IAsyncEventDatabase extends IAsyncEventStoreRead, IAsyncEventStoreActions, IAsyncEventClaims {
+export interface IAsyncEventDatabase extends IAsyncEventStoreRead {
+    /** Add an event to the database */
+    add(event: NostrEvent): Promise<NostrEvent>;
+    /** Remove an event from the database */
+    remove(event: string | NostrEvent): Promise<boolean>;
+    /** Notifies the database that an event has updated */
+    update?: (event: NostrEvent) => void;
 }
-/** @deprecated use {@link IEventDatabase} instead */
-export interface IEventSet extends IEventDatabase {
+/** The base interface for the in-memory database of events */
+export interface IEventMemory extends IEventStoreRead, IEventClaims {
+    /** Add an event to the store */
+    add(event: NostrEvent): NostrEvent;
+    /** Remove an event from the store */
+    remove(event: string | NostrEvent): boolean;
 }
 /** A set of methods that an event store will use to load single events it does not have */
 export interface IEventFallbackLoaders {
@@ -174,7 +175,7 @@ export interface IEventFallbackLoaders {
     addressableLoader?: (pointer: AddressPointer) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
 }
 /** The async event store interface */
-export interface IAsyncEventStore extends IAsyncEventStoreRead, IEventStoreStreams, IEventSubscriptions, IAsyncEventStoreActions, IEventModelMixin<IAsyncEventStore>, IEventHelpfulSubscriptions, IAsyncEventClaims, IEventFallbackLoaders {
+export interface IAsyncEventStore extends IAsyncEventStoreRead, IEventStoreStreams, IEventSubscriptions, IAsyncEventStoreActions, IEventModelMixin<IAsyncEventStore>, IEventHelpfulSubscriptions, IEventClaims, IEventFallbackLoaders {
 }
 /** The sync event store interface */
 export interface IEventStore extends IEventStoreRead, IEventStoreStreams, IEventSubscriptions, IEventStoreActions, IEventModelMixin<IEventStore>, IEventHelpfulSubscriptions, IEventClaims, IEventFallbackLoaders {

package/dist/helpers/gift-wraps.d.ts

@@ -1,11 +1,11 @@
 import { NostrEvent, UnsignedEvent } from "nostr-tools";
-import { InMemoryEventDatabase } from "../event-store/event-database.js";
+import { EventMemory } from "../event-store/event-memory.js";
 import { EncryptedContentSigner } from "./encrypted-content.js";
 /**
  * An internal event set to keep track of seals and rumors
  * This is intentionally isolated from the main applications event store so to prevent seals and rumors from being leaked
  */
-export declare const internalGiftWrapEvents: InMemoryEventDatabase;
+export declare const internalGiftWrapEvents: EventMemory;
 export type Rumor = UnsignedEvent & {
     id: string;
 };

package/dist/helpers/gift-wraps.js

@@ -1,12 +1,12 @@
 import { verifyEvent } from "nostr-tools";
-import { InMemoryEventDatabase } from "../event-store/event-database.js";
+import { EventMemory } from "../event-store/event-memory.js";
 import { getEncryptedContent, isEncryptedContentLocked, lockEncryptedContent, unlockEncryptedContent, } from "./encrypted-content.js";
 import { notifyEventUpdate } from "./event.js";
 /**
  * An internal event set to keep track of seals and rumors
  * This is intentionally isolated from the main applications event store so to prevent seals and rumors from being leaked
  */
-export const internalGiftWrapEvents = new InMemoryEventDatabase();
+export const internalGiftWrapEvents = new EventMemory();
 /** Used to store a reference to the seal event on gift wraps (downstream) or the seal event on rumors (upstream[]) */
 export const SealSymbol = Symbol.for("seal");
 /** Used to store a reference to the rumor on seals (downstream) */

package/dist/observable/claim-events.d.ts

@@ -1,5 +1,5 @@
 import { NostrEvent } from "nostr-tools";
 import { MonoTypeOperatorFunction } from "rxjs";
-import { IAsyncEventClaims, IEventClaims } from "../event-store/interface.js";
+import { IEventClaims } from "../event-store/interface.js";
 /** keep a claim on any event that goes through this observable, claims are removed when the observable completes */
-export declare function claimEvents<T extends NostrEvent[] | NostrEvent | undefined>(claims: IEventClaims | IAsyncEventClaims): MonoTypeOperatorFunction<T>;
+export declare function claimEvents<T extends NostrEvent[] | NostrEvent | undefined>(claims: IEventClaims): MonoTypeOperatorFunction<T>;

package/dist/observable/claim-latest.d.ts

@@ -1,5 +1,5 @@
 import { NostrEvent } from "nostr-tools";
 import { MonoTypeOperatorFunction } from "rxjs";
-import { IAsyncEventClaims, IEventClaims } from "../event-store/interface.js";
+import { IEventClaims } from "../event-store/interface.js";
 /** An operator that claims the latest event with the database */
-export declare function claimLatest<T extends NostrEvent | undefined>(claims: IEventClaims | IAsyncEventClaims): MonoTypeOperatorFunction<T>;
+export declare function claimLatest<T extends NostrEvent | undefined>(claims: IEventClaims): MonoTypeOperatorFunction<T>;

package/package.json

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