nostr-bray 1.26.0 → 1.26.1

package/dist/nip17-wrap.d.ts

@@ -0,0 +1,43 @@
+/**
+ * NIP-17 gift-wrap helpers that work with any SigningContext (local keys OR remote bunker).
+ *
+ * nostr-tools' wrapEvent/unwrapEvent require raw private key bytes, which are
+ * unavailable when signing is delegated to a NIP-46 bunker. These helpers
+ * reimplement the NIP-59 gift-wrap flow using the SigningContext interface
+ * (nip44Encrypt, nip44Decrypt, getSigningFunction) so that both local-key
+ * and bunker modes work identically.
+ */
+import type { Event as NostrEvent } from 'nostr-tools';
+import type { SigningContext } from './signing-context.js';
+interface Recipient {
+    publicKey: string;
+    relayUrl?: string;
+}
+/**
+ * Wrap a DM as a NIP-17 gift-wrapped event using the SigningContext.
+ *
+ * Flow (NIP-59):
+ *   1. Build unsigned rumor (kind 14) with sender pubkey + message
+ *   2. Create seal (kind 13): NIP-44 encrypt rumor with sender key, sign with sender key
+ *   3. Create gift wrap (kind 1059): NIP-44 encrypt seal with random ephemeral key
+ *
+ * The sender's private key is never accessed directly -- all crypto operations
+ * go through ctx.nip44Encrypt() and ctx.getSigningFunction(), which delegate
+ * to the bunker in NIP-46 mode.
+ */
+export declare function wrapEventAsync(ctx: SigningContext, recipient: Recipient, message: string): Promise<NostrEvent>;
+/**
+ * Unwrap a NIP-17 gift-wrapped event using the SigningContext.
+ *
+ * Flow:
+ *   1. Decrypt the gift wrap (kind 1059) content to get the seal
+ *   2. Decrypt the seal (kind 13) content to get the rumor
+ *   3. Return the rumor (the actual DM content)
+ */
+export declare function unwrapEventAsync(ctx: SigningContext, wrap: NostrEvent): Promise<{
+    pubkey: string;
+    content: string;
+    created_at: number;
+    tags: string[][];
+}>;
+export {};

package/dist/nip17-wrap.js

@@ -0,0 +1,91 @@
+/**
+ * NIP-17 gift-wrap helpers that work with any SigningContext (local keys OR remote bunker).
+ *
+ * nostr-tools' wrapEvent/unwrapEvent require raw private key bytes, which are
+ * unavailable when signing is delegated to a NIP-46 bunker. These helpers
+ * reimplement the NIP-59 gift-wrap flow using the SigningContext interface
+ * (nip44Encrypt, nip44Decrypt, getSigningFunction) so that both local-key
+ * and bunker modes work identically.
+ */
+import { generateSecretKey, finalizeEvent, getEventHash } from 'nostr-tools/pure';
+const TWO_DAYS = 2 * 24 * 60 * 60;
+const now = () => Math.round(Date.now() / 1000);
+const randomNow = () => Math.round(now() - Math.random() * TWO_DAYS);
+/** Build the unsigned kind-14 rumor (inner DM event). */
+function createRumor(senderPubkeyHex, recipient, message) {
+    const recipients = Array.isArray(recipient) ? recipient : [recipient];
+    const tags = [];
+    for (const r of recipients) {
+        tags.push(r.relayUrl ? ['p', r.publicKey, r.relayUrl] : ['p', r.publicKey]);
+    }
+    const rumor = {
+        created_at: Math.ceil(Date.now() / 1000),
+        kind: 14,
+        tags,
+        content: message,
+        pubkey: senderPubkeyHex,
+    };
+    rumor.id = getEventHash(rumor);
+    return rumor;
+}
+/**
+ * Wrap a DM as a NIP-17 gift-wrapped event using the SigningContext.
+ *
+ * Flow (NIP-59):
+ *   1. Build unsigned rumor (kind 14) with sender pubkey + message
+ *   2. Create seal (kind 13): NIP-44 encrypt rumor with sender key, sign with sender key
+ *   3. Create gift wrap (kind 1059): NIP-44 encrypt seal with random ephemeral key
+ *
+ * The sender's private key is never accessed directly -- all crypto operations
+ * go through ctx.nip44Encrypt() and ctx.getSigningFunction(), which delegate
+ * to the bunker in NIP-46 mode.
+ */
+export async function wrapEventAsync(ctx, recipient, message) {
+    const senderPubkeyHex = ctx.activePublicKeyHex;
+    // 1. Build the rumor (unsigned kind-14)
+    const rumor = createRumor(senderPubkeyHex, recipient, message);
+    // 2. Create the seal (kind 13) -- encrypted with sender's key, signed by sender
+    const sealContent = await ctx.nip44Encrypt(recipient.publicKey, JSON.stringify(rumor));
+    const sign = ctx.getSigningFunction();
+    const seal = await sign({
+        kind: 13,
+        content: sealContent,
+        created_at: randomNow(),
+        tags: [],
+    });
+    // 3. Create the gift wrap (kind 1059) -- encrypted with random ephemeral key
+    const randomSk = generateSecretKey();
+    const { getConversationKey, encrypt } = await import('nostr-tools/nip44');
+    const ck = getConversationKey(randomSk, recipient.publicKey);
+    const wrapContent = encrypt(JSON.stringify(seal), ck);
+    const wrap = finalizeEvent({
+        kind: 1059,
+        content: wrapContent,
+        created_at: randomNow(),
+        tags: [['p', recipient.publicKey]],
+    }, randomSk);
+    // Zeroise the ephemeral key
+    randomSk.fill(0);
+    return wrap;
+}
+/**
+ * Unwrap a NIP-17 gift-wrapped event using the SigningContext.
+ *
+ * Flow:
+ *   1. Decrypt the gift wrap (kind 1059) content to get the seal
+ *   2. Decrypt the seal (kind 13) content to get the rumor
+ *   3. Return the rumor (the actual DM content)
+ */
+export async function unwrapEventAsync(ctx, wrap) {
+    // 1. Decrypt outer layer (gift wrap -> seal)
+    //    The wrap was encrypted by a random ephemeral key; we decrypt using
+    //    our key + the wrap's pubkey (the ephemeral key's public half).
+    const sealJson = await ctx.nip44Decrypt(wrap.pubkey, wrap.content);
+    const seal = JSON.parse(sealJson);
+    // 2. Decrypt inner layer (seal -> rumor)
+    //    The seal was encrypted by the sender's key; we decrypt using
+    //    our key + the seal's pubkey (the sender's public key).
+    const rumorJson = await ctx.nip44Decrypt(seal.pubkey, seal.content);
+    const rumor = JSON.parse(rumorJson);
+    return rumor;
+}

package/dist/social/dm.js

@@ -1,15 +1,19 @@
-import { wrapEvent } from 'nostr-tools/nip17';
 import * as nip04 from 'nostr-tools/nip04';
 import { decode, npubEncode } from 'nostr-tools/nip19';
 import { toAnnotation } from '../trust-context.js';
+import { wrapEventAsync, unwrapEventAsync } from '../nip17-wrap.js';
 /** Send a DM. Uses NIP-17 gift wrap by default. NIP-04 only if explicitly requested and enabled. */
 export async function handleDmSend(ctx, pool, args) {
     if (args.nip04) {
         if (!args.nip04Enabled) {
             throw new Error('NIP-04 is not enabled. Set NIP04_ENABLED=1 to use legacy DMs.');
         }
-        // NIP-04 legacy DM (kind 4)
-        const encrypted = await nip04.encrypt(ctx.activePrivateKey, args.recipientPubkeyHex, args.message);
+        // NIP-04 legacy DM (kind 4) — requires local key (not available in bunker mode)
+        const localCtx = ctx;
+        if (!localCtx.activePrivateKey) {
+            throw new Error('NIP-04 is not supported in bunker mode. Use NIP-17 (the default) instead.');
+        }
+        const encrypted = await nip04.encrypt(localCtx.activePrivateKey, args.recipientPubkeyHex, args.message);
         const sign = ctx.getSigningFunction();
         const event = await sign({
             kind: 4,
@@ -34,7 +38,7 @@ export async function handleDmSend(ctx, pool, args) {
     }
     const recipientRelayHint = args.recipientRelay ?? recipientRelays[0];
     // Wrap for recipient
-    const event = wrapEvent(ctx.activePrivateKey, { publicKey: args.recipientPubkeyHex, relayUrl: recipientRelayHint }, args.message);
+    const event = await wrapEventAsync(ctx, { publicKey: args.recipientPubkeyHex, relayUrl: recipientRelayHint }, args.message);
     // Publish to recipient's relays (primary) and sender's relays (fallback)
     let publish;
     if (recipientRelays.length > 0) {
@@ -47,10 +51,10 @@ export async function handleDmSend(ctx, pool, args) {
         publish = await pool.publish(ctx.activeNpub, event);
     }
     // Sender copy — wrap the same message addressed to ourselves so our client shows sent DMs.
-    // The inner rumor's p-tag (set by wrapEvent) points to us, but clients use the
+    // The inner rumor's p-tag (set by wrapEventAsync) points to us, but clients use the
     // outer gift-wrap's p-tag to route, and the inner content to display.
     const senderHex = decode(ctx.activeNpub).data;
-    const senderCopy = wrapEvent(ctx.activePrivateKey, { publicKey: senderHex, relayUrl: recipientRelayHint }, args.message);
+    const senderCopy = await wrapEventAsync(ctx, { publicKey: senderHex, relayUrl: recipientRelayHint }, args.message);
     const senderCopyPublish = await pool.publish(ctx.activeNpub, senderCopy);
     const result = { event, senderCopy, protocol: 'nip17', publish, senderCopyPublish };
     if (recipientRelays.length > 0 && publish.accepted.length === 0) {
@@ -97,8 +101,7 @@ async function decryptDmEvents(ctx, events) {
         if (event.kind === 1059) {
             // NIP-17 gift wrap — try to unwrap
             try {
-                const { unwrapEvent } = await import('nostr-tools/nip17');
-                const unwrapped = unwrapEvent(event, ctx.activePrivateKey);
+                const unwrapped = await unwrapEventAsync(ctx, event);
                 results.push({
                     id: event.id,
                     from: unwrapped.pubkey,
@@ -120,9 +123,21 @@ async function decryptDmEvents(ctx, events) {
             }
         }
         else if (event.kind === 4) {
-            // NIP-04 legacy DM
+            // NIP-04 legacy DM — needs local key; silently skip in bunker mode
+            const localCtx = ctx;
+            if (!localCtx.activePrivateKey) {
+                results.push({
+                    id: event.id,
+                    from: event.pubkey,
+                    createdAt: event.created_at,
+                    protocol: 'nip04-deprecated',
+                    decrypted: false,
+                    error: 'NIP-04 decryption not available in bunker mode',
+                });
+                continue;
+            }
             try {
-                const decrypted = await nip04.decrypt(ctx.activePrivateKey, event.pubkey, event.content);
+                const decrypted = await nip04.decrypt(localCtx.activePrivateKey, event.pubkey, event.content);
                 results.push({
                     id: event.id,
                     from: event.pubkey,

package/dist/trust/handlers.js

@@ -1,10 +1,10 @@
 import { createAttestation, createRevocation } from 'nostr-attestations';
 import { validateAttestation } from 'nostr-attestations';
 import { attestationFilter } from 'nostr-attestations';
-import { wrapEvent } from 'nostr-tools/nip17';
 import { toUnsignedEvent } from 'nsec-tree/event';
 import { decode } from 'nostr-tools/nip19';
 import { hasExtendedIdentity } from '../signing-context.js';
+import { wrapEventAsync } from '../nip17-wrap.js';
 /** Create and publish a kind 31000 attestation */
 export async function handleTrustAttest(ctx, pool, args) {
     if (!args.type && !args.assertionId) {
@@ -88,7 +88,7 @@ export async function handleTrustRequest(ctx, pool, args) {
         attestation_type: args.attestationType,
         message: args.message,
     });
-    const event = wrapEvent(ctx.activePrivateKey, { publicKey: args.recipientPubkeyHex }, payload);
+    const event = await wrapEventAsync(ctx, { publicKey: args.recipientPubkeyHex }, payload);
     const publish = await pool.publish(ctx.activeNpub, event);
     return { event, publish };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nostr-bray",
-  "version": "1.26.0",
+  "version": "1.26.1",
   "description": "Trust-aware Nostr for AI and humans. Three dimensions of trust -- verification, proximity, and access -- woven into every interaction.",
   "type": "module",
   "main": "dist/index.js",