libp2r2p 0.0.1 → 0.0.2

package/README.md

@@ -44,40 +44,87 @@ await messenger.tell({
 
 ### Deleting Private Broadcasts
 
-High-level private-message sends create one deletion capability for the whole
-logical message. The returned object keeps its normal result fields and adds
-`deletionPubkey` plus, when the library generated the key, `deletionSeckey`.
-All outer kind `3560` chunks for that send carry the public
-`['s', deletionPubkey]` tag.
+By default, each high-level private-message send creates one fresh deletion
+keypair for its logical message. Every outer kind `3560` event produced for that
+send, including router chunks, recipient subsets, and nym carriers, carries the
+same public key in its `s` tag. The result always contains `delivery.reports`.
+When libp2r2p generated the keypair, it also contains
+`delivery.deletionSeckey`; the public key can be derived from that secret.
+
+This shared `s` value deliberately makes the outer events for one logical send
+linkable to relay operators and other observers. Disable automatic capabilities
+when that tradeoff is not acceptable. The messenger-wide setting defaults to
+`true`, and a channel setting takes precedence:
 
-Pass a pre-generated `deletionPubkey` when the application needs to own and
-persist the secret before sending. In that case the result deliberately omits a
-secret it was not given:
+```js
+const messenger = await createPrivateMessenger({
+  userSigner,
+  autoDeletionCapability: false,
+  channels: [{
+    signer: privateChannelSigner,
+    relays: ['wss://relay.example'],
+    autoDeletionCapability: true
+  }]
+})
+```
+
+With automatic capabilities disabled and no caller-supplied key, the outer
+events have no `s` tag. They are not deliberately linkable through this
+extension, but cannot later be deleted with it. A caller that already owns a
+deletion key can supply its public key on an individual send; libp2r2p then
+does not generate or return a key. Use a fresh caller-owned key for each
+logical message unless cross-message linkability is intentional:
 
 ```js
 import { generateKeypair } from 'libp2r2p/key'
 
 const deletionKey = generateKeypair()
-const sent = await messenger.tell({
+await messenger.tell({
   receiverPubkey,
   payload: { text: 'remove this later' },
   deletionPubkey: deletionKey.pubkey
 })
+```
+
+```js
+import { finalizeEvent } from 'nostr-tools'
+import { keypairFromSeckey } from 'libp2r2p/key'
+import { relayPool } from 'libp2r2p/relay'
+
+const sent = await messenger.tell({
+  receiverPubkey,
+  payload: { text: 'remove this later' }
+})
 
-// Persist deletionKey.seckey with the application's copy of the message.
-console.log(sent.deletionPubkey)
+if (sent.delivery.deletionSeckey) {
+  const deletionKey = keypairFromSeckey(sent.delivery.deletionSeckey)
+  // Persist this secret with the application's copy of the logical message.
+
+  const { result: outerEvents } = await relayPool.getEvents({
+    kinds: [3560],
+    authors: [channelPubkey],
+    '#s': [deletionKey.pubkey]
+  }, relays)
+  for (let offset = 0; offset < outerEvents.length; offset += 100) {
+    const deletion = finalizeEvent({
+      kind: 5,
+      created_at: Math.floor(Date.now() / 1000),
+      tags: [['k', '3560'], ...outerEvents.slice(offset, offset + 100).map(event => ['e', event.id])],
+      content: ''
+    }, deletionKey.secretKey)
+    await relayPool.sendEvent(deletion, relays)
+  }
+}
 ```
 
-The `s` tag is public metadata, so it makes the outer chunks for one message
-linkable. It is a deletion capability, not the channel key or the sender's
-identity. libp2r2p does not automatically delete anything: an application can
-later find candidate outer events with a filter such as
-`{ kinds: [3560], authors: [channelPubkey], '#s': [deletionPubkey] }`, then
-sign a kind `5` deletion event with the matching secret key. Relay support for
-this capability is not universal. A relay that supports it SHOULD recognize
-only the explicit `k=3560` deletion form; a regular NIP-09 kind `5` event
-signed by the outer event's private-channel key MUST NOT delete a kind `3560`
-event, whether or not that event carries an `s` tag.
+The `s` tag is public metadata and a deletion capability, not the channel key
+or sender identity. libp2r2p does not delete anything automatically.
+
+Relay support for this capability is not universal. A relay that implements it
+should accept only a kind `5` request signed by the matching `s` key with exactly
+one `['k', '3560']` tag, explicit matching `e` targets, and no `a` tags. A
+regular NIP-09 kind `5` request signed by the outer event's private-channel key
+must not delete a kind `3560` event, whether or not that event has an `s` tag.
 
 ### Temporary Send Storage
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libp2r2p",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Peer-to-relay-to-peer",
   "keywords": [
     "p2r2p",

package/private-channel/index.js

@@ -527,13 +527,13 @@ export async function publish ({ senderSigner, imkcSigner, privateChannelSigner
     } finally {
       cleanupEnvelopeRows(context.preparedRows)
     }
-    return { results }
+    return results
   }
 
   for await (const wrappedEvent of wrapEvents({ senderSigner, imkcSigner, privateChannelSigner, privateChannelReaderPubkey, receivers, receiverTag, deletionPubkey: normalizedDeletionPubkey, event, expirationSeconds, temporaryStorageArea, _getIykcProofs })) {
     results.push(await _publish(wrappedEvent, withRecoveryRelays(relays, recoveryRelays)))
   }
-  return { results }
+  return results
 }
 
 export async function publishNymEvent ({ nymSigner, privateChannelSigner, privateChannelReaderPubkey, deletionPubkey, event, relays, relayToReceivers, recoveryRelays, expirationSeconds, _publish = sendToRelays }) {
@@ -543,7 +543,7 @@ export async function publishNymEvent ({ nymSigner, privateChannelSigner, privat
   for await (const wrappedEvent of wrapNymEvents({ nymSigner, privateChannelSigner, privateChannelReaderPubkey, deletionPubkey: normalizedDeletionPubkey, event, expirationSeconds })) {
     results.push(await _publish(wrappedEvent, publishRelays))
   }
-  return { results }
+  return results
 }
 
 function readSignerFromMap (signersByPubkey, pubkey) {

package/private-message/index.js

@@ -21,22 +21,32 @@ function uniq (values) {
   return [...new Set((values || []).filter(Boolean))]
 }
 
-function resolveDeletionCapability (deletionPubkey) {
-  if (deletionPubkey !== undefined) {
-    if (typeof deletionPubkey !== 'string' || !HEX_PUBKEY.test(deletionPubkey)) {
-      throw new Error('INVALID_DELETION_PUBKEY')
-    }
-    return { deletionPubkey: deletionPubkey.toLowerCase() }
+function normalizeDeletionPubkey (deletionPubkey) {
+  if (deletionPubkey === undefined) return undefined
+  if (typeof deletionPubkey !== 'string' || !HEX_PUBKEY.test(deletionPubkey)) {
+    throw new Error('INVALID_DELETION_PUBKEY')
   }
+  return deletionPubkey.toLowerCase()
+}
+
+function resolveDeletionCapability ({ deletionPubkey, deletionSeckey, autoDeletionCapability = true }) {
+  if (deletionSeckey !== undefined) throw new Error('DELETION_SECKEY_NOT_ACCEPTED')
+  if (typeof autoDeletionCapability !== 'boolean') throw new Error('AUTO_DELETION_CAPABILITY_BOOLEAN_REQUIRED')
+
+  const normalizedDeletionPubkey = normalizeDeletionPubkey(deletionPubkey)
+  if (normalizedDeletionPubkey) return { deletionPubkey: normalizedDeletionPubkey }
+  if (!autoDeletionCapability) return {}
+
   const { pubkey, seckey } = generateKeypair()
   return { deletionPubkey: pubkey, deletionSeckey: seckey }
 }
 
-function withDeletionCapability (result, capability) {
+function withDelivery (result, reports, deletionSeckey) {
+  const delivery = { reports }
+  if (deletionSeckey !== undefined) delivery.deletionSeckey = deletionSeckey
   return {
     ...result,
-    deletionPubkey: capability.deletionPubkey,
-    ...(capability.deletionSeckey && { deletionSeckey: capability.deletionSeckey })
+    delivery
   }
 }
 
@@ -457,8 +467,10 @@ export async function ask ({
   content,
   expirationSeconds,
   temporaryStorageArea,
-  deletionPubkey,
   _getIykcProofs,
+  deletionPubkey,
+  deletionSeckey,
+  autoDeletionCapability = true,
   _publish = privateChannel.publish
 }) {
   if (!receiverPubkey) throw new Error('RECEIVER_PUBKEY_REQUIRED')
@@ -474,10 +486,10 @@ export async function ask ({
       message: message || { code, payload, error, content }
     })
   })
-  const deletionCapability = resolveDeletionCapability(deletionPubkey)
-  const results = await sendPrivateMessage({ senderSigner, imkcSigner, privateChannelSigner, privateChannelReaderPubkey, receivers: [receiverPubkey], receiverTag: receiverPubkey, deletionPubkey: deletionCapability.deletionPubkey, event: wireEvent, relays, relayToReceivers, recoveryRelays, expirationSeconds, temporaryStorageArea, _getIykcProofs, _publish })
+  const deletion = resolveDeletionCapability({ deletionPubkey, deletionSeckey, autoDeletionCapability })
+  const reports = await sendPrivateMessage({ senderSigner, imkcSigner, privateChannelSigner, privateChannelReaderPubkey, receivers: [receiverPubkey], receiverTag: receiverPubkey, deletionPubkey: deletion.deletionPubkey, event: wireEvent, relays, relayToReceivers, recoveryRelays, expirationSeconds, temporaryStorageArea, _getIykcProofs, _publish })
 
-  return withDeletionCapability({ question, results }, deletionCapability)
+  return withDelivery({ question }, reports, deletion.deletionSeckey)
 }
 
 export async function reply ({
@@ -497,8 +509,10 @@ export async function reply ({
   content,
   expirationSeconds,
   temporaryStorageArea,
-  deletionPubkey,
   _getIykcProofs,
+  deletionPubkey,
+  deletionSeckey,
+  autoDeletionCapability = true,
   _publish = privateChannel.publish
 }) {
   if (!question?.id) throw new Error('QUESTION_REQUIRED')
@@ -511,9 +525,9 @@ export async function reply ({
       message: message || { code, payload, error, content }
     })
   })
-  const deletionCapability = resolveDeletionCapability(deletionPubkey)
-  const results = await sendPrivateMessage({ senderSigner, imkcSigner, privateChannelSigner, privateChannelReaderPubkey, receivers: [receiverPubkey], receiverTag: receiverPubkey, deletionPubkey: deletionCapability.deletionPubkey, event: wireEvent, relays, relayToReceivers, recoveryRelays, expirationSeconds, temporaryStorageArea, _getIykcProofs, _publish })
-  return withDeletionCapability({ reply: event, results }, deletionCapability)
+  const deletion = resolveDeletionCapability({ deletionPubkey, deletionSeckey, autoDeletionCapability })
+  const reports = await sendPrivateMessage({ senderSigner, imkcSigner, privateChannelSigner, privateChannelReaderPubkey, receivers: [receiverPubkey], receiverTag: receiverPubkey, deletionPubkey: deletion.deletionPubkey, event: wireEvent, relays, relayToReceivers, recoveryRelays, expirationSeconds, temporaryStorageArea, _getIykcProofs, _publish })
+  return withDelivery({ reply: event }, reports, deletion.deletionSeckey)
 }
 
 export async function tell ({
@@ -532,8 +546,10 @@ export async function tell ({
   content,
   expirationSeconds,
   temporaryStorageArea,
-  deletionPubkey,
   _getIykcProofs,
+  deletionPubkey,
+  deletionSeckey,
+  autoDeletionCapability = true,
   _publish = privateChannel.publish
 }) {
   if (!receiverPubkey) throw new Error('RECEIVER_PUBKEY_REQUIRED')
@@ -545,9 +561,9 @@ export async function tell ({
       message: message || { code, payload, error, content }
     })
   })
-  const deletionCapability = resolveDeletionCapability(deletionPubkey)
-  const results = await sendPrivateMessage({ senderSigner, imkcSigner, privateChannelSigner, privateChannelReaderPubkey, receivers: [receiverPubkey], receiverTag: receiverPubkey, deletionPubkey: deletionCapability.deletionPubkey, event: wireEvent, relays, relayToReceivers, recoveryRelays, expirationSeconds, temporaryStorageArea, _getIykcProofs, _publish })
-  return withDeletionCapability({ tell: event, results }, deletionCapability)
+  const deletion = resolveDeletionCapability({ deletionPubkey, deletionSeckey, autoDeletionCapability })
+  const reports = await sendPrivateMessage({ senderSigner, imkcSigner, privateChannelSigner, privateChannelReaderPubkey, receivers: [receiverPubkey], receiverTag: receiverPubkey, deletionPubkey: deletion.deletionPubkey, event: wireEvent, relays, relayToReceivers, recoveryRelays, expirationSeconds, temporaryStorageArea, _getIykcProofs, _publish })
+  return withDelivery({ tell: event }, reports, deletion.deletionSeckey)
 }
 
 export async function yell ({
@@ -566,8 +582,10 @@ export async function yell ({
   content,
   expirationSeconds,
   temporaryStorageArea,
-  deletionPubkey,
   _getIykcProofs,
+  deletionPubkey,
+  deletionSeckey,
+  autoDeletionCapability = true,
   _publish = privateChannel.publish
 }) {
   const receivers = uniq(receiverPubkeys)
@@ -580,9 +598,9 @@ export async function yell ({
       message: message || { code, payload, error, content }
     })
   })
-  const deletionCapability = resolveDeletionCapability(deletionPubkey)
-  const results = await sendPrivateMessage({ senderSigner, imkcSigner, privateChannelSigner, privateChannelReaderPubkey, receivers, receiverTag: '', deletionPubkey: deletionCapability.deletionPubkey, event: wireEvent, relays, relayToReceivers, recoveryRelays, expirationSeconds, temporaryStorageArea, _getIykcProofs, _publish })
-  return withDeletionCapability({ yell: event, results }, deletionCapability)
+  const deletion = resolveDeletionCapability({ deletionPubkey, deletionSeckey, autoDeletionCapability })
+  const reports = await sendPrivateMessage({ senderSigner, imkcSigner, privateChannelSigner, privateChannelReaderPubkey, receivers, receiverTag: '', deletionPubkey: deletion.deletionPubkey, event: wireEvent, relays, relayToReceivers, recoveryRelays, expirationSeconds, temporaryStorageArea, _getIykcProofs, _publish })
+  return withDelivery({ yell: event }, reports, deletion.deletionSeckey)
 }
 
 export async function broadcastRumor ({
@@ -597,16 +615,18 @@ export async function broadcastRumor ({
   rumor,
   expirationSeconds,
   temporaryStorageArea,
-  deletionPubkey,
   _getIykcProofs,
+  deletionPubkey,
+  deletionSeckey,
+  autoDeletionCapability = true,
   _publish = privateChannel.publish
 }) {
   const receivers = uniq(receiverPubkeys)
   if (!receivers.length) throw new Error('NO_RECEIVERS')
   const { event, wireEvent } = await makeOutgoingRumor({ senderSigner, rumor })
-  const deletionCapability = resolveDeletionCapability(deletionPubkey)
-  const results = await sendPrivateMessage({ senderSigner, imkcSigner, privateChannelSigner, privateChannelReaderPubkey, receivers, receiverTag: '', deletionPubkey: deletionCapability.deletionPubkey, event: wireEvent, relays, relayToReceivers, recoveryRelays, expirationSeconds, temporaryStorageArea, _getIykcProofs, _publish })
-  return withDeletionCapability({ rumor: event, results }, deletionCapability)
+  const deletion = resolveDeletionCapability({ deletionPubkey, deletionSeckey, autoDeletionCapability })
+  const reports = await sendPrivateMessage({ senderSigner, imkcSigner, privateChannelSigner, privateChannelReaderPubkey, receivers, receiverTag: '', deletionPubkey: deletion.deletionPubkey, event: wireEvent, relays, relayToReceivers, recoveryRelays, expirationSeconds, temporaryStorageArea, _getIykcProofs, _publish })
+  return withDelivery({ rumor: event }, reports, deletion.deletionSeckey)
 }
 
 export async function broadcastEvent ({
@@ -621,16 +641,18 @@ export async function broadcastEvent ({
   event,
   expirationSeconds,
   temporaryStorageArea,
-  deletionPubkey,
   _getIykcProofs,
+  deletionPubkey,
+  deletionSeckey,
+  autoDeletionCapability = true,
   _publish = privateChannel.publish
 }) {
   const receivers = uniq(receiverPubkeys)
   if (!receivers.length) throw new Error('NO_RECEIVERS')
   const wireEvent = assertValidSignedEvent({ ...event, tags: cloneTags(event?.tags) })
-  const deletionCapability = resolveDeletionCapability(deletionPubkey)
-  const results = await sendPrivateMessage({ senderSigner, imkcSigner, privateChannelSigner, privateChannelReaderPubkey, receivers, receiverTag: '', deletionPubkey: deletionCapability.deletionPubkey, event: wireEvent, relays, relayToReceivers, recoveryRelays, expirationSeconds, temporaryStorageArea, _getIykcProofs, _publish })
-  return withDeletionCapability({ event: wireEvent, results }, deletionCapability)
+  const deletion = resolveDeletionCapability({ deletionPubkey, deletionSeckey, autoDeletionCapability })
+  const reports = await sendPrivateMessage({ senderSigner, imkcSigner, privateChannelSigner, privateChannelReaderPubkey, receivers, receiverTag: '', deletionPubkey: deletion.deletionPubkey, event: wireEvent, relays, relayToReceivers, recoveryRelays, expirationSeconds, temporaryStorageArea, _getIykcProofs, _publish })
+  return withDelivery({ event: wireEvent }, reports, deletion.deletionSeckey)
 }
 
 export async function broadcastNymRumor ({
@@ -643,13 +665,15 @@ export async function broadcastNymRumor ({
   rumor,
   expirationSeconds,
   deletionPubkey,
+  deletionSeckey,
+  autoDeletionCapability = true,
   _publish = privateChannel.publishNymEvent
 }) {
   if (!nymSigner?.getPublicKey) throw new Error('NYM_SIGNER_REQUIRED')
   const { event, wireEvent } = await makeOutgoingRumor({ senderSigner: nymSigner, rumor })
-  const deletionCapability = resolveDeletionCapability(deletionPubkey)
-  const results = await sendNymMessage({ nymSigner, privateChannelSigner, privateChannelReaderPubkey, deletionPubkey: deletionCapability.deletionPubkey, event: wireEvent, relays, relayToReceivers, recoveryRelays, expirationSeconds, _publish })
-  return withDeletionCapability({ rumor: event, results }, deletionCapability)
+  const deletion = resolveDeletionCapability({ deletionPubkey, deletionSeckey, autoDeletionCapability })
+  const reports = await sendNymMessage({ nymSigner, privateChannelSigner, privateChannelReaderPubkey, deletionPubkey: deletion.deletionPubkey, event: wireEvent, relays, relayToReceivers, recoveryRelays, expirationSeconds, _publish })
+  return withDelivery({ rumor: event }, reports, deletion.deletionSeckey)
 }
 
 export async function broadcastNymEvent ({
@@ -662,11 +686,13 @@ export async function broadcastNymEvent ({
   event,
   expirationSeconds,
   deletionPubkey,
+  deletionSeckey,
+  autoDeletionCapability = true,
   _publish = privateChannel.publishNymEvent
 }) {
   if (!nymSigner?.getPublicKey) throw new Error('NYM_SIGNER_REQUIRED')
   const wireEvent = assertValidSignedEvent({ ...event, tags: cloneTags(event?.tags) })
-  const deletionCapability = resolveDeletionCapability(deletionPubkey)
-  const results = await sendNymMessage({ nymSigner, privateChannelSigner, privateChannelReaderPubkey, deletionPubkey: deletionCapability.deletionPubkey, event: wireEvent, relays, relayToReceivers, recoveryRelays, expirationSeconds, _publish })
-  return withDeletionCapability({ event: wireEvent, results }, deletionCapability)
+  const deletion = resolveDeletionCapability({ deletionPubkey, deletionSeckey, autoDeletionCapability })
+  const reports = await sendNymMessage({ nymSigner, privateChannelSigner, privateChannelReaderPubkey, deletionPubkey: deletion.deletionPubkey, event: wireEvent, relays, relayToReceivers, recoveryRelays, expirationSeconds, _publish })
+  return withDelivery({ event: wireEvent }, reports, deletion.deletionSeckey)
 }

package/private-messenger/index.js

@@ -112,6 +112,11 @@ function uniq (values) {
   return [...new Set((values || []).filter(Boolean))]
 }
 
+function normalizeAutoDeletionCapability (value) {
+  if (typeof value !== 'boolean') throw new Error('AUTO_DELETION_CAPABILITY_BOOLEAN_REQUIRED')
+  return value
+}
+
 function isPlainObject (value) {
   return value && typeof value === 'object' && !Array.isArray(value)
 }
@@ -140,6 +145,7 @@ export class PrivateMessenger {
     messageQueueMaxBytes = DEFAULT_MESSAGE_QUEUE_MAX_BYTES,
     seedQueueMaxBytes = DEFAULT_SEED_QUEUE_MAX_BYTES,
     temporaryStorageArea = globalThis.sessionStorage,
+    autoDeletionCapability = true,
     _indexedDB = globalThis.indexedDB,
     useContentKeys = true,
     onContentKeyChange,
@@ -165,6 +171,7 @@ export class PrivateMessenger {
     this.messageQueueMaxBytes = messageQueueMaxBytes
     this.seedQueueMaxBytes = seedQueueMaxBytes
     this.temporaryStorageArea = temporaryStorageArea
+    this.autoDeletionCapability = normalizeAutoDeletionCapability(autoDeletionCapability)
     this._indexedDB = _indexedDB
     this.useContentKeys = useContentKeys
     this.onContentKeyChange = onContentKeyChange
@@ -304,6 +311,9 @@ export class PrivateMessenger {
       const mode = channel.mode || defaults.mode || 'leecher'
       if (!signer && storesRecoverySeeds(mode)) throw new Error('PRIVATE_CHANNEL_WRITER_REQUIRED')
       const readerPubkey = channel.readerPubkey || channel.privateChannelReaderPubkey || await readerSigner?.getPublicKey?.() || pubkey
+      const autoDeletionCapability = channel.autoDeletionCapability === undefined
+        ? undefined
+        : normalizeAutoDeletionCapability(channel.autoDeletionCapability)
       out.push({
         pubkey,
         signer,
@@ -314,7 +324,8 @@ export class PrivateMessenger {
         sendRelays: uniq(hasChannelSendRelays ? channel.sendRelays : []),
         usesNip65WatchRelays: !hasChannelRelays && !hasDefaultRelays,
         mode,
-        seeders: uniq(channel.seeders)
+        seeders: uniq(channel.seeders),
+        autoDeletionCapability
       })
     }
     return out
@@ -807,12 +818,13 @@ export class PrivateMessenger {
       ...routing,
       expirationSeconds: this.offlineRecoverySeconds,
       temporaryStorageArea: this.temporaryStorageArea,
+      deletionPubkey,
+      autoDeletionCapability: this.autoDeletionCapabilityFor(channel),
       message,
       code,
       payload,
       error,
       content,
-      deletionPubkey,
       _getIykcProofs: this.contentKeyLookup()
     })
   }
@@ -832,12 +844,13 @@ export class PrivateMessenger {
       ...routing,
       expirationSeconds: this.offlineRecoverySeconds,
       temporaryStorageArea: this.temporaryStorageArea,
+      deletionPubkey,
+      autoDeletionCapability: this.autoDeletionCapabilityFor(channel),
       message,
       code,
       payload,
       error,
       content,
-      deletionPubkey,
       _getIykcProofs: this.contentKeyLookup()
     })
   }
@@ -855,12 +868,13 @@ export class PrivateMessenger {
       ...routing,
       expirationSeconds: this.offlineRecoverySeconds,
       temporaryStorageArea: this.temporaryStorageArea,
+      deletionPubkey,
+      autoDeletionCapability: this.autoDeletionCapabilityFor(channel),
       message,
       code,
       payload,
       error,
       content,
-      deletionPubkey,
       _getIykcProofs: this.contentKeyLookup()
     })
   }
@@ -878,12 +892,13 @@ export class PrivateMessenger {
       ...routing,
       expirationSeconds: this.offlineRecoverySeconds,
       temporaryStorageArea: this.temporaryStorageArea,
+      deletionPubkey,
+      autoDeletionCapability: this.autoDeletionCapabilityFor(channel),
       message,
       code,
       payload,
       error,
       content,
-      deletionPubkey,
       _getIykcProofs: this.contentKeyLookup()
     })
   }
@@ -901,8 +916,9 @@ export class PrivateMessenger {
       ...routing,
       expirationSeconds: this.offlineRecoverySeconds,
       temporaryStorageArea: this.temporaryStorageArea,
-      rumor,
       deletionPubkey,
+      autoDeletionCapability: this.autoDeletionCapabilityFor(channel),
+      rumor,
       _getIykcProofs: this.contentKeyLookup()
     })
   }
@@ -920,8 +936,9 @@ export class PrivateMessenger {
       ...routing,
       expirationSeconds: this.offlineRecoverySeconds,
       temporaryStorageArea: this.temporaryStorageArea,
-      event,
       deletionPubkey,
+      autoDeletionCapability: this.autoDeletionCapabilityFor(channel),
+      event,
       _getIykcProofs: this.contentKeyLookup()
     })
   }
@@ -937,8 +954,9 @@ export class PrivateMessenger {
       privateChannelReaderPubkey: channel.readerPubkey,
       ...routing,
       expirationSeconds: this.offlineRecoverySeconds,
-      rumor,
-      deletionPubkey
+      deletionPubkey,
+      autoDeletionCapability: this.autoDeletionCapabilityFor(channel),
+      rumor
     })
   }
 
@@ -953,8 +971,9 @@ export class PrivateMessenger {
       privateChannelReaderPubkey: channel.readerPubkey,
       ...routing,
       expirationSeconds: this.offlineRecoverySeconds,
-      event,
-      deletionPubkey
+      deletionPubkey,
+      autoDeletionCapability: this.autoDeletionCapabilityFor(channel),
+      event
     })
   }
 
@@ -972,6 +991,7 @@ export class PrivateMessenger {
       ...routing,
       expirationSeconds: this.offlineRecoverySeconds,
       temporaryStorageArea: this.temporaryStorageArea,
+      autoDeletionCapability: this.autoDeletionCapabilityFor(channel),
       code: SEEDER_PRESENCE_CODE,
       payload: {},
       _getIykcProofs: this.contentKeyLookup()
@@ -1036,6 +1056,10 @@ export class PrivateMessenger {
     return channel
   }
 
+  autoDeletionCapabilityFor (channel) {
+    return channel.autoDeletionCapability ?? this.autoDeletionCapability
+  }
+
   requireNymSigner (channel, override) {
     const signer = override || channel?.nymSigner || this.nymSigner
     if (!signer?.getPublicKey) throw new Error('NYM_SIGNER_REQUIRED')

package/relay/helpers/publish.js

@@ -79,7 +79,7 @@ export function createPublishSettlements (promises, timeout, { onSettled } = {})
 
 // Turns ordered relay settlements into a stable, caller-facing report. Failed
 // relays retain their Error while optional successful URLs make acknowledgements visible.
-export function publishSummary (settlements, relays, { result, includeSucceededRelays = false } = {}) {
+export function publishSummary (settlements, relays, { includeSucceededRelays = false } = {}) {
   const succeededRelays = []
   const errors = []
 
@@ -94,7 +94,6 @@ export function publishSummary (settlements, relays, { result, includeSucceededR
     fulfilled: succeededRelays.length,
     errors
   }
-  if (result !== undefined) summary.result = result
   if (includeSucceededRelays) summary.succeededRelays = succeededRelays
   return summary
 }

package/relay/services/relay-pool.js

@@ -842,10 +842,9 @@ export class RelayPool {
     const urls = normalizedRelayUrls(relays)
     if (!urls.length) {
       const promise = Promise.resolve(publishSummary([], urls, {
-        result: null,
         includeSucceededRelays: true
       }))
-      return { result: null, total: 0, success: false, promise }
+      return { total: 0, success: false, promise }
     }
 
     const eventToSend = event.meta ? { ...event } : event
@@ -862,11 +861,10 @@ export class RelayPool {
     })
 
     // Resolves after every relay settles (or reaches the operation timeout) as
-    // { result: null, success, total, fulfilled, succeededRelays, errors },
+    // { success, total, fulfilled, succeededRelays, errors },
     // where errors contains { relay, reason } entries for failed relays.
     const promise = settlement.promise
       .then(settlements => publishSummary(settlements, urls, {
-        result: null,
         includeSucceededRelays: true
       }))
 
@@ -895,7 +893,6 @@ export class RelayPool {
     if (!success) settlement.timeout()
 
     return {
-      result: null,
       total: urls.length,
       success,
       promise

package/tests/private-channel.test.js

@@ -445,7 +445,7 @@ test('wrapEvent creates private broadcast events under relay event size limit',
   assert.equal(globalThis.sessionStorage.getItem(TEMPORARY_STORAGE_KEYS_KEY), null)
 })
 
-test('private broadcast wrappers add a normalized deletion pubkey when supplied', async () => {
+test('private broadcast wrappers share and normalize one deletion pubkey per logical message', async () => {
   const alice = signer()
   const bob = signer()
   const bobPubkey = await bob.getPublicKey()
@@ -477,6 +477,7 @@ test('private broadcast wrappers add a normalized deletion pubkey when supplied'
       /INVALID_DELETION_PUBKEY/
     )
   }
+
 })
 
 test('publish splits relay-targeted routers by receiver subset with separate router pubkeys', async () => {
@@ -500,7 +501,7 @@ test('publish splits relay-targeted routers by receiver subset with separate rou
     }
   }
 
-  await publish({
+  const reports = await publish({
     senderSigner: alice,
     receivers: [bobPubkey, carolPubkey, davePubkey],
     relayToReceivers: new Map([
@@ -524,6 +525,7 @@ test('publish splits relay-targeted routers by receiver subset with separate rou
     ['s', 'd'.repeat(64)],
     ['s', 'd'.repeat(64)]
   ])
+  assert.deepEqual(reports, [{ success: true }, { success: true }])
   assert.deepEqual(published[0].relays, ['wss://one.example', 'wss://two.example', 'wss://seed.example'])
   assert.deepEqual(published[1].relays, ['wss://three.example', 'wss://seed.example', 'wss://one.example'])
 
@@ -626,7 +628,7 @@ test('publishNymEvent mirrors carrier chunks to recovery relays', async () => {
   const nym = signer()
   const published = []
 
-  await publishNymEvent({
+  const reports = await publishNymEvent({
     nymSigner: nym,
     privateChannelSigner: channel,
     event: eventFixture('nym mirror'),
@@ -642,6 +644,7 @@ test('publishNymEvent mirrors carrier chunks to recovery relays', async () => {
   assert.equal(published.length, 1)
   assert.deepEqual(published[0].relays, ['wss://receiver.example', 'wss://seed.example'])
   assert.deepEqual(published[0].outer.tags.find(tag => tag[0] === 's'), ['s', 'e'.repeat(64)])
+  assert.deepEqual(reports, [{ success: true }])
   assert.equal(globalThis.sessionStorage.getItem(TEMPORARY_STORAGE_KEYS_KEY), null)
 })
 
@@ -955,6 +958,7 @@ test('subscribe buffers out-of-order nym carrier chunks by nym pubkey and inner
     const wrapped = await wrapNymEvent({
       nymSigner: nym,
       privateChannelSigner: channel,
+      deletionPubkey: 'e'.repeat(64),
       event: original
     })
     const routedEvents = []
@@ -963,6 +967,7 @@ test('subscribe buffers out-of-order nym carrier chunks by nym pubkey and inner
 
     assert.ok(wrapped.length > 1)
     for (const event of wrapped) assert.ok(new TextEncoder().encode(JSON.stringify(event)).length <= MAX_EVENT_BYTES)
+    assert.deepEqual(new Set(wrapped.map(event => event.tags.find(tag => tag[0] === 's')?.[1])), new Set(['e'.repeat(64)]))
 
     subscribe({
       privateChannelSigner: channel,
@@ -1563,14 +1568,22 @@ test('wrapEvent chunks large jsonl without oversize events and unwraps reassembl
   const imkcPubkey = await imkc.getPublicKey()
   const original = eventFixture('x'.repeat(getJsonlChunkByteSize()))
   NsecSigner.setContentSigners(alice, [imkc])
-  const deletionPubkey = 'd'.repeat(64)
-  const wrapped = await wrapEvent({ senderSigner: alice, imkcSigner: imkc, receivers: [bobPubkey], deletionPubkey, event: original, _getIykcProofs: noContentKeys })
+  const wrapped = await wrapEvent({
+    senderSigner: alice,
+    imkcSigner: imkc,
+    receivers: [bobPubkey],
+    deletionPubkey: 'd'.repeat(64),
+    event: original,
+    _getIykcProofs: noContentKeys
+  })
 
   assert.ok(wrapped.length > 1)
+  const deletionPubkeys = new Set()
   for (const event of wrapped) {
     assert.ok(new TextEncoder().encode(JSON.stringify(event)).length <= MAX_EVENT_BYTES)
-    assert.deepEqual(event.tags.find(tag => tag[0] === 's'), ['s', deletionPubkey])
+    deletionPubkeys.add(event.tags.find(tag => tag[0] === 's')?.[1])
   }
+  assert.deepEqual(deletionPubkeys, new Set(['d'.repeat(64)]))
 
   const routers = []
   for (const event of wrapped) {

package/tests/private-message.test.js

@@ -146,7 +146,7 @@ test('ask requires watching the sender private channel first', async () => {
       receiverPubkey: 'receiver',
       relays: ['wss://relay.example'],
       message: { code: 'PING' },
-      _publish: async () => ({ results: [] })
+      _publish: async () => []
     }),
     /PRIVATE_MESSAGE_NOT_WATCHING/
   )
@@ -170,7 +170,7 @@ test('ask from a reader-only channel requires a writer signer', async () => {
       receiverPubkey: 'receiver',
       relays: ['wss://relay.example'],
       message: { code: 'PING' },
-      _publish: async () => ({ results: [] })
+      _publish: async () => []
     }),
     /PRIVATE_CHANNEL_WRITER_REQUIRED/
   )
@@ -220,7 +220,7 @@ test('ask publishes an ask rumor and watch dispatches the reply with its questio
     message: { code: 'PING', payload: { ok: true } },
     _publish: async options => {
       published = options
-      return { results: [{ success: true }] }
+      return [{ success: true }]
     }
   })
 
@@ -236,6 +236,8 @@ test('ask publishes an ask rumor and watch dispatches the reply with its questio
   assert.deepEqual(published.event.tags, [['r', 'receiver'], ['h', 'PING']])
   assert.equal(result.question.pubkey, senderPubkey)
   assert.equal(result.question.id, getEventHash({ ...published.event, pubkey: senderPubkey }))
+  assert.deepEqual(result.delivery.reports, [{ success: true }])
+  assert.equal(keypairFromSeckey(result.delivery.deletionSeckey).pubkey, published.deletionPubkey)
   assert.throws(() => getEventHash(published.event), /wrong or missing properties/)
 
   calls[0].onEvent({
@@ -259,7 +261,7 @@ test('reply tell and yell publish recognizable private message rumors', async ()
   const bobPubkey = pubkeyFixture(3)
   const _publish = async options => {
     published.push(options)
-    return { results: [] }
+    return []
   }
   const question = {
     id: 'question-id',
@@ -321,37 +323,49 @@ test('reply tell and yell publish recognizable private message rumors', async ()
   assert.deepEqual(signedResult.event, signedEvent)
 })
 
-test('private message sends return generated deletion keys and forward supplied pubkeys', async () => {
+test('private message sends share one deletion capability and return delivery reports', async () => {
   const published = []
+  const reports = [{ success: true, total: 1 }, { success: false, total: 1 }]
   const _publish = async options => {
     published.push(options)
-    return { results: [] }
+    return reports
   }
-  const suppliedPubkey = pubkeyFixture(99).toUpperCase()
 
-  const supplied = await tell({
+  const generated = await tell({
     senderSigner: signer(pubkeyFixture(3)),
     receiverPubkey: 'alice',
     relays: ['wss://relay.example'],
-    payload: 'supplied',
-    deletionPubkey: suppliedPubkey,
+    payload: 'managed',
     _publish
   })
-  const generated = await broadcastNymRumor({
-    nymSigner: signer(pubkeyFixture(4)),
-    privateChannelSigner: signer(pubkeyFixture(5)),
+
+  assert.deepEqual(generated.delivery.reports, reports)
+  assert.equal(keypairFromSeckey(generated.delivery.deletionSeckey).pubkey, published[0].deletionPubkey)
+  assert.equal('results' in generated, false)
+  assert.equal('deletionPubkey' in generated, false)
+  assert.equal('deletionSeckey' in generated, false)
+
+  const supplied = await tell({
+    senderSigner: signer(pubkeyFixture(3)),
+    receiverPubkey: 'alice',
     relays: ['wss://relay.example'],
-    rumor: { kind: 9001, created_at: 1, tags: [], content: 'generated' },
+    payload: 'caller-managed',
+    deletionPubkey: 'A'.repeat(64),
     _publish
   })
+  assert.equal(published[1].deletionPubkey, 'a'.repeat(64))
+  assert.deepEqual(supplied.delivery, { reports })
 
-  assert.equal(supplied.deletionPubkey, suppliedPubkey.toLowerCase())
-  assert.equal('deletionSeckey' in supplied, false)
-  assert.equal(published[0].deletionPubkey, suppliedPubkey.toLowerCase())
-  assert.match(generated.deletionPubkey, /^[0-9a-f]{64}$/)
-  assert.match(generated.deletionSeckey, /^[0-9a-f]{64}$/)
-  assert.equal(keypairFromSeckey(generated.deletionSeckey).pubkey, generated.deletionPubkey)
-  assert.equal(published[1].deletionPubkey, generated.deletionPubkey)
+  const untagged = await tell({
+    senderSigner: signer(pubkeyFixture(3)),
+    receiverPubkey: 'alice',
+    relays: ['wss://relay.example'],
+    payload: 'unlinkable',
+    autoDeletionCapability: false,
+    _publish
+  })
+  assert.equal(published[2].deletionPubkey, undefined)
+  assert.deepEqual(untagged.delivery, { reports })
 
   await assert.rejects(
     () => tell({
@@ -364,6 +378,28 @@ test('private message sends return generated deletion keys and forward supplied
     }),
     /INVALID_DELETION_PUBKEY/
   )
+  await assert.rejects(
+    () => tell({
+      senderSigner: signer(pubkeyFixture(3)),
+      receiverPubkey: 'alice',
+      relays: ['wss://relay.example'],
+      payload: 'bad secret',
+      deletionSeckey: 'b'.repeat(64),
+      _publish
+    }),
+    /DELETION_SECKEY_NOT_ACCEPTED/
+  )
+  await assert.rejects(
+    () => tell({
+      senderSigner: signer(pubkeyFixture(3)),
+      receiverPubkey: 'alice',
+      relays: ['wss://relay.example'],
+      payload: 'bad policy',
+      autoDeletionCapability: 'yes',
+      _publish
+    }),
+    /AUTO_DELETION_CAPABILITY_BOOLEAN_REQUIRED/
+  )
 })
 
 test('broadcastRumor validates normalized unsigned rumors before publishing', async () => {
@@ -416,9 +452,10 @@ test('nym broadcasts publish through the nym channel path without receivers', as
   const nymPubkey = pubkeyFixture(6)
   const channelPubkey = pubkeyFixture(7)
   const authorEvent = finalizeEvent({ kind: 9002, created_at: 30, tags: [], content: 'signed by another key' }, generateSecretKey())
+  const reports = [{ success: true, total: 1 }]
   const _publish = async options => {
     published.push(options)
-    return { results: [] }
+    return reports
   }
 
   const rumorResult = await broadcastNymRumor({
@@ -443,9 +480,13 @@ test('nym broadcasts publish through the nym channel path without receivers', as
   assert.equal(published[0].event.id, undefined)
   assert.equal(rumorResult.rumor.pubkey, nymPubkey)
   assert.equal(rumorResult.rumor.id, getEventHash({ ...published[0].event, pubkey: nymPubkey }))
+  assert.deepEqual(rumorResult.delivery.reports, reports)
+  assert.equal(keypairFromSeckey(rumorResult.delivery.deletionSeckey).pubkey, published[0].deletionPubkey)
   assert.deepEqual(published[1].event, authorEvent)
   assert.notEqual(published[1].event.pubkey, nymPubkey)
   assert.deepEqual(eventResult.event, authorEvent)
+  assert.deepEqual(eventResult.delivery.reports, reports)
+  assert.equal(keypairFromSeckey(eventResult.delivery.deletionSeckey).pubkey, published[1].deletionPubkey)
 })
 
 test('parseRumorContent only reads h tags for private message kinds', () => {

package/tests/private-messenger.test.js

@@ -76,35 +76,35 @@ function fakePrivateMessage () {
     },
     ask: async options => {
       sent.push({ method: 'ask', options })
-      return { question: { id: 'question-id', kind: ASK_KIND, pubkey: 'user' }, results: [] }
+      return { question: { id: 'question-id', kind: ASK_KIND, pubkey: 'user' }, delivery: { reports: [] } }
     },
     reply: async options => {
       sent.push({ method: 'reply', options })
-      return { reply: { id: 'reply-id', kind: REPLY_KIND }, results: [] }
+      return { reply: { id: 'reply-id', kind: REPLY_KIND }, delivery: { reports: [] } }
     },
     tell: async options => {
       sent.push({ method: 'tell', options })
-      return { tell: { id: 'tell-id', kind: TELL_KIND }, results: [] }
+      return { tell: { id: 'tell-id', kind: TELL_KIND }, delivery: { reports: [] } }
     },
     yell: async options => {
       sent.push({ method: 'yell', options })
-      return { yell: { id: 'yell-id', kind: TELL_KIND }, results: [] }
+      return { yell: { id: 'yell-id', kind: TELL_KIND }, delivery: { reports: [] } }
     },
     broadcastRumor: async options => {
       sent.push({ method: 'broadcastRumor', options })
-      return { rumor: { id: 'raw-id', kind: 9001 }, results: [] }
+      return { rumor: { id: 'raw-id', kind: 9001 }, delivery: { reports: [] } }
     },
     broadcastEvent: async options => {
       sent.push({ method: 'broadcastEvent', options })
-      return { event: options.event, results: [] }
+      return { event: options.event, delivery: { reports: [] } }
     },
     broadcastNymRumor: async options => {
       sent.push({ method: 'broadcastNymRumor', options })
-      return { rumor: { id: 'nym-raw-id', kind: 9003, pubkey: options.nymSigner.getPublicKey() }, results: [] }
+      return { rumor: { id: 'nym-raw-id', kind: 9003, pubkey: options.nymSigner.getPublicKey() }, delivery: { reports: [] } }
     },
     broadcastNymEvent: async options => {
       sent.push({ method: 'broadcastNymEvent', options })
-      return { event: options.event, results: [] }
+      return { event: options.event, delivery: { reports: [] } }
     },
     unwatch: channels => stopped.push(channels),
     clearChannelState: channel => cleared.push(channel)
@@ -516,35 +516,55 @@ test('private messenger delegates send helpers with scoped signers and relays',
     assert.deepEqual(sent.options.relays, ['wss://relay.example'])
     assert.equal(sent.options.expirationSeconds, 7 * 24 * 60 * 60)
     assert.equal(sent.options.temporaryStorageArea, globalThis.localStorage)
+    assert.equal(sent.options.autoDeletionCapability, true)
   }
   assert.equal(pm.sent[5].options.event.id, 'signed-id')
   assert.equal(pm.sent[6].options.nymSigner.getPublicKey(), 'global-nym')
   assert.equal(pm.sent[6].options.privateChannelSigner.getPublicKey(), 'channel')
   assert.deepEqual(pm.sent[6].options.relays, ['wss://relay.example'])
   assert.equal(pm.sent[6].options.expirationSeconds, 7 * 24 * 60 * 60)
+  assert.equal(pm.sent[6].options.autoDeletionCapability, true)
   assert.equal(pm.sent[7].options.nymSigner.getPublicKey(), 'global-nym')
   assert.equal(pm.sent[7].options.event.pubkey, 'author')
+  assert.equal(pm.sent[7].options.autoDeletionCapability, true)
 })
 
-test('private messenger forwards supplied deletion pubkeys to regular and nym sends', async () => {
+test('private messenger configures automatic deletion capabilities and forwards caller pubkeys', async () => {
   const pm = fakePrivateMessage()
-  const messenger = await new PrivateMessenger({ _privateMessage: pm }).init({
+  const messenger = await new PrivateMessenger({ _privateMessage: pm, autoDeletionCapability: true }).init({
     userSigner: signer('user'),
-    channels: [{ pubkey: 'channel', signer: signer('channel'), relays: ['wss://relay.example'] }]
+    channels: [
+      { pubkey: 'inherited', signer: signer('inherited'), relays: ['wss://relay.example'] },
+      { pubkey: 'disabled', signer: signer('disabled'), relays: ['wss://relay.example'], autoDeletionCapability: false }
+    ]
   })
-  const regularDeletionPubkey = 'a'.repeat(64)
-  const nymDeletionPubkey = 'b'.repeat(64)
 
-  await messenger.tell({ receiverPubkey: 'alice', payload: 'note', deletionPubkey: regularDeletionPubkey })
-  await messenger.broadcastNymRumor({
-    receiverPubkeys: ['alice'],
-    nymSigner: signer('nym'),
-    rumor: { kind: 9001, created_at: 1, tags: [], content: 'nym' },
-    deletionPubkey: nymDeletionPubkey
+  await messenger.tell({ channelPubkey: 'inherited', receiverPubkey: 'alice', payload: 'default' })
+  await messenger.tell({ channelPubkey: 'disabled', receiverPubkey: 'alice', payload: 'disabled' })
+  await messenger.tell({ channelPubkey: 'disabled', receiverPubkey: 'alice', payload: 'caller-managed', deletionPubkey: 'a'.repeat(64) })
+
+  assert.equal(pm.sent[0].options.autoDeletionCapability, true)
+  assert.equal(pm.sent[1].options.autoDeletionCapability, false)
+  assert.equal(pm.sent[2].options.autoDeletionCapability, false)
+  assert.equal(pm.sent[2].options.deletionPubkey, 'a'.repeat(64))
+
+  const enabledPm = fakePrivateMessage()
+  const enabledMessenger = await new PrivateMessenger({ _privateMessage: enabledPm, autoDeletionCapability: false }).init({
+    userSigner: signer('other-user'),
+    channels: [{ pubkey: 'enabled', signer: signer('enabled'), relays: ['wss://relay.example'], autoDeletionCapability: true }]
   })
+  await enabledMessenger.tell({ receiverPubkey: 'alice', payload: 'enabled' })
+  assert.equal(enabledPm.sent[0].options.autoDeletionCapability, true)
 
-  assert.equal(pm.sent[0].options.deletionPubkey, regularDeletionPubkey)
-  assert.equal(pm.sent[1].options.deletionPubkey, nymDeletionPubkey)
+  await messenger.tell({
+    channelPubkey: 'inherited',
+    receiverPubkey: 'alice',
+    payload: 'ignored fields',
+    deletionSeckey: 'b'.repeat(64),
+    autoDeletionCapability: false
+  })
+  assert.equal(pm.sent[3].options.deletionPubkey, undefined)
+  assert.equal(pm.sent[3].options.autoDeletionCapability, true)
 })
 
 test('private messenger update accepts only same-user replacement signers', async () => {
@@ -1105,18 +1125,20 @@ test('seeder channels publish presence immediately and on interval', async () =>
     _clearInterval: timer => cleared.push(timer)
   }).init({
     userSigner: signer('user'),
-    channels: [{ pubkey: 'channel', signer: signer('channel'), relays: ['wss://relay.example'], mode: 'seeder', seeders: ['alice'] }]
+    channels: [{ pubkey: 'channel', signer: signer('channel'), relays: ['wss://relay.example'], mode: 'seeder', seeders: ['alice'], autoDeletionCapability: false }]
   })
 
   assert.equal(pm.sent[0].method, 'yell')
   assert.equal(pm.sent[0].options.code, SEEDER_PRESENCE_CODE)
   assert.deepEqual(pm.sent[0].options.receiverPubkeys, ['alice', 'user'])
+  assert.equal(pm.sent[0].options.autoDeletionCapability, false)
   assert.equal(intervals[0].ms, 10 * 60 * 1000)
 
   await intervals[0].fn()
 
   assert.equal(pm.sent[1].method, 'yell')
   assert.equal(pm.sent[1].options.code, SEEDER_PRESENCE_CODE)
+  assert.equal(pm.sent[1].options.autoDeletionCapability, false)
 
   messenger.close()
   assert.deepEqual(cleared, intervals)

package/tests/relay-pool.test.js

@@ -1661,7 +1661,6 @@ describe('RelayPool.sendEvent', () => {
       onRelayResult: result => relayResults.push(result)
     })
 
-    assert.equal(early.result, null)
     assert.equal(early.total, 2)
     assert.equal(early.success, true)
     assert.deepEqual(relayResults, [{
@@ -1672,7 +1671,6 @@ describe('RelayPool.sendEvent', () => {
 
     delayed.reject(new Error('relay failed'))
     const full = await early.promise
-    assert.equal(full.result, null)
     assert.equal(full.success, true)
     assert.equal(full.total, 2)
     assert.equal(full.fulfilled, 1)
@@ -2050,7 +2048,6 @@ describe('RelayPool.sendEvent', () => {
     const early = await nostr.sendEvent({ id: 'ev1' }, [])
     const full = await early.promise
     assert.deepEqual(early, {
-      result: null,
       total: 0,
       success: false,
       promise: early.promise
@@ -2060,7 +2057,6 @@ describe('RelayPool.sendEvent', () => {
       total: 0,
       fulfilled: 0,
       errors: [],
-      result: null,
       succeededRelays: []
     })
   })