applesauce-core 0.0.0-next-20250725170333 → 0.0.0-next-20250729145125

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

@@ -1,8 +1,9 @@
 import { Filter, NostrEvent } from "nostr-tools";
 import { Observable } from "rxjs";
+import { AddressPointer, EventPointer, ProfilePointer } from "nostr-tools/nip19";
+import { AddressPointerWithoutD } from "../helpers/pointers.js";
 import { EventSet } from "./event-set.js";
 import { IEventStore, ModelConstructor } from "./interface.js";
-import { AddressPointer, EventPointer } from "nostr-tools/nip19";
 /** An extended {@link EventSet} that handles replaceable events, delets, and models */
 export declare class EventStore implements IEventStore {
     database: EventSet;
@@ -19,6 +20,21 @@ export declare class EventStore implements IEventStore {
     update$: Observable<NostrEvent>;
     /** A stream of events that have been removed */
     remove$: Observable<NostrEvent>;
+    /**
+     * A method that will be called when an event isn't found in the store
+     * @experimental
+     */
+    eventLoader?: (pointer: EventPointer) => Observable<NostrEvent>;
+    /**
+     * A method that will be called when a replaceable event isn't found in the store
+     * @experimental
+     */
+    replaceableLoader?: (pointer: AddressPointerWithoutD) => Observable<NostrEvent>;
+    /**
+     * A method that will be called when an addressable event isn't found in the store
+     * @experimental
+     */
+    addressableLoader?: (pointer: AddressPointer) => Observable<NostrEvent>;
     constructor();
     protected deletedIds: Set<string>;
     protected deletedCoords: Map<string, number>;
@@ -76,36 +92,39 @@ export declare class EventStore implements IEventStore {
     /** Creates an observable that emits when event is updated */
     updated(event: string | NostrEvent): Observable<NostrEvent>;
     /** Creates a {@link EventModel} */
-    event(id: string): Observable<NostrEvent | undefined>;
+    event(pointer: string | EventPointer): Observable<NostrEvent | undefined>;
     /** Creates a {@link ReplaceableModel} */
+    replaceable(pointer: AddressPointer | AddressPointerWithoutD): Observable<NostrEvent | undefined>;
     replaceable(kind: number, pubkey: string, identifier?: string): Observable<NostrEvent | undefined>;
+    /** Subscribe to an addressable event by pointer */
+    addressable(pointer: AddressPointer): Observable<NostrEvent | undefined>;
     /** Creates a {@link TimelineModel} */
     timeline(filters: Filter | Filter[], includeOldVersion?: boolean): Observable<NostrEvent[]>;
-    /** Creates a {@link EventsModel} */
-    events(ids: string[]): Observable<Record<string, NostrEvent>>;
-    /** Creates a {@link ReplaceableSetModel} */
-    replaceableSet(pointers: {
-        kind: number;
-        pubkey: string;
-        identifier?: string;
-    }[]): Observable<Record<string, NostrEvent>>;
-    /** Creates a {@link ProfileModel} */
-    profile(pubkey: string): Observable<import("../helpers/profile.js").ProfileContent | undefined>;
-    /** Creates a {@link ContactsModel} */
-    contacts(pubkey: string): Observable<import("nostr-tools/nip19").ProfilePointer[]>;
-    /** Creates a {@link MuteModel} */
-    mutes(pubkey: string): Observable<import("../helpers/mutes.js").Mutes | undefined>;
-    /** Creates a {@link ReactionsModel} */
-    reactions(event: NostrEvent): Observable<import("nostr-tools").Event[]>;
-    /** Creates a {@link MailboxesModel} */
-    mailboxes(pubkey: string): Observable<{
+    /** Subscribe to a users profile */
+    profile(user: string | ProfilePointer): Observable<import("../helpers/profile.js").ProfileContent | undefined>;
+    /** Subscribe to a users contacts */
+    contacts(user: string | ProfilePointer): Observable<ProfilePointer[]>;
+    /** Subscribe to a users mutes */
+    mutes(user: string | ProfilePointer): Observable<import("../helpers/mutes.js").Mutes | undefined>;
+    /** Subscribe to a users NIP-65 mailboxes */
+    mailboxes(user: string | ProfilePointer): Observable<{
         inboxes: string[];
         outboxes: string[];
     } | undefined>;
-    /** Creates a {@link UserBlossomServersModel} */
-    blossomServers(pubkey: string): Observable<URL[]>;
-    /** Creates a {@link ThreadModel} */
+    /** Subscribe to a users blossom servers */
+    blossomServers(user: string | ProfilePointer): Observable<URL[]>;
+    /** Subscribe to an event's reactions */
+    reactions(event: NostrEvent): Observable<import("nostr-tools").Event[]>;
+    /** Subscribe to a thread */
     thread(root: string | EventPointer | AddressPointer): Observable<import("../models/thread.js").Thread>;
-    /** Creates a {@link CommentsModel} */
+    /** Subscribe to a event's comments */
     comments(event: NostrEvent): Observable<import("nostr-tools").Event[]>;
+    /** @deprecated use multiple {@link EventModel} instead */
+    events(ids: string[]): Observable<Record<string, NostrEvent | undefined>>;
+    /** @deprecated use multiple {@link ReplaceableModel} instead */
+    replaceableSet(pointers: {
+        kind: number;
+        pubkey: string;
+        identifier?: string;
+    }[]): Observable<Record<string, NostrEvent | undefined>>;
 }