applesauce-core 4.4.0 → 4.4.2

package/dist/helpers/event.d.ts

@@ -1,4 +1,4 @@
-import { NostrEvent, VerifiedEvent } from "nostr-tools";
+import { NostrEvent, VerifiedEvent } from "nostr-tools/pure";
 import { IEventStore } from "../event-store/interface.js";
 export { NostrEvent, EventTemplate, UnsignedEvent, verifiedSymbol, verifyEvent, VerifiedEvent } from "nostr-tools/pure";
 export { bytesToHex, hexToBytes, insertEventIntoAscendingList, insertEventIntoDescendingList, binarySearch, } from "nostr-tools/utils";
@@ -36,6 +36,12 @@ export declare function getReplaceableAddress(event: NostrEvent): string;
 export declare function createReplaceableAddress(kind: number, pubkey: string, identifier?: string): string;
 /** @deprecated use createReplaceableAddress instead */
 export declare const getReplaceableUID: typeof createReplaceableAddress;
+/** Method used to verify an events signature */
+export type VerifyEventMethod = (event: NostrEvent) => event is VerifiedEvent;
+/** Sets the internal method used to verify events in helpers (zaps, gift-wraps, etc) */
+export declare function setVerifyWrappedEventMethod(method: VerifyEventMethod): void;
+/** Verifies an internal (wrapped) event using the set internal verification method */
+export declare function verifyWrappedEvent(event: NostrEvent): event is VerifiedEvent;
 /** Sets events verified flag without checking anything */
 export declare function fakeVerifyEvent(event: NostrEvent): event is VerifiedEvent;
 /** Marks an event as being from a cache */

package/dist/helpers/event.js

@@ -1,4 +1,4 @@
-import { verifiedSymbol } from "nostr-tools";
+import { verifiedSymbol, verifyEvent } from "nostr-tools/pure";
 import { isAddressableKind, isReplaceableKind } from "nostr-tools/kinds";
 import { getOrComputeCachedValue } from "./cache.js";
 // Re-export types from nostr-tools
@@ -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 */
@@ -66,6 +65,16 @@ export function createReplaceableAddress(kind, pubkey, identifier) {
 }
 /** @deprecated use createReplaceableAddress instead */
 export const getReplaceableUID = createReplaceableAddress;
+// Internal method for verifying events (used by zaps, gift-wraps, etc)
+let verifyWrappedEventMethod = verifyEvent;
+/** Sets the internal method used to verify events in helpers (zaps, gift-wraps, etc) */
+export function setVerifyWrappedEventMethod(method) {
+    verifyWrappedEventMethod = method;
+}
+/** Verifies an internal (wrapped) event using the set internal verification method */
+export function verifyWrappedEvent(event) {
+    return verifyWrappedEventMethod(event);
+}
 /** Sets events verified flag without checking anything */
 export function fakeVerifyEvent(event) {
     event[verifiedSymbol] = true;

package/dist/helpers/gift-wraps.js

@@ -1,7 +1,7 @@
-import { kinds, verifyEvent } from "nostr-tools";
+import { kinds } from "nostr-tools";
 import { EventMemory } from "../event-store/event-memory.js";
 import { getEncryptedContent, isEncryptedContentUnlocked, lockEncryptedContent, unlockEncryptedContent, } from "./encrypted-content.js";
-import { notifyEventUpdate } from "./event.js";
+import { notifyEventUpdate, verifyWrappedEvent } from "./event.js";
 /**
  * An internal event set to keep track of seals and rumors
  * This is intentionally isolated from the main applications event store so to prevent seals and rumors from being leaked
@@ -130,7 +130,7 @@ export function getGiftWrapSeal(gift) {
     }
     else {
         // Verify the seal event
-        verifyEvent(seal);
+        verifyWrappedEvent(seal);
         // Add to the internal event set
         internalGiftWrapEvents.add(seal);
         // Set the reference to the parent gift wrap event (upstream)

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/zap.js

@@ -1,7 +1,8 @@
-import { kinds, nip57 } from "nostr-tools";
+import { kinds, validateEvent } from "nostr-tools";
 import { parseBolt11 } from "./bolt11.js";
 import { getOrComputeCachedValue } from "./cache.js";
 import { getTagValue } from "./event-tags.js";
+import { verifyWrappedEvent } from "./index.js";
 import { getAddressPointerFromATag, getEventPointerFromETag } from "./pointers.js";
 import { isATag, isETag } from "./tags.js";
 export const ZapRequestSymbol = Symbol.for("zap-request");
@@ -60,10 +61,30 @@ export function getZapRequest(zap) {
             return;
         // Attempt to parse the zap request
         try {
-            const error = nip57.validateZapRequest(description);
-            if (error)
-                return;
-            return JSON.parse(description);
+            // Copied from nostr-tools/nip57 and modified to use the internal verifyZap method and return the zap request event
+            let zapRequest;
+            try {
+                zapRequest = JSON.parse(description);
+            }
+            catch (err) {
+                throw new Error("Invalid zap request JSON.");
+            }
+            if (!validateEvent(zapRequest))
+                throw new Error("Zap request is not a valid Nostr event.");
+            if (!verifyWrappedEvent(zapRequest))
+                throw new Error("Invalid signature on zap request.");
+            let p = zapRequest.tags.find(([t, v]) => t === "p" && v);
+            if (!p)
+                throw new Error("Zap request doesn't have a 'p' tag.");
+            if (!p[1].match(/^[a-f0-9]{64}$/))
+                throw new Error("Zap request 'p' tag is not valid hex.");
+            let e = zapRequest.tags.find(([t, v]) => t === "e" && v);
+            if (e && !e[1].match(/^[a-f0-9]{64}$/))
+                throw new Error("Zap request 'e' tag is not valid hex.");
+            let relays = zapRequest.tags.find(([t, v]) => t === "relays" && v);
+            if (!relays)
+                throw new Error("Zap request doesn't have a 'relays' tag.");
+            return zapRequest;
         }
         catch (error) {
             return undefined;

package/package.json

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