applesauce-core 0.11.0 → 0.12.1

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

@@ -48,6 +48,30 @@ describe("add", () => {
         expect(eventStore.getEvent(profile.id)).toBeUndefined();
     });
 });
+describe("inserts", () => {
+    it("should emit newer replaceable events", () => {
+        const spy = subscribeSpyTo(eventStore.inserts);
+        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.inserts);
+        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.removes);
+        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);
@@ -69,7 +93,7 @@ describe("verifyEvent", () => {
         expect(verifyEvent).toHaveBeenCalledTimes(1);
     });
 });
-describe("deleted", () => {
+describe("removed", () => {
     it("should complete when event is removed", () => {
         eventStore.add(profile);
         const spy = subscribeSpyTo(eventStore.removed(profile.id));
@@ -187,6 +211,13 @@ describe("replaceable", () => {
         eventStore.add(user.profile({ name: "really old name" }, { created_at: profile.created_at - 1000 }));
         expect(spy.getValues()).toEqual([profile]);
     });
+    it("should emit newer events", () => {
+        const spy = subscribeSpyTo(eventStore.replaceable(0, user.pubkey));
+        eventStore.add(profile);
+        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", () => {
@@ -223,6 +254,19 @@ describe("timeline", () => {
         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", () => {

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

@@ -14,6 +14,7 @@ export declare class Database {
     protected created_at: NostrEvent[];
     /** LRU cache of last events touched */
     events: LRU<import("nostr-tools").Event>;
+    /** A sorted array of replaceable events by uid */
     protected replaceable: Map<string, import("nostr-tools").Event[]>;
     /** A stream of events inserted into the database */
     inserted: Subject<import("nostr-tools").Event>;
@@ -60,7 +61,7 @@ export declare class Database {
     iterateIds(ids: Iterable<string>): Generator<NostrEvent>;
     /** Returns all events that match the filter */
     getEventsForFilter(filter: Filter): Set<NostrEvent>;
-    getForFilters(filters: Filter[]): Set<NostrEvent>;
+    getEventsForFilters(filters: Filter[]): Set<NostrEvent>;
     /** Remove the oldest events that are not claimed */
     prune(limit?: number): number;
 }

package/dist/event-store/database.js

@@ -1,6 +1,6 @@
 import { binarySearch, insertEventIntoDescendingList } from "nostr-tools/utils";
 import { Subject } from "rxjs";
-import { FromCacheSymbol, getEventUID, getIndexableTags, getReplaceableUID, isReplaceable } from "../helpers/event.js";
+import { getEventUID, getIndexableTags, getReplaceableUID, isReplaceable } from "../helpers/event.js";
 import { INDEXABLE_TAGS } from "./common.js";
 import { logger } from "../logger.js";
 import { LRU } from "../helpers/lru.js";
@@ -17,6 +17,7 @@ export class Database {
     created_at = [];
     /** LRU cache of last events touched */
     events = new LRU();
+    /** A sorted array of replaceable events by uid */
     replaceable = new Map();
     /** A stream of events inserted into the database */
     inserted = new Subject();
@@ -83,12 +84,8 @@ export class Database {
     addEvent(event) {
         const id = event.id;
         const current = this.events.get(id);
-        if (current) {
-            // if this is a duplicate event, transfer some important symbols
-            if (event[FromCacheSymbol])
-                current[FromCacheSymbol] = event[FromCacheSymbol];
+        if (current)
             return current;
-        }
         this.onBeforeInsert?.(event);
         this.events.set(id, event);
         this.getKindIndex(event.kind).add(event);
@@ -105,9 +102,11 @@ export class Database {
             const uid = getEventUID(event);
             let array = this.replaceable.get(uid);
             if (!this.replaceable.has(uid)) {
+                // add an empty array if there is no array
                 array = [];
                 this.replaceable.set(uid, array);
             }
+            // insert the event into the sorted array
             insertEventIntoDescendingList(array, event);
         }
         this.inserted.next(event);
@@ -287,7 +286,7 @@ export class Database {
         }
         return events;
     }
-    getForFilters(filters) {
+    getEventsForFilters(filters) {
         if (filters.length === 0)
             throw new Error("No Filters");
         let events = new Set();

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

@@ -1,12 +1,20 @@
 import { Filter, NostrEvent } from "nostr-tools";
 import { Observable } from "rxjs";
 import { Database } from "./database.js";
-export declare class EventStore {
+import { IEventStore } from "./interface.js";
+export declare const EventStoreSymbol: unique symbol;
+export declare class EventStore implements IEventStore {
     database: Database;
     /** Enable this to keep old versions of replaceable events */
     keepOldVersions: boolean;
     /** A method used to verify new events before added them */
     verifyEvent?: (event: NostrEvent) => boolean;
+    /** A stream of new events added to the store */
+    inserts: Observable<NostrEvent>;
+    /** A stream of events that have been updated */
+    updates: Observable<NostrEvent>;
+    /** A stream of events that have been removed */
+    removes: Observable<NostrEvent>;
     constructor();
     protected deletedIds: Set<string>;
     protected deletedCoords: Map<string, number>;
@@ -26,16 +34,18 @@ export declare class EventStore {
     /** Add an event to the store and notifies all subscribes it has updated */
     update(event: NostrEvent): NostrEvent;
     /** Get all events matching a filter */
-    getAll(filters: Filter[]): Set<NostrEvent>;
+    getAll(filters: Filter | Filter[]): Set<NostrEvent>;
     /** Check if the store has an event */
-    hasEvent(uid: string): boolean;
-    getEvent(uid: string): NostrEvent | undefined;
+    hasEvent(id: string): boolean;
+    getEvent(id: string): NostrEvent | undefined;
     /** Check if the store has a replaceable event */
     hasReplaceable(kind: number, pubkey: string, d?: string): boolean;
     /** Gets the latest version of a replaceable event */
     getReplaceable(kind: number, pubkey: string, d?: string): NostrEvent | undefined;
     /** Returns all versions of a replaceable event */
     getReplaceableHistory(kind: number, pubkey: string, d?: string): NostrEvent[] | undefined;
+    /** Returns a timeline of events that match filters */
+    getTimeline(filters: Filter | Filter[]): NostrEvent[];
     /**
      * Creates an observable that streams all events that match the filter and remains open
      * @param filters
@@ -45,7 +55,7 @@ export declare class EventStore {
     /** 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(id: string): Observable<NostrEvent>;
+    updated(event: string | NostrEvent): Observable<NostrEvent>;
     /** Creates an observable that subscribes to a single event */
     event(id: string): Observable<NostrEvent | undefined>;
     /** Creates an observable that subscribes to multiple events */

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

@@ -3,12 +3,13 @@ import { insertEventIntoDescendingList } from "nostr-tools/utils";
 import { isParameterizedReplaceableKind } 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 { getEventUID, getReplaceableIdentifier, getReplaceableUID, getTagValue, isReplaceable, } from "../helpers/event.js";
+import { FromCacheSymbol, getEventUID, getReplaceableIdentifier, getReplaceableUID, 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";
+export const EventStoreSymbol = Symbol.for("event-store");
 function sortDesc(a, b) {
     return b.created_at - a.created_at;
 }
@@ -18,6 +19,12 @@ export class EventStore {
     keepOldVersions = false;
     /** A method used to verify new events before added them */
     verifyEvent;
+    /** A stream of new events added to the store */
+    inserts;
+    /** A stream of events that have been updated */
+    updates;
+    /** A stream of events that have been removed */
+    removes;
     constructor() {
         this.database = new Database();
         this.database.onBeforeInsert = (event) => {
@@ -25,6 +32,17 @@ export class EventStore {
             if (this.verifyEvent && this.verifyEvent(event) === false)
                 throw new Error("Invalid event");
         };
+        // when events are added to the database, add the symbol
+        this.database.inserted.subscribe((event) => {
+            Reflect.set(event, EventStoreSymbol, this);
+        });
+        // when events are removed from the database, remove the symbol
+        this.database.removed.subscribe((event) => {
+            Reflect.deleteProperty(event, EventStoreSymbol);
+        });
+        this.inserts = this.database.inserted;
+        this.updates = this.database.updated;
+        this.removes = this.database.removed;
     }
     // delete state
     deletedIds = new Set();
@@ -69,6 +87,10 @@ export class EventStore {
             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 database and update subscriptions
@@ -80,6 +102,25 @@ export class EventStore {
         // Ignore if the event was deleted
         if (this.checkDeleted(event))
             return event;
+        // Get the replaceable identifier
+        const d = isReplaceable(event.kind) ? getTagValue(event, "d") : undefined;
+        // Don't insert the event if there is already a newer version
+        if (!this.keepOldVersions && isReplaceable(event.kind)) {
+            const existing = this.database.getReplaceable(event.kind, event.pubkey, d);
+            // 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]);
+                return existing[0];
+            }
+        }
+        else if (this.database.hasEvent(event.id)) {
+            // Duplicate event, copy symbols and return existing event
+            const existing = this.database.getEvent(event.id);
+            if (existing) {
+                EventStore.mergeDuplicateEvent(event, existing);
+                return existing;
+            }
+        }
         // Insert event into database
         const inserted = this.database.addEvent(event);
         // Copy cached data if its a duplicate event
@@ -90,7 +131,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.getReplaceable(event.kind, event.pubkey, getTagValue(event, "d"));
+            const existing = this.database.getReplaceable(event.kind, event.pubkey, d);
             if (existing) {
                 const older = Array.from(existing).filter((e) => e.created_at < event.created_at);
                 for (const old of older)
@@ -117,14 +158,14 @@ export class EventStore {
     }
     /** Get all events matching a filter */
     getAll(filters) {
-        return this.database.getForFilters(filters);
+        return this.database.getEventsForFilters(Array.isArray(filters) ? filters : [filters]);
     }
     /** Check if the store has an event */
-    hasEvent(uid) {
-        return this.database.hasEvent(uid);
+    hasEvent(id) {
+        return this.database.hasEvent(id);
     }
-    getEvent(uid) {
-        return this.database.getEvent(uid);
+    getEvent(id) {
+        return this.database.getEvent(id);
     }
     /** Check if the store has a replaceable event */
     hasReplaceable(kind, pubkey, d) {
@@ -138,6 +179,10 @@ export class EventStore {
     getReplaceableHistory(kind, pubkey, d) {
         return this.database.getReplaceable(kind, pubkey, d);
     }
+    /** Returns a timeline of events that match filters */
+    getTimeline(filters) {
+        return Array.from(this.database.getEventsForFilters(Array.isArray(filters) ? filters : [filters])).sort(sortDesc);
+    }
     /**
      * Creates an observable that streams all events that match the filter and remains open
      * @param filters
@@ -149,14 +194,14 @@ export class EventStore {
         // merge existing events
         onlyNew ? EMPTY : from(this.getAll(filters)), 
         // subscribe to future events
-        this.database.inserted.pipe(filter((e) => matchFilters(filters, e))));
+        this.inserts.pipe(filter((e) => matchFilters(filters, e))));
     }
     /** Returns an observable that completes when an event is removed */
     removed(id) {
         const deleted = this.checkDeleted(id);
         if (deleted)
             return EMPTY;
-        return this.database.removed.pipe(
+        return this.removes.pipe(
         // listen for removed events
         filter((e) => e.id === id), 
         // complete as soon as we find a matching removed event
@@ -165,8 +210,8 @@ export class EventStore {
         mergeMap(() => EMPTY));
     }
     /** Creates an observable that emits when event is updated */
-    updated(id) {
-        return this.database.updated.pipe(filter((e) => e.id === id));
+    updated(event) {
+        return this.database.updated.pipe(filter((e) => e.id === event || e === event));
     }
     /** Creates an observable that subscribes to a single event */
     event(id) {
@@ -177,13 +222,13 @@ export class EventStore {
             return event ? of(event) : EMPTY;
         }), 
         // subscribe to updates
-        this.database.inserted.pipe(filter((e) => e.id === id)), 
+        this.inserts.pipe(filter((e) => e.id === id)), 
         // subscribe to updates
         this.updated(id), 
         // emit undefined when deleted
         this.removed(id).pipe(endWith(undefined))).pipe(
         // claim all events
-        claimEvents(this.database));
+        claimLatest(this.database));
     }
     /** Creates an observable that subscribes to multiple events */
     events(ids) {
@@ -191,15 +236,15 @@ export class EventStore {
         // lazily get existing events
         defer(() => from(ids.map((id) => this.getEvent(id)))), 
         // subscribe to new events
-        this.database.inserted.pipe(filter((e) => ids.includes(e.id))), 
+        this.inserts.pipe(filter((e) => ids.includes(e.id))), 
         // subscribe to updates
-        this.database.updated.pipe(filter((e) => ids.includes(e.id)))).pipe(
+        this.updates.pipe(filter((e) => ids.includes(e.id)))).pipe(
         // ignore empty messages
         filter((e) => !!e), 
         // claim all events until cleanup
         claimEvents(this.database), 
         // watch for removed events
-        mergeWith(this.database.removed.pipe(filter((e) => ids.includes(e.id)), map((e) => e.id))), 
+        mergeWith(this.removes.pipe(filter((e) => ids.includes(e.id)), map((e) => e.id))), 
         // merge all events into a directory
         scan((dir, event) => {
             if (typeof event === "string") {
@@ -224,13 +269,16 @@ export class EventStore {
             return event ? of(event) : EMPTY;
         }), 
         // subscribe to new events
-        this.database.inserted.pipe(filter((e) => e.pubkey == pubkey && e.kind === kind && (d !== undefined ? getReplaceableIdentifier(e) === d : true)))).pipe(
+        this.inserts.pipe(filter((e) => e.pubkey == pubkey && e.kind === kind && (d !== undefined ? getReplaceableIdentifier(e) === d : true)))).pipe(
         // only update if event is newer
-        distinctUntilChanged((prev, event) => prev.created_at >= event.created_at), 
+        distinctUntilChanged((prev, event) => {
+            // are the events the same? i.e. is the prev event older
+            return prev.created_at >= event.created_at;
+        }), 
         // Hacky way to extract the current event so takeUntil can access it
         tap((event) => (current = event)), 
         // complete when event is removed
-        takeUntil(this.database.removed.pipe(filter((e) => e.id === current?.id))), 
+        takeUntil(this.removes.pipe(filter((e) => e.id === current?.id))), 
         // emit undefined when removed
         endWith(undefined), 
         // keep the observable hot
@@ -245,7 +293,7 @@ export class EventStore {
         // start with existing events
         defer(() => from(pointers.map((p) => this.getReplaceable(p.kind, p.pubkey, p.identifier)))), 
         // subscribe to new events
-        this.database.inserted.pipe(filter((e) => isReplaceable(e.kind) && uids.has(getEventUID(e))))).pipe(
+        this.inserts.pipe(filter((e) => isReplaceable(e.kind) && uids.has(getEventUID(e))))).pipe(
         // filter out undefined
         filter((e) => !!e), 
         // claim all events
@@ -253,7 +301,7 @@ export class EventStore {
         // convert events to add commands
         map((e) => ["add", e]), 
         // watch for removed events
-        mergeWith(this.database.removed.pipe(filter((e) => isReplaceable(e.kind) && uids.has(getEventUID(e))), map((e) => ["remove", e]))), 
+        mergeWith(this.removes.pipe(filter((e) => isReplaceable(e.kind) && uids.has(getEventUID(e))), map((e) => ["remove", e]))), 
         // reduce events into directory
         scan((dir, [action, event]) => {
             const uid = getEventUID(event);
@@ -278,15 +326,15 @@ export class EventStore {
         filters = Array.isArray(filters) ? filters : [filters];
         const seen = new Map();
         // get current events
-        return defer(() => of(Array.from(this.database.getForFilters(filters)).sort(sortDesc))).pipe(
+        return defer(() => of(Array.from(this.database.getEventsForFilters(filters)).sort(sortDesc))).pipe(
         // claim existing events
         claimEvents(this.database), 
         // subscribe to newer events
-        mergeWith(this.database.inserted.pipe(filter((e) => matchFilters(filters, e)), 
+        mergeWith(this.inserts.pipe(filter((e) => matchFilters(filters, e)), 
         // claim all new events
         claimEvents(this.database))), 
         // subscribe to delete events
-        mergeWith(this.database.removed.pipe(filter((e) => matchFilters(filters, e)), map((e) => e.id))), 
+        mergeWith(this.removes.pipe(filter((e) => matchFilters(filters, e)), map((e) => e.id))), 
         // build a timeline
         scan((timeline, event) => {
             // filter out removed events from timeline

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

@@ -1,2 +1,3 @@
 export * from "./event-store.js";
 export * from "./database.js";
+export * from "./interface.js";

package/dist/event-store/index.js

@@ -1,2 +1,3 @@
 export * from "./event-store.js";
 export * from "./database.js";
+export * from "./interface.js";

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

@@ -0,0 +1,29 @@
+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;
+    hasEvent(id: string): boolean;
+    hasReplaceable(kind: number, pubkey: string, identifier?: string): boolean;
+    getEvent(id: string): NostrEvent | undefined;
+    getReplaceable(kind: number, pubkey: string, identifier?: string): NostrEvent | undefined;
+    getReplaceableHistory(kind: number, pubkey: string, identifier?: string): NostrEvent[] | undefined;
+    getAll(filters: Filter | Filter[]): Set<NostrEvent>;
+    getTimeline(filters: Filter | Filter[]): NostrEvent[];
+    filters(filters: Filter | Filter[]): Observable<NostrEvent>;
+    updated(id: string | NostrEvent): Observable<NostrEvent>;
+    removed(id: string): Observable<never>;
+    event(id: string): Observable<NostrEvent | undefined>;
+    events(ids: string[]): Observable<Record<string, NostrEvent>>;
+    replaceable(kind: number, pubkey: string, identifier?: string): Observable<NostrEvent | undefined>;
+    replaceableSet(pointers: {
+        kind: number;
+        pubkey: string;
+        identifier?: string;
+    }[]): Observable<Record<string, NostrEvent>>;
+    timeline(filters: Filter | Filter[], includeOldVersion?: boolean): Observable<NostrEvent[]>;
+}

package/dist/helpers/__tests__/nip-19.test.d.ts

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

package/dist/helpers/__tests__/nip-19.test.js

@@ -0,0 +1,42 @@
+import { describe, expect, it } from "vitest";
+import { bytesToHex } from "@noble/hashes/utils";
+import { normalizeToPubkey, normalizeToSecretKey } from "../nip-19.js";
+describe("normalizeToPubkey", () => {
+    it("should get pubkey from npub", () => {
+        expect(normalizeToPubkey("npub1ye5ptcxfyyxl5vjvdjar2ua3f0hynkjzpx552mu5snj3qmx5pzjscpknpr")).toEqual("266815e0c9210dfa324c6cba3573b14bee49da4209a9456f9484e5106cd408a5");
+    });
+    it("should get pubkey from nprofile", () => {
+        expect(normalizeToPubkey("nprofile1qyw8wumn8ghj7umpw3jkcmrfw3jju6r6wfjrzdpe9e3k7mf0qyf8wumn8ghj7mn0wd68yat99e3k7mf0qqszv6q4uryjzr06xfxxew34wwc5hmjfmfpqn229d72gfegsdn2q3fg5g7lja")).toEqual("266815e0c9210dfa324c6cba3573b14bee49da4209a9456f9484e5106cd408a5");
+    });
+    it("should return hex pubkey", () => {
+        expect(normalizeToPubkey("266815e0c9210dfa324c6cba3573b14bee49da4209a9456f9484e5106cd408a5")).toEqual("266815e0c9210dfa324c6cba3573b14bee49da4209a9456f9484e5106cd408a5");
+    });
+    it("should throw on invalid hex pubkey", () => {
+        expect(() => {
+            normalizeToPubkey("5028372");
+        }).toThrow();
+    });
+    it("should throw on invalid string", () => {
+        expect(() => {
+            normalizeToPubkey("testing");
+        }).toThrow();
+    });
+});
+describe("normalizeToSecretKey", () => {
+    it("should get secret key from nsec", () => {
+        expect(bytesToHex(normalizeToSecretKey("nsec1xe7znq745x5n68566l32ru72aajz3pk2cys9lnf3tuexvkw0dldsj8v2lm"))).toEqual("367c2983d5a1a93d1e9ad7e2a1f3caef642886cac1205fcd315f326659cf6fdb");
+    });
+    it("should get secret key from raw hex", () => {
+        expect(bytesToHex(normalizeToSecretKey("367c2983d5a1a93d1e9ad7e2a1f3caef642886cac1205fcd315f326659cf6fdb"))).toEqual("367c2983d5a1a93d1e9ad7e2a1f3caef642886cac1205fcd315f326659cf6fdb");
+    });
+    it("should throw on invalid hex key", () => {
+        expect(() => {
+            normalizeToSecretKey("209573290");
+        }).toThrow();
+    });
+    it("should throw on npub", () => {
+        expect(() => {
+            normalizeToSecretKey("npub1ye5ptcxfyyxl5vjvdjar2ua3f0hynkjzpx552mu5snj3qmx5pzjscpknpr");
+        }).toThrow();
+    });
+});

package/dist/helpers/cache.d.ts

@@ -1,5 +1,4 @@
-import { EventTemplate, NostrEvent } from "nostr-tools";
-export declare function getCachedValue<T extends unknown>(event: NostrEvent | EventTemplate, symbol: symbol): T | undefined;
-export declare function setCachedValue<T extends unknown>(event: NostrEvent | EventTemplate, symbol: symbol, value: T): void;
+export declare function getCachedValue<T extends unknown>(event: any, symbol: symbol): T | undefined;
+export declare function setCachedValue<T extends unknown>(event: any, symbol: symbol, value: T): void;
 /** Internal method used to cache computed values on events */
-export declare function getOrComputeCachedValue<T extends unknown>(event: NostrEvent | EventTemplate, symbol: symbol, compute: (event: NostrEvent | EventTemplate) => T): T;
+export declare function getOrComputeCachedValue<T extends unknown>(event: any, symbol: symbol, compute: () => T): T;

package/dist/helpers/cache.js

@@ -10,7 +10,7 @@ export function getOrComputeCachedValue(event, symbol, compute) {
         return Reflect.get(event, symbol);
     }
     else {
-        const value = compute(event);
+        const value = compute();
         Reflect.set(event, symbol, value);
         return value;
     }

package/dist/helpers/direct-messages.d.ts

@@ -0,0 +1,4 @@
+import { NostrEvent } from "nostr-tools";
+import { HiddenContentSigner } from "./hidden-content.js";
+/** Returns the decrypted content of a direct message */
+export declare function decryptDirectMessage(message: NostrEvent, signer: HiddenContentSigner): Promise<string>;

package/dist/helpers/direct-messages.js

@@ -0,0 +1,5 @@
+import { getHiddenContent, unlockHiddenContent } from "./hidden-content.js";
+/** Returns the decrypted content of a direct message */
+export async function decryptDirectMessage(message, signer) {
+    return getHiddenContent(message) || (await unlockHiddenContent(message, signer));
+}

package/dist/helpers/event.d.ts

@@ -1,4 +1,5 @@
-import { EventTemplate, NostrEvent, VerifiedEvent } from "nostr-tools";
+import { NostrEvent, VerifiedEvent } from "nostr-tools";
+import { IEventStore } from "../event-store/interface.js";
 export declare const EventUIDSymbol: unique symbol;
 export declare const EventIndexableTagsSymbol: unique symbol;
 export declare const FromCacheSymbol: unique symbol;
@@ -34,13 +35,20 @@ export declare function getIndexableTags(event: NostrEvent): Set<string>;
  * Returns the second index ( tag[1] ) of the first tag that matches the name
  * If the event has any hidden tags they will be searched first
  */
-export declare function getTagValue(event: NostrEvent | EventTemplate, name: string): string | undefined;
+export declare function getTagValue<T extends {
+    kind: number;
+    tags: string[][];
+    content: string;
+    pubkey: string;
+}>(event: T, name: string): string | undefined;
 /** Sets events verified flag without checking anything */
 export declare function fakeVerifyEvent(event: NostrEvent): event is VerifiedEvent;
 /** Marks an event as being from a cache */
 export declare function markFromCache(event: NostrEvent): void;
 /** Returns if an event was from a cache */
 export declare function isFromCache(event: NostrEvent): boolean;
+/** Returns the EventStore of an event if its been added to one */
+export declare function getParentEventStore<T extends object>(event: T): IEventStore | undefined;
 /**
  * Returns the replaceable identifier for a replaceable event
  * @throws

package/dist/helpers/event.js

@@ -3,6 +3,7 @@ import { INDEXABLE_TAGS } from "../event-store/common.js";
 import { getHiddenTags } from "./hidden-tags.js";
 import { getOrComputeCachedValue } from "./cache.js";
 import { isParameterizedReplaceableKind } from "nostr-tools/kinds";
+import { EventStoreSymbol } from "../event-store/event-store.js";
 export const EventUIDSymbol = Symbol.for("event-uid");
 export const EventIndexableTagsSymbol = Symbol.for("indexable-tags");
 export const FromCacheSymbol = Symbol.for("from-cache");
@@ -90,6 +91,10 @@ export function markFromCache(event) {
 export function isFromCache(event) {
     return !!event[FromCacheSymbol];
 }
+/** Returns the EventStore of an event if its been added to one */
+export function getParentEventStore(event) {
+    return Reflect.get(event, EventStoreSymbol);
+}
 /**
  * Returns the replaceable identifier for a replaceable event
  * @throws

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

@@ -0,0 +1,12 @@
+import { NostrEvent, UnsignedEvent } from "nostr-tools";
+import { HiddenContentSigner } from "./hidden-content.js";
+export declare const GiftWrapSealSymbol: unique symbol;
+export declare const GiftWrapEventSymbol: unique symbol;
+/** Returns the unsigned seal event in a gift-wrap event */
+export declare function getGiftWrapSeal(gift: NostrEvent): NostrEvent | undefined;
+/** Returns the unsigned event in the gift-wrap seal */
+export declare function getGiftWrapEvent(gift: NostrEvent): UnsignedEvent | undefined;
+/** Returns if a gift-wrap event or gift-wrap seal is locked */
+export declare function isGiftWrapLocked(gift: NostrEvent): boolean;
+/** Unlocks and returns the unsigned seal event in a gift-wrap */
+export declare function unlockGiftWrap(gift: NostrEvent, signer: HiddenContentSigner): Promise<UnsignedEvent>;