libp2r2p 0.11.21 → 0.11.23

package/README.md

@@ -242,6 +242,78 @@ stream according to the existing partial-failure rules.
 
 ## Private Messenger
 
+### Pending ciphertext recovery (0.11.22)
+
+The known three-field message deduplication index is migrated automatically to
+include provenance, preserving positions, records and byte accounting. Other
+incompatible queue definitions still fail explicitly; no database reset is needed.
+
+PrivateMessenger defers `CONTENT_KEY_NOT_FOUND` and `INVALID_MAC` packets to its
+separate `${prefix}:pending-decryption:idb-queue`: 16 MiB FIFO, ciphertext only,
+no per-item TTL. Duplicate packets and attempts preserve their queue positions.
+Explicit channel removal and identity storage maintenance remove their pending
+records. Oversized records and capacity eviction are reported as discards.
+Stale channel metadata cleanup does not expire pending ciphertext.
+History continues only after deferral commits; storage/permission failures are
+not converted into successful coverage. Deferral is not message delivery.
+
+Call `retryPendingDecryptions()` after new content keys become available. Initial
+readiness and resume also request a pass. A single background worker coalesces
+requests, uses an origin/identity Web Lock when available, and stops on pause or
+close. Missing-key retries have no polling timer. MAC failures permit three total
+attempts, persisted across reloads; exhausted packets remain until FIFO eviction.
+`retryPendingDecryptions({ force: true })` explicitly retries exhausted packets.
+Success enters the normal acknowledged inbox before removing the pending item.
+The session coordinator forwards this API.
+
+Pending recovery waits for 250 ms without channel setup, live/history processing
+or publication activity. Session foreground persistence/publication also delays
+it. After at most five seconds of eligible waiting, a busy channel may advance
+one packet, then receives a fresh deadline. Idle channels take batches of up to
+four records, yielding a task between every record. A busy channel does not hold
+up other channels; overdue channels precede the preferred foreground channel.
+Only requested passes run: a missing key never starts a polling loop. Timer
+throttling or an in-flight signer/storage call can extend actual elapsed time.
+
+`pendingDecryptionReady` defaults to `true` on messenger/session construction.
+Apps may pass `false` and call `setPendingDecryptionReady(true)` after their
+initial interface is presented; `false` holds only pending recovery, not live
+reception, publication or channel setup. The idle/deadline windows start after
+release. `setPendingDecryptionPriority(pubkey | null)` selects a channel on the
+messenger or a peer on the session; self-chat/`null` clear the session preference.
+The session retains a peer preference until preparation finishes and clears it
+on peer removal. Keep startup release and account lifecycle fencing in the app.
+
+`retryPendingDecryptions()` resolves after the requested scheduled pass (including
+an aggregated follow-up). `force: true` only overrides the MAC attempt ceiling;
+it does not bypass availability or admission. Requests before the first snapshot
+share that pass; requests during it aggregate into one following pass. Queue
+reads wait for initial release. Each packet is revalidated under the identity
+Web Lock when available; waits hold neither that lock nor the normal inbox/IDB
+queues. Fragment assembly survives scheduling boundaries. Pause/close cancel
+waits; channel removal fences its queued and in-flight results.
+
+Private-channel consumers may opt in
+with `onDecryptionFailure({ error, record })`, returning true only after durable
+handling, and replay records with `replayDeferredDecryptions`. Without the hook,
+standalone readers retain their existing error behavior.
+The optional `isDecryptionPending(record)` hook skips an already persisted
+packet before decryption; PrivateMessenger uses it for live/history/seeder
+duplicates so retransmission cannot bypass the MAC attempt budget.
+
+For standalone replay, pass `records: [{ id, channelPubkey, packet }]`, where
+`packet` is the ciphertext record received by the failure hook, together with
+the current receiver/channel signers and receiver pubkey. `onEvent` and
+`onNymEvent` admit normal deliveries; `onRecovered(record)` removes durable
+pending ciphertext only after admission, and `onFailure(record, error)` retains
+it and records the failed attempt. Both settlement callbacks are required.
+An optional AbortSignal fences processing; one batch shares a fragment processor.
+
+`rememberContentKeyEvent(event)` from `libp2r2p/content-key` validates and remembers
+a confirmed local announcement. Newest timestamp, then lowest ID, wins. Pending
+discovery queries cannot overwrite or return an older result; normal positive
+and negative cache windows remain unchanged.
+
 The main API is `createPrivateMessenger` from `libp2r2p/private-messenger`.
 It coordinates private-channel wrapping, relay watching, recovery state, and
 content-key lookup for direct or group-style private app messages.

package/content-key/index.js

@@ -1 +1 @@
-export { getIykcProofs } from './services/iykc-proof.js'
+export { getIykcProofs, rememberContentKeyEvent } from './services/iykc-proof.js'

package/content-key/services/iykc-proof.js

@@ -1,6 +1,7 @@
 import { parseContentKeyEvent } from '../event/index.js'
 import { CONTENT_KEY_ANNOUNCEMENT } from '../../kind/index.js'
 import { pickRelaysForPubkeys, getRelaysByPubkey, relayPool } from '../../relay/index.js'
+import { ValidationError } from '../../error/index.js'
 
 const QUERY_CACHE_MS = 40 * 60 * 1000
 const NEGATIVE_CACHE_MS = 5 * 60 * 1000
@@ -10,6 +11,7 @@ const contentKeysByPubkey = Object.create(null)
 const iykcCacheTimersByPubkey = Object.create(null)
 const iykcCacheAddedAtByPubkey = Object.create(null)
 const inFlightByPubkey = new Map()
+const announcementOrder = new Map()
 
 const getEvents = (...args) => relayPool.getEvents(...args)
 
@@ -37,6 +39,7 @@ function cloneContentKey (contentKey) {
 }
 
 function deleteCachedValue (cache, timers, addedAt, key) {
+  if (cache === contentKeysByPubkey) announcementOrder.delete(key)
   clearTimeout(timers[key])
   delete cache[key]
   delete timers[key]
@@ -72,6 +75,23 @@ export function clearContentKeyCache () {
   for (const key of Object.keys(iykcCacheTimersByPubkey)) delete iykcCacheTimersByPubkey[key]
   for (const key of Object.keys(iykcCacheAddedAtByPubkey)) delete iykcCacheAddedAtByPubkey[key]
   inFlightByPubkey.clear()
+  announcementOrder.clear()
+}
+
+// Remember only authenticated announcements, including those just published
+// locally. An older query may still finish, but cannot undo this selection.
+export function rememberContentKeyEvent (event) {
+  const proof = parseContentKeyEvent(event)
+  if (!proof) throw new ValidationError('INVALID_CONTENT_KEY_EVENT')
+  const previous = announcementOrder.get(event.pubkey)
+  if (previous && (previous.createdAt > event.created_at ||
+      (previous.createdAt === event.created_at && previous.id <= event.id))) return false
+  announcementOrder.set(event.pubkey, { createdAt: event.created_at, id: event.id })
+  setCachedValue(contentKeysByPubkey, iykcCacheTimersByPubkey, iykcCacheAddedAtByPubkey,
+    event.pubkey, cloneContentKey(proof), QUERY_CACHE_MS)
+  pruneCache(contentKeysByPubkey, iykcCacheTimersByPubkey, iykcCacheAddedAtByPubkey, IYKC_CACHE_MAX_ITEMS)
+  for (const key of announcementOrder.keys()) if (!hasCachedKey(contentKeysByPubkey, key)) announcementOrder.delete(key)
+  return true
 }
 
 async function queryContentKeyProofs (pubkeyList, { _getEvents, _getRelaysByPubkey, cacheMs, negativeCacheMs }) {
@@ -102,18 +122,28 @@ async function queryContentKeyProofs (pubkeyList, { _getEvents, _getRelaysByPubk
   for (const event of eventGroups.flat()) {
     const parsed = parseContentKeyEvent(event)
     if (!parsed) continue
-    if (!latestByPubkey[event.pubkey] || event.created_at > latestByPubkey[event.pubkey].created_at) {
-      latestByPubkey[event.pubkey] = { created_at: event.created_at, ...parsed }
+    const previous = latestByPubkey[event.pubkey]
+    if (!previous || event.created_at > previous.created_at ||
+        (event.created_at === previous.created_at && event.id < previous.id)) {
+      latestByPubkey[event.pubkey] = { created_at: event.created_at, id: event.id, ...parsed }
     }
   }
 
   const out = {}
   for (const pubkey of pubkeyList) {
     const entry = latestByPubkey[pubkey]
+    const selected = announcementOrder.get(pubkey)
+    if (selected && (!entry || selected.createdAt > entry.created_at ||
+        (selected.createdAt === entry.created_at && selected.id <= entry.id))) {
+      const cached = cloneContentKey(contentKeysByPubkey[pubkey])
+      if (cached) out[pubkey] = cached
+      continue
+    }
     const proof = entry
       ? { iykcPubkey: entry.iykcPubkey, iykcProof: entry.iykcProof }
       : null
     if (proof) {
+      announcementOrder.set(pubkey, { createdAt: entry.created_at, id: entry.id })
       setCachedValue(contentKeysByPubkey, iykcCacheTimersByPubkey, iykcCacheAddedAtByPubkey, pubkey, cloneContentKey(proof), cacheMs)
       out[pubkey] = proof
     } else if (negativeCacheMs > 0) {
@@ -123,6 +153,7 @@ async function queryContentKeyProofs (pubkeyList, { _getEvents, _getRelaysByPubk
     }
   }
   pruneCache(contentKeysByPubkey, iykcCacheTimersByPubkey, iykcCacheAddedAtByPubkey, IYKC_CACHE_MAX_ITEMS)
+  for (const key of announcementOrder.keys()) if (!hasCachedKey(contentKeysByPubkey, key)) announcementOrder.delete(key)
   return out
 }
 
@@ -169,5 +200,13 @@ export async function getIykcProofs (pubkeys, {
       if (cached) out[pubkey] = cached
     }
   }
+  // A batch may wait for another author after reading an already cached proof.
+  // Reconcile again before returning so a publication during that wait wins too.
+  for (const pubkey of pubkeyList) {
+    if (!hasCachedKey(contentKeysByPubkey, pubkey)) continue
+    const cached = cloneContentKey(contentKeysByPubkey[pubkey])
+    if (cached) out[pubkey] = cached
+    else delete out[pubkey]
+  }
   return out
 }

package/package.json

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

package/private-channel/helpers/decryption-error.js

@@ -0,0 +1,15 @@
+// Select only operationally useful public coordinates. Never attach a packet,
+// signer, plaintext, scope or message key to an error that can reach a logger.
+export function decryptionError (cause, context) {
+  const error = new Error(cause.message, { cause })
+  error.name = cause.name
+  const code = cause.code || (cause.message === 'CONTENT_KEY_NOT_FOUND' ? 'CONTENT_KEY_NOT_FOUND' : cause.message === 'invalid MAC' ? 'INVALID_MAC' : undefined)
+  if (code) error.code = code
+  for (const key of ['stage', 'channelPubkey', 'eventId', 'eventKind', 'senderPubkey', 'receiverPubkey', 'ownContentPubkey', 'peerContentPubkey', 'hasOwnContentKey']) {
+    const value = context?.[key] ?? cause[key]
+    if (['string', 'number', 'boolean'].includes(typeof value)) error[key] = value
+  }
+  return error
+}
+
+export const isDeferredDecryptionError = error => ['CONTENT_KEY_NOT_FOUND', 'INVALID_MAC'].includes(error?.code)

package/private-channel/index.js

@@ -5,6 +5,7 @@ import { hexToBytes } from '../base16/index.js'
 import { isValidContentKeyProof, isValidIykcProof, makeContentKeyEventForPubkey, parseContentKeyEvent } from '../content-key/event/index.js'
 import { getIykcProofs } from '../content-key/index.js'
 import { ValidationError } from '../error/index.js'
+import { decryptionError, isDeferredDecryptionError } from './helpers/decryption-error.js'
 import { normalizeRumor, deliveryInfo } from './helpers/rumor.js'
 import { incompleteFetchError } from './helpers/fetch-error.js'
 import { readHistory } from './helpers/history.js'
@@ -416,19 +417,27 @@ async function unwrapRecipientEnvelope ({ payloadCiphertext, envelope, receiverS
     // no iykc pubkey, so hand imkc to the signer as the receiver's own key.
     const ownContentPubkey = envelope.iykcPubkey ||
       (senderPubkey && receiverPubkey && senderPubkey === receiverPubkey ? imkcPubkey : '')
-    messageSeckey = base64ToText(await receiverSigner.nip44DecryptDoubleDH(
-      senderPubkey,
-      ROUTER_KIND,
-      rowScope,
-      envelope.ciphertext,
-      imkcPubkey,
-      ownContentPubkey
-    ))
+    try {
+      messageSeckey = base64ToText(await receiverSigner.nip44DecryptDoubleDH(
+        senderPubkey,
+        ROUTER_KIND,
+        rowScope,
+        envelope.ciphertext,
+        imkcPubkey,
+        ownContentPubkey
+      ))
+    } catch (cause) {
+      throw decryptionError(cause, { stage: 'recipient-envelope', channelPubkey: rowScope, senderPubkey, receiverPubkey, ownContentPubkey, peerContentPubkey: imkcPubkey })
+    }
   } else {
     if (!receiverSigner?.nip44v3Decrypt) throw new ValidationError('RECEIVER_SIGNER_NIP44V3_DECRYPT_UNSUPPORTED')
-    messageSeckey = base64ToText(await receiverSigner.nip44v3Decrypt(senderPubkey, ROUTER_KIND, rowScope, envelope.ciphertext))
+    try {
+      messageSeckey = base64ToText(await receiverSigner.nip44v3Decrypt(senderPubkey, ROUTER_KIND, rowScope, envelope.ciphertext))
+    } catch (cause) { throw decryptionError(cause, { stage: 'recipient-envelope', channelPubkey: rowScope, senderPubkey, receiverPubkey }) }
+  }
+  try { return eventFromPayload({ payloadCiphertext, messageSeckey, senderPubkey }) } catch (cause) {
+    throw decryptionError(cause, { stage: 'message-payload', channelPubkey: rowScope, senderPubkey, receiverPubkey })
   }
-  return eventFromPayload({ payloadCiphertext, messageSeckey, senderPubkey })
 }
 
 export async function unwrapEvent ({ receiverSigner, privateChannelSigner = receiverSigner, privateChannelReaderSigner = privateChannelSigner, privateChannelReaderPubkey, event, receiverPubkey }) {
@@ -708,6 +717,7 @@ function createProcessor ({
   onNymEvent,
   onSeedEvent,
   onContentKeyUsage,
+  onDecryptionFailure, isDecryptionPending, _onProcessing,
   onError,
   receivedChunkScope = '',
   receivedChunkTtlMs = DEFAULT_RECEIVED_CHUNK_TTL_MS,
@@ -731,8 +741,16 @@ function createProcessor ({
   storeReady.catch(() => {})
 
   async function processOuterEvent (outer) {
-    await storeReady
+    const release = _onProcessing?.(outer.pubkey)
+    try {
+      await storeReady
+      return await processReadyOuterEvent(outer)
+    } finally { release?.() }
+  }
+
+  async function processReadyOuterEvent (outer) {
     let groupKey = ''
+    let routerDecrypted = false
     try {
       const channelPubkey = outer.pubkey || await privateChannelSigner?.getPublicKey?.()
       const channelSigner = readSignerFromMap(privateChannelSignersByPubkey, channelPubkey) || privateChannelSigner
@@ -742,6 +760,7 @@ function createProcessor ({
       const channelReceivedChunkTtlMs = readValueFromMap(receivedChunkTtlMsByPubkey, channelPubkey) ?? receivedChunkTtlMs
       if (!channelPubkey) throw new ValidationError('PRIVATE_CHANNEL_PUBKEY_REQUIRED')
 
+      if (await isDecryptionPending?.({ format: 'outer_v1', channelPubkey, outer })) return
       const decrypted = await decryptRouter({
         content: outer.content,
         channelPubkey,
@@ -749,6 +768,7 @@ function createProcessor ({
         channelReaderSigner,
         channelReaderPubkey
       })
+      routerDecrypted = true
       if (decrypted.kind === NYM_CARRIER_KIND) {
         const carrier = assertValidNymCarrierEvent(decrypted)
         const { index, total } = readChunkTag(carrier)
@@ -834,6 +854,7 @@ function createProcessor ({
       // regular leechers can stop as soon as their envelope is decrypted.
       const mustScanWholeBundle = shouldSeed || sentByReceiver
       let event = null
+      let deferred = false
       const innerEventIdsByRowIndex = {}
 
       const drained = await receivedChunks.drainAvailable(groupKey, {
@@ -858,15 +879,36 @@ function createProcessor ({
               onContentKeyUsage
             })
             if (receiverSigner && !event) {
-              event = await unwrapRecipientEnvelope({
-                payloadCiphertext: groupMeta.payloadCiphertext,
-                envelope,
-                receiverSigner,
-                receiverPubkey,
-                senderPubkey,
-                imkcPubkey,
-                rowScope: channelPubkey
-              })
+              const record = () => {
+                const row = JSON.stringify([envelope.receiverPubkey, envelope.ciphertext, envelope.iykcPubkey, envelope.iykcProof])
+                return {
+                  format: 'routerRow_v1', channelPubkey,
+                  outer: { id: outer.id, kind: outer.kind, pubkey: outer.pubkey, created_at: outer.created_at },
+                  router: joinedRouter(router, bytesToBase64(encoder.encode(JSON.stringify([groupMeta.payloadCiphertext]) + '\n' + row + '\n')))
+                }
+              }
+              if (await isDecryptionPending?.(record())) {
+                deferred = true
+                if (!mustScanWholeBundle) return { stop: true }
+                return
+              }
+              try {
+                event = await unwrapRecipientEnvelope({
+                  payloadCiphertext: groupMeta.payloadCiphertext,
+                  envelope,
+                  receiverSigner,
+                  receiverPubkey,
+                  senderPubkey,
+                  imkcPubkey,
+                  rowScope: channelPubkey
+                })
+              } catch (cause) {
+                const error = decryptionError(cause, { eventId: outer.id, eventKind: outer.kind, channelPubkey })
+                if (!onDecryptionFailure || !isDeferredDecryptionError(error)) throw error
+                if (!await onDecryptionFailure({ error, record: record() })) throw error
+                deferred = true
+                if (!mustScanWholeBundle) return { stop: true }
+              }
               if (event) {
                 innerEventIdsByRowIndex[rowIndex] = event.id
                 if (!mustScanWholeBundle) return { stop: true }
@@ -876,8 +918,8 @@ function createProcessor ({
         }
       })
 
-      if (event && !mustScanWholeBundle) {
-        await onEvent?.(event, outer, { router: joinedRouter(router), channelPubkey, ...deliveryInfo(event, senderPubkey) })
+      if ((event || deferred) && !mustScanWholeBundle) {
+        if (event) await onEvent?.(event, outer, { router: joinedRouter(router), channelPubkey, ...deliveryInfo(event, senderPubkey) })
         ignoredGroups.add(groupKey)
         await receivedChunks.removeGroup(groupKey)
         return
@@ -902,7 +944,13 @@ function createProcessor ({
       if (event) await onEvent?.(event, outer, { router: completeRouter, channelPubkey, jsonl, ...deliveryInfo(event, senderPubkey) })
 
       await receivedChunks.removeGroup(groupKey)
-    } catch (err) {
+    } catch (cause) {
+      let err = cause
+      if (!routerDecrypted) {
+        err = decryptionError(err, { stage: 'outer-envelope', channelPubkey: outer.pubkey, eventId: outer.id, eventKind: outer.kind })
+        if (onDecryptionFailure && isDeferredDecryptionError(err) &&
+            await onDecryptionFailure({ error: err, record: { format: 'outer_v1', channelPubkey: outer.pubkey, outer } })) return
+      }
       if (shouldIgnoreGroupError(err) && groupKey) {
         ignoredGroups.add(groupKey)
         await receivedChunks.removeGroup(groupKey).catch(() => {})
@@ -939,7 +987,85 @@ function shouldIgnoreGroupError (err) {
   ].includes(err?.message)
 }
 
-export async function fetch ({ signal, receiverSigner, iykcSigner, privateChannelSigner = receiverSigner, privateChannelSignersByPubkey, privateChannelReaderSigner = privateChannelSigner, privateChannelReaderSignersByPubkey, privateChannelReaderPubkey, privateChannelReaderPubkeysByPubkey, privateChannelPubkey, privateChannelPubkeys, receiverPubkey, relays, onChunk, onEvent, onNymEvent, onSeedEvent, onContentKeyUsage, onError, since, until, limit, mode = 'leecher', modeByPubkey, receivedChunkScope = '', receivedChunkTtlMs = DEFAULT_RECEIVED_CHUNK_TTL_MS, receivedChunkTtlMsByPubkey, receivedChunkMaxBytes = DEFAULT_RECEIVED_CHUNK_MAX_BYTES, receivedChunkIndexedDB = globalThis.indexedDB, ignoredGroupTtlMs = DEFAULT_IGNORED_GROUP_TTL_MS, ignoredGroupMaxEntries = DEFAULT_IGNORED_GROUP_MAX_ENTRIES, _getEvents = getEvents }) {
+// Replay ciphertext only. Keep one fragment processor for the entire batch;
+// incomplete outer groups remain pending until a later key/channel transition.
+export async function replayDeferredDecryptions ({ records, onRecovered, onFailure, _runRecord = (_record, work) => work(), ...options }) {
+  if (!Array.isArray(records) || records.some(record => typeof record?.id !== 'string' ||
+      typeof record.channelPubkey !== 'string' || !['outer_v1', 'routerRow_v1'].includes(record.packet?.format))) throw new ValidationError('INVALID_DEFERRED_RECORDS')
+  if (typeof onRecovered !== 'function' || typeof onFailure !== 'function') throw new ValidationError('DEFERRED_CALLBACKS_REQUIRED')
+  const groups = new Map()
+  const completed = new Set()
+  let current
+  let chunked = false
+  const processor = createProcessor({
+    ...options, onDecryptionFailure: undefined, isDecryptionPending: undefined,
+    onError: error => { throw error },
+    onChunk: chunk => {
+      chunked = true
+      const key = chunk.router?.pubkey || nymCarrierGroupId(chunk.nymCarrier)
+      if (!groups.has(key)) groups.set(key, new Set())
+      groups.get(key).add(current.id)
+    },
+    onEvent: async (event, outer, meta) => {
+      options.signal?.throwIfAborted()
+      await options.onEvent?.(event, outer, meta)
+      completed.add(meta.router?.pubkey)
+    },
+    onNymEvent: async (event, outer, meta) => {
+      options.signal?.throwIfAborted()
+      await options.onNymEvent?.(event, outer, meta)
+      completed.add(nymCarrierGroupId(meta.carrier))
+    },
+    onSeedEvent: async seed => {
+      options.signal?.throwIfAborted()
+      await options.onSeedEvent?.(seed)
+      completed.add(seed.router?.pubkey || nymCarrierGroupId(seed.carrier))
+    }
+  })
+  try {
+    for (const record of records) {
+      await _runRecord(record, async () => {
+        options.signal?.throwIfAborted()
+        current = record
+        chunked = false
+        try {
+          if (record.packet.format === 'outer_v1') {
+            await processor(record.packet.outer)
+            if (!chunked) await onRecovered(record)
+          } else {
+            const event = await unwrapRouterEvent({
+              receiverSigner: options.receiverSigner, receiverPubkey: options.receiverPubkey,
+              channelPubkey: record.channelPubkey, router: record.packet.router
+            })
+            options.signal?.throwIfAborted()
+            if (event) {
+              await options.onEvent?.(event, record.packet.outer, {
+                router: record.packet.router, channelPubkey: record.channelPubkey,
+                ...deliveryInfo(event, readSenderTag(record.packet.router))
+              })
+            }
+            await onRecovered(record)
+          }
+        } catch (error) {
+          options.signal?.throwIfAborted()
+          await onFailure(record, decryptionError(error, { channelPubkey: record.channelPubkey, eventId: record.packet.outer?.id }))
+        }
+        for (const key of completed) {
+          for (const id of groups.get(key) || []) {
+            const recovered = records.find(record => record.id === id)
+            if (recovered) await onRecovered(recovered)
+          }
+          groups.delete(key)
+        }
+        completed.clear()
+      })
+      // Let live ingestion and foreground signer work run between records.
+      await new Promise(resolve => setTimeout(resolve, 0))
+    }
+  } finally { processor.close() }
+}
+
+export async function fetch ({ signal, receiverSigner, iykcSigner, privateChannelSigner = receiverSigner, privateChannelSignersByPubkey, privateChannelReaderSigner = privateChannelSigner, privateChannelReaderSignersByPubkey, privateChannelReaderPubkey, privateChannelReaderPubkeysByPubkey, privateChannelPubkey, privateChannelPubkeys, receiverPubkey, relays, onChunk, onEvent, onNymEvent, onSeedEvent, onContentKeyUsage, onDecryptionFailure, isDecryptionPending, _onProcessing, onError, since, until, limit, mode = 'leecher', modeByPubkey, receivedChunkScope = '', receivedChunkTtlMs = DEFAULT_RECEIVED_CHUNK_TTL_MS, receivedChunkTtlMsByPubkey, receivedChunkMaxBytes = DEFAULT_RECEIVED_CHUNK_MAX_BYTES, receivedChunkIndexedDB = globalThis.indexedDB, ignoredGroupTtlMs = DEFAULT_IGNORED_GROUP_TTL_MS, ignoredGroupMaxEntries = DEFAULT_IGNORED_GROUP_MAX_ENTRIES, _getEvents = getEvents }) {
   if (!relays?.length) throw new ValidationError('NO_RELAYS')
   const authors = privateChannelPubkeyList({ privateChannelPubkey, privateChannelPubkeys })
   const filter = { kinds: [PRIVATE_BROADCAST_KIND] }
@@ -958,7 +1084,7 @@ export async function fetch ({ signal, receiverSigner, iykcSigner, privateChanne
   const elapsedMs = Math.round(performance.now() - startedAt)
   const events = result.map(({ event }) => event)
   events.sort((a, b) => a.created_at - b.created_at)
-  const processOuterEvent = createProcessor({ receiverSigner, iykcSigner, privateChannelSigner, privateChannelSignersByPubkey, privateChannelReaderSigner, privateChannelReaderSignersByPubkey, privateChannelReaderPubkey, privateChannelReaderPubkeysByPubkey, receiverPubkey, mode, modeByPubkey, onChunk, onEvent, onNymEvent, onSeedEvent, onContentKeyUsage, onError, receivedChunkScope, receivedChunkTtlMs, receivedChunkTtlMsByPubkey, receivedChunkMaxBytes, receivedChunkIndexedDB, ignoredGroupTtlMs, ignoredGroupMaxEntries })
+  const processOuterEvent = createProcessor({ receiverSigner, iykcSigner, privateChannelSigner, privateChannelSignersByPubkey, privateChannelReaderSigner, privateChannelReaderSignersByPubkey, privateChannelReaderPubkey, privateChannelReaderPubkeysByPubkey, receiverPubkey, mode, modeByPubkey, onChunk, onEvent, onNymEvent, onSeedEvent, onContentKeyUsage, onDecryptionFailure, isDecryptionPending, _onProcessing, onError, receivedChunkScope, receivedChunkTtlMs, receivedChunkTtlMsByPubkey, receivedChunkMaxBytes, receivedChunkIndexedDB, ignoredGroupTtlMs, ignoredGroupMaxEntries })
   try {
     for (const event of events) {
       signal?.throwIfAborted()
@@ -988,7 +1114,7 @@ export async function fetchHistory ({ receiverSigner, privateChannelSigner = rec
   } finally { processOuterEvent.close() }
 }
 
-export function subscribe ({ receiverSigner, iykcSigner, privateChannelSigner = receiverSigner, privateChannelSignersByPubkey, privateChannelReaderSigner = privateChannelSigner, privateChannelReaderSignersByPubkey, privateChannelReaderPubkey, privateChannelReaderPubkeysByPubkey, privateChannelPubkey, privateChannelPubkeys, receiverPubkey, relays, onChunk, onEvent, onNymEvent, onSeedEvent, onContentKeyUsage, onError, since = nowSeconds() - 5, limit, liveOnly = false, mode = 'leecher', modeByPubkey, receivedChunkScope = '', receivedChunkTtlMs = DEFAULT_RECEIVED_CHUNK_TTL_MS, receivedChunkTtlMsByPubkey, receivedChunkMaxBytes = DEFAULT_RECEIVED_CHUNK_MAX_BYTES, receivedChunkIndexedDB = globalThis.indexedDB, ignoredGroupTtlMs = DEFAULT_IGNORED_GROUP_TTL_MS, ignoredGroupMaxEntries = DEFAULT_IGNORED_GROUP_MAX_ENTRIES, _liveEventsGenerator = getLiveEventsGenerator, _eventsFeedGenerator = getEventsFeedGenerator }) {
+export function subscribe ({ receiverSigner, iykcSigner, privateChannelSigner = receiverSigner, privateChannelSignersByPubkey, privateChannelReaderSigner = privateChannelSigner, privateChannelReaderSignersByPubkey, privateChannelReaderPubkey, privateChannelReaderPubkeysByPubkey, privateChannelPubkey, privateChannelPubkeys, receiverPubkey, relays, onChunk, onEvent, onNymEvent, onSeedEvent, onContentKeyUsage, onDecryptionFailure, isDecryptionPending, _onProcessing, onError, since = nowSeconds() - 5, limit, liveOnly = false, mode = 'leecher', modeByPubkey, receivedChunkScope = '', receivedChunkTtlMs = DEFAULT_RECEIVED_CHUNK_TTL_MS, receivedChunkTtlMsByPubkey, receivedChunkMaxBytes = DEFAULT_RECEIVED_CHUNK_MAX_BYTES, receivedChunkIndexedDB = globalThis.indexedDB, ignoredGroupTtlMs = DEFAULT_IGNORED_GROUP_TTL_MS, ignoredGroupMaxEntries = DEFAULT_IGNORED_GROUP_MAX_ENTRIES, _liveEventsGenerator = getLiveEventsGenerator, _eventsFeedGenerator = getEventsFeedGenerator }) {
   if (!relays?.length) throw new ValidationError('NO_RELAYS')
   if (receiverSigner && !receiverSigner?.nip44DecryptDoubleDH && !receiverSigner?.nip44v3Decrypt) throw new ValidationError('RECEIVER_SIGNER_NIP44V3_DECRYPT_UNSUPPORTED')
   if (!privateChannelReaderSigner && !privateChannelReaderSignersByPubkey && !privateChannelSigner && !privateChannelSignersByPubkey) throw new ValidationError('PRIVATE_CHANNEL_READER_REQUIRED')
@@ -997,7 +1123,7 @@ export function subscribe ({ receiverSigner, iykcSigner, privateChannelSigner =
   const filter = { kinds: [PRIVATE_BROADCAST_KIND], since }
   if (authors.length) filter.authors = authors
   if (limit != null) filter.limit = limit
-  const processOuterEvent = createProcessor({ receiverSigner, iykcSigner, privateChannelSigner, privateChannelSignersByPubkey, privateChannelReaderSigner, privateChannelReaderSignersByPubkey, privateChannelReaderPubkey, privateChannelReaderPubkeysByPubkey, receiverPubkey, mode, modeByPubkey, onChunk, onEvent, onNymEvent, onSeedEvent, onContentKeyUsage, onError, receivedChunkScope, receivedChunkTtlMs, receivedChunkTtlMsByPubkey, receivedChunkMaxBytes, receivedChunkIndexedDB, ignoredGroupTtlMs, ignoredGroupMaxEntries })
+  const processOuterEvent = createProcessor({ receiverSigner, iykcSigner, privateChannelSigner, privateChannelSignersByPubkey, privateChannelReaderSigner, privateChannelReaderSignersByPubkey, privateChannelReaderPubkey, privateChannelReaderPubkeysByPubkey, receiverPubkey, mode, modeByPubkey, onChunk, onEvent, onNymEvent, onSeedEvent, onContentKeyUsage, onDecryptionFailure, isDecryptionPending, _onProcessing, onError, receivedChunkScope, receivedChunkTtlMs, receivedChunkTtlMsByPubkey, receivedChunkMaxBytes, receivedChunkIndexedDB, ignoredGroupTtlMs, ignoredGroupMaxEntries })
   const controller = new AbortController()
   const events = liveOnly
     ? _liveEventsGenerator(filter, relays, {

package/private-message/index.js

@@ -477,6 +477,9 @@ export function createPrivateMessageSession ({ _setTimeout = setTimeout, _clearT
           return dispatchSeedEvent(seed)
         },
         onContentKeyUsage: dispatchContentKeyUsage,
+        _onProcessing: pubkey => watchCallbacks(pubkey)._onProcessing?.(pubkey),
+        isDecryptionPending: record => watchCallbacks(record.channelPubkey).isDecryptionPending?.(record),
+        onDecryptionFailure: failure => watchCallbacks(failure.record.channelPubkey).onDecryptionFailure?.(failure),
         onError: err => reportSubscriptionError(channels, err)
       })
 
@@ -522,6 +525,7 @@ export function createPrivateMessageSession ({ _setTimeout = setTimeout, _clearT
     onSeed,
     onChunk,
     onContentKeyUsage,
+    onDecryptionFailure, isDecryptionPending, _onProcessing,
     onSubscriptionState,
     onError,
     receivedChunkTtlMs,
@@ -542,7 +546,7 @@ export function createPrivateMessageSession ({ _setTimeout = setTimeout, _clearT
     const ownPubkey = receiverPubkey || await receiverSigner?.getPublicKey?.()
     if (identity !== undefined && identity !== ownPubkey) throw new ValidationError('PRIVATE_MESSAGE_IDENTITY_MISMATCH')
     identity = ownPubkey
-    const callbacks = { onAsk, onReply, onTell, onYell, onNym, onMessage, onSeed, onChunk, onContentKeyUsage, onSubscriptionState, onError }
+    const callbacks = { onAsk, onReply, onTell, onYell, onNym, onMessage, onSeed, onChunk, onContentKeyUsage, onDecryptionFailure, isDecryptionPending, _onProcessing, onSubscriptionState, onError }
 
     for (const channel of channelList) {
       if (watchRequests.get(channel) !== request) continue