add hidden content helper methods

Author: hzrd149

.changeset/flat-mirrors-hang.md

@@ -0,0 +1,5 @@
+---
+"applesauce-core": minor
+---
+
+Add gift-wrap helper methods

.changeset/plenty-jeans-leave.md

@@ -0,0 +1,5 @@
+---
+"applesauce-core": minor
+---
+
+Add direct message helper methods

.changeset/silent-drinks-wink.md

@@ -0,0 +1,5 @@
+---
+"applesauce-core": minor
+---
+
+Add hidden content helper methods

packages/core/src/helpers/direct-messages.ts

@@ -0,0 +1,7 @@
+import { NostrEvent } from "nostr-tools";
+import { getHiddenContent, HiddenContentSigner, unlockHiddenContent } from "./hidden-content.js";
+
+/** Returns the decrypted content of a direct message */
+export async function decryptDirectMessage(message: NostrEvent, signer: HiddenContentSigner): Promise<string> {
+  return getHiddenContent(message) || (await unlockHiddenContent(message, signer));
+}

packages/core/src/helpers/gift-wraps.ts

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

packages/core/src/helpers/hidden-content.ts

@@ -0,0 +1,95 @@
+import * as kinds from "nostr-tools/kinds";
+import { UnsignedEvent, type EventTemplate, type NostrEvent } from "nostr-tools";
+
+import { GROUPS_LIST_KIND } from "./groups.js";
+
+export const HiddenContentSymbol = Symbol.for("hidden-content");
+
+export type HiddenContentSigner = {
+  nip04?: {
+    encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
+    decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
+  };
+  nip44?: {
+    encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
+    decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
+  };
+};
+
+/** Various event kinds that can have encrypted tags in their content and which encryption method they use */
+export const EventContentEncryptionMethod: Record<number, "nip04" | "nip44"> = {
+  // NIP-60 wallet
+  17375: "nip44",
+  7375: "nip44",
+  7376: "nip44",
+
+  // DMs
+  [kinds.EncryptedDirectMessage]: "nip04",
+
+  // Gift wraps
+  [kinds.GiftWrap]: "nip44",
+
+  // NIP-51 lists
+  [kinds.BookmarkList]: "nip04",
+  [kinds.InterestsList]: "nip04",
+  [kinds.Mutelist]: "nip04",
+  [kinds.CommunitiesList]: "nip04",
+  [kinds.PublicChatsList]: "nip04",
+  [kinds.SearchRelaysList]: "nip04",
+  [GROUPS_LIST_KIND]: "nip04",
+
+  // NIP-51 sets
+  [kinds.Bookmarksets]: "nip04",
+  [kinds.Relaysets]: "nip04",
+  [kinds.Followsets]: "nip04",
+  [kinds.Curationsets]: "nip04",
+  [kinds.Interestsets]: "nip04",
+};
+
+/** Checks if an event can have hidden content */
+export function canHaveHiddenContent(kind: number): boolean {
+  return EventContentEncryptionMethod[kind] !== undefined;
+}
+
+/** Checks if an event has hidden content */
+export function hasHiddenContent(event: { kind: number; content: string }): boolean {
+  return canHaveHiddenContent(event.kind) && event.content.length > 0;
+}
+
+/** Returns the hidden tags for an event if they are unlocked */
+export function getHiddenContent(event: NostrEvent | EventTemplate): string | undefined {
+  return Reflect.get(event, HiddenContentSymbol) as string | undefined;
+}
+
+/** Checks if the hidden tags are locked */
+export function isHiddenContentLocked(event: NostrEvent | UnsignedEvent): boolean {
+  return hasHiddenContent(event) && getHiddenContent(event) === undefined;
+}
+
+/** Returns either nip04 or nip44 encryption methods depending on event kind */
+export function getHiddenContentEncryptionMethods(kind: number, signer: HiddenContentSigner) {
+  const method = EventContentEncryptionMethod[kind];
+  const encryption = signer[method];
+  if (!encryption) throw new Error(`Signer does not support ${method} encryption`);
+
+  return encryption;
+}
+
+/**
+ * Unlocks the encrypted content in an event
+ * @param event The event with content to decrypt
+ * @param signer A signer to use to decrypt the tags
+ * @throws
+ */
+export async function unlockHiddenContent(
+  event: { kind: number; pubkey: string; content: string },
+  signer: HiddenContentSigner,
+): Promise<string> {
+  if (!canHaveHiddenContent(event.kind)) throw new Error("Event kind does not support hidden content");
+  const encryption = getHiddenContentEncryptionMethods(event.kind, signer);
+  const plaintext = await encryption.decrypt(event.pubkey, event.content);
+
+  Reflect.set(event, HiddenContentSymbol, plaintext);
+
+  return plaintext;
+}

packages/core/src/helpers/hidden-tags.ts

@@ -1,48 +1,20 @@
-import { EventTemplate, kinds, NostrEvent } from "nostr-tools";
+import { EventTemplate, NostrEvent } from "nostr-tools";
 
-import { GROUPS_LIST_KIND } from "./groups.js";
 import { EventStore } from "../event-store/event-store.js";
 import { unixNow } from "./time.js";
 import { isEvent } from "./event.js";
-
-export type HiddenTagsSigner = {
-  nip04?: {
-    encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
-    decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
-  };
-  nip44?: {
-    encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
-    decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
-  };
-};
+import {
+  canHaveHiddenContent,
+  getHiddenContentEncryptionMethods,
+  HiddenContentSigner,
+  unlockHiddenContent,
+} from "./hidden-content.js";
 
 export const HiddenTagsSymbol = Symbol.for("hidden-tags");
 
-/** Various event kinds that can have encrypted tags in their content and which encryption method they use */
-export const EventEncryptionMethod: Record<number, "nip04" | "nip44"> = {
-  // NIP-60 wallet
-  17375: "nip44",
-
-  // NIP-51 lists
-  [kinds.BookmarkList]: "nip04",
-  [kinds.InterestsList]: "nip04",
-  [kinds.Mutelist]: "nip04",
-  [kinds.CommunitiesList]: "nip04",
-  [kinds.PublicChatsList]: "nip04",
-  [kinds.SearchRelaysList]: "nip04",
-  [GROUPS_LIST_KIND]: "nip04",
-
-  // NIP-51 sets
-  [kinds.Bookmarksets]: "nip04",
-  [kinds.Relaysets]: "nip04",
-  [kinds.Followsets]: "nip04",
-  [kinds.Curationsets]: "nip04",
-  [kinds.Interestsets]: "nip04",
-};
-
 /** Checks if an event can have hidden tags */
 export function canHaveHiddenTags(kind: number): boolean {
-  return EventEncryptionMethod[kind] !== undefined;
+  return canHaveHiddenContent(kind);
 }
 
 /** Checks if an event has hidden tags */
@@ -61,12 +33,8 @@ export function isHiddenTagsLocked(event: NostrEvent): boolean {
 }
 
 /** Returns either nip04 or nip44 encryption method depending on list kind */
-export function getListEncryptionMethods(kind: number, signer: HiddenTagsSigner) {
-  const method = EventEncryptionMethod[kind];
-  const encryption = signer[method];
-  if (!encryption) throw new Error(`Signer does not support ${method} encryption`);
-
-  return encryption;
+export function getListEncryptionMethods(kind: number, signer: HiddenContentSigner) {
+  return getHiddenContentEncryptionMethods(kind, signer);
 }
 
 /**
@@ -78,12 +46,11 @@ export function getListEncryptionMethods(kind: number, signer: HiddenTagsSigner)
  */
 export async function unlockHiddenTags<T extends { kind: number; pubkey: string; content: string }>(
   event: T,
-  signer: HiddenTagsSigner,
+  signer: HiddenContentSigner,
   store?: EventStore,
 ): Promise<T> {
   if (!canHaveHiddenTags(event.kind)) throw new Error("Event kind does not support hidden tags");
-  const encryption = getListEncryptionMethods(event.kind, signer);
-  const plaintext = await encryption.decrypt(event.pubkey, event.content);
+  const plaintext = await unlockHiddenContent(event, signer);
 
   const parsed = JSON.parse(plaintext) as string[][];
   if (!Array.isArray(parsed)) throw new Error("Content is not an array of tags");
@@ -100,12 +67,13 @@ export async function unlockHiddenTags<T extends { kind: number; pubkey: string;
 
 /**
  * Override the hidden tags in an event
+ * @deprecated use EventFactory to create draft events
  * @throws
  */
 export async function overrideHiddenTags(
   event: NostrEvent,
   hidden: string[][],
-  signer: HiddenTagsSigner,
+  signer: HiddenContentSigner,
 ): Promise<EventTemplate> {
   if (!canHaveHiddenTags(event.kind)) throw new Error("Event kind does not support hidden tags");
   const encryption = getListEncryptionMethods(event.kind, signer);

packages/core/src/helpers/index.ts

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

packages/relay/src/relay.ts

@@ -8,7 +8,6 @@ import {
   NEVER,
   Observable,
   of,
-  retry,
   shareReplay,
   switchMap,
   take,
@@ -74,8 +73,6 @@ export class Relay {
 
     // create an observable for listening for AUTH
     this.challenge$ = this.socket$.pipe(
-      // trying connection on error
-      retry({ count: 20, delay: 5_000, resetOnSuccess: true }),
       // listen for AUTH messages
       filter((message) => message[0] === "AUTH"),
       // pick the challenge string out
@@ -115,8 +112,6 @@ export class Relay {
           (message) => (message[0] === "EVENT" || message[0] === "CLOSE" || message[0] === "EOSE") && message[1] === id,
         )
         .pipe(
-          // trying connection on error
-          retry({ count: 20, delay: 5_000, resetOnSuccess: true }),
           // listen for CLOSE auth-required
           tap((m) => {
             if (m[0] === "CLOSE" && m[1].startsWith("auth-required") && !this.authRequiredForReq.value) {
@@ -150,8 +145,6 @@ export class Relay {
         (m) => m[0] === "OK" && m[1] === event.id,
       )
       .pipe(
-        // trying connection on error
-        retry({ count: 20, delay: 5_000, resetOnSuccess: true }),
         // format OK message
         map((m) => ({ ok: m[2], message: m[3], from: this.url })),
         // complete on first value