applesauce-core 4.2.0 → 4.4.1

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

@@ -41,7 +41,7 @@ declare const AsyncEventStore_base: {
 export declare class AsyncEventStore extends AsyncEventStore_base implements IAsyncEventStore {
     database: IAsyncEventDatabase;
     /** Optional memory database for ensuring single event instances */
-    memory?: EventMemory;
+    memory: EventMemory;
     /** Enable this to keep old versions of replaceable events */
     keepOldVersions: boolean;
     /** Enable this to keep expired events */
@@ -115,13 +115,13 @@ export declare class AsyncEventStore extends AsyncEventStore_base implements IAs
     /** Returns a timeline of events that match filters */
     getTimeline(filters: Filter | Filter[]): Promise<NostrEvent[]>;
     /** Passthrough method for the database.touch */
-    touch(event: NostrEvent): void | undefined;
-    /** Sets the claim on the event and touches it */
-    claim(event: NostrEvent, claim: any): void;
+    touch(event: NostrEvent): void;
+    /** Increments the claim count on the event and touches it */
+    claim(event: NostrEvent): 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;
+    /** Decrements the claim count on an event */
+    removeClaim(event: NostrEvent): void;
     /** Removes all claims on an event */
     clearClaim(event: NostrEvent): void;
     /** Pass through method for the database.unclaimed */

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

@@ -320,17 +320,17 @@ export class AsyncEventStore extends EventStoreModelMixin(class {
     touch(event) {
         return this.memory?.touch(event);
     }
-    /** Sets the claim on the event and touches it */
-    claim(event, claim) {
-        return this.memory?.claim(event, claim);
+    /** Increments the claim count on the event and touches it */
+    claim(event) {
+        return this.memory?.claim(event);
     }
     /** Checks if an event is claimed by anything */
     isClaimed(event) {
         return this.memory?.isClaimed(event) ?? false;
     }
-    /** Removes a claim from an event */
-    removeClaim(event, claim) {
-        return this.memory?.removeClaim(event, claim);
+    /** Decrements the claim count on an event */
+    removeClaim(event) {
+        return this.memory?.removeClaim(event);
     }
     /** Removes all claims on an event */
     clearClaim(event) {

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

@@ -1,4 +1,5 @@
-import { Filter, NostrEvent } from "nostr-tools";
+import { NostrEvent } from "nostr-tools";
+import { FilterWithAnd } from "../helpers/filter.js";
 import { LRU } from "../helpers/lru.js";
 import { IEventMemory } from "./interface.js";
 /** An in-memory database of events */
@@ -9,11 +10,13 @@ export declare class EventMemory implements IEventMemory {
     protected authors: Map<string, Set<import("nostr-tools").Event>>;
     protected tags: LRU<Set<import("nostr-tools").Event>>;
     protected created_at: NostrEvent[];
+    /** Composite index for kind+author queries (common pattern) */
+    protected kindAuthor: Map<string, Set<import("nostr-tools").Event>>;
     /** LRU cache of last events touched */
     events: LRU<import("nostr-tools").Event>;
     /** A sorted array of replaceable events by address */
     protected replaceable: Map<string, import("nostr-tools").Event[]>;
-    /** The number of events in the event set */
+    /** The number of events in the database */
     get size(): number;
     /** Checks if the database contains an event without touching it */
     hasEvent(id: string): boolean;
@@ -26,27 +29,27 @@ export declare class EventMemory implements IEventMemory {
     /** Gets the history of a replaceable event */
     getReplaceableHistory(kind: number, pubkey: string, identifier?: string): NostrEvent[] | undefined;
     /** Gets all events that match the filters */
-    getByFilters(filters: Filter | Filter[]): NostrEvent[];
+    getByFilters(filters: FilterWithAnd | FilterWithAnd[]): NostrEvent[];
     /** Gets a timeline of events that match the filters */
-    getTimeline(filters: Filter | Filter[]): NostrEvent[];
+    getTimeline(filters: FilterWithAnd | FilterWithAnd[]): NostrEvent[];
     /** Inserts an event into the database and notifies all subscriptions */
     add(event: NostrEvent): NostrEvent;
     /** Removes an event from the database and notifies all subscriptions */
     remove(eventOrId: string | NostrEvent): boolean;
     /** Remove multiple events that match the given filters */
-    removeByFilters(filters: Filter | Filter[]): number;
+    removeByFilters(filters: FilterWithAnd | FilterWithAnd[]): number;
     /** Notify the database that an event has updated */
     update(_event: NostrEvent): void;
-    /** A weak map of events that are claimed by other things */
-    protected claims: WeakMap<import("nostr-tools").Event, any>;
+    /** A weak map of events to claim reference counts */
+    protected claims: WeakMap<import("nostr-tools").Event, number>;
     /** Moves an event to the top of the LRU cache */
     touch(event: NostrEvent): void;
-    /** Sets the claim on the event and touches it */
-    claim(event: NostrEvent, claim: any): void;
+    /** Increments the claim count on the event and touches it */
+    claim(event: NostrEvent): 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;
+    /** Decrements the claim count on an event */
+    removeClaim(event: NostrEvent): void;
     /** Removes all claims on an event */
     clearClaim(event: NostrEvent): void;
     /** Returns a generator of unclaimed events in order of least used */
@@ -56,7 +59,13 @@ export declare class EventMemory implements IEventMemory {
     /** Index helper methods */
     protected getKindIndex(kind: number): Set<import("nostr-tools").Event>;
     protected getAuthorsIndex(author: string): Set<import("nostr-tools").Event>;
+    protected getKindAuthorIndex(kind: number, pubkey: string): Set<import("nostr-tools").Event>;
     protected getTagIndex(tagAndValue: string): Set<import("nostr-tools").Event>;
+    /**
+     * Helper method to remove an event from a sorted array using binary search.
+     * Falls back to indexOf if binary search doesn't find exact match.
+     */
+    protected removeFromSortedArray(array: NostrEvent[], event: NostrEvent): void;
     /** Iterates over all events by author */
     iterateAuthors(authors: Iterable<string>): Generator<NostrEvent>;
     /** Iterates over all events by indexable tag and value */
@@ -68,9 +77,9 @@ export declare class EventMemory implements IEventMemory {
     /** Iterates over all events by id */
     iterateIds(ids: Iterable<string>): Generator<NostrEvent>;
     /** Returns all events that match the filter */
-    protected getEventsForFilter(filter: Filter): Set<NostrEvent>;
+    protected getEventsForFilter(filter: FilterWithAnd): Set<NostrEvent>;
     /** Returns all events that match the filters */
-    protected getEventsForFilters(filters: Filter[]): Set<NostrEvent>;
+    protected getEventsForFilters(filters: FilterWithAnd[]): Set<NostrEvent>;
     /** Resets the event set */
     reset(): void;
 }

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

@@ -11,11 +11,13 @@ export class EventMemory {
     authors = new Map();
     tags = new LRU();
     created_at = [];
+    /** Composite index for kind+author queries (common pattern) */
+    kindAuthor = new Map();
     /** LRU cache of last events touched */
     events = new LRU();
     /** A sorted array of replaceable events by address */
     replaceable = new Map();
-    /** The number of events in the event set */
+    /** The number of events in the database */
     get size() {
         return this.events.size;
     }
@@ -64,6 +66,7 @@ export class EventMemory {
         this.events.set(id, event);
         this.getKindIndex(event.kind).add(event);
         this.getAuthorsIndex(event.pubkey).add(event);
+        this.getKindAuthorIndex(event.kind, event.pubkey).add(event);
         // Add the event to the tag indexes if they exist
         for (const tag of getIndexableTags(event)) {
             if (this.tags.has(tag))
@@ -97,24 +100,26 @@ export class EventMemory {
             return false;
         this.getAuthorsIndex(event.pubkey).delete(event);
         this.getKindIndex(event.kind).delete(event);
+        // Remove from composite kind+author index
+        const kindAuthorKey = `${event.kind}:${event.pubkey}`;
+        if (this.kindAuthor.has(kindAuthorKey)) {
+            this.kindAuthor.get(kindAuthorKey).delete(event);
+        }
         for (const tag of getIndexableTags(event)) {
             if (this.tags.has(tag)) {
                 this.getTagIndex(tag).delete(event);
             }
         }
-        // remove from created_at index
-        const i = this.created_at.indexOf(event);
-        this.created_at.splice(i, 1);
+        // remove from created_at index using binary search
+        this.removeFromSortedArray(this.created_at, event);
         this.events.delete(id);
-        // remove from replaceable index
+        // remove from replaceable index using binary search
         if (isReplaceable(event.kind)) {
             const identifier = event.tags.find((t) => t[0] === "d")?.[1];
             const address = createReplaceableAddress(event.kind, event.pubkey, identifier);
             const array = this.replaceable.get(address);
-            if (array && array.includes(event)) {
-                const idx = array.indexOf(event);
-                array.splice(idx, 1);
-            }
+            if (array)
+                this.removeFromSortedArray(array, event);
         }
         // remove any claims this event has
         this.claims.delete(event);
@@ -135,7 +140,7 @@ export class EventMemory {
     update(_event) {
         // Do nothing
     }
-    /** A weak map of events that are claimed by other things */
+    /** A weak map of events to claim reference counts */
     claims = new WeakMap();
     /** Moves an event to the top of the LRU cache */
     touch(event) {
@@ -145,23 +150,30 @@ export class EventMemory {
         // Move to the top of the LRU
         this.events.set(event.id, event);
     }
-    /** Sets the claim on the event and touches it */
-    claim(event, claim) {
-        if (!this.claims.has(event)) {
-            this.claims.set(event, claim);
-        }
+    /** Increments the claim count on the event and touches it */
+    claim(event) {
+        const currentCount = this.claims.get(event) || 0;
+        this.claims.set(event, currentCount + 1);
         // always touch event
         this.touch(event);
     }
     /** Checks if an event is claimed by anything */
     isClaimed(event) {
-        return this.claims.has(event);
+        const count = this.claims.get(event);
+        return count !== undefined && count > 0;
     }
-    /** Removes a claim from an event */
-    removeClaim(event, claim) {
-        const current = this.claims.get(event);
-        if (current === claim)
-            this.claims.delete(event);
+    /** Decrements the claim count on an event */
+    removeClaim(event) {
+        const currentCount = this.claims.get(event);
+        if (currentCount !== undefined && currentCount > 0) {
+            const newCount = currentCount - 1;
+            if (newCount === 0) {
+                this.claims.delete(event);
+            }
+            else {
+                this.claims.set(event, newCount);
+            }
+        }
     }
     /** Removes all claims on an event */
     clearClaim(event) {
@@ -202,6 +214,12 @@ export class EventMemory {
             this.authors.set(author, new Set());
         return this.authors.get(author);
     }
+    getKindAuthorIndex(kind, pubkey) {
+        const key = `${kind}:${pubkey}`;
+        if (!this.kindAuthor.has(key))
+            this.kindAuthor.set(key, new Set());
+        return this.kindAuthor.get(key);
+    }
     getTagIndex(tagAndValue) {
         if (!this.tags.has(tagAndValue)) {
             // build new tag index from existing events
@@ -219,6 +237,50 @@ export class EventMemory {
         }
         return this.tags.get(tagAndValue);
     }
+    /**
+     * Helper method to remove an event from a sorted array using binary search.
+     * Falls back to indexOf if binary search doesn't find exact match.
+     */
+    removeFromSortedArray(array, event) {
+        if (array.length === 0)
+            return;
+        // Use binary search to find the approximate position
+        const result = binarySearch(array, (mid) => mid.created_at - event.created_at);
+        if (result) {
+            let index = result[0];
+            // Binary search finds the position, but we need to find the exact event
+            // since multiple events can have the same created_at timestamp.
+            // Search backwards and forwards from the found position
+            let found = false;
+            // Check the found position first
+            if (array[index] === event) {
+                array.splice(index, 1);
+                return;
+            }
+            // Search backwards
+            for (let i = index - 1; i >= 0 && array[i].created_at === event.created_at; i--) {
+                if (array[i] === event) {
+                    array.splice(i, 1);
+                    found = true;
+                    break;
+                }
+            }
+            if (found)
+                return;
+            // Search forwards
+            for (let i = index + 1; i < array.length && array[i].created_at === event.created_at; i++) {
+                if (array[i] === event) {
+                    array.splice(i, 1);
+                    return;
+                }
+            }
+        }
+        // Fallback to indexOf if binary search doesn't find the event
+        // This should rarely happen, but ensures correctness
+        const idx = array.indexOf(event);
+        if (idx !== -1)
+            array.splice(idx, 1);
+    }
     /** Iterates over all events by author */
     *iterateAuthors(authors) {
         for (const author of authors) {
@@ -251,24 +313,32 @@ export class EventMemory {
     }
     /** Iterates over all events by time */
     *iterateTime(since, until) {
-        let untilIndex = 0;
-        let sinceIndex = this.created_at.length - 1;
+        let startIndex = 0;
+        let endIndex = this.created_at.length - 1;
+        // If until is set, use binary search to find better start index
         let start = until
             ? binarySearch(this.created_at, (mid) => {
                 return mid.created_at - until;
             })
             : undefined;
         if (start)
-            untilIndex = start[0];
+            startIndex = start[0];
+        // If since is set, use binary search to find better end index
         const end = since
             ? binarySearch(this.created_at, (mid) => {
                 return mid.created_at - since;
             })
             : undefined;
         if (end)
-            sinceIndex = end[0];
-        for (let i = untilIndex; i < sinceIndex; i++) {
-            yield this.created_at[i];
+            endIndex = end[0];
+        // Yield events in the range, filtering by exact bounds
+        for (let i = startIndex; i <= endIndex; i++) {
+            const event = this.created_at[i];
+            if (until !== undefined && event.created_at > until)
+                continue;
+            if (since !== undefined && event.created_at < since)
+                break;
+            yield event;
         }
     }
     /** Iterates over all events by id */
@@ -307,21 +377,66 @@ export class EventMemory {
             time = Array.from(this.iterateTime(filter.since, filter.until));
             and(time);
         }
+        // Process AND tag filters (& prefix) first - NIP-ND
+        // AND takes precedence and requires ALL values to be present
+        for (const t of INDEXABLE_TAGS) {
+            const key = `&${t}`;
+            const values = filter[key];
+            if (values?.length) {
+                // For AND logic, we need to intersect events that have ALL the specified tag values
+                // We do this by iterating through each value and intersecting the results
+                for (const value of values) {
+                    and(this.iterateTag(t, [value]));
+                }
+            }
+        }
+        // Process OR tag filters (# prefix)
+        // Skip values that are in AND tags (NIP-ND rule)
         for (const t of INDEXABLE_TAGS) {
             const key = `#${t}`;
             const values = filter[key];
-            if (values?.length)
-                and(this.iterateTag(t, values));
+            if (values?.length) {
+                // Check if there's a corresponding AND filter for this tag
+                const andKey = `&${t}`;
+                const andValues = filter[andKey];
+                // Filter out values that are in AND tags (NIP-ND rule)
+                const filteredValues = andValues ? values.filter((v) => !andValues.includes(v)) : values;
+                // Only apply OR filter if there are values left after filtering
+                if (filteredValues.length > 0)
+                    and(this.iterateTag(t, filteredValues));
+            }
+        }
+        // Optimize: Use composite kind+author index when both are present and the cross-product is small
+        if (filter.authors && filter.kinds && filter.authors.length * filter.kinds.length <= 20) {
+            const combined = new Set();
+            for (const kind of filter.kinds) {
+                for (const author of filter.authors) {
+                    const key = `${kind}:${author}`;
+                    const kindAuthorEvents = this.kindAuthor.get(key);
+                    if (kindAuthorEvents) {
+                        for (const event of kindAuthorEvents)
+                            combined.add(event);
+                    }
+                }
+            }
+            and(combined);
+        }
+        else {
+            // Use separate indexes
+            if (filter.authors)
+                and(this.iterateAuthors(filter.authors));
+            if (filter.kinds)
+                and(this.iterateKinds(filter.kinds));
         }
-        if (filter.authors)
-            and(this.iterateAuthors(filter.authors));
-        if (filter.kinds)
-            and(this.iterateKinds(filter.kinds));
         // query for time last if only until is set
         if (filter.since === undefined && filter.until !== undefined) {
             time = Array.from(this.iterateTime(filter.since, filter.until));
             and(time);
         }
+        // If no filters were applied (empty filter), return all events
+        if (first) {
+            return new Set(this.events.values());
+        }
         // if the filter queried on time and has a limit. truncate the events now
         if (filter.limit && time) {
             const limited = new Set();
@@ -352,6 +467,7 @@ export class EventMemory {
         this.events.clear();
         this.kinds.clear();
         this.authors.clear();
+        this.kindAuthor.clear();
         this.tags.clear();
         this.created_at = [];
         this.replaceable.clear();

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

@@ -41,7 +41,7 @@ declare const EventStore_base: {
 export declare class EventStore extends EventStore_base implements IEventStore {
     database: IEventDatabase;
     /** Optional memory database for ensuring single event instances */
-    memory?: EventMemory;
+    memory: EventMemory;
     /** Enable this to keep old versions of replaceable events */
     keepOldVersions: boolean;
     /** Enable this to keep expired events */
@@ -115,13 +115,13 @@ export declare class EventStore extends EventStore_base implements IEventStore {
     /** Returns a timeline of events that match filters */
     getTimeline(filters: Filter | Filter[]): NostrEvent[];
     /** Passthrough method for the database.touch */
-    touch(event: NostrEvent): void | undefined;
-    /** Sets the claim on the event and touches it */
-    claim(event: NostrEvent, claim: any): void;
+    touch(event: NostrEvent): void;
+    /** Increments the claim count on the event and touches it */
+    claim(event: NostrEvent): 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;
+    /** Decrements the claim count on an event */
+    removeClaim(event: NostrEvent): void;
     /** Removes all claims on an event */
     clearClaim(event: NostrEvent): void;
     /** Pass through method for the database.unclaimed */

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

@@ -322,17 +322,17 @@ export class EventStore extends EventStoreModelMixin(class {
     touch(event) {
         return this.memory?.touch(event);
     }
-    /** Sets the claim on the event and touches it */
-    claim(event, claim) {
-        return this.memory?.claim(event, claim);
+    /** Increments the claim count on the event and touches it */
+    claim(event) {
+        return this.memory?.claim(event);
     }
     /** Checks if an event is claimed by anything */
     isClaimed(event) {
         return this.memory?.isClaimed(event) ?? false;
     }
-    /** Removes a claim from an event */
-    removeClaim(event, claim) {
-        return this.memory?.removeClaim(event, claim);
+    /** Decrements the claim count on an event */
+    removeClaim(event) {
+        return this.memory?.removeClaim(event);
     }
     /** Removes all claims on an event */
     clearClaim(event) {

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

@@ -1,6 +1,7 @@
-import { Filter, NostrEvent } from "nostr-tools";
+import { NostrEvent } from "nostr-tools";
 import { AddressPointer, EventPointer, ProfilePointer } from "nostr-tools/nip19";
 import { Observable } from "rxjs";
+import { FilterWithAnd } from "../helpers/filter.js";
 import { AddressPointerWithoutD } from "../helpers/pointers.js";
 import { ProfileContent } from "../helpers/profile.js";
 import { Mutes } from "../helpers/mutes.js";
@@ -18,9 +19,9 @@ export interface IEventStoreRead {
     /** Get the history of a replaceable event */
     getReplaceableHistory(kind: number, pubkey: string, identifier?: string): NostrEvent[] | undefined;
     /** Get all events that match the filters */
-    getByFilters(filters: Filter | Filter[]): NostrEvent[];
+    getByFilters(filters: FilterWithAnd | FilterWithAnd[]): NostrEvent[];
     /** Get a timeline of events that match the filters */
-    getTimeline(filters: Filter | Filter[]): NostrEvent[];
+    getTimeline(filters: FilterWithAnd | FilterWithAnd[]): NostrEvent[];
 }
 /** The async read interface for an event store */
 export interface IAsyncEventStoreRead {
@@ -35,9 +36,9 @@ export interface IAsyncEventStoreRead {
     /** Get the history of a replaceable event */
     getReplaceableHistory(kind: number, pubkey: string, identifier?: string): Promise<NostrEvent[] | undefined>;
     /** Get all events that match the filters */
-    getByFilters(filters: Filter | Filter[]): Promise<NostrEvent[]>;
+    getByFilters(filters: FilterWithAnd | FilterWithAnd[]): Promise<NostrEvent[]>;
     /** Get a timeline of events that match the filters */
-    getTimeline(filters: Filter | Filter[]): Promise<NostrEvent[]>;
+    getTimeline(filters: FilterWithAnd | FilterWithAnd[]): Promise<NostrEvent[]>;
 }
 /** The stream interface for an event store */
 export interface IEventStoreStreams {
@@ -70,12 +71,12 @@ export interface IAsyncEventStoreActions {
 export interface IEventClaims {
     /** Tell the store that this event was used */
     touch(event: NostrEvent): void;
-    /** Sets the claim on the event and touches it */
-    claim(event: NostrEvent, claim: any): void;
+    /** Increments the claim count on the event */
+    claim(event: NostrEvent): 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;
+    /** Decrements the claim count on an event */
+    removeClaim(event: NostrEvent): void;
     /** Removes all claims on an event */
     clearClaim(event: NostrEvent): void;
     /** Returns a generator of unclaimed events in order of least used */
@@ -92,9 +93,9 @@ export interface IEventSubscriptions {
     /** Subscribe to an addressable event by pointer */
     addressable(pointer: AddressPointer): Observable<NostrEvent | undefined>;
     /** Subscribe to a batch of events that match the filters */
-    filters(filters: Filter | Filter[], onlyNew?: boolean): Observable<NostrEvent>;
+    filters(filters: FilterWithAnd | FilterWithAnd[], onlyNew?: boolean): Observable<NostrEvent>;
     /** Subscribe to a sorted timeline of events that match the filters */
-    timeline(filters: Filter | Filter[], onlyNew?: boolean): Observable<NostrEvent[]>;
+    timeline(filters: FilterWithAnd | FilterWithAnd[], onlyNew?: boolean): Observable<NostrEvent[]>;
 }
 /** @deprecated use {@link IEventSubscriptions} instead */
 export interface IEventStoreSubscriptions extends IEventSubscriptions {
@@ -147,7 +148,7 @@ export interface IEventDatabase extends IEventStoreRead {
     /** Remove an event from the database */
     remove(event: string | NostrEvent): boolean;
     /** Remove multiple events that match the given filters */
-    removeByFilters(filters: Filter | Filter[]): number;
+    removeByFilters(filters: FilterWithAnd | FilterWithAnd[]): number;
     /** Notifies the database that an event has updated */
     update?: (event: NostrEvent) => void;
 }
@@ -158,7 +159,7 @@ export interface IAsyncEventDatabase extends IAsyncEventStoreRead {
     /** Remove an event from the database */
     remove(event: string | NostrEvent): Promise<boolean>;
     /** Remove multiple events that match the given filters */
-    removeByFilters(filters: Filter | Filter[]): Promise<number>;
+    removeByFilters(filters: FilterWithAnd | FilterWithAnd[]): Promise<number>;
     /** Notifies the database that an event has updated */
     update?: (event: NostrEvent) => void;
 }

package/dist/helpers/event.js

@@ -43,7 +43,7 @@ export function isReplaceable(kind) {
 export function getEventUID(event) {
     let uid = Reflect.get(event, EventUIDSymbol);
     if (!uid) {
-        if (isReplaceable(event.kind))
+        if (isAddressableKind(event.kind) || isReplaceableKind(event.kind))
             uid = getReplaceableAddress(event);
         else
             uid = event.id;
@@ -53,11 +53,10 @@ export function getEventUID(event) {
 }
 /** Returns the replaceable event address for an addressable event */
 export function getReplaceableAddress(event) {
-    if (!isReplaceable(event.kind))
+    if (!isAddressableKind(event.kind) && !isReplaceableKind(event.kind))
         throw new Error("Event is not replaceable or addressable");
     return getOrComputeCachedValue(event, ReplaceableAddressSymbol, () => {
-        const identifier = isAddressableKind(event.kind) ? getReplaceableIdentifier(event) : undefined;
-        return createReplaceableAddress(event.kind, event.pubkey, identifier);
+        return createReplaceableAddress(event.kind, event.pubkey, getReplaceableIdentifier(event));
     });
 }
 /** Creates a replaceable event address from a kind, pubkey, and identifier */

package/dist/helpers/filter.d.ts

@@ -1,13 +1,27 @@
 import { Filter, NostrEvent } from "nostr-tools";
 export { Filter } from "nostr-tools/filter";
+/**
+ * Extended Filter type that supports NIP-ND AND operator
+ * Uses `&` prefix for tag filters that require ALL values to match (AND logic)
+ * @example
+ * {
+ *   kinds: [1],
+ *   "&t": ["meme", "cat"],  // Must have BOTH "meme" AND "cat" tags
+ *   "#t": ["black", "white"] // Must have "black" OR "white" tags
+ * }
+ */
+export type FilterWithAnd = Filter & {
+    [key: `&${string}`]: string[] | undefined;
+};
 /**
  * Copied from nostr-tools and modified to use {@link getIndexableTags}
+ * Extended to support NIP-ND AND operator with `&` prefix
  * @see https://github.com/nbd-wtf/nostr-tools/blob/a61cde77eacc9518001f11d7f67f1a50ae05fd80/filter.ts
  */
-export declare function matchFilter(filter: Filter, event: NostrEvent): boolean;
+export declare function matchFilter(filter: FilterWithAnd, event: NostrEvent): boolean;
 /** Copied from nostr-tools and modified to use {@link matchFilter} */
-export declare function matchFilters(filters: Filter[], event: NostrEvent): boolean;
-/** Copied from nostr-tools and modified to support undefined values */
-export declare function mergeFilters(...filters: Filter[]): Filter;
+export declare function matchFilters(filters: FilterWithAnd[], event: NostrEvent): boolean;
+/** Copied from nostr-tools and modified to support undefined values and NIP-ND AND operator */
+export declare function mergeFilters(...filters: FilterWithAnd[]): FilterWithAnd;
 /** Check if two filters are equal */
-export declare function isFilterEqual(a: Filter | Filter[], b: Filter | Filter[]): boolean;
+export declare function isFilterEqual(a: FilterWithAnd | FilterWithAnd[], b: FilterWithAnd | FilterWithAnd[]): boolean;

package/dist/helpers/filter.js

@@ -2,45 +2,69 @@ import equal from "fast-deep-equal";
 import { getIndexableTags } from "./event-tags.js";
 /**
  * Copied from nostr-tools and modified to use {@link getIndexableTags}
+ * Extended to support NIP-ND AND operator with `&` prefix
  * @see https://github.com/nbd-wtf/nostr-tools/blob/a61cde77eacc9518001f11d7f67f1a50ae05fd80/filter.ts
  */
 export function matchFilter(filter, event) {
-    if (filter.ids && filter.ids.indexOf(event.id) === -1) {
+    if (filter.ids && filter.ids.indexOf(event.id) === -1)
         return false;
-    }
-    if (filter.kinds && filter.kinds.indexOf(event.kind) === -1) {
+    if (filter.kinds && filter.kinds.indexOf(event.kind) === -1)
         return false;
-    }
-    if (filter.authors && filter.authors.indexOf(event.pubkey) === -1) {
+    if (filter.authors && filter.authors.indexOf(event.pubkey) === -1)
         return false;
+    if (filter.since && event.created_at < filter.since)
+        return false;
+    if (filter.until && event.created_at > filter.until)
+        return false;
+    // Process AND tag filters (& prefix) first - NIP-ND
+    // AND takes precedence and requires ALL values to be present
+    for (let f in filter) {
+        if (f[0] === "&") {
+            let tagName = f.slice(1);
+            let values = filter[f];
+            if (values && values.length > 0) {
+                const tags = getIndexableTags(event);
+                // ALL values must be present (AND logic)
+                for (const value of values) {
+                    if (!tags.has(tagName + ":" + value)) {
+                        return false;
+                    }
+                }
+            }
+        }
     }
+    // Process OR tag filters (# prefix)
+    // Skip values that are in AND tags (NIP-ND rule)
     for (let f in filter) {
         if (f[0] === "#") {
             let tagName = f.slice(1);
             let values = filter[f];
             if (values) {
+                // Check if there's a corresponding AND filter for this tag
+                const andKey = `&${tagName}`;
+                const andValues = filter[andKey];
+                // Filter out values that are in AND tags (NIP-ND rule)
+                const filteredValues = andValues ? values.filter((v) => !andValues.includes(v)) : values;
+                // If there are no values left after filtering, skip this check
+                if (filteredValues.length === 0)
+                    continue;
                 const tags = getIndexableTags(event);
-                if (values.some((v) => tags.has(tagName + ":" + v)) === false)
+                if (filteredValues.some((v) => tags.has(tagName + ":" + v)) === false)
                     return false;
             }
         }
     }
-    if (filter.since && event.created_at < filter.since)
-        return false;
-    if (filter.until && event.created_at > filter.until)
-        return false;
     return true;
 }
 /** Copied from nostr-tools and modified to use {@link matchFilter} */
 export function matchFilters(filters, event) {
     for (let i = 0; i < filters.length; i++) {
-        if (matchFilter(filters[i], event)) {
+        if (matchFilter(filters[i], event))
             return true;
-        }
     }
     return false;
 }
-/** Copied from nostr-tools and modified to support undefined values */
+/** Copied from nostr-tools and modified to support undefined values and NIP-ND AND operator */
 export function mergeFilters(...filters) {
     let result = {};
     for (let i = 0; i < filters.length; i++) {
@@ -49,7 +73,11 @@ export function mergeFilters(...filters) {
             // skip undefined
             if (values === undefined)
                 return;
-            if (property === "kinds" || property === "ids" || property === "authors" || property[0] === "#") {
+            if (property === "kinds" ||
+                property === "ids" ||
+                property === "authors" ||
+                property[0] === "#" ||
+                property[0] === "&") {
                 // @ts-ignore
                 result[property] = result[property] || [];
                 // @ts-ignore

package/dist/helpers/pointers.d.ts

@@ -16,6 +16,8 @@ export declare function parseCoordinate(a: string, requireD: true, silent: true)
 export declare function parseCoordinate(a: string, requireD: false, silent: true): AddressPointerWithoutD | null;
 /** Extra a pubkey from the result of nip19.decode */
 export declare function getPubkeyFromDecodeResult(result?: DecodeResult): string | undefined;
+/** Gets the relays from a decode result */
+export declare function getRelaysFromDecodeResult(result?: DecodeResult): string[] | undefined;
 /** Encodes the result of nip19.decode */
 export declare function encodeDecodeResult(result: DecodeResult): "" | `nevent1${string}` | `naddr1${string}` | `nprofile1${string}` | `nsec1${string}` | `npub1${string}` | `note1${string}`;
 /**
@@ -25,17 +27,17 @@ export declare function encodeDecodeResult(result: DecodeResult): "" | `nevent1$
 export declare function getEventPointerFromETag(tag: string[]): EventPointer;
 /**
  * Gets an EventPointer form a common "q" tag
- * @throws
+ * @throws if the tag is invalid
  */
 export declare function getEventPointerFromQTag(tag: string[]): EventPointer;
 /**
  * Get an AddressPointer from a common "a" tag
- * @throws
+ * @throws if the tag is invalid
  */
 export declare function getAddressPointerFromATag(tag: string[]): AddressPointer;
 /**
  * Gets a ProfilePointer from a common "p" tag
- * @throws
+ * @throws if the tag is invalid
  */
 export declare function getProfilePointerFromPTag(tag: string[]): ProfilePointer;
 /** Checks if a pointer is an AddressPointer */
@@ -46,15 +48,12 @@ export declare function isEventPointer(pointer: DecodeResult["data"]): pointer i
 export declare function getCoordinateFromAddressPointer(pointer: AddressPointer): string;
 /**
  * Returns an AddressPointer for a replaceable event
- * @throws
+ * @throws if the event is not replaceable or addressable
  */
 export declare function getAddressPointerForEvent(event: NostrEvent, relays?: string[]): AddressPointer;
 /** Returns an EventPointer for an event */
 export declare function getEventPointerForEvent(event: NostrEvent, relays?: string[]): EventPointer;
-/**
- * Returns a pointer for a given event
- * @throws
- */
+/** Returns a pointer for a given event */
 export declare function getPointerForEvent(event: NostrEvent, relays?: string[]): DecodeResult;
 /** Adds relay hints to a pointer object that has a relays array */
 export declare function addRelayHintsToPointer<T extends {
@@ -62,6 +61,8 @@ export declare function addRelayHintsToPointer<T extends {
 }>(pointer: T, relays?: Iterable<string>): T;
 /** Gets the hex pubkey from any nip-19 encoded string */
 export declare function normalizeToPubkey(str: string): string;
+/** Gets a ProfilePointer from any nip-19 encoded string */
+export declare function normalizeToProfilePointer(str: string): ProfilePointer;
 /** Converts hex to nsec strings into Uint8 secret keys */
 export declare function normalizeToSecretKey(str: string | Uint8Array): Uint8Array;
 /**

package/dist/helpers/pointers.js

@@ -3,8 +3,8 @@ import { getPublicKey, kinds, nip19 } from "nostr-tools";
 // export nip-19 helpers
 export { naddrEncode, neventEncode, noteEncode, nprofileEncode, npubEncode, nsecEncode, decode as decodePointer, } from "nostr-tools/nip19";
 import { getReplaceableIdentifier } from "./event.js";
-import { isAddressableKind } from "nostr-tools/kinds";
-import { isSafeRelayURL, mergeRelaySets } from "./relays.js";
+import { isAddressableKind, isReplaceableKind } from "nostr-tools/kinds";
+import { isSafeRelayURL, relaySet } from "./relays.js";
 import { isHexKey } from "./string.js";
 import { hexToBytes } from "@noble/hashes/utils";
 import { normalizeURL } from "./url.js";
@@ -53,6 +53,20 @@ export function getPubkeyFromDecodeResult(result) {
             return undefined;
     }
 }
+/** Gets the relays from a decode result */
+export function getRelaysFromDecodeResult(result) {
+    if (!result)
+        return;
+    switch (result.type) {
+        case "naddr":
+            return result.data.relays;
+        case "nprofile":
+            return result.data.relays;
+        case "nevent":
+            return result.data.relays;
+    }
+    return undefined;
+}
 /** Encodes the result of nip19.decode */
 export function encodeDecodeResult(result) {
     switch (result.type) {
@@ -85,7 +99,7 @@ export function getEventPointerFromETag(tag) {
 }
 /**
  * Gets an EventPointer form a common "q" tag
- * @throws
+ * @throws if the tag is invalid
  */
 export function getEventPointerFromQTag(tag) {
     if (!tag[1])
@@ -99,7 +113,7 @@ export function getEventPointerFromQTag(tag) {
 }
 /**
  * Get an AddressPointer from a common "a" tag
- * @throws
+ * @throws if the tag is invalid
  */
 export function getAddressPointerFromATag(tag) {
     if (!tag[1])
@@ -111,7 +125,7 @@ export function getAddressPointerFromATag(tag) {
 }
 /**
  * Gets a ProfilePointer from a common "p" tag
- * @throws
+ * @throws if the tag is invalid
  */
 export function getProfilePointerFromPTag(tag) {
     if (!tag[1])
@@ -140,10 +154,10 @@ export function getCoordinateFromAddressPointer(pointer) {
 }
 /**
  * Returns an AddressPointer for a replaceable event
- * @throws
+ * @throws if the event is not replaceable or addressable
  */
 export function getAddressPointerForEvent(event, relays) {
-    if (!isAddressableKind(event.kind))
+    if (!isAddressableKind(event.kind) && !isReplaceableKind(event.kind))
         throw new Error("Cant get AddressPointer for non-replaceable event");
     const d = getReplaceableIdentifier(event);
     return {
@@ -162,12 +176,9 @@ export function getEventPointerForEvent(event, relays) {
         relays,
     };
 }
-/**
- * Returns a pointer for a given event
- * @throws
- */
+/** Returns a pointer for a given event */
 export function getPointerForEvent(event, relays) {
-    if (kinds.isAddressableKind(event.kind)) {
+    if (kinds.isAddressableKind(event.kind) || kinds.isReplaceableKind(event.kind)) {
         return {
             type: "naddr",
             data: getAddressPointerForEvent(event, relays),
@@ -185,7 +196,7 @@ export function addRelayHintsToPointer(pointer, relays) {
     if (!relays)
         return pointer;
     else
-        return { ...pointer, relays: mergeRelaySets(relays, pointer.relays) };
+        return { ...pointer, relays: relaySet(relays, pointer.relays) };
 }
 /** Gets the hex pubkey from any nip-19 encoded string */
 export function normalizeToPubkey(str) {
@@ -199,6 +210,23 @@ export function normalizeToPubkey(str) {
         return pubkey;
     }
 }
+/** Gets a ProfilePointer from any nip-19 encoded string */
+export function normalizeToProfilePointer(str) {
+    if (isHexKey(str))
+        return { pubkey: str.toLowerCase() };
+    else {
+        const decode = nip19.decode(str);
+        // Return it if it's a profile pointer
+        if (decode.type === "nprofile")
+            return decode.data;
+        // fallback to just getting the pubkey
+        const pubkey = getPubkeyFromDecodeResult(decode);
+        if (!pubkey)
+            throw new Error(`Cant find pubkey in ${decode.type}`);
+        const relays = getRelaysFromDecodeResult(decode);
+        return { pubkey, relays };
+    }
+}
 /** Converts hex to nsec strings into Uint8 secret keys */
 export function normalizeToSecretKey(str) {
     if (str instanceof Uint8Array)
@@ -219,7 +247,7 @@ export function normalizeToSecretKey(str) {
 export function mergeEventPointers(a, b) {
     if (a.id !== b.id)
         throw new Error("Cant merge event pointers with different ids");
-    const relays = mergeRelaySets(a.relays, b.relays);
+    const relays = relaySet(a.relays, b.relays);
     return { id: a.id, kind: a.kind ?? b.kind, author: a.author ?? b.author, relays };
 }
 /**
@@ -229,7 +257,7 @@ export function mergeEventPointers(a, b) {
 export function mergeAddressPointers(a, b) {
     if (a.kind !== b.kind || a.pubkey !== b.pubkey || a.identifier !== b.identifier)
         throw new Error("Cant merge address pointers with different kinds, pubkeys, or identifiers");
-    const relays = mergeRelaySets(a.relays, b.relays);
+    const relays = relaySet(a.relays, b.relays);
     return { ...a, relays };
 }
 /**
@@ -239,6 +267,6 @@ export function mergeAddressPointers(a, b) {
 export function mergeProfilePointers(a, b) {
     if (a.pubkey !== b.pubkey)
         throw new Error("Cant merge profile pointers with different pubkeys");
-    const relays = mergeRelaySets(a.relays, b.relays);
+    const relays = relaySet(a.relays, b.relays);
     return { ...a, relays };
 }

package/dist/helpers/share.d.ts

@@ -1,9 +1,13 @@
-import { NostrEvent } from "nostr-tools";
+import { kinds, NostrEvent } from "nostr-tools";
 import { AddressPointer, EventPointer } from "nostr-tools/nip19";
+import { KnownEvent } from "./index.js";
+/** Type of a known share event */
+export type ShareEvent = KnownEvent<kinds.Repost | kinds.GenericRepost>;
 export declare const SharedEventSymbol: unique symbol;
 export declare const SharedEventPointerSymbol: unique symbol;
 export declare const SharedAddressPointerSymbol: unique symbol;
 /** Returns the event pointer of a kind 6 or 16 share event */
+export declare function getSharedEventPointer(event: ShareEvent): EventPointer;
 export declare function getSharedEventPointer(event: NostrEvent): EventPointer | undefined;
 /** Returns the address pointer of a kind 6 or 16 share event */
 export declare function getSharedAddressPointer(event: NostrEvent): AddressPointer | undefined;
@@ -11,3 +15,5 @@ export declare function getSharedAddressPointer(event: NostrEvent): AddressPoint
 export declare function getEmbededSharedEvent(event: NostrEvent): NostrEvent | undefined;
 /** @deprecated use getEmbededSharedEvent instead */
 export declare const parseSharedEvent: typeof getEmbededSharedEvent;
+/** Validates that an event is a valid share event */
+export declare function isValidShare(event?: NostrEvent): event is ShareEvent;

package/dist/helpers/share.js

@@ -1,13 +1,25 @@
-import { nip18 } from "nostr-tools";
+import { kinds, nip18 } from "nostr-tools";
+import { isKind } from "nostr-tools/kinds";
 import { getOrComputeCachedValue } from "./cache.js";
-import { isATag } from "./tags.js";
-import { getAddressPointerFromATag } from "./pointers.js";
+import { getTagValue } from "./index.js";
+import { getAddressPointerFromATag, getEventPointerFromETag } from "./pointers.js";
+import { isATag, isETag } from "./tags.js";
 export const SharedEventSymbol = Symbol.for("shared-event");
 export const SharedEventPointerSymbol = Symbol.for("shared-event-pointer");
 export const SharedAddressPointerSymbol = Symbol.for("shared-address-pointer");
-/** Returns the event pointer of a kind 6 or 16 share event */
 export function getSharedEventPointer(event) {
-    return getOrComputeCachedValue(event, SharedEventPointerSymbol, () => nip18.getRepostedEventPointer(event));
+    return getOrComputeCachedValue(event, SharedEventPointerSymbol, () => {
+        const e = event.tags.find(isETag);
+        if (!e)
+            return undefined;
+        // Get kind from k tag if it exists
+        const kStr = getTagValue(event, "k");
+        const k = kStr ? parseInt(kStr) : undefined;
+        const pointer = getEventPointerFromETag(e);
+        if (k !== undefined)
+            pointer.kind = k;
+        return pointer;
+    });
 }
 /** Returns the address pointer of a kind 6 or 16 share event */
 export function getSharedAddressPointer(event) {
@@ -24,3 +36,9 @@ export function getEmbededSharedEvent(event) {
 }
 /** @deprecated use getEmbededSharedEvent instead */
 export const parseSharedEvent = getEmbededSharedEvent;
+/** Validates that an event is a valid share event */
+export function isValidShare(event) {
+    if (!event)
+        return false;
+    return isKind(event, [kinds.Repost, kinds.GenericRepost]) && getSharedEventPointer(event) !== undefined;
+}

package/dist/helpers/zap.js

@@ -23,7 +23,13 @@ export function getZapRecipient(zap) {
 export function getZapPayment(zap) {
     return getOrComputeCachedValue(zap, ZapInvoiceSymbol, () => {
         const bolt11 = getTagValue(zap, "bolt11");
-        return bolt11 ? parseBolt11(bolt11) : undefined;
+        try {
+            // Catch errors with parsing the bolt11 invoice
+            return bolt11 ? parseBolt11(bolt11) : undefined;
+        }
+        catch (error) {
+            return undefined;
+        }
     });
 }
 export function getZapAmount(zap) {

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

@@ -1,5 +1,5 @@
 import { NostrEvent } from "nostr-tools";
 import { MonoTypeOperatorFunction } from "rxjs";
 import { IEventClaims } from "../event-store/interface.js";
-/** keep a claim on any event that goes through this observable, claims are removed when the observable completes */
+/** keep a claim on any event that goes through this observable, claims are removed when the observable is unsubscribed or completes */
 export declare function claimEvents<T extends NostrEvent[] | NostrEvent | undefined>(claims: IEventClaims): MonoTypeOperatorFunction<T>;

package/dist/observable/claim-events.js

@@ -1,5 +1,5 @@
 import { finalize, tap } from "rxjs";
-/** keep a claim on any event that goes through this observable, claims are removed when the observable completes */
+/** keep a claim on any event that goes through this observable, claims are removed when the observable is unsubscribed or completes */
 export function claimEvents(claims) {
     return (source) => {
         const seen = new Set();
@@ -10,19 +10,21 @@ export function claimEvents(claims) {
                 return;
             if (Array.isArray(message)) {
                 for (const event of message) {
+                    if (seen.has(event))
+                        continue;
                     seen.add(event);
-                    claims.claim(event, source);
+                    claims.claim(event);
                 }
             }
-            else {
+            else if (!seen.has(message)) {
                 seen.add(message);
-                claims.claim(message, source);
+                claims.claim(message);
             }
         }), 
         // remove claims on cleanup
         finalize(() => {
             for (const e of seen)
-                claims.removeClaim(e, source);
+                claims.removeClaim(e);
         }));
     };
 }

package/dist/observable/claim-latest.js

@@ -4,18 +4,21 @@ export function claimLatest(claims) {
     return (source) => {
         let latest = undefined;
         return source.pipe(tap((event) => {
-            // remove old claim
-            if (latest)
-                claims.removeClaim(latest, source);
-            // claim new event
-            if (event)
-                claims.claim(event, source);
-            // update state
-            latest = event;
+            // only update if the event changed
+            if (latest !== event) {
+                // remove old claim
+                if (latest)
+                    claims.removeClaim(latest);
+                // claim new event
+                if (event)
+                    claims.claim(event);
+                // update state
+                latest = event;
+            }
         }), finalize(() => {
             // remove latest claim
             if (latest)
-                claims.removeClaim(latest, source);
+                claims.removeClaim(latest);
         }));
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-core",
-  "version": "4.2.0",
+  "version": "4.4.1",
   "description": "",
   "type": "module",
   "main": "dist/index.js",