applesauce-core 0.2.0 → 0.4.0

package/README.md

@@ -1 +1,39 @@
 # applesauce-core
+
+AppleSauce Core is an interpretation layer for nostr clients, Push events into the in-memory [database](https://hzrd149.github.io/applesauce/classes/Database.html) and get nicely formatted data out with [queries](https://hzrd149.github.io/applesauce/modules/Queries)
+
+# Example
+
+```js
+import { EventStore, QueryStore } from "applesauce-core";
+import { Relay } from "nostr-tools/relay";
+
+// The EventStore handles all the events
+const eventStore = new EventStore();
+
+// The QueryStore handles queries and makes sure not to run multiple of the same query
+const queryStore = new QueryStore(eventStore);
+
+// Use nostr-tools or anything else to talk to relays
+const relay = await Relay.connect("wss://relay.example.com");
+
+const sub = relay.subscribe([{ authors: ["266815e0c9210dfa324c6cba3573b14bee49da4209a9456f9484e5106cd408a5"] }], {
+  onevent(event) {
+    eventStore.add(event);
+  },
+});
+
+// This will return an Observable<ProfileContent | undefined> of the parsed metadata
+const profile = queryStore.profile("266815e0c9210dfa324c6cba3573b14bee49da4209a9456f9484e5106cd408a5");
+
+profile.subscribe((parsed) => {
+  if (parsed) console.log(parsed);
+});
+
+// This will return an Observable<NostrEvent[]> of all kind 1 events sorted by created_at
+const timeline = queryStore.timeline({ kinds: [1] });
+
+timeline.subscribe((events) => {
+  console.log(events);
+});
+```

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

@@ -14,7 +14,9 @@ export declare class EventStore {
     hasReplaceable(kind: number, pubkey: string, d?: string): boolean;
     getReplaceable(kind: number, pubkey: string, d?: string): import("nostr-tools").Event | undefined;
     /** Creates an observable that updates a single event */
-    single(uid: string): Observable<import("nostr-tools").Event | undefined>;
+    event(uid: string): Observable<import("nostr-tools").Event | undefined>;
+    /** Creates an observable that updates a single replaceable event */
+    replaceable(kind: number, pubkey: string, d?: string): Observable<import("nostr-tools").Event | undefined>;
     /** Creates an observable that streams all events that match the filter */
     stream(filters: Filter[]): Observable<import("nostr-tools").Event>;
     /** Creates an observable that updates with an array of sorted events */

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

@@ -1,7 +1,7 @@
 import { insertEventIntoDescendingList } from "nostr-tools/utils";
 import Observable from "zen-observable";
 import { Database } from "./database.js";
-import { getEventUID } from "../helpers/event.js";
+import { getEventUID, getReplaceableUID } from "../helpers/event.js";
 import { matchFilters } from "../helpers/filter.js";
 import { addSeenRelay } from "../helpers/relays.js";
 export class EventStore {
@@ -34,7 +34,7 @@ export class EventStore {
         return this.events.getReplaceable(kind, pubkey, d);
     }
     /** Creates an observable that updates a single event */
-    single(uid) {
+    event(uid) {
         return new Observable((observer) => {
             let current = this.events.getEvent(uid);
             if (current) {
@@ -71,6 +71,10 @@ export class EventStore {
             };
         });
     }
+    /** Creates an observable that updates a single replaceable event */
+    replaceable(kind, pubkey, d) {
+        return this.event(getReplaceableUID(kind, pubkey, d));
+    }
     /** Creates an observable that streams all events that match the filter */
     stream(filters) {
         return new Observable((observer) => {

package/dist/helpers/channel.d.ts

@@ -0,0 +1,15 @@
+import { nip19, NostrEvent } from "nostr-tools";
+import { ChannelMetadata } from "nostr-tools/nip28";
+export declare const ChannelMetadataSymbol: unique symbol;
+declare module "nostr-tools" {
+    interface Event {
+        [ChannelMetadataSymbol]?: ChannelMetadataContent;
+    }
+}
+export type ChannelMetadataContent = ChannelMetadata & {
+    relays?: string[];
+};
+/** Gets the parsed metadata on a channel creation or channel metadata event */
+export declare function getChannelMetadataContent(channel: NostrEvent): ChannelMetadataContent;
+/** gets the EventPointer for a channel message or metadata event */
+export declare function getChannelPointer(event: NostrEvent): nip19.EventPointer | undefined;

package/dist/helpers/channel.js

@@ -0,0 +1,27 @@
+export const ChannelMetadataSymbol = Symbol.for("channel-metadata");
+function parseChannelMetadataContent(channel) {
+    const metadata = JSON.parse(channel.content);
+    if (metadata.name === undefined)
+        throw new Error("Missing name");
+    if (metadata.about === undefined)
+        throw new Error("Missing about");
+    if (metadata.picture === undefined)
+        throw new Error("Missing picture");
+    if (metadata.relays && !Array.isArray(metadata.relays))
+        throw new Error("Invalid relays");
+    return metadata;
+}
+/** Gets the parsed metadata on a channel creation or channel metadata event */
+export function getChannelMetadataContent(channel) {
+    let metadata = channel[ChannelMetadataSymbol];
+    if (!metadata)
+        metadata = channel[ChannelMetadataSymbol] = parseChannelMetadataContent(channel);
+    return metadata;
+}
+/** gets the EventPointer for a channel message or metadata event */
+export function getChannelPointer(event) {
+    const tag = event.tags.find((t) => t[0] === "e" && t[1]);
+    if (!tag)
+        return undefined;
+    return tag[2] ? { id: tag[1], relays: [tag[2]] } : { id: tag[1] };
+}

package/dist/helpers/event.d.ts

@@ -1,10 +1,26 @@
 import { NostrEvent } from "nostr-tools";
+export declare const EventUIDSymbol: unique symbol;
+export declare const EventIndexableTagsSymbol: unique symbol;
+declare module "nostr-tools" {
+    interface Event {
+        [EventUIDSymbol]?: string;
+        [EventIndexableTagsSymbol]?: Set<string>;
+    }
+}
 /**
  * Returns if a kind is replaceable ( 10000 <= n < 20000 || n == 0 || n == 3 )
  * or parameterized replaceable ( 30000 <= n < 40000 )
  */
 export declare function isReplaceable(kind: number): boolean;
-/** returns the events Unique ID */
+/**
+ * Returns the events Unique ID
+ * For normal or ephemeral events this is ( event.id )
+ * For replaceable events this is ( event.kind + ":" + event.pubkey )
+ * For parametrized replaceable events this is ( event.kind + ":" + event.pubkey + ":" + event.tags.d.1 )
+ */
 export declare function getEventUID(event: NostrEvent): string;
 export declare function getReplaceableUID(kind: number, pubkey: string, d?: string): string;
+/** Returns a Set of tag names and values that are indexable */
 export declare function getIndexableTags(event: NostrEvent): Set<string>;
+/** Returns the second index ( tag[1] ) of the first tag that matches the name */
+export declare function getTagValue(event: NostrEvent, name: string): string | undefined;

package/dist/helpers/event.js

@@ -1,6 +1,7 @@
 import { kinds } from "nostr-tools";
 import { INDEXABLE_TAGS } from "../event-store/common.js";
-import { EventIndexableTags, EventUID } from "./symbols.js";
+export const EventUIDSymbol = Symbol.for("event-uid");
+export const EventIndexableTagsSymbol = Symbol.for("indexable-tags");
 /**
  * Returns if a kind is replaceable ( 10000 <= n < 20000 || n == 0 || n == 3 )
  * or parameterized replaceable ( 30000 <= n < 40000 )
@@ -8,31 +9,43 @@ import { EventIndexableTags, EventUID } from "./symbols.js";
 export function isReplaceable(kind) {
     return kinds.isReplaceableKind(kind) || kinds.isParameterizedReplaceableKind(kind);
 }
-/** returns the events Unique ID */
+/**
+ * Returns the events Unique ID
+ * For normal or ephemeral events this is ( event.id )
+ * For replaceable events this is ( event.kind + ":" + event.pubkey )
+ * For parametrized replaceable events this is ( event.kind + ":" + event.pubkey + ":" + event.tags.d.1 )
+ */
 export function getEventUID(event) {
-    if (!event[EventUID]) {
+    let id = event[EventUIDSymbol];
+    if (!id) {
         if (isReplaceable(event.kind)) {
             const d = event.tags.find((t) => t[0] === "d")?.[1];
-            event[EventUID] = getReplaceableUID(event.kind, event.pubkey, d);
+            id = getReplaceableUID(event.kind, event.pubkey, d);
         }
         else {
-            event[EventUID] = event.id;
+            id = event.id;
         }
     }
-    return event[EventUID];
+    return id;
 }
 export function getReplaceableUID(kind, pubkey, d) {
     return d ? `${kind}:${pubkey}:${d}` : `${kind}:${pubkey}`;
 }
+/** Returns a Set of tag names and values that are indexable */
 export function getIndexableTags(event) {
-    if (!event[EventIndexableTags]) {
+    let indexable = event[EventIndexableTagsSymbol];
+    if (!indexable) {
         const tags = new Set();
         for (const tag of event.tags) {
             if (tag[0] && INDEXABLE_TAGS.has(tag[0]) && tag[1]) {
                 tags.add(tag[0] + ":" + tag[1]);
             }
         }
-        event[EventIndexableTags] = tags;
+        indexable = event[EventIndexableTagsSymbol] = tags;
     }
-    return event[EventIndexableTags];
+    return indexable;
+}
+/** Returns the second index ( tag[1] ) of the first tag that matches the name */
+export function getTagValue(event, name) {
+    return event.tags.find((t) => t[0] === name)?.[1];
 }

package/dist/helpers/index.d.ts

@@ -3,4 +3,5 @@ export * from "./relays.js";
 export * from "./event.js";
 export * from "./filter.js";
 export * from "./mailboxes.js";
-export * as symbols from "./symbols.js";
+export * from "./threading.js";
+export * from "./pointers.js";

package/dist/helpers/index.js

@@ -3,4 +3,5 @@ export * from "./relays.js";
 export * from "./event.js";
 export * from "./filter.js";
 export * from "./mailboxes.js";
-export * as symbols from "./symbols.js";
+export * from "./threading.js";
+export * from "./pointers.js";

package/dist/helpers/json.d.ts

@@ -0,0 +1 @@
+export declare function safeParse<T extends unknown = any>(str: string): T | undefined;

package/dist/helpers/json.js

@@ -0,0 +1,8 @@
+export function safeParse(str) {
+    try {
+        return JSON.parse(str);
+    }
+    catch (error) {
+        return undefined;
+    }
+}

package/dist/helpers/mailboxes.d.ts

@@ -1,9 +1,17 @@
 import { NostrEvent } from "nostr-tools";
+export declare const MailboxesInboxesSymbol: unique symbol;
+export declare const MailboxesOutboxesSymbol: unique symbol;
+declare module "nostr-tools" {
+    interface Event {
+        [MailboxesInboxesSymbol]?: Set<string>;
+        [MailboxesOutboxesSymbol]?: Set<string>;
+    }
+}
 /**
- * Parses a 10002 event and stores the inboxes in the event using the {@link MailboxesInboxes} symbol
+ * Parses a 10002 event and stores the inboxes in the event using the {@link MailboxesInboxesSymbol} symbol
  */
 export declare function getInboxes(event: NostrEvent): Set<string>;
 /**
- * Parses a 10002 event and stores the outboxes in the event using the {@link MailboxesOutboxes} symbol
+ * Parses a 10002 event and stores the outboxes in the event using the {@link MailboxesOutboxesSymbol} symbol
  */
 export declare function getOutboxes(event: NostrEvent): Set<string>;

package/dist/helpers/mailboxes.js

@@ -1,10 +1,11 @@
 import { safeRelayUrl } from "./relays.js";
-import { MailboxesInboxes, MailboxesOutboxes } from "./symbols.js";
+export const MailboxesInboxesSymbol = Symbol.for("mailboxes-inboxes");
+export const MailboxesOutboxesSymbol = Symbol.for("mailboxes-outboxes");
 /**
- * Parses a 10002 event and stores the inboxes in the event using the {@link MailboxesInboxes} symbol
+ * Parses a 10002 event and stores the inboxes in the event using the {@link MailboxesInboxesSymbol} symbol
  */
 export function getInboxes(event) {
-    if (!event[MailboxesInboxes]) {
+    if (!event[MailboxesInboxesSymbol]) {
         const inboxes = new Set();
         for (const tag of event.tags) {
             if (tag[0] === "r" && tag[1] && (tag[2] === "read" || tag[2] === undefined)) {
@@ -13,15 +14,15 @@ export function getInboxes(event) {
                     inboxes.add(url);
             }
         }
-        event[MailboxesInboxes] = inboxes;
+        event[MailboxesInboxesSymbol] = inboxes;
     }
-    return event[MailboxesInboxes];
+    return event[MailboxesInboxesSymbol];
 }
 /**
- * Parses a 10002 event and stores the outboxes in the event using the {@link MailboxesOutboxes} symbol
+ * Parses a 10002 event and stores the outboxes in the event using the {@link MailboxesOutboxesSymbol} symbol
  */
 export function getOutboxes(event) {
-    if (!event[MailboxesOutboxes]) {
+    if (!event[MailboxesOutboxesSymbol]) {
         const outboxes = new Set();
         for (const tag of event.tags) {
             if (tag[0] === "r" && tag[1] && (tag[2] === "write" || tag[2] === undefined)) {
@@ -30,7 +31,7 @@ export function getOutboxes(event) {
                     outboxes.add(url);
             }
         }
-        event[MailboxesOutboxes] = outboxes;
+        event[MailboxesOutboxesSymbol] = outboxes;
     }
-    return event[MailboxesOutboxes];
+    return event[MailboxesOutboxesSymbol];
 }

package/dist/helpers/mailboxes.test.d.ts

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

package/dist/helpers/mailboxes.test.js

@@ -0,0 +1,80 @@
+import { getInboxes, getOutboxes } from "./mailboxes.js";
+const emptyEvent = {
+    kind: 10002,
+    content: "",
+    tags: [],
+    created_at: 0,
+    sig: "",
+    id: "",
+    pubkey: "",
+};
+describe("Mailboxes", () => {
+    describe("getInboxes", () => {
+        test("should transform urls", () => {
+            expect(Array.from(getInboxes({
+                ...emptyEvent,
+                tags: [["r", "wss://inbox.com"]],
+            }))).toIncludeAllMembers(["wss://inbox.com/"]);
+        });
+        test("should remove bad urls", () => {
+            expect(Array.from(getInboxes({
+                ...emptyEvent,
+                tags: [["r", "bad://inbox.com"]],
+            }))).toBeArrayOfSize(0);
+            expect(Array.from(getInboxes({
+                ...emptyEvent,
+                tags: [["r", "something that is not a url"]],
+            }))).toBeArrayOfSize(0);
+            expect(Array.from(getInboxes({
+                ...emptyEvent,
+                tags: [["r", "wss://inbox.com,wss://inbox.org"]],
+            }))).toBeArrayOfSize(0);
+        });
+        test("without marker", () => {
+            expect(Array.from(getInboxes({
+                ...emptyEvent,
+                tags: [["r", "wss://inbox.com/"]],
+            }))).toIncludeAllMembers(["wss://inbox.com/"]);
+        });
+        test("with marker", () => {
+            expect(Array.from(getInboxes({
+                ...emptyEvent,
+                tags: [["r", "wss://inbox.com/", "read"]],
+            }))).toIncludeAllMembers(["wss://inbox.com/"]);
+        });
+    });
+    describe("getOutboxes", () => {
+        test("should transform urls", () => {
+            expect(Array.from(getOutboxes({
+                ...emptyEvent,
+                tags: [["r", "wss://outbox.com"]],
+            }))).toIncludeAllMembers(["wss://outbox.com/"]);
+        });
+        test("should remove bad urls", () => {
+            expect(Array.from(getOutboxes({
+                ...emptyEvent,
+                tags: [["r", "bad://inbox.com"]],
+            }))).toBeArrayOfSize(0);
+            expect(Array.from(getOutboxes({
+                ...emptyEvent,
+                tags: [["r", "something that is not a url"]],
+            }))).toBeArrayOfSize(0);
+            expect(Array.from(getOutboxes({
+                ...emptyEvent,
+                tags: [["r", "wss://outbox.com,wss://inbox.org"]],
+            }))).toBeArrayOfSize(0);
+        });
+        test("without marker", () => {
+            expect(Array.from(getOutboxes({
+                ...emptyEvent,
+                tags: [["r", "wss://outbox.com/"]],
+            }))).toIncludeAllMembers(["wss://outbox.com/"]);
+        });
+        test("with marker", () => {
+            expect(Array.from(getOutboxes({
+                ...emptyEvent,
+                tags: [["r", "wss://outbox.com/", "write"]],
+            }))).toIncludeAllMembers(["wss://outbox.com/"]);
+        });
+    });
+});

package/dist/helpers/mute.d.ts

@@ -0,0 +1,21 @@
+import { NostrEvent } from "nostr-tools";
+export declare const MutePubkeysSymbol: unique symbol;
+export declare const MuteThreadsSymbol: unique symbol;
+export declare const MuteHashtagsSymbol: unique symbol;
+export declare const MuteWordsSymbol: unique symbol;
+declare module "nostr-tools" {
+    interface Event {
+        [MutePubkeysSymbol]?: Set<string>;
+        [MuteThreadsSymbol]?: Set<string>;
+        [MuteHashtagsSymbol]?: Set<string>;
+        [MuteWordsSymbol]?: Set<string>;
+    }
+}
+/** Returns a set of muted pubkeys */
+export declare function getMutedPubkeys(mute: NostrEvent): Set<string>;
+/** Returns a set of muted threads */
+export declare function getMutedThreads(mute: NostrEvent): Set<string>;
+/** Returns a set of muted words ( lowercase ) */
+export declare function getMutedWords(mute: NostrEvent): Set<string>;
+/** Returns a set of muted hashtags ( lowercase ) */
+export declare function getMutedHashtags(mute: NostrEvent): Set<string>;

package/dist/helpers/mute.js

@@ -0,0 +1,52 @@
+export const MutePubkeysSymbol = Symbol.for("mute-pubkeys");
+export const MuteThreadsSymbol = Symbol.for("mute-threads");
+export const MuteHashtagsSymbol = Symbol.for("mute-hashtags");
+export const MuteWordsSymbol = Symbol.for("mute-words");
+/** Returns a set of muted pubkeys */
+export function getMutedPubkeys(mute) {
+    let pubkeys = mute[MutePubkeysSymbol];
+    if (!pubkeys) {
+        pubkeys = mute[MutePubkeysSymbol] = new Set();
+        for (const tag of mute.tags) {
+            if (tag[0] === "p" && tag[1])
+                pubkeys.add(tag[1]);
+        }
+    }
+    return pubkeys;
+}
+/** Returns a set of muted threads */
+export function getMutedThreads(mute) {
+    let threads = mute[MuteThreadsSymbol];
+    if (!threads) {
+        threads = mute[MuteThreadsSymbol] = new Set();
+        for (const tag of mute.tags) {
+            if (tag[0] === "e" && tag[1])
+                threads.add(tag[1]);
+        }
+    }
+    return threads;
+}
+/** Returns a set of muted words ( lowercase ) */
+export function getMutedWords(mute) {
+    let words = mute[MuteWordsSymbol];
+    if (!words) {
+        words = mute[MuteWordsSymbol] = new Set();
+        for (const tag of mute.tags) {
+            if (tag[0] === "word" && tag[1])
+                words.add(tag[1].toLocaleLowerCase());
+        }
+    }
+    return words;
+}
+/** Returns a set of muted hashtags ( lowercase ) */
+export function getMutedHashtags(mute) {
+    let hashtags = mute[MuteHashtagsSymbol];
+    if (!hashtags) {
+        hashtags = mute[MuteHashtagsSymbol] = new Set();
+        for (const tag of mute.tags) {
+            if (tag[0] === "t" && tag[1])
+                hashtags.add(tag[1].toLocaleLowerCase());
+        }
+    }
+    return hashtags;
+}

package/dist/helpers/pointers.d.ts

@@ -0,0 +1,22 @@
+import { AddressPointer, DecodeResult, EventPointer, ProfilePointer } from "nostr-tools/nip19";
+export type AddressPointerWithoutD = Omit<AddressPointer, "identifier"> & {
+    identifier?: string;
+};
+export declare function parseCoordinate(a: string): AddressPointerWithoutD | null;
+export declare function parseCoordinate(a: string, requireD: false): AddressPointerWithoutD | null;
+export declare function parseCoordinate(a: string, requireD: true): AddressPointer | null;
+export declare function parseCoordinate(a: string, requireD: false, silent: false): AddressPointerWithoutD;
+export declare function parseCoordinate(a: string, requireD: true, silent: false): AddressPointer;
+export declare function parseCoordinate(a: string, requireD: true, silent: true): AddressPointer | null;
+export declare function parseCoordinate(a: string, requireD: false, silent: true): AddressPointerWithoutD | null;
+export declare function getPubkeyFromDecodeResult(result?: DecodeResult): string | undefined;
+export declare function encodeDecodeResult(result: DecodeResult): "" | `nsec1${string}` | `npub1${string}` | `note1${string}` | `nprofile1${string}` | `nevent1${string}` | `naddr1${string}` | `nrelay1${string}`;
+export declare function getEventPointerFromTag(tag: string[]): EventPointer;
+export declare function getAddressPointerFromTag(tag: string[]): AddressPointer;
+export declare function getProfilePointerFromTag(tag: string[]): ProfilePointer;
+export declare function getPointerFromTag(tag: string[]): DecodeResult | null;
+export declare function isAddressPointer(pointer: DecodeResult["data"]): pointer is AddressPointer;
+export declare function isEventPointer(pointer: DecodeResult["data"]): pointer is EventPointer;
+export declare function getCoordinateFromAddressPointer(pointer: AddressPointer): string;
+export declare function getATagFromAddressPointer(pointer: AddressPointer): ["a", ...string[]];
+export declare function getETagFromEventPointer(pointer: EventPointer): ["e", ...string[]];

package/dist/helpers/pointers.js

@@ -0,0 +1,127 @@
+import { naddrEncode, neventEncode, noteEncode, nprofileEncode, npubEncode, nrelayEncode, nsecEncode, } from "nostr-tools/nip19";
+import { getPublicKey } from "nostr-tools";
+import { safeRelayUrls } from "./relays.js";
+export function parseCoordinate(a, requireD = false, silent = true) {
+    const parts = a.split(":");
+    const kind = parts[0] && parseInt(parts[0]);
+    const pubkey = parts[1];
+    const d = parts[2];
+    if (!kind) {
+        if (silent)
+            return null;
+        else
+            throw new Error("Missing kind");
+    }
+    if (!pubkey) {
+        if (silent)
+            return null;
+        else
+            throw new Error("Missing pubkey");
+    }
+    if (requireD && d === undefined) {
+        if (silent)
+            return null;
+        else
+            throw new Error("Missing identifier");
+    }
+    return {
+        kind,
+        pubkey,
+        identifier: d,
+    };
+}
+export function getPubkeyFromDecodeResult(result) {
+    if (!result)
+        return;
+    switch (result.type) {
+        case "naddr":
+        case "nprofile":
+            return result.data.pubkey;
+        case "npub":
+            return result.data;
+        case "nsec":
+            return getPublicKey(result.data);
+        default:
+            return undefined;
+    }
+}
+export function encodeDecodeResult(result) {
+    switch (result.type) {
+        case "naddr":
+            return naddrEncode(result.data);
+        case "nprofile":
+            return nprofileEncode(result.data);
+        case "nevent":
+            return neventEncode(result.data);
+        case "nrelay":
+            return nrelayEncode(result.data);
+        case "nsec":
+            return nsecEncode(result.data);
+        case "npub":
+            return npubEncode(result.data);
+        case "note":
+            return noteEncode(result.data);
+    }
+    return "";
+}
+export function getEventPointerFromTag(tag) {
+    if (!tag[1])
+        throw new Error("Missing event id in tag");
+    let pointer = { id: tag[1] };
+    if (tag[2])
+        pointer.relays = safeRelayUrls([tag[2]]);
+    return pointer;
+}
+export function getAddressPointerFromTag(tag) {
+    if (!tag[1])
+        throw new Error("Missing coordinate in tag");
+    const pointer = parseCoordinate(tag[1], true, false);
+    if (tag[2])
+        pointer.relays = safeRelayUrls([tag[2]]);
+    return pointer;
+}
+export function getProfilePointerFromTag(tag) {
+    if (!tag[1])
+        throw new Error("Missing pubkey in tag");
+    const pointer = { pubkey: tag[1] };
+    if (tag[2])
+        pointer.relays = safeRelayUrls([tag[2]]);
+    return pointer;
+}
+export function getPointerFromTag(tag) {
+    try {
+        switch (tag[0]) {
+            case "e":
+                return { type: "nevent", data: getEventPointerFromTag(tag) };
+            case "a":
+                return {
+                    type: "naddr",
+                    data: getAddressPointerFromTag(tag),
+                };
+            case "p":
+                return { type: "nprofile", data: getProfilePointerFromTag(tag) };
+        }
+    }
+    catch (error) { }
+    return null;
+}
+export function isAddressPointer(pointer) {
+    return (typeof pointer !== "string" &&
+        Object.hasOwn(pointer, "identifier") &&
+        Object.hasOwn(pointer, "pubkey") &&
+        Object.hasOwn(pointer, "kind"));
+}
+export function isEventPointer(pointer) {
+    return typeof pointer !== "string" && Object.hasOwn(pointer, "id");
+}
+export function getCoordinateFromAddressPointer(pointer) {
+    return `${pointer.kind}:${pointer.pubkey}:${pointer.identifier}`;
+}
+export function getATagFromAddressPointer(pointer) {
+    const relay = pointer.relays?.[0];
+    const coordinate = getCoordinateFromAddressPointer(pointer);
+    return relay ? ["a", coordinate, relay] : ["a", coordinate];
+}
+export function getETagFromEventPointer(pointer) {
+    return pointer.relays?.length ? ["e", pointer.id, pointer.relays[0]] : ["e", pointer.id];
+}

package/dist/helpers/profile.d.ts

@@ -1,4 +1,10 @@
 import { NostrEvent } from "nostr-tools";
+export declare const ProfileContentSymbol: unique symbol;
+declare module "nostr-tools" {
+    interface Event {
+        [ProfileContentSymbol]?: ProfileContent | Error;
+    }
+}
 export type ProfileContent = {
     name?: string;
     display_name?: string;
@@ -13,6 +19,7 @@ export type ProfileContent = {
     lud06?: string;
     nip05?: string;
 };
+/** Returns the parsed profile content for a kind 0 event */
 export declare function getProfileContent(event: NostrEvent): ProfileContent;
 export declare function getProfileContent(event: NostrEvent, quite: false): ProfileContent;
 export declare function getProfileContent(event: NostrEvent, quite: true): ProfileContent | Error;

package/dist/helpers/profile.js

@@ -1,17 +1,17 @@
-import { ProfileContent } from "./symbols.js";
+export const ProfileContentSymbol = Symbol.for("profile-content");
 export function getProfileContent(event, quite = false) {
-    let cached = event[ProfileContent];
+    let cached = event[ProfileContentSymbol];
     if (!cached) {
         try {
             const profile = JSON.parse(event.content);
             // ensure nip05 is a string
             if (profile.nip05 && typeof profile.nip05 !== "string")
                 profile.nip05 = String(profile.nip05);
-            cached = event[ProfileContent] = profile;
+            cached = event[ProfileContentSymbol] = profile;
         }
         catch (e) {
             if (e instanceof Error)
-                cached = event[ProfileContent] = e;
+                cached = event[ProfileContentSymbol] = e;
         }
     }
     if (cached === undefined) {