libp2r2p 0.12.0 → 0.12.1

package/README.md

@@ -358,6 +358,13 @@ 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`.
+Each routed report also identifies its exact outer event in `outerEventId` and
+the encrypted recipient subset in `receiverPubkeys`. The same recipient can
+appear in multiple reports when a message spans chunks or recipient groups; it
+is fully covered only when every report containing it succeeds. Fixed relay
+lists publish one shared recipient set, while explicit `relayToReceivers` maps
+and automatic NIP-65 routing can produce partial recipient coverage. Nym uses
+one carrier union and does not expose per-recipient partial delivery.
 When libp2r2p generated the keypair, it also contains
 `delivery.deletionSeckey`; the public key can be derived from that secret.
 
@@ -797,7 +804,7 @@ Maintainers can rebuild the checked-in WASM module with `npm run build:wasm`;
 see the
 [WASM build guide](https://github.com/arthurfranca/libp2r2p/blob/main/wasm/README.md).
 Run the non-gating comparison against the JavaScript backend with
-`npm run benchmark:event`.
+`npm run benchmark:event` (implemented by `benchmark/event-crypto.js`).
 
 Median speedup after explicit WASM initialization, measured with Node.js 24 on
 an AMD Ryzen 5 5600G:
@@ -1181,6 +1188,10 @@ complete per-relay report without delaying the first-success return. Connection
 establishment retains its separate 3-second deadline. PrivateMessenger inherits
 this publication policy, including seeder/recovery messages. A timeout indicates
 missing acknowledgement and cannot prove that the recipient did not receive it.
+Its optional `getRetryEvent({ event, report })` accepts one replacement signed
+event after every relay terminally rejected the original with
+`auth-required:`/`restricted:`/`invalid:`. The replacement and its retry share the original
+deadline; mixed failures and ambiguous timeouts never invoke it.
 
 ## Private file channels (0.11)
 
@@ -1209,10 +1220,32 @@ including an optional `onSendError` callback identifying the failed outbox messa
 Private messages, including multi-recipient channels, retry NIP-65 read relays
 in pairs per recipient when
 selected relays reject publication or become unreachable while connectivity is
-confirmed. The exact encrypted outer events are reused. Optional `fallbackRelays` on
+confirmed. The exact encrypted outer events are reused, except that a 3560
+publication rejected in full by age-related AUTH policy may be re-enveloped once:
+ciphertext, router, chunks, seeds, recipients and deletion capability remain
+unchanged while every outer is re-signed with one fresh `created_at` and a
+refreshed `expiration`. The durable replacement is written before retry and is
+never refreshed a second time. A relay may use `invalid:` rather than
+`auth-required:` for a stale 3560 wrapper; `invalid:` triggers this refresh but
+never attempts NIP-42. Optional `fallbackRelays` on
 `createPrivateMessenger` and `createPrivateMessageSession` are tried after the
 primary destinations by default, including explicit per-call `relays`, channel `sendRelays`
 and channel/global `relays`, as well as explicit `relayToReceivers` maps.
+
+This bounded re-envelope is preferred over NIP-42 authentication with the
+channel key because NIP-42 state belongs to the connection, not to one outer
+event. The `44b-relay` currently permits only one authenticated identity per
+connection and resets subscriptions when that identity changes. Even relays
+that support multiple identities per connection must bound them. A user with
+many contacts has one derived channel key per conversation, so authenticating
+each channel would either require one authenticated connection per channel or
+reconnect/resubscribe while switching identities, consuming connection,
+subscription and recovery budgets. It would also create a connection-scoped linkage
+between the connection and a channel key. The 3560 wrapper is disposable and
+privacy-oriented; relays are expected to impose freshness limits instead of
+correlating it with an authenticated session. A modern 3560 is normally
+accepted without AUTH, so refreshing an age-rejected outer should remain rare.
+
 Retries preserve each encrypted recipient subset; success requires accepted
 publication covering every recipient in that subset. Receive routing adds them from the start for live
 messages, history and files while preserving automatic NIP-65 updates. Successful sends keep first-ACK
@@ -1224,6 +1257,20 @@ paused or otherwise unavailable now stay pending in the outbox and retry on a
 bounded session backoff (1–30 seconds, 20% jitter) instead of surfacing a
 user-facing send error.
 
+Multi-recipient callers that persist exact envelopes use the canonical
+`preparedPublications` array supplied through `onPreparedSeed`. Each element is
+one recipient group with its own encrypted `events`, recovery `seeds`, and
+`receiverPubkeys`. A later send can pass the array plus only the pending
+recipients; matching groups are replayed with their original IDs, bytes and
+signatures, and routed only for the pending peers. The legacy
+`preparedPublication` public argument is rejected with
+`LEGACY_PREPARED_PUBLICATION`; existing encrypted outbox snapshots containing
+`prepared.publication` are migrated internally to
+`prepared.publications` before processing. `yell` callers must reuse the
+original `createdAt` when replaying so the inner rumor identity matches;
+`broadcastRumor` and `broadcastEvent` already carry their original inner event.
+Nym broadcasts intentionally remain a single carrier union.
+
 
 ### Relay backpressure and bounded synchronization (0.11.7)
 

package/helpers/secp256k1-wasm/backend.js

@@ -1,3 +1,4 @@
+import { bytesToBase16 } from '../../base16/index.js'
 import { ValidationError } from '../../error/index.js'
 import { createSecp256k1WasmBackend } from './binding.js'
 
@@ -13,8 +14,6 @@ let backend = null
 let pending = null
 let generation = 0
 
-const toHex = bytes => Array.from(bytes, byte => byte.toString(16).padStart(2, '0')).join('')
-
 async function initialize (forceRetry) {
   if (!enabled) return 'javascript'
   if (backend) return 'wasm'
@@ -27,7 +26,7 @@ async function initialize (forceRetry) {
     let candidate
     try {
       candidate = await createSecp256k1WasmBackend()
-      const publicKey = toHex(candidate.getPublicKey(SELF_TEST_SECRET))
+      const publicKey = bytesToBase16(candidate.getPublicKey(SELF_TEST_SECRET))
       const signature = candidate.signHash(
         SELF_TEST_HASH,
         SELF_TEST_SECRET,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libp2r2p",
-  "version": "0.12.0",
+  "version": "0.12.1",
   "description": "Peer-to-relay-to-peer",
   "keywords": [
     "p2r2p",
@@ -51,8 +51,8 @@
     "web-storage-queue"
   ],
   "scripts": {
-    "benchmark:event": "node --expose-gc benchmark/event-crypto.mjs",
-    "build:wasm": "node wasm/build.mjs",
+    "benchmark:event": "node --expose-gc benchmark/event-crypto.js",
+    "build:wasm": "node wasm/build.js",
     "test": "node --test --experimental-test-module-mocks 'tests/**/*.test.js'",
     "test:files": "node --test --experimental-test-module-mocks",
     "test:only": "node --test --test-only --experimental-test-module-mocks 'tests/**/*.test.js'"

package/private-channel/helpers/prepared.js

@@ -0,0 +1,12 @@
+import { ValidationError } from '../../error/index.js'
+
+export function normalizePreparedPublications ({ preparedPublication, preparedPublications } = {}) {
+  if (preparedPublication !== undefined) throw new ValidationError('LEGACY_PREPARED_PUBLICATION')
+  if (preparedPublications !== undefined) {
+    if (!Array.isArray(preparedPublications) || preparedPublications.length === 0) {
+      throw new ValidationError('INVALID_PREPARED_PUBLICATIONS')
+    }
+    return preparedPublications
+  }
+  return []
+}

package/private-channel/index.js

@@ -11,6 +11,7 @@ import { incompleteFetchError } from './helpers/fetch-error.js'
 import { readHistory } from './helpers/history.js'
 import { subscriptionError } from './helpers/subscription-error.js'
 import { createLookupWarningLogger } from './helpers/lookup-warning.js'
+import { normalizePreparedPublications } from './helpers/prepared.js'
 import * as nip44v3 from '../nip44-v3/index.js'
 import { relayPool } from '../relay/index.js'
 import { JSONL_CHUNK_BYTES, NYM_CARRIER_CHUNK_CHARS } from './helpers/chunk-size.js'
@@ -40,7 +41,7 @@ const decoder = new TextDecoder()
 const warnLookupFailure = createLookupWarningLogger()
 const NIP44_V3_SCOPE = ''
 
-const sendToRelays = (event, relays) => relayPool.sendEvent(event, relays)
+const sendToRelays = (event, relays, options) => relayPool.sendEvent(event, relays, options)
 const getEvents = (...args) => relayPool.getEvents(...args)
 const getLiveEventsGenerator = (...args) => relayPool.getLiveEventsGenerator(...args)
 const getEventsFeedGenerator = (...args) => relayPool.getEventsFeedGenerator(...args)
@@ -153,18 +154,29 @@ async function prepareRoutedMessage ({ senderSigner, imkcSigner, privateChannelS
   }
 }
 
-async function * wrapPreparedEvents ({ privateChannelSigner, senderSigner, event, receivers, receiverTag, fileChunkIndex, onPreparedSeed, deletionPubkey, expirationSeconds = EXPIRATION_SECONDS, context, preparedPublication }) {
+async function validatePreparedPublication ({ privateChannelSigner, senderSigner, event, receivers, preparedPublication }) {
+  const channelPubkey = await privateChannelSigner.getPublicKey()
+  const innerEventId = getEventHash({ ...event, pubkey: event.pubkey || await senderSigner.getPublicKey() })
+  const publicationReceivers = Array.isArray(preparedPublication?.receiverPubkeys)
+    ? [...new Set(preparedPublication.receiverPubkeys)]
+    : []
+  const expected = receivers ? receiverPubkeys(receivers).sort().join(',') : ''
+  if (preparedPublication?.innerEventId !== innerEventId || preparedPublication?.channelPubkey !== channelPubkey ||
+      !publicationReceivers.length || (receivers && publicationReceivers.slice().sort().join(',') !== expected) ||
+      !Array.isArray(preparedPublication.events) || !preparedPublication.events.length || !Array.isArray(preparedPublication.seeds) ||
+      preparedPublication.events.some(value => !isValidEvent(value) || value.pubkey !== channelPubkey || value.kind !== PRIVATE_BROADCAST_KIND)) {
+    throw new ValidationError('INVALID_PREPARED_PUBLICATION')
+  }
+  if (preparedPublication.events.some(value => Number(value.tags.find(tag => tag[0] === 'expiration')?.[1]) <= nowSeconds())) {
+    throw new ValidationError('PREPARED_PUBLICATION_EXPIRED')
+  }
+  return publicationReceivers
+}
+
+async function * wrapPreparedEvents ({ privateChannelSigner, senderSigner, event, receivers, receiverTag, fileChunkIndex, onPreparedSeed, onPreparedPublication, deletionPubkey, expirationSeconds = EXPIRATION_SECONDS, context, preparedPublication }) {
   let publication = preparedPublication
   if (publication) {
-    const channelPubkey = await privateChannelSigner.getPublicKey()
-    const expected = receiverPubkeys(receivers).sort().join(',')
-    const innerEventId = getEventHash({ ...event, pubkey: event.pubkey || await senderSigner.getPublicKey() })
-    if (publication.innerEventId !== innerEventId || publication.channelPubkey !== channelPubkey || !Array.isArray(publication.receiverPubkeys) || publication.receiverPubkeys.slice().sort().join(',') !== expected ||
-        !Array.isArray(publication.events) || !publication.events.length || !Array.isArray(publication.seeds) ||
-        publication.events.some(event => !isValidEvent(event) || event.pubkey !== channelPubkey || event.kind !== PRIVATE_BROADCAST_KIND)) {
-      throw new ValidationError('INVALID_PREPARED_PUBLICATION')
-    }
-    if (publication.events.some(event => Number(event.tags.find(tag => tag[0] === 'expiration')?.[1]) <= nowSeconds())) throw new ValidationError('PREPARED_PUBLICATION_EXPIRED')
+    await validatePreparedPublication({ privateChannelSigner, senderSigner, event, receivers, preparedPublication: publication })
   } else {
     const routerSeckey = generateSecretKey()
     const routerPubkey = getPublicKey(routerSeckey)
@@ -194,6 +206,7 @@ async function * wrapPreparedEvents ({ privateChannelSigner, senderSigner, event
     }
     publication = { innerEventId: context.innerEventId, channelPubkey: context.channelPubkey, receiverPubkeys: receiverPubkeyList, events, seeds }
   }
+  onPreparedPublication?.(publication)
   // The callback commits recovery data before any bytes leave this publisher.
   // A session commits its encrypted journal; a direct messenger commits seeds.
   if (onPreparedSeed) {
@@ -203,9 +216,12 @@ async function * wrapPreparedEvents ({ privateChannelSigner, senderSigner, event
 }
 
 // Streaming version of wrapEvent
-export async function * wrapEvents ({ senderSigner, imkcSigner, privateChannelSigner = senderSigner, privateChannelReaderPubkey, receivers, receiverTag, fileChunkIndex, onPreparedSeed, deletionPubkey, event, expirationSeconds = EXPIRATION_SECONDS, temporaryStorageArea, _getIykcProofs = getIykcProofs, preparedPublication }) {
+export async function * wrapEvents ({ senderSigner, imkcSigner, privateChannelSigner = senderSigner, privateChannelReaderPubkey, receivers, receiverTag, fileChunkIndex, onPreparedSeed, onPreparedPublication, deletionPubkey, event, expirationSeconds = EXPIRATION_SECONDS, temporaryStorageArea, _getIykcProofs = getIykcProofs, preparedPublication, preparedPublications }) {
   const normalizedDeletionPubkey = normalizeDeletionPubkey(deletionPubkey)
-  const context = preparedPublication
+  const prepared = normalizePreparedPublications({ preparedPublication, preparedPublications })
+  if (prepared.length > 1) throw new ValidationError('INVALID_PREPARED_PUBLICATIONS')
+  const publication = prepared[0]
+  const context = publication
     ? null
     : await prepareRoutedMessage({
       senderSigner,
@@ -218,7 +234,7 @@ export async function * wrapEvents ({ senderSigner, imkcSigner, privateChannelSi
       _getIykcProofs
     })
   try {
-    yield * wrapPreparedEvents({ privateChannelSigner, senderSigner, event, receivers, receiverTag, fileChunkIndex, onPreparedSeed, deletionPubkey: normalizedDeletionPubkey, expirationSeconds, context, preparedPublication })
+    yield * wrapPreparedEvents({ privateChannelSigner, senderSigner, event, receivers, receiverTag, fileChunkIndex, onPreparedSeed, onPreparedPublication, deletionPubkey: normalizedDeletionPubkey, expirationSeconds, context, preparedPublication: publication })
   } finally {
     if (context) cleanupEnvelopeRows(context.preparedRows)
   }
@@ -558,29 +574,208 @@ function withRecoveryRelays (relays, recoveryRelays) {
   return uniq([...(relays || []), ...(recoveryRelays || [])])
 }
 
-export async function publish ({ senderSigner, imkcSigner, privateChannelSigner = senderSigner, privateChannelReaderPubkey, receivers, receiverTag, fileChunkIndex, onPreparedSeed, deletionPubkey, event, relays, relayToReceivers, recoveryRelays, expirationSeconds, temporaryStorageArea, _getIykcProofs = getIykcProofs, _publish = sendToRelays, preparedPublication }) {
+function withPublicationCoverage (report, event, receivers) {
+  if (!report || typeof report !== 'object' || Array.isArray(report)) return report
+  return {
+    ...report,
+    outerEventId: event.id,
+    receiverPubkeys: receiverPubkeys(receivers)
+  }
+}
+
+function expirationRetentionSeconds (publication, expirationSeconds) {
+  if (Number.isSafeInteger(expirationSeconds) && expirationSeconds >= 0) return expirationSeconds
+  for (const event of publication.events || []) {
+    const expiration = Number(event.tags?.find(tag => tag[0] === 'expiration')?.[1])
+    if (Number.isSafeInteger(expiration) && expiration >= event.created_at) return expiration - event.created_at
+  }
+  return null
+}
+
+async function refreshPublicationForRetry ({ privateChannelSigner, publication, expirationSeconds }) {
+  if (publication?.outerRefreshAttempted === true) throw new ValidationError('OUTER_REFRESH_ALREADY_ATTEMPTED')
+  if (!Array.isArray(publication?.events) || publication.events.length === 0) throw new ValidationError('INVALID_PREPARED_PUBLICATION')
+  const channelPubkey = await privateChannelSigner.getPublicKey()
+  if (publication.channelPubkey !== channelPubkey) throw new ValidationError('INVALID_PREPARED_PUBLICATION')
+  const currentTime = nowSeconds()
+  const createdAt = Math.max(currentTime, ...publication.events.map(event => event.created_at + 1))
+  const retention = expirationRetentionSeconds(publication, expirationSeconds)
+  const events = []
+  for (const previous of publication.events) {
+    if (!isValidEvent(previous) || previous.kind !== PRIVATE_BROADCAST_KIND || previous.pubkey !== channelPubkey) {
+      throw new ValidationError('INVALID_PREPARED_PUBLICATION')
+    }
+    const tags = previous.tags.map(tag => {
+      if (tag[0] !== 'expiration' || retention === null) return [...tag]
+      return ['expiration', String(createdAt + retention)]
+    })
+    const refreshed = await privateChannelSigner.signEvent({
+      kind: PRIVATE_BROADCAST_KIND,
+      created_at: createdAt,
+      tags,
+      content: previous.content
+    })
+    if (!isValidEvent(refreshed) || refreshed.id === previous.id || refreshed.kind !== PRIVATE_BROADCAST_KIND || refreshed.pubkey !== channelPubkey ||
+        refreshed.created_at !== createdAt || refreshed.content !== previous.content || JSON.stringify(refreshed.tags) !== JSON.stringify(tags)) {
+      throw new ValidationError('INVALID_PREPARED_PUBLICATION')
+    }
+    if (eventByteLength(refreshed) > MAX_EVENT_BYTES) throw new ValidationError('EVENT_TOO_LARGE')
+    events.push(refreshed)
+  }
+  return {
+    ...structuredClone(publication),
+    events,
+    outerRefreshAttempted: true
+  }
+}
+
+async function publishOuterEvents ({
+  publication,
+  publishRelays,
+  primaryRelays,
+  receivers,
+  privateChannelSigner,
+  expirationSeconds,
+  onPreparedSeed,
+  _publish,
+  includeCoverage = true,
+  includeRoutingContext = true
+}) {
+  let current = publication
+  let refreshed = false
+  let refreshWork
+  const results = []
+  for (let index = 0; index < current.events.length; index++) {
+    const getRetryEvent = index === 0 && current.outerRefreshAttempted !== true
+      ? async ({ event }) => {
+        if (refreshed || refreshWork || event.id !== current.events[0].id) return null
+        refreshWork = (async () => {
+          const next = await refreshPublicationForRetry({ privateChannelSigner, publication: current, expirationSeconds })
+          const firstSeed = next.seeds?.[0]
+          if (firstSeed && onPreparedSeed) await onPreparedSeed({ ...firstSeed, publication: next }, { replace: true })
+          current = next
+          refreshed = true
+          return current.events[0]
+        })()
+        return await refreshWork
+      }
+      : undefined
+    const report = await _publish(current.events[index], publishRelays, includeRoutingContext
+      ? {
+          receiverPubkeys: receiverPubkeys(receivers),
+          primaryRelays,
+          getRetryEvent
+        }
+      : { getRetryEvent })
+    results.push(includeCoverage ? withPublicationCoverage(report, current.events[index], receivers) : report)
+  }
+  return { publication: current, results }
+}
+
+function relayMapForReceivers (relayToReceivers, receivers) {
+  if (!relayToReceivers) return null
+  const wanted = new Set(receivers)
+  const relays = []
+  for (const [relay, values] of relayReceiverEntries(relayToReceivers)) {
+    const offered = (Array.isArray(values) ? values : [values])
+      .map(value => typeof value === 'string' ? value : receiverPubkeys([value])[0])
+    if (!offered.some(pubkey => wanted.has(pubkey))) continue
+    relays.push(relay)
+  }
+  return relays
+}
+
+export async function publish ({ senderSigner, imkcSigner, privateChannelSigner = senderSigner, privateChannelReaderPubkey, receivers, receiverTag, fileChunkIndex, onPreparedSeed, deletionPubkey, event, relays, relayToReceivers, recoveryRelays, expirationSeconds, temporaryStorageArea, _getIykcProofs = getIykcProofs, _publish = sendToRelays, preparedPublication, preparedPublications }) {
   const normalizedDeletionPubkey = normalizeDeletionPubkey(deletionPubkey)
   const results = []
-  // Relays are grouped only when they have the exact same recipient pubkey set
-  const groups = groupedRelayReceivers({ relayToReceivers, receivers })
-  if (groups) {
-    const context = preparedPublication
-      ? null
-      : await prepareRoutedMessage({
-        senderSigner,
-        imkcSigner,
+  const requestedReceivers = receiverPubkeys(receivers)
+  const prepared = normalizePreparedPublications({ preparedPublication, preparedPublications })
+  if (prepared.length) {
+    const requested = new Set(requestedReceivers)
+    const covered = new Set()
+    for (let publicationIndex = 0; publicationIndex < prepared.length; publicationIndex++) {
+      const publication = prepared[publicationIndex]
+      const candidateReceivers = Array.isArray(publication?.receiverPubkeys)
+        ? [...new Set(publication.receiverPubkeys)]
+        : []
+      const candidateTargets = candidateReceivers.filter(pubkey => requested.has(pubkey))
+      if (!candidateTargets.length) continue
+      const publicationReceivers = await validatePreparedPublication({
         privateChannelSigner,
-        privateChannelReaderPubkey,
-        receivers,
+        senderSigner,
         event,
-        temporaryStorageArea,
-        _getIykcProofs
+        preparedPublication: publication
+      })
+      const targeted = publicationReceivers.filter(pubkey => requested.has(pubkey))
+      for (const pubkey of targeted) covered.add(pubkey)
+      if (onPreparedSeed) {
+        for (const seed of publication.seeds) await onPreparedSeed({ ...seed, publication })
+      }
+      const targetRelays = relayMapForReceivers(relayToReceivers, targeted) || uniq(relays)
+      const publishRelays = withRecoveryRelays(targetRelays, recoveryRelays)
+      if (!publishRelays.length) throw new ValidationError('NO_RELAYS')
+      const outcome = await publishOuterEvents({
+        publication,
+        publishRelays,
+        primaryRelays: targetRelays,
+        receivers: targeted.map(pubkey => ({ receiverPubkey: pubkey })),
+        privateChannelSigner,
+        expirationSeconds,
+        onPreparedSeed,
+        _publish
       })
+      prepared[publicationIndex] = outcome.publication
+      results.push(...outcome.results)
+    }
+    if ([...requested].some(pubkey => !covered.has(pubkey))) {
+      throw new ValidationError('PREPARED_PUBLICATION_RECEIVER_MISSING')
+    }
+    return results
+  }
+  // Relays are grouped only when they have the exact same recipient pubkey set
+  const groups = groupedRelayReceivers({ relayToReceivers, receivers })
+  if (groups) {
+    const context = await prepareRoutedMessage({
+      senderSigner,
+      imkcSigner,
+      privateChannelSigner,
+      privateChannelReaderPubkey,
+      receivers,
+      event,
+      temporaryStorageArea,
+      _getIykcProofs
+    })
     try {
       for (const group of groups) {
-        for await (const wrappedEvent of wrapPreparedEvents({ privateChannelSigner, senderSigner, event, receivers: group.receivers, receiverTag, fileChunkIndex, onPreparedSeed, deletionPubkey: normalizedDeletionPubkey, expirationSeconds, context, preparedPublication })) {
-          results.push(await _publish(wrappedEvent, withRecoveryRelays(group.relays, recoveryRelays), { receiverPubkeys: receiverPubkeys(group.receivers), primaryRelays: group.relays }))
+        let publication
+        const events = []
+        for await (const wrappedEvent of wrapPreparedEvents({
+          privateChannelSigner,
+          senderSigner,
+          event,
+          receivers: group.receivers,
+          receiverTag,
+          fileChunkIndex,
+          onPreparedSeed,
+          onPreparedPublication: value => { publication = value },
+          deletionPubkey: normalizedDeletionPubkey,
+          expirationSeconds,
+          context
+        })) {
+          events.push(wrappedEvent)
         }
+        const publishRelays = withRecoveryRelays(group.relays, recoveryRelays)
+        const outcome = await publishOuterEvents({
+          publication: publication || { events },
+          publishRelays,
+          primaryRelays: group.relays,
+          receivers: group.receivers,
+          privateChannelSigner,
+          expirationSeconds,
+          onPreparedSeed,
+          _publish
+        })
+        results.push(...outcome.results)
       }
     } finally {
       if (context) cleanupEnvelopeRows(context.preparedRows)
@@ -588,9 +783,37 @@ export async function publish ({ senderSigner, imkcSigner, privateChannelSigner
     return results
   }
 
-  for await (const wrappedEvent of wrapEvents({ senderSigner, imkcSigner, privateChannelSigner, privateChannelReaderPubkey, receivers, receiverTag, fileChunkIndex, onPreparedSeed, deletionPubkey: normalizedDeletionPubkey, event, expirationSeconds, temporaryStorageArea, _getIykcProofs, preparedPublication })) {
-    results.push(await _publish(wrappedEvent, withRecoveryRelays(relays, recoveryRelays), { receiverPubkeys: receiverPubkeys(receivers), primaryRelays: relays }))
+  let publication
+  const events = []
+  for await (const wrappedEvent of wrapEvents({
+    senderSigner,
+    imkcSigner,
+    privateChannelSigner,
+    privateChannelReaderPubkey,
+    receivers,
+    receiverTag,
+    fileChunkIndex,
+    onPreparedSeed,
+    onPreparedPublication: value => { publication = value },
+    deletionPubkey: normalizedDeletionPubkey,
+    event,
+    expirationSeconds,
+    temporaryStorageArea,
+    _getIykcProofs
+  })) {
+    events.push(wrappedEvent)
   }
+  const outcome = await publishOuterEvents({
+    publication: publication || { events },
+    publishRelays: withRecoveryRelays(relays, recoveryRelays),
+    primaryRelays: relays,
+    receivers,
+    privateChannelSigner,
+    expirationSeconds,
+    onPreparedSeed,
+    _publish
+  })
+  results.push(...outcome.results)
   return results
 }
 
@@ -598,8 +821,24 @@ export async function publishNymEvent ({ nymSigner, privateChannelSigner, privat
   const normalizedDeletionPubkey = normalizeDeletionPubkey(deletionPubkey)
   const results = []
   const publishRelays = withRecoveryRelays(relayToReceivers ? relaysFromRelayReceivers(relayToReceivers) : relays, recoveryRelays)
+  const events = []
   for await (const wrappedEvent of wrapNymEvents({ nymSigner, privateChannelSigner, privateChannelReaderPubkey, deletionPubkey: normalizedDeletionPubkey, event, expirationSeconds })) {
-    results.push(await _publish(wrappedEvent, publishRelays))
+    events.push(wrappedEvent)
+  }
+  if (events.length) {
+    const channelPubkey = await privateChannelSigner.getPublicKey()
+    const outcome = await publishOuterEvents({
+      publication: { channelPubkey, receiverPubkeys: [], events, seeds: [] },
+      publishRelays,
+      primaryRelays: publishRelays,
+      receivers: [],
+      privateChannelSigner,
+      expirationSeconds,
+      includeCoverage: false,
+      includeRoutingContext: false,
+      _publish
+    })
+    results.push(...outcome.results)
   }
   return results
 }