libp2r2p 0.0.1 → 0.1.0

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/base93/index.js

@@ -0,0 +1,193 @@
+// Derived from https://github.com/ticlo/arrow-code/blob/master/src/base93.ts
+// Apache-2.0. JSON-safe alphabet: space is included; double quote and
+// backslash are intentionally excluded.
+
+export const BASE93_ALPHABET =
+  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!#$%&'()*+,-./:;<=>?@[]^_`{|}~ "
+
+const ENCODING_TABLE = (() => {
+  const out = new Uint16Array(93)
+  for (let i = 0; i < out.length; i++) out[i] = BASE93_ALPHABET.charCodeAt(i)
+  return out
+})()
+
+const DECODING_TABLE = (() => {
+  const out = new Int16Array(128)
+  out.fill(-1)
+  for (let i = 0; i < BASE93_ALPHABET.length; i++) out[BASE93_ALPHABET.charCodeAt(i)] = i
+  return out
+})()
+
+function codesToString (codes, length) {
+  const chunkLength = 16384
+  let result = ''
+  for (let i = 0; i < length; i += chunkLength) {
+    result += String.fromCharCode.apply(
+      null,
+      Array.prototype.slice.call(codes, i, Math.min(i + chunkLength, length))
+    )
+  }
+  return result
+}
+
+function asBytes (bytes) {
+  if (bytes instanceof Uint8Array) return bytes
+  if (ArrayBuffer.isView(bytes)) return new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength)
+  if (bytes instanceof ArrayBuffer) return new Uint8Array(bytes)
+  return Uint8Array.from(bytes)
+}
+
+export class Base93Encoder {
+  constructor (prefix = '') {
+    this.queuedBits = 0
+    this.bitCount = 0
+    this.parts = prefix ? [String(prefix)] : []
+    this.finished = false
+  }
+
+  update (bytes) {
+    if (this.finished) throw new Error('Base93 encoder is already finalized.')
+    const source = asBytes(bytes)
+    const output = new Uint16Array(Math.ceil(source.length * 8 / 6.5) + 4)
+    let position = 0
+    let queuedBits = this.queuedBits
+    let bitCount = this.bitCount
+
+    for (let i = 0; i < source.length; i++) {
+      queuedBits |= source[i] << bitCount
+      bitCount += 8
+      if (bitCount > 13) {
+        let value = queuedBits & 0x1fff
+        if (value > 456) {
+          queuedBits >>>= 13
+          bitCount -= 13
+        } else {
+          value = queuedBits & 0x3fff
+          queuedBits >>>= 14
+          bitCount -= 14
+        }
+        output[position++] = ENCODING_TABLE[value % 93]
+        output[position++] = ENCODING_TABLE[Math.floor(value / 93)]
+      }
+    }
+
+    this.queuedBits = queuedBits
+    this.bitCount = bitCount
+    if (position > 0) this.parts.push(codesToString(output, position))
+    return this
+  }
+
+  getEncoded () {
+    if (!this.finished) {
+      if (this.bitCount > 0) {
+        const output = new Uint16Array(2)
+        let position = 0
+        output[position++] = ENCODING_TABLE[this.queuedBits % 93]
+        if (this.bitCount > 7 || this.queuedBits > 92) {
+          output[position++] = ENCODING_TABLE[Math.floor(this.queuedBits / 93)]
+        }
+        this.parts.push(codesToString(output, position))
+      }
+      this.finished = true
+      this.queuedBits = 0
+      this.bitCount = 0
+    }
+    return this.parts.join('')
+  }
+}
+
+export function encode (bytes) {
+  return new Base93Encoder().update(bytes).getEncoded()
+}
+
+function decodeUnchecked (value) {
+  const output = new Uint8Array(Math.ceil(value.length * 7 / 8))
+  let queuedBits = 0
+  let bitCount = 0
+  let first = -1
+  let position = 0
+
+  for (let i = 0; i < value.length; i++) {
+    const code = value.charCodeAt(i)
+    if (code >= DECODING_TABLE.length || DECODING_TABLE[code] < 0) {
+      throw new Error(`Invalid Base93 character at offset ${i}.`)
+    }
+    const decoded = DECODING_TABLE[code]
+    if (first === -1) {
+      first = decoded
+      continue
+    }
+
+    const pair = first + decoded * 93
+    first = -1
+    queuedBits |= pair << bitCount
+    bitCount += (pair & 0x1fff) > 456 ? 13 : 14
+    while (bitCount > 7) {
+      output[position++] = queuedBits & 0xff
+      queuedBits >>>= 8
+      bitCount -= 8
+    }
+  }
+
+  if (first !== -1) output[position++] = (queuedBits | (first << bitCount)) & 0xff
+  return output.slice(0, position)
+}
+
+export function decode (text, offset = 0, length = -1) {
+  if (typeof text !== 'string') throw new TypeError('Base93 input must be a string.')
+  if (!Number.isSafeInteger(offset) || offset < 0 || offset > text.length) throw new RangeError('Invalid Base93 offset.')
+  if (!Number.isSafeInteger(length) || length < -1) throw new RangeError('Invalid Base93 length.')
+
+  const end = length < 0 ? text.length : Math.min(text.length, offset + length)
+  const encoded = text.slice(offset, end)
+  const bytes = decodeUnchecked(encoded)
+  if (encode(bytes) !== encoded) throw new Error('Non-canonical or truncated Base93 input.')
+  return bytes
+}
+
+function normalizeSource (source) {
+  if (typeof source === 'function') source = source()
+  if (typeof source === 'string') return [source]
+  if (source?.[Symbol.asyncIterator] || source?.[Symbol.iterator]) return source
+  throw new TypeError('Base93 stream source must be iterable.')
+}
+
+export class Base93Decoder {
+  constructor (source, { mimeType = '', preferTextStreamDecoding = false } = {}) {
+    this.source = normalizeSource(source)
+    this.asText = preferTextStreamDecoding && mimeType.startsWith('text/')
+  }
+
+  async * decodedValues () {
+    const textDecoder = this.asText ? new TextDecoder() : null
+    for await (const encoded of this.source) {
+      const bytes = decode(encoded)
+      const value = textDecoder ? textDecoder.decode(bytes, { stream: true }) : bytes
+      if (value.length > 0) yield value
+    }
+    if (textDecoder) {
+      const tail = textDecoder.decode()
+      if (tail.length > 0) yield tail
+    }
+  }
+
+  getDecoded () {
+    const iterator = this.decodedValues()[Symbol.asyncIterator]()
+    return new ReadableStream({
+      async pull (controller) {
+        try {
+          const { value, done } = await iterator.next()
+          if (done) controller.close()
+          else controller.enqueue(value)
+        } catch (error) {
+          controller.error(error)
+        }
+      },
+      async cancel () {
+        await iterator.return?.()
+      }
+    })
+  }
+}
+
+export default Base93Decoder

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libp2r2p",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "description": "Peer-to-relay-to-peer",
   "keywords": [
     "p2r2p",
@@ -11,6 +11,27 @@
   "author": "arthurfranca",
   "type": "module",
   "sideEffects": false,
+  "files": [
+    "base16",
+    "base64",
+    "base93",
+    "content-key",
+    "double-dh",
+    "ecdh",
+    "idb",
+    "idb-queue",
+    "index.js",
+    "key",
+    "network",
+    "nip44-v3",
+    "nip46",
+    "private-channel",
+    "private-message",
+    "private-messenger",
+    "relay",
+    "temporary-storage",
+    "web-storage-queue"
+  ],
   "scripts": {
     "test": "node --test --experimental-test-module-mocks 'tests/**/*.test.js'",
     "test:only": "node --test --test-only --experimental-test-module-mocks 'tests/**/*.test.js'"
@@ -19,6 +40,7 @@
     ".": "./index.js",
     "./base16": "./base16/index.js",
     "./base64": "./base64/index.js",
+    "./base93": "./base93/index.js",
     "./content-key": "./content-key/index.js",
     "./content-key/event": "./content-key/event/index.js",
     "./double-dh": "./double-dh/index.js",

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)
 }