applesauce-core 3.0.1 → 4.0.0

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

@@ -0,0 +1,134 @@
+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[]): {
+        [x: string]: any;
+        models: Map<import("./interface.js").ModelConstructor<any, any[], import("./interface.js").IEventStore | IAsyncEventStore>, Map<string, Observable<any>>>;
+        modelKeepWarm: number;
+        model<T extends unknown, Args extends Array<any>>(constructor: import("./interface.js").ModelConstructor<T, Args, import("./interface.js").IEventStore | IAsyncEventStore>, ...args: Args): Observable<T>;
+        filters(filters: Filter | Filter[], onlyNew?: boolean): Observable<NostrEvent>;
+        event(pointer: string | EventPointer): Observable<NostrEvent | undefined>;
+        replaceable(pointer: AddressPointer | AddressPointerWithoutD): Observable<NostrEvent | undefined>;
+        replaceable(kind: number, pubkey: string, identifier?: string): Observable<NostrEvent | undefined>;
+        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[]>;
+        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[];
+            outboxes: string[];
+        } | undefined>;
+        blossomServers(user: string | import("nostr-tools/nip19").ProfilePointer): Observable<URL[]>;
+        reactions(event: NostrEvent): Observable<import("nostr-tools").Event[]>;
+        thread(root: string | EventPointer | AddressPointer): Observable<import("../models/thread.js").Thread>;
+        comments(event: NostrEvent): Observable<import("nostr-tools").Event[]>;
+        events(ids: string[]): Observable<Record<string, NostrEvent | undefined>>;
+        replaceableSet(pointers: {
+            kind: number;
+            pubkey: string;
+            identifier?: string;
+        }[]): Observable<Record<string, NostrEvent | undefined>>;
+    };
+} & {
+    new (): {};
+};
+/** 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 */
+    keepExpired: boolean;
+    /**
+     * A method used to verify new events before added them
+     * @returns true if the event is valid, false if it should be ignored
+     */
+    verifyEvent?: (event: NostrEvent) => boolean;
+    /** A stream of new events added to the store */
+    insert$: Subject<import("nostr-tools").Event>;
+    /** A stream of events that have been updated */
+    update$: Subject<import("nostr-tools").Event>;
+    /** A stream of events that have been removed */
+    remove$: Subject<import("nostr-tools").Event>;
+    /**
+     * A method that will be called when an event isn't found in the store
+     * @experimental
+     */
+    eventLoader?: (pointer: EventPointer) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
+    /**
+     * A method that will be called when a replaceable event isn't found in the store
+     * @experimental
+     */
+    replaceableLoader?: (pointer: AddressPointerWithoutD) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
+    /**
+     * A method that will be called when an addressable event isn't found in the store
+     * @experimental
+     */
+    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;
+    protected expirations: Map<string, number>;
+    /** Adds an event to the expiration map */
+    protected addExpiration(event: NostrEvent): void;
+    protected expirationTimeout: number | null;
+    protected nextExpirationCheck: number | null;
+    protected handleExpiringEvent(event: NostrEvent): void;
+    /** Remove expired events from the store */
+    protected pruneExpired(): Promise<void>;
+    protected handleDeleteEvent(deleteEvent: NostrEvent): Promise<void>;
+    /** Copies important metadata from and identical event to another */
+    static mergeDuplicateEvent(source: NostrEvent, dest: NostrEvent): void;
+    /**
+     * Adds an event to the store and update subscriptions
+     * @returns The existing event or the event that was added, if it was ignored returns null
+     */
+    add(event: NostrEvent, fromRelay?: string): Promise<NostrEvent | null>;
+    /** Removes an event from the store and updates subscriptions */
+    remove(event: string | NostrEvent): Promise<boolean>;
+    /** Add an event to the store and notifies all subscribes it has updated */
+    update(event: NostrEvent): Promise<void>;
+    /** Check if the store has an event by id */
+    hasEvent(id: string): Promise<boolean>;
+    /** Get an event by id from the store */
+    getEvent(id: string): Promise<NostrEvent | undefined>;
+    /** Check if the store has a replaceable event */
+    hasReplaceable(kind: number, pubkey: string, d?: string): Promise<boolean>;
+    /** Gets the latest version of a replaceable event */
+    getReplaceable(kind: number, pubkey: string, identifier?: string): Promise<NostrEvent | undefined>;
+    /** 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<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): 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;
+    /** 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 */
+    updated(event: string | NostrEvent): Observable<NostrEvent>;
+}
+export {};

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

@@ -0,0 +1,349 @@
+import { kinds } from "nostr-tools";
+import { isAddressableKind } from "nostr-tools/kinds";
+import { EMPTY, filter, mergeMap, Subject, take } from "rxjs";
+import { getDeleteCoordinates, getDeleteIds } from "../helpers/delete.js";
+import { createReplaceableAddress, EventStoreSymbol, FromCacheSymbol, isReplaceable } from "../helpers/event.js";
+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 { 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 */
+    keepExpired = false;
+    /**
+     * A method used to verify new events before added them
+     * @returns true if the event is valid, false if it should be ignored
+     */
+    verifyEvent;
+    /** A stream of new events added to the store */
+    insert$ = new Subject();
+    /** A stream of events that have been updated */
+    update$ = new Subject();
+    /** A stream of events that have been removed */
+    remove$ = new Subject();
+    /**
+     * A method that will be called when an event isn't found in the store
+     * @experimental
+     */
+    eventLoader;
+    /**
+     * A method that will be called when a replaceable event isn't found in the store
+     * @experimental
+     */
+    replaceableLoader;
+    /**
+     * A method that will be called when an addressable event isn't found in the store
+     * @experimental
+     */
+    addressableLoader;
+    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);
+        });
+        // when events are removed from the database, remove the symbol
+        this.remove$.subscribe((event) => {
+            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();
+    checkDeleted(event) {
+        if (typeof event === "string")
+            return this.deletedIds.has(event);
+        else {
+            if (this.deletedIds.has(event.id))
+                return true;
+            if (isAddressableKind(event.kind)) {
+                const identifier = event.tags.find((t) => t[0] === "d")?.[1];
+                const deleted = this.deletedCoords.get(createReplaceableAddress(event.kind, event.pubkey, identifier));
+                if (deleted)
+                    return deleted > event.created_at;
+            }
+        }
+        return false;
+    }
+    expirations = new Map();
+    /** Adds an event to the expiration map */
+    addExpiration(event) {
+        const expiration = getExpirationTimestamp(event);
+        if (expiration && Number.isFinite(expiration))
+            this.expirations.set(event.id, expiration);
+    }
+    expirationTimeout = null;
+    nextExpirationCheck = null;
+    handleExpiringEvent(event) {
+        const expiration = getExpirationTimestamp(event);
+        if (!expiration)
+            return;
+        // Add event to expiration map
+        this.expirations.set(event.id, expiration);
+        // Exit if the next check is already less than the next expiration
+        if (this.expirationTimeout && this.nextExpirationCheck && this.nextExpirationCheck < expiration)
+            return;
+        // Set timeout to prune expired events
+        if (this.expirationTimeout)
+            clearTimeout(this.expirationTimeout);
+        const timeout = expiration - unixNow();
+        this.expirationTimeout = setTimeout(this.pruneExpired.bind(this), timeout * 1000 + 10);
+        this.nextExpirationCheck = expiration;
+    }
+    /** Remove expired events from the store */
+    async pruneExpired() {
+        const now = unixNow();
+        for (const [id, expiration] of this.expirations) {
+            if (expiration <= now) {
+                this.expirations.delete(id);
+                await this.remove(id);
+            }
+        }
+        // Cleanup timers
+        if (this.expirationTimeout)
+            clearTimeout(this.expirationTimeout);
+        this.nextExpirationCheck = null;
+        this.expirationTimeout = null;
+    }
+    // handling delete events
+    async handleDeleteEvent(deleteEvent) {
+        const ids = getDeleteIds(deleteEvent);
+        for (const id of ids) {
+            this.deletedIds.add(id);
+            // remove deleted events in the database
+            await this.remove(id);
+        }
+        const coords = getDeleteCoordinates(deleteEvent);
+        for (const coord of coords) {
+            this.deletedCoords.set(coord, Math.max(this.deletedCoords.get(coord) ?? 0, deleteEvent.created_at));
+            // Parse the nostr address coordinate
+            const parsed = parseCoordinate(coord);
+            if (!parsed)
+                continue;
+            // Remove older versions of replaceable events
+            const events = await this.database.getReplaceableHistory(parsed.kind, parsed.pubkey, parsed.identifier);
+            if (events) {
+                for (const event of events) {
+                    if (event.created_at < deleteEvent.created_at)
+                        await this.remove(event);
+                }
+            }
+        }
+    }
+    /** Copies important metadata from and identical event to another */
+    static mergeDuplicateEvent(source, dest) {
+        const relays = getSeenRelays(source);
+        if (relays) {
+            for (const relay of relays)
+                addSeenRelay(dest, relay);
+        }
+        // copy the from cache symbol only if its true
+        const fromCache = Reflect.get(source, FromCacheSymbol);
+        if (fromCache && !Reflect.get(dest, FromCacheSymbol))
+            Reflect.set(dest, FromCacheSymbol, fromCache);
+    }
+    /**
+     * Adds an event to the store and update subscriptions
+     * @returns The existing event or the event that was added, if it was ignored returns null
+     */
+    async add(event, fromRelay) {
+        // Handle delete events differently
+        if (event.kind === kinds.EventDeletion)
+            await this.handleDeleteEvent(event);
+        // Ignore if the event was deleted
+        if (this.checkDeleted(event))
+            return event;
+        // Reject expired events if keepExpired is false
+        const expiration = getExpirationTimestamp(event);
+        if (this.keepExpired === false && expiration && expiration <= unixNow())
+            return null;
+        // Get the replaceable identifier
+        const identifier = isReplaceable(event.kind) ? event.tags.find((t) => t[0] === "d")?.[1] : undefined;
+        // Don't insert the event if there is already a newer version
+        if (!this.keepOldVersions && isReplaceable(event.kind)) {
+            const existing = await this.database.getReplaceableHistory(event.kind, event.pubkey, identifier);
+            // If there is already a newer version, copy cached symbols and return existing event
+            if (existing && existing.length > 0 && existing[0].created_at >= event.created_at) {
+                AsyncEventStore.mergeDuplicateEvent(event, existing[0]);
+                return existing[0];
+            }
+        }
+        // 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 = this.mapToMemory(await this.database.add(event));
+        // Copy cached data if its a duplicate event
+        if (event !== inserted)
+            AsyncEventStore.mergeDuplicateEvent(event, inserted);
+        // attach relay this event was from
+        if (fromRelay)
+            addSeenRelay(inserted, fromRelay);
+        // Emit insert$ signal
+        if (inserted === event)
+            this.insert$.next(inserted);
+        // 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 && 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);
+                // return the newest version of the replaceable event
+                // most of the time this will be === event, but not always
+                if (existing.length !== older.length)
+                    return existing[0];
+            }
+        }
+        // Add event to expiration map
+        if (this.keepExpired === false && expiration)
+            this.handleExpiringEvent(inserted);
+        return inserted;
+    }
+    /** Removes an event from the store and updates subscriptions */
+    async remove(event) {
+        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 = await this.database.remove(event);
+        // 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 */
+    async update(event) {
+        // Map the event to the current instance in the database
+        const e = await this.database.add(event);
+        if (!e)
+            return;
+        // Notify the database that the event has updated
+        this.database.update?.(event);
+        this.update$.next(event);
+    }
+    /** Check if the store has an event by id */
+    async 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) {
+        // 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) {
+        // 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) {
+        // 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) {
+        // 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) {
+        // 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) {
+        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 */
+    claim(event, claim) {
+        return this.memory?.claim(event, claim);
+    }
+    /** Checks if an event is claimed by anything */
+    isClaimed(event) {
+        return this.memory?.isClaimed(event) ?? false;
+    }
+    /** Removes a claim from an event */
+    removeClaim(event, claim) {
+        return this.memory?.removeClaim(event, claim);
+    }
+    /** Removes all claims on an 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) {
+        const deleted = this.checkDeleted(id);
+        if (deleted)
+            return EMPTY;
+        return this.remove$.pipe(
+        // listen for removed events
+        filter((e) => e.id === id), 
+        // complete as soon as we find a matching removed event
+        take(1), 
+        // switch to empty
+        mergeMap(() => EMPTY));
+    }
+    /** Creates an observable that emits when event is updated */
+    updated(event) {
+        return this.update$.pipe(filter((e) => e.id === event || e === event));
+    }
+}

package/dist/event-store/{event-set.d.ts → event-memory.d.ts}

@@ -1,12 +1,8 @@
 import { Filter, NostrEvent } from "nostr-tools";
-import { Subject } from "rxjs";
 import { LRU } from "../helpers/lru.js";
-import { IEventSet } from "./interface.js";
-/**
- * A set of nostr events that can be queried and subscribed to
- * NOTE: does not handle replaceable events or any deletion logic
- */
-export declare class EventSet implements IEventSet {
+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>>;
@@ -17,18 +13,8 @@ export declare class EventSet implements IEventSet {
     events: LRU<import("nostr-tools").Event>;
     /** A sorted array of replaceable events by address */
     protected replaceable: Map<string, import("nostr-tools").Event[]>;
-    /** A stream of events inserted into the database */
-    insert$: Subject<import("nostr-tools").Event>;
-    /** A stream of events that have been updated */
-    update$: Subject<import("nostr-tools").Event>;
-    /** A stream of events removed from the database */
-    remove$: Subject<import("nostr-tools").Event>;
-    /** A method thats called before a new event is inserted */
-    onBeforeInsert?: (event: NostrEvent) => boolean;
     /** The number of events in the event set */
     get size(): number;
-    /** Moves an event to the top of the LRU cache */
-    touch(event: NostrEvent): void;
     /** Checks if the database contains an event without touching it */
     hasEvent(id: string): boolean;
     /** Gets a single event based on id */
@@ -40,17 +26,19 @@ export declare class EventSet implements IEventSet {
     /** 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[]): Set<NostrEvent>;
+    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 | null;
-    /** Inserts and event into the database and notifies all subscriptions that the event has updated */
-    update(event: NostrEvent): boolean;
+    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 */
@@ -59,6 +47,10 @@ export declare class EventSet implements IEventSet {
     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>;
@@ -74,11 +66,9 @@ export declare class EventSet implements IEventSet {
     /** 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>;
-    /** Remove the oldest events that are not claimed */
-    prune(limit?: number): number;
+    protected getEventsForFilters(filters: Filter[]): Set<NostrEvent>;
     /** Resets the event set */
     reset(): void;
 }