applesauce-core 0.11.0 → 0.12.0

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

@@ -69,7 +69,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));
@@ -223,6 +223,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

@@ -60,7 +60,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

@@ -287,7 +287,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,16 @@
 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 events that have been updated */
+    updates: Observable<NostrEvent>;
     constructor();
     protected deletedIds: Set<string>;
     protected deletedCoords: Map<string, number>;
@@ -26,16 +30,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 +51,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

@@ -9,6 +9,7 @@ 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,8 @@ export class EventStore {
     keepOldVersions = false;
     /** A method used to verify new events before added them */
     verifyEvent;
+    /** A stream of events that have been updated */
+    updates;
     constructor() {
         this.database = new Database();
         this.database.onBeforeInsert = (event) => {
@@ -25,6 +28,15 @@ 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.updates = this.database.updated;
     }
     // delete state
     deletedIds = new Set();
@@ -117,14 +129,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 +150,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
@@ -165,8 +181,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) {
@@ -183,7 +199,7 @@ export class EventStore {
         // 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) {
@@ -278,7 +294,7 @@ 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

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,27 @@
+import { Filter, NostrEvent } from "nostr-tools";
+import { Observable } from "rxjs";
+export interface IEventStore {
+    updates: 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>;

package/dist/helpers/gift-wraps.js

@@ -0,0 +1,49 @@
+import { verifyEvent } from "nostr-tools";
+import { getHiddenContent, isHiddenContentLocked, unlockHiddenContent } from "./hidden-content.js";
+import { getOrComputeCachedValue } from "./cache.js";
+export const GiftWrapSealSymbol = Symbol.for("gift-wrap-seal");
+export const GiftWrapEventSymbol = Symbol.for("gift-wrap-event");
+/** Returns the unsigned seal event in a gift-wrap event */
+export function getGiftWrapSeal(gift) {
+    if (isHiddenContentLocked(gift))
+        return undefined;
+    return getOrComputeCachedValue(gift, GiftWrapSealSymbol, () => {
+        const plaintext = getHiddenContent(gift);
+        if (!plaintext)
+            throw new Error("Gift-wrap is locked");
+        const seal = JSON.parse(plaintext);
+        // verify the seal is valid
+        verifyEvent(seal);
+        return seal;
+    });
+}
+/** Returns the unsigned event in the gift-wrap seal */
+export function getGiftWrapEvent(gift) {
+    if (isHiddenContentLocked(gift))
+        return undefined;
+    return getOrComputeCachedValue(gift, GiftWrapEventSymbol, () => {
+        const seal = getGiftWrapSeal(gift);
+        if (!seal)
+            throw new Error("Gift is locked");
+        const plaintext = getHiddenContent(seal);
+        if (!plaintext)
+            throw new Error("Gift-wrap seal is locked");
+        const event = JSON.parse(plaintext);
+        if (event.pubkey !== seal.pubkey)
+            throw new Error("Seal author does not match content");
+        return event;
+    });
+}
+/** Returns if a gift-wrap event or gift-wrap seal is locked */
+export function isGiftWrapLocked(gift) {
+    return isHiddenContentLocked(gift) || isHiddenContentLocked(getGiftWrapSeal(gift));
+}
+/** Unlocks and returns the unsigned seal event in a gift-wrap */
+export async function unlockGiftWrap(gift, signer) {
+    if (isHiddenContentLocked(gift))
+        await unlockHiddenContent(gift, signer);
+    const seal = getGiftWrapSeal(gift);
+    if (isHiddenContentLocked(seal))
+        await unlockHiddenContent(seal, signer);
+    return getGiftWrapEvent(gift);
+}

package/dist/helpers/hidden-content.d.ts

@@ -0,0 +1,48 @@
+export declare const HiddenContentSymbol: unique symbol;
+export type HiddenContentSigner = {
+    nip04?: {
+        encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
+        decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
+    };
+    nip44?: {
+        encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
+        decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
+    };
+};
+/** Various event kinds that can have encrypted tags in their content and which encryption method they use */
+export declare const EventContentEncryptionMethod: Record<number, "nip04" | "nip44">;
+/** Sets the encryption method that is used for the contents of a specific event kind */
+export declare function setEventContentEncryptionMethod(kind: number, method: "nip04" | "nip44"): void;
+/** Checks if an event can have hidden content */
+export declare function canHaveHiddenContent(kind: number): boolean;
+/** Checks if an event has hidden content */
+export declare function hasHiddenContent<T extends {
+    kind: number;
+    content: string;
+}>(event: T): boolean;
+/** Returns the hidden tags for an event if they are unlocked */
+export declare function getHiddenContent<T extends object>(event: T): string | undefined;
+/** Checks if the hidden tags are locked */
+export declare function isHiddenContentLocked<T extends object>(event: T): boolean;
+/** Returns either nip04 or nip44 encryption methods depending on event kind */
+export declare function getHiddenContentEncryptionMethods(kind: number, signer: HiddenContentSigner): {
+    encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
+    decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
+} | {
+    encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
+    decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
+};
+export type HiddenContentEvent = {
+    kind: number;
+    pubkey: string;
+    content: string;
+};
+/**
+ * Unlocks the encrypted content in an event
+ * @param event The event with content to decrypt
+ * @param signer A signer to use to decrypt the tags
+ * @throws
+ */
+export declare function unlockHiddenContent<T extends HiddenContentEvent>(event: T, signer: HiddenContentSigner): Promise<string>;
+/** Removes the unencrypted hidden content on an event */
+export declare function lockHiddenContent<T extends object>(event: T): void;

package/dist/helpers/hidden-content.js

@@ -0,0 +1,88 @@
+import * as kinds from "nostr-tools/kinds";
+import { GROUPS_LIST_KIND } from "./groups.js";
+import { getParentEventStore, isEvent } from "./event.js";
+export const HiddenContentSymbol = Symbol.for("hidden-content");
+/** Various event kinds that can have encrypted tags in their content and which encryption method they use */
+export const EventContentEncryptionMethod = {
+    // NIP-60 wallet
+    17375: "nip44",
+    375: "nip44",
+    7375: "nip44",
+    7376: "nip44",
+    // DMs
+    [kinds.EncryptedDirectMessage]: "nip04",
+    // Gift wraps
+    [kinds.GiftWrap]: "nip44",
+    // NIP-51 lists
+    [kinds.BookmarkList]: "nip04",
+    [kinds.InterestsList]: "nip04",
+    [kinds.Mutelist]: "nip04",
+    [kinds.CommunitiesList]: "nip04",
+    [kinds.PublicChatsList]: "nip04",
+    [kinds.SearchRelaysList]: "nip04",
+    [GROUPS_LIST_KIND]: "nip04",
+    // NIP-51 sets
+    [kinds.Bookmarksets]: "nip04",
+    [kinds.Relaysets]: "nip04",
+    [kinds.Followsets]: "nip04",
+    [kinds.Curationsets]: "nip04",
+    [kinds.Interestsets]: "nip04",
+};
+/** Sets the encryption method that is used for the contents of a specific event kind */
+export function setEventContentEncryptionMethod(kind, method) {
+    EventContentEncryptionMethod[kind] = method;
+}
+/** Checks if an event can have hidden content */
+export function canHaveHiddenContent(kind) {
+    return EventContentEncryptionMethod[kind] !== undefined;
+}
+/** Checks if an event has hidden content */
+export function hasHiddenContent(event) {
+    return canHaveHiddenContent(event.kind) && event.content.length > 0;
+}
+/** Returns the hidden tags for an event if they are unlocked */
+export function getHiddenContent(event) {
+    return Reflect.get(event, HiddenContentSymbol);
+}
+/** Checks if the hidden tags are locked */
+export function isHiddenContentLocked(event) {
+    return Reflect.has(event, HiddenContentSymbol) === false;
+}
+/** Returns either nip04 or nip44 encryption methods depending on event kind */
+export function getHiddenContentEncryptionMethods(kind, signer) {
+    const method = EventContentEncryptionMethod[kind];
+    const encryption = signer[method];
+    if (!encryption)
+        throw new Error(`Signer does not support ${method} encryption`);
+    return encryption;
+}
+/**
+ * Unlocks the encrypted content in an event
+ * @param event The event with content to decrypt
+ * @param signer A signer to use to decrypt the tags
+ * @throws
+ */
+export async function unlockHiddenContent(event, signer) {
+    if (!canHaveHiddenContent(event.kind))
+        throw new Error("Event kind does not support hidden content");
+    const encryption = getHiddenContentEncryptionMethods(event.kind, signer);
+    const plaintext = await encryption.decrypt(event.pubkey, event.content);
+    Reflect.set(event, HiddenContentSymbol, plaintext);
+    // if the event has been added to an event store, notify it
+    if (isEvent(event)) {
+        const eventStore = getParentEventStore(event);
+        if (eventStore)
+            eventStore.update(event);
+    }
+    return plaintext;
+}
+/** Removes the unencrypted hidden content on an event */
+export function lockHiddenContent(event) {
+    Reflect.deleteProperty(event, HiddenContentSymbol);
+    // if the event has been added to an event store, notify it
+    if (isEvent(event)) {
+        const eventStore = getParentEventStore(event);
+        if (eventStore)
+            eventStore.update(event);
+    }
+}

package/dist/helpers/hidden-tags.d.ts

@@ -1,28 +1,18 @@
-import { EventTemplate, NostrEvent } from "nostr-tools";
-import { EventStore } from "../event-store/event-store.js";
-export type HiddenTagsSigner = {
-    nip04?: {
-        encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
-        decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
-    };
-    nip44?: {
-        encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
-        decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
-    };
-};
+import { HiddenContentEvent, HiddenContentSigner } from "./hidden-content.js";
 export declare const HiddenTagsSymbol: unique symbol;
-/** Various event kinds that can have encrypted tags in their content and which encryption method they use */
-export declare const EventEncryptionMethod: Record<number, "nip04" | "nip44">;
 /** Checks if an event can have hidden tags */
 export declare function canHaveHiddenTags(kind: number): boolean;
 /** Checks if an event has hidden tags */
-export declare function hasHiddenTags(event: NostrEvent | EventTemplate): boolean;
+export declare function hasHiddenTags<T extends {
+    content: string;
+    kind: number;
+}>(event: T): boolean;
 /** Returns the hidden tags for an event if they are unlocked */
-export declare function getHiddenTags(event: NostrEvent | EventTemplate): string[][] | undefined;
+export declare function getHiddenTags<T extends object>(event: T): string[][] | undefined;
 /** Checks if the hidden tags are locked */
-export declare function isHiddenTagsLocked(event: NostrEvent): boolean;
+export declare function isHiddenTagsLocked<T extends object>(event: T): boolean;
 /** Returns either nip04 or nip44 encryption method depending on list kind */
-export declare function getListEncryptionMethods(kind: number, signer: HiddenTagsSigner): {
+export declare function getHiddenTagsEncryptionMethods(kind: number, signer: HiddenContentSigner): {
     encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
     decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
 } | {
@@ -36,13 +26,5 @@ export declare function getListEncryptionMethods(kind: number, signer: HiddenTag
  * @param store An optional EventStore to notify about the update
  * @throws
  */
-export declare function unlockHiddenTags<T extends {
-    kind: number;
-    pubkey: string;
-    content: string;
-}>(event: T, signer: HiddenTagsSigner, store?: EventStore): Promise<T>;
-/**
- * Override the hidden tags in an event
- * @throws
- */
-export declare function overrideHiddenTags(event: NostrEvent, hidden: string[][], signer: HiddenTagsSigner): Promise<EventTemplate>;
+export declare function unlockHiddenTags<T extends HiddenContentEvent>(event: T, signer: HiddenContentSigner): Promise<string[][]>;
+export declare function lockHiddenTags<T extends object>(event: T): void;

package/dist/helpers/hidden-tags.js

@@ -1,30 +1,9 @@
-import { kinds } from "nostr-tools";
-import { GROUPS_LIST_KIND } from "./groups.js";
-import { unixNow } from "./time.js";
-import { isEvent } from "./event.js";
+import { canHaveHiddenContent, getHiddenContent, getHiddenContentEncryptionMethods, isHiddenContentLocked, lockHiddenContent, unlockHiddenContent, } from "./hidden-content.js";
+import { getOrComputeCachedValue } from "./cache.js";
 export const HiddenTagsSymbol = Symbol.for("hidden-tags");
-/** Various event kinds that can have encrypted tags in their content and which encryption method they use */
-export const EventEncryptionMethod = {
-    // NIP-60 wallet
-    37375: "nip44",
-    // NIP-51 lists
-    [kinds.BookmarkList]: "nip04",
-    [kinds.InterestsList]: "nip04",
-    [kinds.Mutelist]: "nip04",
-    [kinds.CommunitiesList]: "nip04",
-    [kinds.PublicChatsList]: "nip04",
-    [kinds.SearchRelaysList]: "nip04",
-    [GROUPS_LIST_KIND]: "nip04",
-    // NIP-51 sets
-    [kinds.Bookmarksets]: "nip04",
-    [kinds.Relaysets]: "nip04",
-    [kinds.Followsets]: "nip04",
-    [kinds.Curationsets]: "nip04",
-    [kinds.Interestsets]: "nip04",
-};
 /** Checks if an event can have hidden tags */
 export function canHaveHiddenTags(kind) {
-    return EventEncryptionMethod[kind] !== undefined;
+    return canHaveHiddenContent(kind);
 }
 /** Checks if an event has hidden tags */
 export function hasHiddenTags(event) {
@@ -32,19 +11,24 @@ export function hasHiddenTags(event) {
 }
 /** Returns the hidden tags for an event if they are unlocked */
 export function getHiddenTags(event) {
-    return Reflect.get(event, HiddenTagsSymbol);
+    if (isHiddenTagsLocked(event))
+        return undefined;
+    return getOrComputeCachedValue(event, HiddenTagsSymbol, () => {
+        const plaintext = getHiddenContent(event);
+        const parsed = JSON.parse(plaintext);
+        if (!Array.isArray(parsed))
+            throw new Error("Content is not an array of tags");
+        // Convert array to tags array string[][]
+        return parsed.filter((t) => Array.isArray(t)).map((t) => t.map((v) => String(v)));
+    });
 }
 /** Checks if the hidden tags are locked */
 export function isHiddenTagsLocked(event) {
-    return hasHiddenTags(event) && getHiddenTags(event) === undefined;
+    return isHiddenContentLocked(event);
 }
 /** Returns either nip04 or nip44 encryption method depending on list kind */
-export function getListEncryptionMethods(kind, signer) {
-    const method = EventEncryptionMethod[kind];
-    const encryption = signer[method];
-    if (!encryption)
-        throw new Error(`Signer does not support ${method} encryption`);
-    return encryption;
+export function getHiddenTagsEncryptionMethods(kind, signer) {
+    return getHiddenContentEncryptionMethods(kind, signer);
 }
 /**
  * Decrypts the private list
@@ -53,34 +37,15 @@ export function getListEncryptionMethods(kind, signer) {
  * @param store An optional EventStore to notify about the update
  * @throws
  */
-export async function unlockHiddenTags(event, signer, store) {
+export async function unlockHiddenTags(event, signer) {
     if (!canHaveHiddenTags(event.kind))
         throw new Error("Event kind does not support hidden tags");
-    const encryption = getListEncryptionMethods(event.kind, signer);
-    const plaintext = await encryption.decrypt(event.pubkey, event.content);
-    const parsed = JSON.parse(plaintext);
-    if (!Array.isArray(parsed))
-        throw new Error("Content is not an array of tags");
-    // Convert array to tags array string[][]
-    const tags = parsed.filter((t) => Array.isArray(t)).map((t) => t.map((v) => String(v)));
-    Reflect.set(event, HiddenTagsSymbol, tags);
-    if (store && isEvent(event))
-        store.update(event);
-    return event;
+    // unlock hidden content is needed
+    if (isHiddenContentLocked(event))
+        await unlockHiddenContent(event, signer);
+    return getHiddenTags(event);
 }
-/**
- * Override the hidden tags in an event
- * @throws
- */
-export async function overrideHiddenTags(event, hidden, signer) {
-    if (!canHaveHiddenTags(event.kind))
-        throw new Error("Event kind does not support hidden tags");
-    const encryption = getListEncryptionMethods(event.kind, signer);
-    const ciphertext = await encryption.encrypt(event.pubkey, JSON.stringify(hidden));
-    return {
-        kind: event.kind,
-        content: ciphertext,
-        created_at: unixNow(),
-        tags: event.tags,
-    };
+export function lockHiddenTags(event) {
+    Reflect.deleteProperty(event, HiddenTagsSymbol);
+    lockHiddenContent(event);
 }

package/dist/helpers/index.d.ts

@@ -7,14 +7,17 @@ export * from "./comment.js";
 export * from "./contacts.js";
 export * from "./content.js";
 export * from "./delete.js";
+export * from "./direct-messages.js";
 export * from "./dns-identity.js";
 export * from "./emoji.js";
 export * from "./event.js";
 export * from "./external-id.js";
 export * from "./file-metadata.js";
 export * from "./filter.js";
+export * from "./gift-wraps.js";
 export * from "./groups.js";
 export * from "./hashtag.js";
+export * from "./hidden-content.js";
 export * from "./hidden-tags.js";
 export * from "./json.js";
 export * from "./lists.js";

package/dist/helpers/index.js

@@ -7,14 +7,17 @@ export * from "./comment.js";
 export * from "./contacts.js";
 export * from "./content.js";
 export * from "./delete.js";
+export * from "./direct-messages.js";
 export * from "./dns-identity.js";
 export * from "./emoji.js";
 export * from "./event.js";
 export * from "./external-id.js";
 export * from "./file-metadata.js";
 export * from "./filter.js";
+export * from "./gift-wraps.js";
 export * from "./groups.js";
 export * from "./hashtag.js";
+export * from "./hidden-content.js";
 export * from "./hidden-tags.js";
 export * from "./json.js";
 export * from "./lists.js";

package/dist/helpers/mutes.d.ts

@@ -7,6 +7,7 @@ export type Mutes = {
     hashtags: Set<string>;
     words: Set<string>;
 };
+/** Parses mute tags */
 export declare function parseMutedTags(tags: string[][]): Mutes;
 /** Returns muted things */
 export declare function getMutedThings(mute: NostrEvent): Mutes;

package/dist/helpers/mutes.js

@@ -3,6 +3,7 @@ import { getOrComputeCachedValue } from "./cache.js";
 import { getHiddenTags } from "./hidden-tags.js";
 export const MutePublicSymbol = Symbol.for("mute-public");
 export const MuteHiddenSymbol = Symbol.for("mute-hidden");
+/** Parses mute tags */
 export function parseMutedTags(tags) {
     const pubkeys = new Set(tags.filter(isPTag).map((t) => t[1]));
     const threads = new Set(tags.filter(isETag).map((t) => t[1]));
@@ -12,7 +13,7 @@ export function parseMutedTags(tags) {
 }
 /** Returns muted things */
 export function getMutedThings(mute) {
-    return getOrComputeCachedValue(mute, MutePublicSymbol, (e) => parseMutedTags(e.tags));
+    return getOrComputeCachedValue(mute, MutePublicSymbol, () => parseMutedTags(mute.tags));
 }
 /** Returns the hidden muted content if the event is unlocked */
 export function getHiddenMutedThings(mute) {

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

@@ -0,0 +1,4 @@
+/** Gets the hex pubkey from any nip-19 encoded string */
+export declare function normalizeToPubkey(str: string): string;
+/** Converts hex to nsec strings into Uint8 secret keys */
+export declare function normalizeToSecretKey(str: string): Uint8Array;

package/dist/helpers/nip-19.js

@@ -0,0 +1,27 @@
+import { nip19 } from "nostr-tools";
+import { hexToBytes } from "@noble/hashes/utils";
+import { isHexKey } from "./string.js";
+import { getPubkeyFromDecodeResult } from "./pointers.js";
+/** Gets the hex pubkey from any nip-19 encoded string */
+export function normalizeToPubkey(str) {
+    if (isHexKey(str))
+        return str;
+    else {
+        const decode = nip19.decode(str);
+        const pubkey = getPubkeyFromDecodeResult(decode);
+        if (!pubkey)
+            throw new Error(`Cant find pubkey in ${decode.type}`);
+        return pubkey;
+    }
+}
+/** Converts hex to nsec strings into Uint8 secret keys */
+export function normalizeToSecretKey(str) {
+    if (isHexKey(str))
+        return hexToBytes(str);
+    else {
+        const decode = nip19.decode(str);
+        if (decode.type !== "nsec")
+            throw new Error(`Cant get secret key from ${decode.type}`);
+        return decode.data;
+    }
+}

package/dist/observable/claim-latest.d.ts

@@ -1,4 +1,5 @@
 import { MonoTypeOperatorFunction } from "rxjs";
 import { NostrEvent } from "nostr-tools";
-import { Database } from "../event-store/database.js";
-export declare function claimLatest(database: Database): MonoTypeOperatorFunction<NostrEvent | undefined>;
+import { type Database } from "../event-store/database.js";
+/** An operator that claims the latest event with the database */
+export declare function claimLatest<T extends NostrEvent | undefined>(database: Database): MonoTypeOperatorFunction<T>;

package/dist/observable/claim-latest.js

@@ -1,4 +1,5 @@
 import { finalize, tap } from "rxjs";
+/** An operator that claims the latest event with the database */
 export function claimLatest(database) {
     return (source) => {
         let latest = undefined;
@@ -12,7 +13,7 @@ export function claimLatest(database) {
             // update state
             latest = event;
         }), finalize(() => {
-            // late claim
+            // remove latest claim
             if (latest)
                 database.removeClaim(latest, source);
         }));

package/dist/observable/with-immediate-value.d.ts

@@ -0,0 +1,3 @@
+import { OperatorFunction } from "rxjs";
+/** if a synchronous value is not emitted, default is emitted */
+export declare function withImmediateValueOrDefault<Value, Default extends unknown = unknown>(defaultValue: Default): OperatorFunction<Value, Value | Default>;

package/dist/observable/with-immediate-value.js

@@ -0,0 +1,19 @@
+import { Observable } from "rxjs";
+/** if a synchronous value is not emitted, default is emitted */
+export function withImmediateValueOrDefault(defaultValue) {
+    return (source) => new Observable((observer) => {
+        let seen = false;
+        const sub = source.subscribe({
+            next: (v) => {
+                seen = true;
+                observer.next(v);
+            },
+            error: (err) => observer.error(err),
+            complete: () => observer.complete(),
+        });
+        // if a value is not emitted sync, emit default
+        if (!seen)
+            observer.next(defaultValue);
+        return sub;
+    });
+}

package/dist/queries/mutes.js

@@ -5,7 +5,7 @@ import { isHiddenTagsLocked } from "../helpers/hidden-tags.js";
 export function UserMuteQuery(pubkey) {
     return {
         key: pubkey,
-        run: (store) => store.replaceable(kinds.Mutelist, pubkey).pipe(map((event) => event && getMutedThings(event))),
+        run: (event) => event.replaceable(kinds.Mutelist, pubkey).pipe(map((event) => event && getMutedThings(event))),
     };
 }
 export function UserHiddenMuteQuery(pubkey) {

package/dist/queries/simple.d.ts

@@ -7,7 +7,7 @@ export declare function MultipleEventsQuery(ids: string[]): Query<Record<string,
 /** Creates a Query returning the latest version of a replaceable event */
 export declare function ReplaceableQuery(kind: number, pubkey: string, d?: string): Query<NostrEvent | undefined>;
 /** Creates a Query that returns an array of sorted events matching the filters */
-export declare function TimelineQuery(filters: Filter | Filter[], keepOldVersions?: boolean): Query<NostrEvent[]>;
+export declare function TimelineQuery(filters: Filter | Filter[], includeOldVersion?: boolean): Query<NostrEvent[]>;
 /** Creates a Query that returns a directory of events by their UID */
 export declare function ReplaceableSetQuery(pointers: {
     kind: number;

package/dist/queries/simple.js

@@ -22,11 +22,11 @@ export function ReplaceableQuery(kind, pubkey, d) {
     };
 }
 /** Creates a Query that returns an array of sorted events matching the filters */
-export function TimelineQuery(filters, keepOldVersions) {
+export function TimelineQuery(filters, includeOldVersion) {
     filters = Array.isArray(filters) ? filters : [filters];
     return {
-        key: hash_sum(filters) + (keepOldVersions ? "-history" : ""),
-        run: (events) => events.timeline(filters, keepOldVersions),
+        key: hash_sum(filters) + (includeOldVersion ? "-history" : ""),
+        run: (events) => events.timeline(filters, includeOldVersion),
     };
 }
 /** Creates a Query that returns a directory of events by their UID */

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

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

package/dist/query-store/{query-store.test.js → __tests__/query-store.test.js}

@@ -1,7 +1,9 @@
 import { describe, it, expect, beforeEach } from "vitest";
-import { EventStore } from "../event-store/event-store.js";
-import { QueryStore } from "./query-store.js";
-import { ProfileQuery } from "../queries/profile.js";
+import { subscribeSpyTo } from "@hirez_io/observer-spy";
+import { EventStore } from "../../event-store/event-store.js";
+import { QueryStore } from "../query-store.js";
+import { ProfileQuery } from "../../queries/profile.js";
+import { SingleEventQuery } from "../../queries/simple.js";
 let eventStore;
 let queryStore;
 const event = {
@@ -17,6 +19,34 @@ beforeEach(() => {
     eventStore = new EventStore();
     queryStore = new QueryStore(eventStore);
 });
+describe("createQuery", () => {
+    it("should emit synchronous value if it exists", () => {
+        let value = undefined;
+        eventStore.add(event);
+        queryStore.createQuery(ProfileQuery, event.pubkey).subscribe((v) => (value = v));
+        expect(value).not.toBe(undefined);
+    });
+    it("should not emit undefined if value exists", () => {
+        eventStore.add(event);
+        const spy = subscribeSpyTo(queryStore.createQuery(SingleEventQuery, event.id));
+        expect(spy.getValues()).toEqual([event]);
+    });
+    it("should emit synchronous undefined if value does not exists", () => {
+        let value = 0;
+        queryStore.createQuery(ProfileQuery, event.pubkey).subscribe((v) => {
+            value = v;
+        });
+        expect(value).not.toBe(0);
+        expect(value).toBe(undefined);
+    });
+    it("should share latest value", () => {
+        eventStore.add(event);
+        const spy = subscribeSpyTo(queryStore.createQuery(SingleEventQuery, event.id));
+        const spy2 = subscribeSpyTo(queryStore.createQuery(SingleEventQuery, event.id));
+        expect(spy.getValues()).toEqual([event]);
+        expect(spy2.getValues()).toEqual([event]);
+    });
+});
 describe("executeQuery", () => {
     it("should resolve when value is already present", async () => {
         eventStore.add(event);

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

@@ -1,19 +1,19 @@
 import { Observable } from "rxjs";
 import { Filter, NostrEvent } from "nostr-tools";
 import type { AddressPointer, EventPointer } from "nostr-tools/nip19";
-import { EventStore } from "../event-store/event-store.js";
+import { IEventStore } from "../event-store/interface.js";
 import * as Queries from "../queries/index.js";
 export type Query<T extends unknown> = {
     /** A unique key for this query. this is used to detect duplicate queries */
     key: string;
     /** The meat of the query, this should return an Observables that subscribes to the eventStore in some way */
-    run: (events: EventStore, store: QueryStore) => Observable<T>;
+    run: (events: IEventStore, store: QueryStore) => Observable<T>;
 };
 export type QueryConstructor<T extends unknown, Args extends Array<any>> = (...args: Args) => Query<T>;
 export declare class QueryStore {
     static Queries: typeof Queries;
-    store: EventStore;
-    constructor(store: EventStore);
+    store: IEventStore;
+    constructor(store: IEventStore);
     /** A directory of all active queries */
     queries: Map<QueryConstructor<any, any[]>, Map<string, Observable<any>>>;
     /** How long a query should be kept "warm" while nothing is subscribed to it */
@@ -45,6 +45,8 @@ export declare class QueryStore {
         inboxes: string[];
         outboxes: string[];
     } | undefined>;
+    /** Creates a query for a users blossom servers */
+    blossomServers(pubkey: string): Observable<URL[] | undefined>;
     /** Creates a ThreadQuery */
     thread(root: string | EventPointer | AddressPointer): Observable<Queries.Thread | undefined>;
 }

package/dist/query-store/query-store.js

@@ -1,7 +1,8 @@
-import { filter, finalize, ReplaySubject, share, startWith, timer } from "rxjs";
+import { filter, finalize, ReplaySubject, share, timer } from "rxjs";
 import hash_sum from "hash-sum";
 import * as Queries from "../queries/index.js";
 import { getObservableValue } from "../observable/get-observable-value.js";
+import { withImmediateValueOrDefault } from "../observable/with-immediate-value.js";
 export class QueryStore {
     static Queries = Queries;
     store;
@@ -32,11 +33,15 @@ export class QueryStore {
                 .run(this.store, this)
                 .pipe(
             // always emit undefined so the observable is sync
-            startWith(undefined), 
+            withImmediateValueOrDefault(undefined), 
             // remove the observable when its subscribed
             finalize(cleanup), 
             // only create a single observable for all components
-            share({ connector: () => new ReplaySubject(1), resetOnComplete: () => timer(this.queryKeepWarmTimeout) }));
+            share({
+                connector: () => new ReplaySubject(1),
+                resetOnComplete: () => timer(this.queryKeepWarmTimeout),
+                resetOnRefCountZero: () => timer(this.queryKeepWarmTimeout),
+            }));
             // set debug fields
             Reflect.set(observable, "queryArgs", args);
             observables.set(key, observable);
@@ -80,6 +85,10 @@ export class QueryStore {
     mailboxes(pubkey) {
         return this.createQuery(Queries.MailboxesQuery, pubkey);
     }
+    /** Creates a query for a users blossom servers */
+    blossomServers(pubkey) {
+        return this.createQuery(Queries.UserBlossomServersQuery, pubkey);
+    }
     /** Creates a ThreadQuery */
     thread(root) {
         return this.createQuery(Queries.ThreadQuery, root);

package/package.json

@@ -1,18 +1,18 @@
 {
   "name": "applesauce-core",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "keywords": [
-    "nostr"
+    "nostr",
+    "applesauce"
   ],
   "author": "hzrd149",
   "license": "MIT",
   "files": [
-    "dist",
-    "applesauce"
+    "dist"
   ],
   "exports": {
     ".": {
@@ -62,6 +62,7 @@
     }
   },
   "dependencies": {
+    "@noble/hashes": "^1.7.1",
     "@scure/base": "^1.2.4",
     "debug": "^4.4.0",
     "fast-deep-equal": "^3.1.3",