applesauce-core 0.0.0-next-20250609184904 → 0.0.0-next-20250610175335

package/dist/helpers/bolt11.d.ts

@@ -4,6 +4,7 @@ export type ParsedInvoice = {
     amount?: number;
     timestamp: number;
     expiry: number;
+    paymentHash?: string;
 };
 /** Parses a lightning invoice */
 export declare function parseBolt11(paymentRequest: string): ParsedInvoice;

package/dist/helpers/bolt11.js

@@ -5,11 +5,13 @@ export function parseBolt11(paymentRequest) {
     const timestamp = decoded.sections.find((s) => s.name === "timestamp")?.value ?? 0;
     const description = decoded.sections.find((s) => s.name === "description")?.value ?? "";
     const amount = parseInt(decoded.sections.find((s) => s.name === "amount")?.value ?? "0");
+    const paymentHash = decoded.sections.find((s) => s.name === "payment_hash");
     return {
         paymentRequest: decoded.paymentRequest,
         description: description,
         amount: amount,
         timestamp: timestamp,
         expiry: timestamp + decoded.expiry,
+        paymentHash: paymentHash?.value,
     };
 }

package/dist/helpers/expiration.js

@@ -6,7 +6,7 @@ export const ExpirationTimestampSymbol = Symbol("expiration-timestamp");
 export function getExpirationTimestamp(event) {
     return getOrComputeCachedValue(event, ExpirationTimestampSymbol, () => {
         const expiration = getTagValue(event, "expiration");
-        return expiration ? parseInt(expiration[1]) : undefined;
+        return expiration ? parseInt(expiration) : undefined;
     });
 }
 /** Checks if an event has expired based on the NIP-40 expiration timestamp */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-core",
-  "version": "0.0.0-next-20250609184904",
+  "version": "0.0.0-next-20250610175335",
   "description": "",
   "type": "module",
   "main": "dist/index.js",
@@ -72,7 +72,7 @@
     "@types/debug": "^4.1.12",
     "@types/hash-sum": "^1.0.2",
     "typescript": "^5.8.3",
-    "vitest": "^3.1.1"
+    "vitest": "^3.2.3"
   },
   "funding": {
     "type": "lightning",

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

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

package/dist/__tests__/exports.test.js

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

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

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

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

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

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

@@ -1,67 +0,0 @@
-import { Filter, NostrEvent } from "nostr-tools";
-import { Subject } from "rxjs";
-import { LRU } from "../helpers/lru.js";
-/**
- * An in-memory database for nostr events
- * NOTE: does not handle replaceable events
- */
-export declare class Database {
-    protected log: import("debug").Debugger;
-    /** Indexes */
-    protected kinds: Map<number, Set<import("nostr-tools").Event>>;
-    protected authors: Map<string, Set<import("nostr-tools").Event>>;
-    protected tags: LRU<Set<import("nostr-tools").Event>>;
-    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>;
-    /** A stream of events that have been updated */
-    updated: Subject<import("nostr-tools").Event>;
-    /** A stream of events removed from the database */
-    removed: Subject<import("nostr-tools").Event>;
-    /** A method thats called before a new event is inserted */
-    onBeforeInsert?: (event: NostrEvent) => boolean;
-    get size(): number;
-    protected claims: WeakMap<import("nostr-tools").Event, any>;
-    /** Index helper methods */
-    protected getKindIndex(kind: number): Set<import("nostr-tools").Event>;
-    protected getAuthorsIndex(author: string): Set<import("nostr-tools").Event>;
-    protected getTagIndex(tagAndValue: string): Set<import("nostr-tools").Event>;
-    /** Moves an event to the top of the LRU cache */
-    touch(event: NostrEvent): void;
-    /** Checks if the database contains an event without touching it */
-    hasEvent(id: string): boolean;
-    /** Gets a single event based on id */
-    getEvent(id: string): NostrEvent | undefined;
-    /** Checks if the database contains a replaceable event without touching it */
-    hasReplaceable(kind: number, pubkey: string, d?: string): boolean;
-    /** Gets an array of replaceable events */
-    getReplaceable(kind: number, pubkey: string, d?: string): NostrEvent[] | undefined;
-    /** Inserts an event into the database and notifies all subscriptions */
-    addEvent(event: NostrEvent): NostrEvent | null;
-    /** Inserts and event into the database and notifies all subscriptions that the event has updated */
-    updateEvent(event: NostrEvent): boolean;
-    /** Removes an event from the database and notifies all subscriptions */
-    removeEvent(eventOrId: string | NostrEvent): boolean;
-    /** Sets the claim on the event and touches it */
-    claimEvent(event: NostrEvent, claim: any): void;
-    /** Checks if an event is claimed by anything */
-    isClaimed(event: NostrEvent): boolean;
-    /** Removes a claim from an event */
-    removeClaim(event: NostrEvent, claim: any): void;
-    /** Removes all claims on an event */
-    clearClaim(event: NostrEvent): void;
-    iterateAuthors(authors: Iterable<string>): Generator<NostrEvent>;
-    iterateTag(tag: string, values: Iterable<string>): Generator<NostrEvent>;
-    iterateKinds(kinds: Iterable<number>): Generator<NostrEvent>;
-    iterateTime(since: number | undefined, until: number | undefined): Generator<NostrEvent>;
-    iterateIds(ids: Iterable<string>): Generator<NostrEvent>;
-    /** Returns all events that match the filter */
-    getEventsForFilter(filter: Filter): Set<NostrEvent>;
-    getEventsForFilters(filters: Filter[]): Set<NostrEvent>;
-    /** Remove the oldest events that are not claimed */
-    prune(limit?: number): number;
-}