applesauce-core 0.0.0-next-20250726160247 → 0.0.0-next-20250806165639

package/dist/__tests__/exports.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/exports.test.js

@@ -0,0 +1,27 @@
+import { describe, expect, it } from "vitest";
+import * as exports from "../index.js";
+describe("exports", () => {
+    it("should export the expected functions", () => {
+        expect(Object.keys(exports).sort()).toMatchInlineSnapshot(`
+      [
+        "EventSet",
+        "EventStore",
+        "EventStoreSymbol",
+        "Helpers",
+        "Models",
+        "TimeoutError",
+        "defined",
+        "firstValueFrom",
+        "getObservableValue",
+        "lastValueFrom",
+        "logger",
+        "mapEventsToStore",
+        "mapEventsToTimeline",
+        "simpleTimeout",
+        "watchEventUpdates",
+        "watchEventsUpdates",
+        "withImmediateValueOrDefault",
+      ]
+    `);
+    });
+});

package/dist/__tests__/fixtures.d.ts

@@ -0,0 +1,17 @@
+import type { NostrEvent } from "nostr-tools";
+import { EncryptedContentSigner } from "../helpers/encrypted-content.js";
+export declare class FakeUser implements EncryptedContentSigner {
+    key: Uint8Array<ArrayBufferLike>;
+    pubkey: string;
+    nip04: {
+        encrypt: (pubkey: string, plaintext: string) => string;
+        decrypt: (pubkey: string, ciphertext: string) => string;
+    };
+    nip44: {
+        encrypt: (pubkey: string, plaintext: string) => string;
+        decrypt: (pubkey: string, ciphertext: string) => string;
+    };
+    event(data?: Partial<NostrEvent>): NostrEvent;
+    note(content?: string, extra?: Partial<NostrEvent>): import("nostr-tools").Event;
+    profile(profile: any, extra?: Partial<NostrEvent>): import("nostr-tools").Event;
+}

package/dist/__tests__/fixtures.js

@@ -0,0 +1,28 @@
+import { finalizeEvent, generateSecretKey, getPublicKey, kinds, nip04, nip44 } from "nostr-tools";
+import { unixNow } from "../helpers/time.js";
+export class FakeUser {
+    key = generateSecretKey();
+    pubkey = getPublicKey(this.key);
+    nip04 = {
+        encrypt: (pubkey, plaintext) => nip04.encrypt(this.key, pubkey, plaintext),
+        decrypt: (pubkey, ciphertext) => nip04.decrypt(this.key, pubkey, ciphertext),
+    };
+    nip44 = {
+        encrypt: (pubkey, plaintext) => nip44.encrypt(plaintext, nip44.getConversationKey(this.key, pubkey)),
+        decrypt: (pubkey, ciphertext) => nip44.decrypt(ciphertext, nip44.getConversationKey(this.key, pubkey)),
+    };
+    event(data) {
+        return finalizeEvent({
+            kind: data?.kind ?? kinds.ShortTextNote,
+            content: data?.content || "",
+            created_at: data?.created_at ?? unixNow(),
+            tags: data?.tags || [],
+        }, this.key);
+    }
+    note(content = "Hello World", extra) {
+        return this.event({ kind: kinds.ShortTextNote, content, ...extra });
+    }
+    profile(profile, extra) {
+        return this.event({ kind: kinds.Metadata, content: JSON.stringify({ ...profile }), ...extra });
+    }
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,386 @@
+import { subscribeSpyTo } from "@hirez_io/observer-spy";
+import { kinds } from "nostr-tools";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { FakeUser } from "../../__tests__/fixtures.js";
+import { getEventUID } from "../../helpers/event.js";
+import { addSeenRelay, getSeenRelays } from "../../helpers/relays.js";
+import { EventModel } from "../../models/common.js";
+import { ProfileModel } from "../../models/profile.js";
+import { EventStore } from "../event-store.js";
+let eventStore;
+beforeEach(() => {
+    eventStore = new EventStore();
+});
+const user = new FakeUser();
+const profile = user.profile({ name: "fake user" });
+const note = user.note();
+describe("add", () => {
+    it("should return original event in case of duplicates", () => {
+        const a = { ...profile };
+        expect(eventStore.add(a)).toBe(a);
+        const b = { ...profile };
+        expect(eventStore.add(b)).toBe(a);
+        const c = { ...profile };
+        expect(eventStore.add(c)).toBe(a);
+    });
+    it("should merge seen relays on duplicate events", () => {
+        const a = { ...profile };
+        addSeenRelay(a, "wss://relay.a.com");
+        eventStore.add(a);
+        const b = { ...profile };
+        addSeenRelay(b, "wss://relay.b.com");
+        eventStore.add(b);
+        expect(eventStore.getEvent(profile.id)).toBeDefined();
+        expect([...getSeenRelays(eventStore.getEvent(profile.id))]).toEqual(expect.arrayContaining(["wss://relay.a.com", "wss://relay.b.com"]));
+    });
+    it("should ignore old deleted events but not newer ones", () => {
+        const deleteEvent = {
+            id: "delete event id",
+            kind: kinds.EventDeletion,
+            created_at: profile.created_at + 100,
+            pubkey: user.pubkey,
+            tags: [["e", profile.id]],
+            sig: "this should be ignored for the test",
+            content: "test",
+        };
+        // add delete event first
+        eventStore.add(deleteEvent);
+        // now event should be ignored
+        eventStore.add(profile);
+        const newProfile = user.profile({ name: "new name" }, { created_at: profile.created_at + 1000 });
+        eventStore.add(newProfile);
+        expect(eventStore.getEvent(profile.id)).toBeUndefined();
+        expect(eventStore.getEvent(newProfile.id)).toBeDefined();
+    });
+    it("should remove profile events when delete event is added", () => {
+        // Add initial replaceable event
+        eventStore.add(profile);
+        expect(eventStore.getEvent(profile.id)).toBeDefined();
+        const newProfile = user.profile({ name: "new name" }, { created_at: profile.created_at + 1000 });
+        eventStore.add(newProfile);
+        const deleteEvent = {
+            id: "delete event id",
+            kind: kinds.EventDeletion,
+            created_at: profile.created_at + 100,
+            pubkey: user.pubkey,
+            tags: [["a", `${profile.kind}:${profile.pubkey}`]],
+            sig: "this should be ignored for the test",
+            content: "test",
+        };
+        // Add delete event with coordinate
+        eventStore.add(deleteEvent);
+        // Profile should be removed since delete event is newer
+        expect(eventStore.getEvent(profile.id)).toBeUndefined();
+        expect(eventStore.getEvent(newProfile.id)).toBeDefined();
+        expect(eventStore.getReplaceable(profile.kind, profile.pubkey)).toBe(newProfile);
+    });
+    it("should remove addressable replaceable events when delete event is added", () => {
+        // Add initial replaceable event
+        const event = user.event({ content: "test", kind: 30000, tags: [["d", "test"]] });
+        eventStore.add(event);
+        expect(eventStore.getEvent(event.id)).toBeDefined();
+        const newEvent = user.event({
+            ...event,
+            created_at: event.created_at + 500,
+        });
+        eventStore.add(newEvent);
+        const deleteEvent = {
+            id: "delete event id",
+            kind: kinds.EventDeletion,
+            created_at: event.created_at + 100,
+            pubkey: user.pubkey,
+            tags: [["a", `${event.kind}:${event.pubkey}:test`]],
+            sig: "this should be ignored for the test",
+            content: "test",
+        };
+        // Add delete event with coordinate
+        eventStore.add(deleteEvent);
+        // Profile should be removed since delete event is newer
+        expect(eventStore.getEvent(event.id)).toBeUndefined();
+        expect(eventStore.getEvent(newEvent.id)).toBeDefined();
+        expect(eventStore.getReplaceable(event.kind, event.pubkey, "test")).toBe(newEvent);
+    });
+    it("should return null when event is invalid and there isn't an existing event", () => {
+        const verifyEvent = vi.fn().mockReturnValue(false);
+        eventStore.verifyEvent = verifyEvent;
+        expect(eventStore.add(profile)).toBeNull();
+        expect(verifyEvent).toHaveBeenCalledWith(profile);
+    });
+});
+describe("inserts", () => {
+    it("should emit newer replaceable events", () => {
+        const spy = subscribeSpyTo(eventStore.insert$);
+        eventStore.add(profile);
+        const newer = user.profile({ name: "new name" }, { created_at: profile.created_at + 100 });
+        eventStore.add(newer);
+        expect(spy.getValues()).toEqual([profile, newer]);
+    });
+    it("should not emit when older replaceable event is added", () => {
+        const spy = subscribeSpyTo(eventStore.insert$);
+        eventStore.add(profile);
+        eventStore.add(user.profile({ name: "new name" }, { created_at: profile.created_at - 1000 }));
+        expect(spy.getValues()).toEqual([profile]);
+    });
+});
+describe("removes", () => {
+    it("should emit older replaceable events when the newest replaceable event is added", () => {
+        const spy = subscribeSpyTo(eventStore.remove$);
+        eventStore.add(profile);
+        const newer = user.profile({ name: "new name" }, { created_at: profile.created_at + 1000 });
+        eventStore.add(newer);
+        expect(spy.getValues()).toEqual([profile]);
+    });
+});
+describe("verifyEvent", () => {
+    it("should be called for all events added", () => {
+        const verifyEvent = vi.fn().mockReturnValue(true);
+        eventStore.verifyEvent = verifyEvent;
+        eventStore.add(profile);
+        expect(verifyEvent).toHaveBeenCalledWith(profile);
+    });
+    it("should not be called for duplicate events", () => {
+        const verifyEvent = vi.fn().mockReturnValue(true);
+        eventStore.verifyEvent = verifyEvent;
+        const a = { ...profile };
+        eventStore.add(a);
+        expect(verifyEvent).toHaveBeenCalledWith(a);
+        const b = { ...profile };
+        eventStore.add(b);
+        expect(verifyEvent).toHaveBeenCalledTimes(1);
+        const c = { ...profile };
+        eventStore.add(c);
+        expect(verifyEvent).toHaveBeenCalledTimes(1);
+    });
+});
+describe("removed", () => {
+    it("should complete when event is removed", () => {
+        eventStore.add(profile);
+        const spy = subscribeSpyTo(eventStore.removed(profile.id));
+        eventStore.remove(profile);
+        expect(spy.getValues()).toEqual([]);
+        expect(spy.receivedComplete()).toBe(true);
+    });
+});
+describe("model", () => {
+    it("should emit synchronous value if it exists", () => {
+        let value = undefined;
+        eventStore.add(profile);
+        eventStore.model(ProfileModel, user.pubkey).subscribe((v) => (value = v));
+        expect(value).not.toBe(undefined);
+    });
+    it("should not emit undefined if value exists", () => {
+        eventStore.add(profile);
+        const spy = subscribeSpyTo(eventStore.model(EventModel, profile.id));
+        expect(spy.getValues()).toEqual([profile]);
+    });
+    it("should emit synchronous undefined if value does not exists", () => {
+        let value = 0;
+        eventStore.model(ProfileModel, user.pubkey).subscribe((v) => {
+            value = v;
+        });
+        expect(value).not.toBe(0);
+        expect(value).toBe(undefined);
+    });
+    it("should share latest value", () => {
+        eventStore.add(profile);
+        const spy = subscribeSpyTo(eventStore.model(EventModel, profile.id));
+        const spy2 = subscribeSpyTo(eventStore.model(EventModel, profile.id));
+        expect(spy.getValues()).toEqual([profile]);
+        expect(spy2.getValues()).toEqual([profile]);
+    });
+});
+describe("event", () => {
+    it("should emit existing event", () => {
+        eventStore.add(profile);
+        const spy = subscribeSpyTo(eventStore.event(profile.id));
+        expect(spy.getValues()).toEqual([profile]);
+    });
+    it("should emit then event when its added", () => {
+        const spy = subscribeSpyTo(eventStore.event(profile.id));
+        expect(spy.getValues()).toEqual([undefined]);
+        eventStore.add(profile);
+        expect(spy.getValues()).toEqual([undefined, profile]);
+    });
+    it("should emit undefined when event is removed", () => {
+        eventStore.add(profile);
+        const spy = subscribeSpyTo(eventStore.event(profile.id));
+        expect(spy.getValues()).toEqual([profile]);
+        eventStore.remove(profile);
+        expect(spy.getValues()).toEqual([profile, undefined]);
+    });
+    it("should emit new value if event is re-added", () => {
+        eventStore.add(profile);
+        const spy = subscribeSpyTo(eventStore.event(profile.id));
+        eventStore.remove(profile);
+        eventStore.add(profile);
+        expect(spy.getValues()).toEqual([profile, undefined, profile]);
+    });
+    it("should not complete when event is removed", () => {
+        eventStore.add(profile);
+        const spy = subscribeSpyTo(eventStore.event(profile.id));
+        eventStore.remove(profile);
+        expect(spy.receivedComplete()).toBe(false);
+    });
+    it("should emit undefined if event is not found", () => {
+        const spy = subscribeSpyTo(eventStore.event(profile.id));
+        expect(spy.getValues()).toEqual([undefined]);
+    });
+});
+describe("events", () => {
+    it("should emit existing events", () => {
+        eventStore.add(profile);
+        const spy = subscribeSpyTo(eventStore.events([profile.id]));
+        expect(spy.getValues()).toEqual([{ [profile.id]: profile }]);
+    });
+    it("should remove events when they are removed", () => {
+        eventStore.add(profile);
+        const spy = subscribeSpyTo(eventStore.events([profile.id]));
+        expect(spy.getValues()).toEqual([{ [profile.id]: profile }]);
+        eventStore.remove(profile);
+        expect(spy.getValues()).toEqual([{ [profile.id]: profile }, {}]);
+    });
+    it("should add events back if then are re-added", () => {
+        eventStore.add(profile);
+        const spy = subscribeSpyTo(eventStore.events([profile.id]));
+        eventStore.remove(profile);
+        eventStore.add(profile);
+        expect(spy.getValues()).toEqual([{ [profile.id]: profile }, {}, { [profile.id]: profile }]);
+    });
+    it("should not emit any values if there are no events", () => {
+        const spy = subscribeSpyTo(eventStore.events([profile.id]));
+        expect(spy.receivedNext()).toBe(false);
+    });
+});
+describe("replaceable", () => {
+    it("should emit existing events", () => {
+        eventStore.add(profile);
+        const spy = subscribeSpyTo(eventStore.replaceable(0, user.pubkey));
+        expect(spy.getValues()).toEqual([profile]);
+    });
+    it("should emit undefined when event is removed", () => {
+        eventStore.add(profile);
+        const spy = subscribeSpyTo(eventStore.replaceable(0, user.pubkey));
+        eventStore.remove(profile);
+        expect(spy.getValues()).toEqual([profile, undefined]);
+    });
+    it("should not complete when event is removed", () => {
+        eventStore.add(profile);
+        const spy = subscribeSpyTo(eventStore.replaceable(0, user.pubkey));
+        eventStore.remove(profile);
+        expect(spy.receivedComplete()).toBe(false);
+    });
+    it("should emit event when re-added", () => {
+        eventStore.add(profile);
+        const spy = subscribeSpyTo(eventStore.replaceable(0, user.pubkey));
+        eventStore.remove(profile);
+        eventStore.add(profile);
+        expect(spy.getValues()).toEqual([profile, undefined, profile]);
+    });
+    it("should claim event", () => {
+        eventStore.add(profile);
+        eventStore.replaceable(0, user.pubkey).subscribe();
+        expect(eventStore.database.isClaimed(profile)).toBe(true);
+    });
+    it("should remove claim when event is removed", () => {
+        eventStore.add(profile);
+        eventStore.replaceable(0, user.pubkey).subscribe();
+        eventStore.remove(profile);
+        expect(eventStore.database.isClaimed(profile)).toBe(false);
+    });
+    it("should ignore older events added later", () => {
+        eventStore.add(profile);
+        const spy = subscribeSpyTo(eventStore.replaceable(0, user.pubkey));
+        eventStore.add(user.profile({ name: "old name" }, { created_at: profile.created_at - 500 }));
+        eventStore.add(user.profile({ name: "really old name" }, { created_at: profile.created_at - 1000 }));
+        expect(spy.getValues()).toEqual([profile]);
+    });
+    it("should emit newer events", () => {
+        eventStore.add(profile);
+        const spy = subscribeSpyTo(eventStore.replaceable(0, user.pubkey));
+        const newProfile = user.profile({ name: "new name" }, { created_at: profile.created_at + 500 });
+        eventStore.add(newProfile);
+        expect(spy.getValues()).toEqual([profile, newProfile]);
+    });
+});
+describe("timeline", () => {
+    it("should emit an empty array if there are not events", () => {
+        const spy = subscribeSpyTo(eventStore.timeline({ kinds: [1] }));
+        expect(spy.getValues()).toEqual([[]]);
+    });
+    it("should emit existing events", () => {
+        eventStore.add(profile);
+        const spy = subscribeSpyTo(eventStore.timeline({ kinds: [0] }));
+        expect(spy.getValues()).toEqual([[profile]]);
+    });
+    it("should emit new events", () => {
+        const spy = subscribeSpyTo(eventStore.timeline({ kinds: [0, 1] }));
+        eventStore.add(profile);
+        eventStore.add(note);
+        expect(spy.getValues()).toEqual([[], [profile], [note, profile]]);
+    });
+    it("should remove event when its removed", () => {
+        eventStore.add(profile);
+        const spy = subscribeSpyTo(eventStore.timeline({ kinds: [0] }));
+        eventStore.remove(profile);
+        expect(spy.getValues()).toEqual([[profile], []]);
+    });
+    it("should not emit when other events are removed", () => {
+        eventStore.add(profile);
+        const spy = subscribeSpyTo(eventStore.timeline({ kinds: [0] }));
+        eventStore.add(note);
+        eventStore.remove(note);
+        expect(spy.getValues()).toEqual([[profile]]);
+    });
+    it("should ignore older events added later", () => {
+        eventStore.add(profile);
+        const spy = subscribeSpyTo(eventStore.timeline({ kinds: [0] }));
+        eventStore.add(user.profile({ name: "old-name" }, { created_at: profile.created_at - 1000 }));
+        expect(spy.getValues()).toEqual([[profile]]);
+    });
+    it("should return new array for every value", () => {
+        const first = user.note("first note");
+        const second = user.note("second note");
+        const third = user.note("third note");
+        eventStore.add(first);
+        const spy = subscribeSpyTo(eventStore.timeline({ kinds: [0] }));
+        eventStore.add(second);
+        eventStore.add(third);
+        const hasDuplicates = (arr) => {
+            return new Set(arr).size !== arr.length;
+        };
+        expect(hasDuplicates(spy.getValues())).toBe(false);
+    });
+});
+describe("replaceableSet", () => {
+    it("should not emit if there are not events", () => {
+        const spy = subscribeSpyTo(eventStore.replaceableSet([{ kind: 0, pubkey: user.pubkey }]));
+        expect(spy.receivedNext()).toBe(false);
+    });
+    it("should emit existing events", () => {
+        eventStore.add(profile);
+        const spy = subscribeSpyTo(eventStore.replaceableSet([{ kind: 0, pubkey: user.pubkey }]));
+        expect(spy.getValues()).toEqual([{ [getEventUID(profile)]: profile }]);
+    });
+    it("should remove event when removed", () => {
+        eventStore.add(profile);
+        const spy = subscribeSpyTo(eventStore.replaceableSet([{ kind: 0, pubkey: user.pubkey }]));
+        eventStore.remove(profile);
+        expect(spy.getValues()).toEqual([{ [getEventUID(profile)]: profile }, {}]);
+    });
+    it("should replace older events", () => {
+        const event2 = { ...profile, created_at: profile.created_at + 100, id: "newer-event" };
+        const uid = getEventUID(profile);
+        eventStore.add(profile);
+        const spy = subscribeSpyTo(eventStore.replaceableSet([{ kind: 0, pubkey: user.pubkey }]));
+        eventStore.add(event2);
+        expect(spy.getValues()).toEqual([{ [uid]: profile }, { [uid]: event2 }]);
+    });
+    it("should ignore old events added later", () => {
+        const old = user.profile({ name: "old-name" }, { created_at: profile.created_at - 1000 });
+        const uid = getEventUID(profile);
+        eventStore.add(profile);
+        const spy = subscribeSpyTo(eventStore.replaceableSet([{ kind: 0, pubkey: user.pubkey }]));
+        eventStore.add(old);
+        expect(spy.getValues()).toEqual([{ [uid]: profile }]);
+    });
+});

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

@@ -0,0 +1 @@
+export declare const INDEXABLE_TAGS: Set<string>;

package/dist/event-store/common.js

@@ -0,0 +1,2 @@
+const LETTERS = "abcdefghijklmnopqrstuvwxyz";
+export const INDEXABLE_TAGS = new Set((LETTERS + LETTERS.toUpperCase()).split(""));

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

@@ -1,7 +1,7 @@
 import { binarySearch, insertEventIntoDescendingList } from "nostr-tools/utils";
 import { Subject } from "rxjs";
 import { getIndexableTags, INDEXABLE_TAGS } from "../helpers/event-tags.js";
-import { createReplaceableAddress, getReplaceableAddress, isReplaceable } from "../helpers/event.js";
+import { createReplaceableAddress, isReplaceable } from "../helpers/event.js";
 import { LRU } from "../helpers/lru.js";
 import { logger } from "../logger.js";
 /**
@@ -92,7 +92,8 @@ export class EventSet {
         insertEventIntoDescendingList(this.created_at, event);
         // Insert into replaceable index
         if (isReplaceable(event.kind)) {
-            const address = getReplaceableAddress(event);
+            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
@@ -135,7 +136,8 @@ export class EventSet {
         this.events.delete(id);
         // remove from replaceable index
         if (isReplaceable(event.kind)) {
-            const address = getReplaceableAddress(event);
+            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);

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

@@ -9,6 +9,8 @@ export declare class EventStore implements IEventStore {
     database: EventSet;
     /** 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
@@ -24,21 +26,29 @@ export declare class EventStore implements IEventStore {
      * A method that will be called when an event isn't found in the store
      * @experimental
      */
-    eventLoader?: (pointer: EventPointer) => Observable<NostrEvent>;
+    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>;
+    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>;
+    addressableLoader?: (pointer: AddressPointer) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
     constructor();
     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(): void;
     protected handleDeleteEvent(deleteEvent: NostrEvent): void;
     /** Copies important metadata from and identical event to another */
     static mergeDuplicateEvent(source: NostrEvent, dest: NostrEvent): void;

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

@@ -3,10 +3,12 @@ import { isAddressableKind } from "nostr-tools/kinds";
 import { EMPTY, filter, finalize, from, merge, mergeMap, ReplaySubject, share, take, timer } from "rxjs";
 import hash_sum from "hash-sum";
 import { getDeleteCoordinates, getDeleteIds } from "../helpers/delete.js";
-import { EventStoreSymbol, FromCacheSymbol, getReplaceableAddress, isReplaceable } from "../helpers/event.js";
+import { createReplaceableAddress, EventStoreSymbol, FromCacheSymbol, isReplaceable } from "../helpers/event.js";
+import { getExpirationTimestamp } from "../helpers/expiration.js";
 import { matchFilters } from "../helpers/filter.js";
 import { parseCoordinate } from "../helpers/pointers.js";
 import { addSeenRelay, getSeenRelays } from "../helpers/relays.js";
+import { unixNow } from "../helpers/time.js";
 import { UserBlossomServersModel } from "../models/blossom.js";
 import { EventModel, EventsModel, ReplaceableModel, ReplaceableSetModel, TimelineModel } from "../models/common.js";
 import { ContactsModel } from "../models/contacts.js";
@@ -21,6 +23,8 @@ export class EventStore {
     database;
     /** 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
@@ -79,12 +83,53 @@ export class EventStore {
             if (this.deletedIds.has(event.id))
                 return true;
             if (isAddressableKind(event.kind)) {
-                const deleted = this.deletedCoords.get(getReplaceableAddress(event));
+                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;
         }
+        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 */
+    pruneExpired() {
+        const now = unixNow();
+        for (const [id, expiration] of this.expirations) {
+            if (expiration <= now) {
+                this.expirations.delete(id);
+                this.remove(id);
+            }
+        }
+        // Cleanup timers
+        if (this.expirationTimeout)
+            clearTimeout(this.expirationTimeout);
+        this.nextExpirationCheck = null;
+        this.expirationTimeout = null;
     }
     // handling delete events
     handleDeleteEvent(deleteEvent) {
@@ -133,11 +178,15 @@ export class EventStore {
         // 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 d = isReplaceable(event.kind) ? event.tags.find((t) => t[0] === "d")?.[1] : undefined;
+        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 = this.database.getReplaceableHistory(event.kind, event.pubkey, d);
+            const existing = 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) {
                 EventStore.mergeDuplicateEvent(event, existing[0]);
@@ -165,7 +214,7 @@ export class EventStore {
             addSeenRelay(inserted, fromRelay);
         // remove all old version of the replaceable event
         if (!this.keepOldVersions && isReplaceable(event.kind)) {
-            const existing = this.database.getReplaceableHistory(event.kind, event.pubkey, d);
+            const existing = this.database.getReplaceableHistory(event.kind, event.pubkey, identifier);
             if (existing) {
                 const older = Array.from(existing).filter((e) => e.created_at < event.created_at);
                 for (const old of older)
@@ -176,6 +225,9 @@ export class EventStore {
                     return existing[0];
             }
         }
+        // Add event to expiration map
+        if (this.keepExpired === false && expiration)
+            this.handleExpiringEvent(inserted);
         return inserted;
     }
     /** Removes an event from the database and updates subscriptions */