libp2r2p 0.11.36 → 0.12.1

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
 }

package/private-message/index.js

@@ -4,6 +4,7 @@ import { ValidationError } from '../error/index.js'
 import { generateKeypair, keypairFromSeckey } from '../key/index.js'
 import * as privateChannel from '../private-channel/index.js'
 import { normalizeRumor, deliveryInfo } from '../private-channel/helpers/rumor.js'
+import { normalizePreparedPublications } from '../private-channel/helpers/prepared.js'
 
 export const ASK_KIND = 7329
 export const REPLY_KIND = 7330
@@ -41,17 +42,25 @@ function normalizeDeletionPubkey (deletionPubkey) {
   return deletionPubkey.toLowerCase()
 }
 
-function resolveDeletionCapability ({ deletionPubkey, deletionSeckey, autoDeletionCapability = true, preparedPublication }) {
+function resolveDeletionCapability ({ deletionPubkey, deletionSeckey, autoDeletionCapability = true, preparedPublications = [] }) {
   if (deletionSeckey !== undefined) throw new ValidationError('DELETION_SECKEY_NOT_ACCEPTED')
   if (typeof autoDeletionCapability !== 'boolean') throw new ValidationError('AUTO_DELETION_CAPABILITY_BOOLEAN_REQUIRED')
 
   const normalizedDeletionPubkey = normalizeDeletionPubkey(deletionPubkey)
-  if (preparedPublication) {
-    const capability = preparedPublication.deletionCapability
-    if (!capability || (capability.deletionPubkey !== undefined && normalizeDeletionPubkey(capability.deletionPubkey) !== capability.deletionPubkey) ||
-        (normalizedDeletionPubkey && normalizedDeletionPubkey !== capability.deletionPubkey) ||
-        (capability.deletionSeckey !== undefined && keypairFromSeckey(capability.deletionSeckey).pubkey !== capability.deletionPubkey) ||
-        preparedPublication.events?.some(event => event.tags.find(tag => tag[0] === 's')?.[1] !== capability.deletionPubkey)) throw new ValidationError('INVALID_PREPARED_PUBLICATION')
+  if (preparedPublications.length) {
+    const capability = preparedPublications[0].deletionCapability
+    if (!capability) throw new ValidationError('INVALID_PREPARED_PUBLICATION')
+    for (const publication of preparedPublications) {
+      const current = publication.deletionCapability
+      if (!current || (current.deletionPubkey !== capability.deletionPubkey) ||
+          (current.deletionSeckey !== capability.deletionSeckey) ||
+          (current.deletionPubkey !== undefined && normalizeDeletionPubkey(current.deletionPubkey) !== current.deletionPubkey) ||
+          (normalizedDeletionPubkey && normalizedDeletionPubkey !== capability.deletionPubkey) ||
+          (capability.deletionSeckey !== undefined && keypairFromSeckey(capability.deletionSeckey).pubkey !== capability.deletionPubkey) ||
+          publication.events?.some(event => event.tags.find(tag => tag[0] === 's')?.[1] !== capability.deletionPubkey)) {
+        throw new ValidationError('INVALID_PREPARED_PUBLICATION')
+      }
+    }
     return { ...capability }
   }
   if (normalizedDeletionPubkey) return { deletionPubkey: normalizedDeletionPubkey }
@@ -63,9 +72,9 @@ function resolveDeletionCapability ({ deletionPubkey, deletionSeckey, autoDeleti
 
 function preparedSeedHandler (onPreparedSeed, deletion) {
   if (!onPreparedSeed) return undefined
-  return seed => {
+  return (seed, options) => {
     seed.publication.deletionCapability = deletion
-    return onPreparedSeed(seed)
+    return onPreparedSeed(seed, options)
   }
 }
 
@@ -668,11 +677,11 @@ async function sendPrivateMessage ({
   _getIykcProofs,
   fileChunkIndex,
   onPreparedSeed,
-  preparedPublication,
+  preparedPublications,
   _publish = privateChannel.publish
 }) {
   if (!privateChannelSigner?.getPublicKey) throw new ValidationError('PRIVATE_CHANNEL_WRITER_REQUIRED')
-  return _publish({ senderSigner, imkcSigner, privateChannelSigner, privateChannelReaderPubkey, receivers, receiverTag, deletionPubkey, event, relays, relayToReceivers, recoveryRelays, expirationSeconds, temporaryStorageArea, fileChunkIndex, onPreparedSeed, preparedPublication, _getIykcProofs })
+  return _publish({ senderSigner, imkcSigner, privateChannelSigner, privateChannelReaderPubkey, receivers, receiverTag, deletionPubkey, event, relays, relayToReceivers, recoveryRelays, expirationSeconds, temporaryStorageArea, fileChunkIndex, onPreparedSeed, preparedPublications: preparedPublications?.length ? preparedPublications : undefined, _getIykcProofs })
 }
 
 async function sendNymMessage ({
@@ -841,21 +850,29 @@ export async function yell ({
   deletionSeckey,
   autoDeletionCapability = true,
   fileChunkIndex,
+  createdAt,
   onPreparedSeed,
+  preparedPublication,
+  preparedPublications,
   _publish = privateChannel.publish
 }) {
-  const receivers = uniq(receiverPubkeys)
+  const prepared = normalizePreparedPublications({ preparedPublication, preparedPublications })
+  const receivers = uniq(receiverPubkeys?.length
+    ? receiverPubkeys
+    : prepared.flatMap(publication => publication.receiverPubkeys || []))
   if (!receivers.length) throw new ValidationError('NO_RECEIVERS')
+  const rumor = makeMessageRumor({
+    kind: TELL_KIND,
+    tags: [],
+    message: message || { code, payload, error, content }
+  })
+  if (createdAt !== undefined) rumor.created_at = createdAt
   const { event, wireEvent } = await makeOutgoingRumor({
     senderSigner,
-    rumor: makeMessageRumor({
-      kind: TELL_KIND,
-      tags: [],
-      message: message || { code, payload, error, content }
-    })
+    rumor
   })
-  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, fileChunkIndex, onPreparedSeed, _getIykcProofs, _publish })
+  const deletion = resolveDeletionCapability({ deletionPubkey, deletionSeckey, autoDeletionCapability, preparedPublications: prepared })
+  const reports = await sendPrivateMessage({ senderSigner, imkcSigner, privateChannelSigner, privateChannelReaderPubkey, receivers, receiverTag: '', deletionPubkey: deletion.deletionPubkey, event: wireEvent, relays, relayToReceivers, recoveryRelays, expirationSeconds, temporaryStorageArea, fileChunkIndex, onPreparedSeed: preparedSeedHandler(onPreparedSeed, deletion), preparedPublications: prepared, _getIykcProofs, _publish })
   return withDelivery({ yell: event }, reports, deletion.deletionSeckey)
 }
 
@@ -878,13 +895,15 @@ export async function broadcastRumor ({
   fileChunkIndex,
   onPreparedSeed,
   preparedPublication,
+  preparedPublications,
   _publish = privateChannel.publish
 }) {
   const receivers = uniq(receiverPubkeys)
   if (!receivers.length) throw new ValidationError('NO_RECEIVERS')
+  const prepared = normalizePreparedPublications({ preparedPublication, preparedPublications })
   const { event, wireEvent } = await makeOutgoingRumor({ senderSigner, rumor })
-  const deletion = resolveDeletionCapability({ deletionPubkey, deletionSeckey, autoDeletionCapability, preparedPublication })
-  const reports = await sendPrivateMessage({ senderSigner, imkcSigner, privateChannelSigner, privateChannelReaderPubkey, receivers, receiverTag: '', deletionPubkey: deletion.deletionPubkey, event: wireEvent, relays, relayToReceivers, recoveryRelays, expirationSeconds, temporaryStorageArea, fileChunkIndex, onPreparedSeed: preparedSeedHandler(onPreparedSeed, deletion), preparedPublication, _getIykcProofs, _publish })
+  const deletion = resolveDeletionCapability({ deletionPubkey, deletionSeckey, autoDeletionCapability, preparedPublications: prepared })
+  const reports = await sendPrivateMessage({ senderSigner, imkcSigner, privateChannelSigner, privateChannelReaderPubkey, receivers, receiverTag: '', deletionPubkey: deletion.deletionPubkey, event: wireEvent, relays, relayToReceivers, recoveryRelays, expirationSeconds, temporaryStorageArea, fileChunkIndex, onPreparedSeed: preparedSeedHandler(onPreparedSeed, deletion), preparedPublications: prepared, _getIykcProofs, _publish })
   return withDelivery({ rumor: event }, reports, deletion.deletionSeckey)
 }
 
@@ -907,13 +926,15 @@ export async function broadcastEvent ({
   fileChunkIndex,
   onPreparedSeed,
   preparedPublication,
+  preparedPublications,
   _publish = privateChannel.publish
 }) {
   const receivers = uniq(receiverPubkeys)
   if (!receivers.length) throw new ValidationError('NO_RECEIVERS')
+  const prepared = normalizePreparedPublications({ preparedPublication, preparedPublications })
   const wireEvent = assertValidSignedEvent({ ...event, tags: cloneTags(event?.tags) })
-  const deletion = resolveDeletionCapability({ deletionPubkey, deletionSeckey, autoDeletionCapability, preparedPublication })
-  const reports = await sendPrivateMessage({ senderSigner, imkcSigner, privateChannelSigner, privateChannelReaderPubkey, receivers, receiverTag: '', deletionPubkey: deletion.deletionPubkey, event: wireEvent, relays, relayToReceivers, recoveryRelays, expirationSeconds, temporaryStorageArea, fileChunkIndex, onPreparedSeed: preparedSeedHandler(onPreparedSeed, deletion), preparedPublication, _getIykcProofs, _publish })
+  const deletion = resolveDeletionCapability({ deletionPubkey, deletionSeckey, autoDeletionCapability, preparedPublications: prepared })
+  const reports = await sendPrivateMessage({ senderSigner, imkcSigner, privateChannelSigner, privateChannelReaderPubkey, receivers, receiverTag: '', deletionPubkey: deletion.deletionPubkey, event: wireEvent, relays, relayToReceivers, recoveryRelays, expirationSeconds, temporaryStorageArea, fileChunkIndex, onPreparedSeed: preparedSeedHandler(onPreparedSeed, deletion), preparedPublications: prepared, _getIykcProofs, _publish })
   return withDelivery({ event: wireEvent }, reports, deletion.deletionSeckey)
 }
 

package/private-messenger/file/index.js

@@ -4,6 +4,7 @@ import { createFileCache } from './helpers/cache.js'
 export { createFileCache, DEFAULT_FILE_CACHE_BYTES } from './helpers/cache.js'
 import { createFileCatalog } from './helpers/catalog.js'
 import { assertMessagePublished } from '../helpers/publication.js'
+import { normalizePreparedPublications } from '../../private-channel/helpers/prepared.js'
 import { ValidationError } from '../../error/index.js'
 import { IRFS_CHUNK_BYTES, decodeIrfsChunk } from '../../irfs/index.js'
 import { createQueue } from '../../idb-queue/index.js'
@@ -151,9 +152,10 @@ export function createPrivateFileTransfer ({ messenger, resolveChannel, storage,
   function sendOptions (file, routes) {
     return { senderSigner: messenger.userSigner, imkcSigner: messenger.contentKeySigner, privateChannelSigner: file.signer, ...routes, temporaryStorageArea: messenger.temporaryStorageArea, expirationSeconds: messenger.eventExpirationSecondsFor(file.controlChannelPubkey), _getIykcProofs: messenger.contentKeyLookup() }
   }
-  async function publishChunk (descriptor, event, { signal, attemptStartedAt, onPreparedSeed, preparedPublication, onDebug } = {}) {
+  async function publishChunk (descriptor, event, { signal, attemptStartedAt, onPreparedSeed, preparedPublication, preparedPublications, onDebug } = {}) {
     const file = await register(descriptor)
     usable(file)
+    const prepared = normalizePreparedPublications({ preparedPublication, preparedPublications })
     const decoded = checked(file, event)
     await catalog.ready
     if (ownsStorage) {
@@ -162,7 +164,7 @@ export function createPrivateFileTransfer ({ messenger, resolveChannel, storage,
     }
     let result
     try {
-      const options = { ...sendOptions(file, await routing(file, file.peerPubkey, signal, attemptStartedAt, onDebug)), receiverPubkeys: [file.peerPubkey], fileChunkIndex: decoded.index, preparedPublication, ...(onPreparedSeed ? { onPreparedSeed } : messenger.channels.get(file.controlChannelPubkey)?.mode === 'watchtower' ? { onPreparedSeed: seed => saveSeed(file, seed) } : {}) }
+      const options = { ...sendOptions(file, await routing(file, file.peerPubkey, signal, attemptStartedAt, onDebug)), receiverPubkeys: [file.peerPubkey], fileChunkIndex: decoded.index, preparedPublications: prepared.length ? prepared : undefined, ...(onPreparedSeed ? { onPreparedSeed } : messenger.channels.get(file.controlChannelPubkey)?.mode === 'watchtower' ? { onPreparedSeed: seed => saveSeed(file, seed) } : {}) }
       result = event.sig ? await _messages.broadcastEvent({ ...options, event }) : await _messages.broadcastRumor({ ...options, rumor: event })
       await assertMessagePublished(result, result?.rumor || result?.event || { ...event, pubkey: event.pubkey || messenger.userPubkey })
     } catch (error) { await uploadLeases.get(file.root)?.(); uploadLeases.delete(file.root); throw error }

package/private-messenger/helpers/fallback-race.js

@@ -2,7 +2,7 @@ import { isReplaceableRelayFailure } from '../../relay/helpers/failure.js'
 
 // Each invocation owns one already signed outer event and its encrypted subset.
 // Lanes share coverage and the tried set; only started reports outlive the race.
-export function publishWithEarlyFallback ({ event, receivers, first, mirrors, tried, nextPrimary, nextFallback, sendEvent, isOnline, isCurrent, signal, pauseSignal, remember, rememberSuccess = () => {}, delay, attemptStartedAt, monotonicNow = () => performance.now(), now, setTimer, clearTimer }) {
+export function publishWithEarlyFallback ({ event, receivers, first, mirrors, tried, getRetryEvent, nextPrimary, nextFallback, sendEvent, isOnline, isCurrent, signal, pauseSignal, remember, rememberSuccess = () => {}, delay, attemptStartedAt, monotonicNow = () => performance.now(), now, setTimer, clearTimer }) {
   const pending = new Set(receivers)
   const summaries = []
   const transportSignal = signal && pauseSignal ? AbortSignal.any([signal, pauseSignal]) : signal || pauseSignal
@@ -33,6 +33,13 @@ export function publishWithEarlyFallback ({ event, receivers, first, mirrors, tr
       ...(interruptedWork && !signal?.aborted ? { retryWhenAvailable: true, ...(offline ? { retryWhenOnline: true } : {}) } : {})
     })
   }
+  const fail = error => {
+    if (done) return
+    done = true
+    clearTimer(timer); timer = null
+    transportSignal?.removeEventListener('abort', interrupted)
+    outcome.reject(error)
+  }
   const check = () => {
     if (done) return
     if (!pending.size) finish(true)
@@ -59,7 +66,11 @@ export function publishWithEarlyFallback ({ event, receivers, first, mirrors, tr
     const slot = Promise.withResolvers()
     summaries.push(slot.promise)
     let result
-    try { result = await sendEvent(event, relays, { signal: transportSignal }) } catch (reason) {
+    try { result = await sendEvent(event, relays, { signal: transportSignal, getRetryEvent }) } catch (reason) {
+      if (reason?.code === 'RETRY_EVENT_PREPARATION_FAILED') {
+        fail(reason)
+        return
+      }
       result = { success: false, promise: Promise.resolve({ fulfilled: 0, errors: [{ reason }] }) }
     }
     const settled = Promise.resolve(result.promise).catch(reason => ({ fulfilled: 0, errors: [{ reason }] }))

package/private-messenger/helpers/send-routing.js

@@ -123,6 +123,7 @@ export function createSendRelayRouting ({ peer, peers = [peer], relaysByPubkey,
       }
       const result = await publishWithEarlyFallback({
         event, receivers, first: first.length ? { receivers, relays: first } : null, mirrors, tried,
+        getRetryEvent: context.getRetryEvent,
         nextPrimary: pending => pick(pending, false), nextFallback: pending => pick(pending, true),
         sendEvent, isOnline, isCurrent, signal, pauseSignal, remember, rememberSuccess,
         delay: fallbackDelayMs, attemptStartedAt, monotonicNow, now, setTimer, clearTimer
@@ -158,7 +159,7 @@ export function createSendRelayRouting ({ peer, peers = [peer], relaysByPubkey,
       for (const relay of relays) tried.add(normalized(relay))
       // Every relay in this batch serves the same pending recipient subset.
       // One ACK covers that subset, never unrelated members of the ciphertext.
-      result = await sendEvent(event, relays, { signal: transportSignal })
+      result = await sendEvent(event, relays, { signal: transportSignal, getRetryEvent: context.getRetryEvent })
       const settled = Promise.resolve(result.promise)
       summaries.push(settled)
       settled.then(report => rememberSuccess(report?.succeededRelays || [])).catch(() => {})