applesauce-core 0.12.1 → 1.2.0

package/README.md

@@ -1,37 +1,55 @@
 # applesauce-core
 
-AppleSauce Core is an interpretation layer for nostr clients, Push events into the in-memory [database](https://hzrd149.github.io/applesauce/typedoc/classes/Database.html) and get nicely formatted data out with [queries](https://hzrd149.github.io/applesauce/typedoc/modules/Queries)
+AppleSauce is a collection of utilities for building reactive nostr applications. The core package provides an in-memory event database and reactive queries to help you build nostr UIs with less code.
 
-# Example
+## Key Components
+
+- **Helpers**: Core utility methods for parsing and extracting data from nostr events
+- **EventStore**: In-memory database for storing and subscribing to nostr events
+- **QueryStore**: Manages queries and ensures efficient subscription handling
+- **Queries**: Complex subscriptions for common nostr data patterns
+
+## Documentation
+
+For detailed documentation and guides, visit:
+
+- [Getting Started](https://hzrd149.github.io/applesauce/introduction/getting-started)
+- [API Reference](https://hzrd149.github.io/applesauce/typedoc/)
+
+## Example
 
 ```js
 import { EventStore, QueryStore } from "applesauce-core";
 import { Relay } from "nostr-tools/relay";
 
-// The EventStore handles all the events
+// Create a single EventStore instance for your app
 const eventStore = new EventStore();
 
-// The QueryStore handles queries and makes sure not to run multiple of the same query
+// Create a QueryStore to manage subscriptions efficiently
 const queryStore = new QueryStore(eventStore);
 
-// Use nostr-tools or anything else to talk to relays
+// Use any nostr library for relay connections (nostr-tools, ndk, nostrify, etc...)
 const relay = await Relay.connect("wss://relay.example.com");
 
-const sub = relay.subscribe([{ authors: ["266815e0c9210dfa324c6cba3573b14bee49da4209a9456f9484e5106cd408a5"] }], {
+// Subscribe to events and add them to the store
+const sub = relay.subscribe([{ authors: ["3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d"] }], {
   onevent(event) {
     eventStore.add(event);
   },
 });
 
-// This will return an Observable<ProfileContent | undefined> of the parsed metadata
-const profile = queryStore.profile("266815e0c9210dfa324c6cba3573b14bee49da4209a9456f9484e5106cd408a5");
+// Subscribe to profile changes using ProfileQuery
+const profile = queryStore.createQuery(
+  ProfileQuery,
+  "3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d",
+);
 
 profile.subscribe((parsed) => {
   if (parsed) console.log(parsed);
 });
 
-// This will return an Observable<NostrEvent[]> of all kind 1 events sorted by created_at
-const timeline = queryStore.timeline({ kinds: [1] });
+// Subscribe to a timeline of events
+const timeline = queryStore.createQuery(TimelineQuery, { kinds: [1] });
 
 timeline.subscribe((events) => {
   console.log(events);

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

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

package/dist/__tests__/exports.test.js

@@ -0,0 +1,17 @@
+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(`
+      [
+        "Database",
+        "EventStore",
+        "EventStoreSymbol",
+        "Helpers",
+        "Queries",
+        "QueryStore",
+        "logger",
+      ]
+    `);
+    });
+});

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

@@ -31,7 +31,7 @@ describe("add", () => {
         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 deleted events", () => {
+    it("should ignore old deleted events but not newer ones", () => {
         const deleteEvent = {
             id: "delete event id",
             kind: kinds.EventDeletion,
@@ -45,7 +45,58 @@ describe("add", () => {
         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);
     });
 });
 describe("inserts", () => {

package/dist/event-store/database.js

@@ -1,6 +1,6 @@
 import { binarySearch, insertEventIntoDescendingList } from "nostr-tools/utils";
 import { Subject } from "rxjs";
-import { getEventUID, getIndexableTags, getReplaceableUID, isReplaceable } from "../helpers/event.js";
+import { getEventUID, getIndexableTags, createReplaceableAddress, isReplaceable } from "../helpers/event.js";
 import { INDEXABLE_TAGS } from "./common.js";
 import { logger } from "../logger.js";
 import { LRU } from "../helpers/lru.js";
@@ -73,12 +73,12 @@ export class Database {
     }
     /** Checks if the database contains a replaceable event without touching it */
     hasReplaceable(kind, pubkey, d) {
-        const events = this.replaceable.get(getReplaceableUID(kind, pubkey, d));
+        const events = this.replaceable.get(createReplaceableAddress(kind, pubkey, d));
         return !!events && events.length > 0;
     }
     /** Gets an array of replaceable events */
     getReplaceable(kind, pubkey, d) {
-        return this.replaceable.get(getReplaceableUID(kind, pubkey, d));
+        return this.replaceable.get(createReplaceableAddress(kind, pubkey, d));
     }
     /** Inserts an event into the database and notifies all subscriptions */
     addEvent(event) {

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

@@ -1,14 +1,15 @@
 import { kinds } from "nostr-tools";
 import { insertEventIntoDescendingList } from "nostr-tools/utils";
-import { isParameterizedReplaceableKind } from "nostr-tools/kinds";
+import { isAddressableKind } from "nostr-tools/kinds";
 import { defer, distinctUntilChanged, EMPTY, endWith, filter, finalize, from, map, merge, mergeMap, mergeWith, of, repeat, scan, take, takeUntil, tap, } from "rxjs";
 import { Database } from "./database.js";
-import { FromCacheSymbol, getEventUID, getReplaceableIdentifier, getReplaceableUID, getTagValue, isReplaceable, } from "../helpers/event.js";
+import { FromCacheSymbol, getEventUID, getReplaceableIdentifier, createReplaceableAddress, getTagValue, isReplaceable, } from "../helpers/event.js";
 import { matchFilters } from "../helpers/filter.js";
 import { addSeenRelay, getSeenRelays } from "../helpers/relays.js";
 import { getDeleteCoordinates, getDeleteIds } from "../helpers/delete.js";
 import { claimEvents } from "../observable/claim-events.js";
 import { claimLatest } from "../observable/claim-latest.js";
+import { parseCoordinate } from "../helpers/pointers.js";
 export const EventStoreSymbol = Symbol.for("event-store");
 function sortDesc(a, b) {
     return b.created_at - a.created_at;
@@ -53,7 +54,7 @@ export class EventStore {
         else {
             if (this.deletedIds.has(event.id))
                 return true;
-            if (isParameterizedReplaceableKind(event.kind)) {
+            if (isAddressableKind(event.kind)) {
                 const deleted = this.deletedCoords.get(getEventUID(event));
                 if (deleted)
                     return deleted > event.created_at;
@@ -74,10 +75,16 @@ export class EventStore {
         const coords = getDeleteCoordinates(deleteEvent);
         for (const coord of coords) {
             this.deletedCoords.set(coord, Math.max(this.deletedCoords.get(coord) ?? 0, deleteEvent.created_at));
-            // remove deleted events in the database
-            const event = this.database.getEvent(coord);
-            if (event && event.created_at < deleteEvent.created_at)
-                this.database.removeEvent(event);
+            // Parse the nostr address coordinate
+            const parsed = parseCoordinate(coord);
+            if (!parsed)
+                continue;
+            // Remove older versions of replaceable events
+            const events = this.database.getReplaceable(parsed.kind, parsed.pubkey, parsed.identifier) ?? [];
+            for (const event of events) {
+                if (event.created_at < deleteEvent.created_at)
+                    this.database.removeEvent(event);
+            }
         }
     }
     /** Copies important metadata from and identical event to another */
@@ -288,7 +295,7 @@ export class EventStore {
     }
     /** Creates an observable that subscribes to the latest version of an array of replaceable events*/
     replaceableSet(pointers) {
-        const uids = new Set(pointers.map((p) => getReplaceableUID(p.kind, p.pubkey, p.identifier)));
+        const uids = new Set(pointers.map((p) => createReplaceableAddress(p.kind, p.pubkey, p.identifier)));
         return merge(
         // start with existing events
         defer(() => from(pointers.map((p) => this.getReplaceable(p.kind, p.pubkey, p.identifier)))), 

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

@@ -1,12 +1,6 @@
 import { Filter, NostrEvent } from "nostr-tools";
 import { Observable } from "rxjs";
-export interface IEventStore {
-    inserts: Observable<NostrEvent>;
-    updates: Observable<NostrEvent>;
-    removes: Observable<NostrEvent>;
-    add(event: NostrEvent, fromRelay?: string): NostrEvent;
-    remove(event: string | NostrEvent): boolean;
-    update(event: NostrEvent): NostrEvent;
+export interface ISyncEventStore {
     hasEvent(id: string): boolean;
     hasReplaceable(kind: number, pubkey: string, identifier?: string): boolean;
     getEvent(id: string): NostrEvent | undefined;
@@ -14,6 +8,11 @@ export interface IEventStore {
     getReplaceableHistory(kind: number, pubkey: string, identifier?: string): NostrEvent[] | undefined;
     getAll(filters: Filter | Filter[]): Set<NostrEvent>;
     getTimeline(filters: Filter | Filter[]): NostrEvent[];
+}
+export interface IStreamEventStore {
+    inserts: Observable<NostrEvent>;
+    updates: Observable<NostrEvent>;
+    removes: Observable<NostrEvent>;
     filters(filters: Filter | Filter[]): Observable<NostrEvent>;
     updated(id: string | NostrEvent): Observable<NostrEvent>;
     removed(id: string): Observable<never>;
@@ -27,3 +26,8 @@ export interface IEventStore {
     }[]): Observable<Record<string, NostrEvent>>;
     timeline(filters: Filter | Filter[], includeOldVersion?: boolean): Observable<NostrEvent[]>;
 }
+export interface IEventStore extends ISyncEventStore, IStreamEventStore {
+    add(event: NostrEvent, fromRelay?: string): NostrEvent;
+    remove(event: string | NostrEvent): boolean;
+    update(event: NostrEvent): NostrEvent;
+}

package/dist/helpers/__tests__/bookmarks.test.d.ts

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

package/dist/helpers/__tests__/bookmarks.test.js

@@ -0,0 +1,88 @@
+import { describe, it, expect } from "vitest";
+import { kinds } from "nostr-tools";
+import { mergeBookmarks } from "../bookmarks.js";
+describe("mergeBookmarks", () => {
+    it("should merge bookmarks and handle duplicates", () => {
+        // Create test data with some duplicates
+        const eventPointer1 = {
+            id: "event1",
+            relays: ["wss://relay1.com/", "wss://relay2.com/"],
+            author: "author1",
+        };
+        const eventPointer2 = {
+            id: "event1", // Same ID as eventPointer1
+            relays: ["wss://relay2.com/", "wss://relay3.com/"],
+            author: "author1",
+        };
+        const eventPointer3 = {
+            id: "event2",
+            relays: ["wss://relay1.com/"],
+            author: "author2",
+        };
+        const addressPointer1 = {
+            kind: kinds.LongFormArticle,
+            pubkey: "pubkey1",
+            identifier: "article1",
+            relays: ["wss://relay1.com/", "wss://relay2.com/"],
+        };
+        const addressPointer2 = {
+            kind: kinds.LongFormArticle,
+            pubkey: "pubkey1",
+            identifier: "article1", // Same as addressPointer1
+            relays: ["wss://relay3.com/"],
+        };
+        const bookmark1 = {
+            notes: [eventPointer1],
+            articles: [addressPointer1],
+            hashtags: ["tag1", "tag2"],
+            urls: ["https://example1.com/"],
+        };
+        const bookmark2 = {
+            notes: [eventPointer2, eventPointer3],
+            articles: [addressPointer2],
+            hashtags: ["tag2", "tag3"],
+            urls: ["https://example1.com/", "https://example2.com/"],
+        };
+        const result = mergeBookmarks(bookmark1, bookmark2);
+        // Check that duplicates are properly merged
+        expect(result.notes).toHaveLength(2); // event1 should be merged, plus event2
+        expect(result.articles).toHaveLength(1); // article1 should be merged
+        expect(result.hashtags).toHaveLength(3); // unique tags
+        expect(result.urls).toHaveLength(2); // unique urls
+        // Check that relays are merged for duplicate event
+        const mergedEvent = result.notes.find((note) => note.id === "event1");
+        expect(mergedEvent?.relays).toHaveLength(3);
+        expect(mergedEvent?.relays).toContain("wss://relay1.com/");
+        expect(mergedEvent?.relays).toContain("wss://relay2.com/");
+        expect(mergedEvent?.relays).toContain("wss://relay3.com/");
+        // Check that relays are merged for duplicate article
+        const mergedArticle = result.articles[0];
+        expect(mergedArticle.relays).toHaveLength(3);
+        expect(mergedArticle.relays).toContain("wss://relay1.com/");
+        expect(mergedArticle.relays).toContain("wss://relay2.com/");
+        expect(mergedArticle.relays).toContain("wss://relay3.com/");
+        // Check that hashtags are unique
+        expect(result.hashtags).toContain("tag1");
+        expect(result.hashtags).toContain("tag2");
+        expect(result.hashtags).toContain("tag3");
+        // Check that urls are unique
+        expect(result.urls).toContain("https://example1.com/");
+        expect(result.urls).toContain("https://example2.com/");
+    });
+    it("should handle undefined bookmarks", () => {
+        const bookmark = {
+            notes: [{ id: "event1", relays: ["wss://relay1.com/"] }],
+            articles: [],
+            hashtags: ["tag1"],
+            urls: ["https://example.com/"],
+        };
+        const result = mergeBookmarks(bookmark, undefined);
+        expect(result).toEqual(bookmark);
+        expect(mergeBookmarks(undefined, undefined)).toEqual({
+            notes: [],
+            articles: [],
+            hashtags: [],
+            urls: [],
+        });
+    });
+});

package/dist/helpers/__tests__/comment.test.js

@@ -27,6 +27,7 @@ describe("getCommentEventPointer", () => {
             ["e", "86c0b95589b016ffb703bfc080d49e54106e74e2d683295119c3453e494dbe6f"],
         ];
         expect(getCommentEventPointer(tags, true)).toEqual({
+            type: "event",
             id: "86c0b95589b016ffb703bfc080d49e54106e74e2d683295119c3453e494dbe6f",
             kind: 1621,
             pubkey: "e4336cd525df79fa4d3af364fd9600d4b10dce4215aa4c33ed77ea0842344b10",
@@ -45,6 +46,7 @@ describe("getCommentEventPointer", () => {
             ["P", "bad-pubkey"],
         ];
         expect(getCommentEventPointer(tags, true)).toEqual({
+            type: "event",
             id: "86c0b95589b016ffb703bfc080d49e54106e74e2d683295119c3453e494dbe6f",
             kind: 1621,
             pubkey: "e4336cd525df79fa4d3af364fd9600d4b10dce4215aa4c33ed77ea0842344b10",
@@ -62,6 +64,7 @@ describe("getCommentEventPointer", () => {
             ["K", "1621"],
         ];
         expect(getCommentEventPointer(tags, true)).toEqual({
+            type: "event",
             id: "86c0b95589b016ffb703bfc080d49e54106e74e2d683295119c3453e494dbe6f",
             kind: 1621,
             pubkey: "e4336cd525df79fa4d3af364fd9600d4b10dce4215aa4c33ed77ea0842344b10",
@@ -75,6 +78,7 @@ describe("getCommentEventPointer", () => {
             ["P", "e4336cd525df79fa4d3af364fd9600d4b10dce4215aa4c33ed77ea0842344b10"],
         ];
         expect(getCommentEventPointer(tags, true)).toEqual({
+            type: "event",
             id: "86c0b95589b016ffb703bfc080d49e54106e74e2d683295119c3453e494dbe6f",
             kind: 1621,
             pubkey: "e4336cd525df79fa4d3af364fd9600d4b10dce4215aa4c33ed77ea0842344b10",
@@ -107,6 +111,7 @@ describe("getCommentAddressPointer", () => {
             ["E", "86c0b95589b016ffb703bfc080d49e54106e74e2d683295119c3453e494dbe6f"],
             ["K", "30000"],
         ], true)).toEqual({
+            type: "address",
             id: "86c0b95589b016ffb703bfc080d49e54106e74e2d683295119c3453e494dbe6f",
             kind: 30000,
             pubkey: "e4336cd525df79fa4d3af364fd9600d4b10dce4215aa4c33ed77ea0842344b10",
@@ -118,6 +123,7 @@ describe("getCommentAddressPointer", () => {
             ["e", "86c0b95589b016ffb703bfc080d49e54106e74e2d683295119c3453e494dbe6f"],
             ["k", "30000"],
         ])).toEqual({
+            type: "address",
             id: "86c0b95589b016ffb703bfc080d49e54106e74e2d683295119c3453e494dbe6f",
             kind: 30000,
             pubkey: "e4336cd525df79fa4d3af364fd9600d4b10dce4215aa4c33ed77ea0842344b10",
@@ -130,6 +136,7 @@ describe("getCommentAddressPointer", () => {
             ["A", "30000:e4336cd525df79fa4d3af364fd9600d4b10dce4215aa4c33ed77ea0842344b10:list", "wss://relay.io/"],
             ["K", "30000"],
         ], true)).toEqual({
+            type: "address",
             kind: 30000,
             pubkey: "e4336cd525df79fa4d3af364fd9600d4b10dce4215aa4c33ed77ea0842344b10",
             identifier: "list",
@@ -140,6 +147,7 @@ describe("getCommentAddressPointer", () => {
             ["a", "30000:e4336cd525df79fa4d3af364fd9600d4b10dce4215aa4c33ed77ea0842344b10:list", "wss://relay.io/"],
             ["k", "30000"],
         ])).toEqual({
+            type: "address",
             kind: 30000,
             pubkey: "e4336cd525df79fa4d3af364fd9600d4b10dce4215aa4c33ed77ea0842344b10",
             identifier: "list",
@@ -153,6 +161,7 @@ describe("getCommentAddressPointer", () => {
             ["E", "86c0b95589b016ffb703bfc080d49e54106e74e2d683295119c3453e494dbe6f", "wss://relay.io/"],
             ["K", "30000"],
         ], true)).toEqual({
+            type: "address",
             id: "86c0b95589b016ffb703bfc080d49e54106e74e2d683295119c3453e494dbe6f",
             kind: 30000,
             pubkey: "e4336cd525df79fa4d3af364fd9600d4b10dce4215aa4c33ed77ea0842344b10",
@@ -165,6 +174,7 @@ describe("getCommentAddressPointer", () => {
             ["e", "86c0b95589b016ffb703bfc080d49e54106e74e2d683295119c3453e494dbe6f", "wss://relay.io/"],
             ["k", "30000"],
         ])).toEqual({
+            type: "address",
             id: "86c0b95589b016ffb703bfc080d49e54106e74e2d683295119c3453e494dbe6f",
             kind: 30000,
             pubkey: "e4336cd525df79fa4d3af364fd9600d4b10dce4215aa4c33ed77ea0842344b10",
@@ -178,6 +188,7 @@ describe("getCommentAddressPointer", () => {
             ["A", "30010:e4336cd525df79fa4d3af364fd9600d4b10dce4215aa4c33ed77ea0842344b10:list"],
             ["K", "30000"],
         ], true)).toEqual({
+            type: "address",
             kind: 30010,
             pubkey: "e4336cd525df79fa4d3af364fd9600d4b10dce4215aa4c33ed77ea0842344b10",
             identifier: "list",
@@ -187,6 +198,7 @@ describe("getCommentAddressPointer", () => {
             ["a", "30010:e4336cd525df79fa4d3af364fd9600d4b10dce4215aa4c33ed77ea0842344b10:list"],
             ["k", "30000"],
         ])).toEqual({
+            type: "address",
             kind: 30010,
             pubkey: "e4336cd525df79fa4d3af364fd9600d4b10dce4215aa4c33ed77ea0842344b10",
             identifier: "list",
@@ -214,6 +226,7 @@ describe("getCommentExternalPointer", () => {
             ["I", "podcast:item:guid:d98d189b-dc7b-45b1-8720-d4b98690f31f"],
             ["K", "podcast:item:guid"],
         ], true)).toEqual({
+            type: "external",
             identifier: "podcast:item:guid:d98d189b-dc7b-45b1-8720-d4b98690f31f",
             kind: "podcast:item:guid",
         });
@@ -222,6 +235,7 @@ describe("getCommentExternalPointer", () => {
             ["i", "podcast:item:guid:d98d189b-dc7b-45b1-8720-d4b98690f31f"],
             ["k", "podcast:item:guid"],
         ])).toEqual({
+            type: "external",
             identifier: "podcast:item:guid:d98d189b-dc7b-45b1-8720-d4b98690f31f",
             kind: "podcast:item:guid",
         });

package/dist/helpers/__tests__/contacts.test.d.ts

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

package/dist/helpers/__tests__/contacts.test.js

@@ -0,0 +1,34 @@
+import { describe, it, expect } from "vitest";
+import { mergeContacts } from "../contacts.js";
+describe("mergeContacts", () => {
+    it("should merge contacts and remove duplicates", () => {
+        // Create some test profile pointers
+        const pointer1 = { pubkey: "pubkey1", relays: ["relay1"] };
+        const pointer2 = { pubkey: "pubkey2" }; // No relays
+        const pointer3 = { pubkey: "pubkey3", relays: ["relay3"] };
+        const pointer4 = { pubkey: "pubkey1" }; // Duplicate pubkey without relays
+        // Test merging arrays of pointers
+        const result1 = mergeContacts([pointer1, pointer2], [pointer3, pointer4]);
+        // Should have 3 unique pubkeys
+        expect(result1.length).toBe(3);
+        // Check that the duplicate was handled correctly (last one should win)
+        const pubkey1Entry = result1.find((p) => p.pubkey === "pubkey1");
+        expect(pubkey1Entry).toBeDefined();
+        expect(pubkey1Entry?.relays).toBeUndefined();
+        // Test with undefined values
+        const result2 = mergeContacts([pointer1], undefined, [pointer2, undefined]);
+        expect(result2.length).toBe(2);
+        // Test with single pointers
+        const result3 = mergeContacts(pointer1, pointer2, pointer1);
+        expect(result3.length).toBe(2);
+        // Test with empty arrays
+        const result4 = mergeContacts([], [pointer1], []);
+        expect(result4.length).toBe(1);
+        // Test with pointers that have and don't have relays
+        const pointer5 = { pubkey: "pubkey5", relays: ["relay5"] };
+        const pointer6 = { pubkey: "pubkey5" }; // Same pubkey without relays
+        const result5 = mergeContacts([pointer5], [pointer6]);
+        expect(result5.length).toBe(1);
+        expect(result5[0].relays).toBeUndefined();
+    });
+});

package/dist/helpers/__tests__/events.test.d.ts

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

package/dist/helpers/__tests__/events.test.js

@@ -0,0 +1,32 @@
+import { kinds } from "nostr-tools";
+import { describe, expect, it } from "vitest";
+import { FakeUser } from "../../__tests__/fixtures.js";
+import { getReplaceableAddress } from "../event.js";
+const user = new FakeUser();
+describe("getReplaceableAddress", () => {
+    it("should throw an error for non-replaceable events", () => {
+        const normalEvent = user.note("Hello world");
+        expect(() => {
+            getReplaceableAddress(normalEvent);
+        }).toThrow("Event is not replaceable or addressable");
+    });
+    it("should return the correct address for replaceable events", () => {
+        const replaceableEvent = user.event({
+            kind: kinds.Metadata,
+            content: JSON.stringify({ name: "Test User" }),
+            tags: [],
+        });
+        const expectedAddress = `${kinds.Metadata}:${user.pubkey}:`;
+        expect(getReplaceableAddress(replaceableEvent)).toBe(expectedAddress);
+    });
+    it("should include the identifier for addressable events", () => {
+        const identifier = "test-profile";
+        const addressableEvent = user.event({
+            kind: 30000, // Parameterized replaceable event
+            content: "Test content",
+            tags: [["d", identifier]],
+        });
+        const expectedAddress = `30000:${user.pubkey}:${identifier}`;
+        expect(getReplaceableAddress(addressableEvent)).toBe(expectedAddress);
+    });
+});

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

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