libp2r2p 0.11.30 → 0.11.31

package/README.md

@@ -1278,3 +1278,9 @@ circuit: explicit bans/refusals open immediately, repeated transport failures
 open after three attempts, and a fully quarantined route reports
 `RELAY_CIRCUIT_OPEN` with `retryAt` before another envelope is prepared. Reads and
 receive routing are unaffected. See [session relay fallback](private-messenger/session/README.md#relay-fallback).
+
+The 0.11.31 pending-decryption retry groups records by
+`(receiverPubkey, ownContentPubkey)` for one pass. A FIFO probe may skip the
+remaining records only when the local signer confirms `CONTENT_KEY_NOT_FOUND`
+with `hasOwnContentKey: false`. MAC, proof, parsing and operational failures are
+never generalized to the group, and every deferred record remains persisted.

package/package.json

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

package/private-messenger/index.js

@@ -57,7 +57,7 @@ import { assertMessagePublished, publicationFailureDiagnostic, sanitizePublicati
 import { normalizeRelayUrl } from '../url/index.js'
 import { deliveryInfo } from '../private-channel/helpers/rumor.js'
 import { migrateMessageQueue } from './services/migrate-message-queue.js'
-import { createPendingDecryption } from './services/pending-decryption.js'
+import { createPendingDecryption, pendingContentKeyGroup, pendingMissingContentKeyGroup } from './services/pending-decryption.js'
 import { createDecryptionScheduler } from './services/decryption-scheduler.js'
 import { decryptionError, isDeferredDecryptionError } from '../private-channel/helpers/decryption-error.js'
 import { bytesToBase64 } from '../base64/index.js'
@@ -3259,12 +3259,7 @@ export class PrivateMessenger {
         job.started = true
         const force = job.force
         job.force = false
-        const groups = new Map()
-        for (const record of await this.pendingDecryption.records({ force })) {
-          if (!groups.has(record.channelPubkey)) groups.set(record.channelPubkey, [])
-          groups.get(record.channelPubkey).push(record)
-        }
-        const results = await Promise.allSettled([...groups].map(async ([channelPubkey, records]) => {
+        const replay = async (channelPubkey, records, callbacks = {}) => {
           const channel = this.channels.get(channelPubkey)
           if (!channel || !this.desiredChannels.has(channelPubkey)) return
           const current = () => {
@@ -3302,15 +3297,78 @@ export class PrivateMessenger {
                 return this.receive(channelPubkey, () => this.enqueueRumor('nym', channelPubkey, { event, outer, meta, payload: parseEventContent(event) }), { event, outer }, { trackActivity: false })
               },
               onSeedEvent: seed => { current(); return this.receive(channelPubkey, () => this.enqueueSeed(channelPubkey, seed), seed, { trackActivity: false }) },
-              onRecovered: record => { current(); return this.pendingDecryption.recovered(record) },
-              onFailure: (record, error) => { current(); return this.pendingDecryption.failed(record, error) }
+              onRecovered: async record => {
+                current()
+                await callbacks.onRecovered?.(record)
+                return this.pendingDecryption.recovered(record)
+              },
+              onFailure: async (record, error) => {
+                current()
+                if (await callbacks.onFailure?.(record, error) === false) return
+                return this.pendingDecryption.failed(record, error)
+              }
             })
           } catch (error) {
             if (this.channels.get(channelPubkey) === channel && this.desiredChannels.has(channelPubkey)) throw error
           } finally { this.decryptionScheduler.finish(channelPubkey) }
-        }))
+        }
+
+        const records = await this.pendingDecryption.records({ force })
+        const probes = new Map()
+        for (const record of records) {
+          const channelPubkey = record.channelPubkey
+          if (!this.channels.has(channelPubkey) || !this.desiredChannels.has(channelPubkey)) continue
+          const missingGroup = pendingMissingContentKeyGroup(record)
+          if (missingGroup && !probes.has(missingGroup)) probes.set(missingGroup, record)
+        }
+
+        const unavailableGroups = new Set()
+        const probed = new Set()
+        let probeError
+        for (const [groupKey, candidate] of probes) {
+          signal.throwIfAborted()
+          const current = await this.pendingDecryption.current(candidate, { force })
+          if (!current || pendingMissingContentKeyGroup(current) !== groupKey) continue
+          probed.add(current.id)
+          let missing = false
+          await replay(current.channelPubkey, [current], {
+            onFailure: async (_record, error) => {
+              const failedGroup = pendingMissingContentKeyGroup({
+                code: error.code,
+                receiverPubkey: error.receiverPubkey,
+                ownContentPubkey: error.ownContentPubkey,
+                hasOwnContentKey: error.hasOwnContentKey
+              })
+              if (failedGroup === groupKey) missing = true
+              if (isDeferredDecryptionError(error)) {
+                await this.pendingDecryption.failed(current, error)
+                return false
+              }
+              probeError ||= error
+              return false
+            }
+          })
+          if (missing) unavailableGroups.add(groupKey)
+        }
+
+        const remaining = []
+        for (const record of records) {
+          if (!this.channels.has(record.channelPubkey) || !this.desiredChannels.has(record.channelPubkey)) continue
+          if (probed.has(record.id)) continue
+          const groupKey = pendingContentKeyGroup(record)
+          if (groupKey && unavailableGroups.has(groupKey)) continue
+          remaining.push(record)
+        }
+        const groups = new Map()
+        for (const record of remaining) {
+          if (!groups.has(record.channelPubkey)) groups.set(record.channelPubkey, [])
+          groups.get(record.channelPubkey).push(record)
+        }
+        const results = await Promise.allSettled([...groups].map(([channelPubkey, channelRecords]) =>
+          replay(channelPubkey, channelRecords)))
         const failed = results.find(result => result.status === 'rejected')
         if (failed) throw failed.reason
+        if (probeError) throw probeError
         job.started = false
       } while (job.again)
     }

package/private-messenger/services/pending-decryption.js

@@ -6,6 +6,8 @@ import { isDeferredDecryptionError } from '../../private-channel/helpers/decrypt
 
 const encoder = new TextEncoder()
 const decoder = new TextDecoder()
+const HEX64 = /^[0-9a-f]{64}$/i
+const CONTENT_KEY_FIELDS = ['receiverPubkey', 'ownContentPubkey', 'peerContentPubkey']
 export const PENDING_DECRYPTION_MAX_BYTES = 16 * 1024 * 1024
 
 function storedBytes (item) {
@@ -30,6 +32,34 @@ function packetSnapshot (packet) {
   return { format: packet.format, channelPubkey: packet.channelPubkey, outer: event(packet.outer), ...(packet.router ? { router: event(packet.router, true) } : {}) }
 }
 
+function errorMetadata (error) {
+  const metadata = {}
+  for (const key of CONTENT_KEY_FIELDS) {
+    const value = error?.[key]
+    if (typeof value === 'string' && HEX64.test(value)) metadata[key] = value.toLowerCase()
+  }
+  if (typeof error?.hasOwnContentKey === 'boolean') metadata.hasOwnContentKey = error.hasOwnContentKey
+  return metadata
+}
+
+function replaceErrorMetadata (item, error) {
+  const next = { ...item, code: error?.code }
+  for (const key of [...CONTENT_KEY_FIELDS, 'hasOwnContentKey']) delete next[key]
+  return Object.assign(next, errorMetadata(error))
+}
+
+export function pendingContentKeyGroup (item) {
+  const receiver = item?.receiverPubkey
+  const own = item?.ownContentPubkey
+  if (typeof receiver !== 'string' || typeof own !== 'string' || !HEX64.test(receiver) || !HEX64.test(own)) return ''
+  return `${receiver.toLowerCase()}:${own.toLowerCase()}`
+}
+
+export function pendingMissingContentKeyGroup (item) {
+  if (item?.code !== 'CONTENT_KEY_NOT_FOUND' || item?.hasOwnContentKey !== false) return ''
+  return pendingContentKeyGroup(item)
+}
+
 // Stable across live, history and synthesized recovery wrappers.
 function packetId (record) {
   const rows = record.format === 'routerRow_v1'
@@ -72,8 +102,19 @@ export async function createPendingDecryption ({ prefix, indexedDB, maxBytes = P
       record = packetSnapshot(record)
       return serial(async () => {
         const id = packetId(record)
-        if (await queue.someBy('byId', id)) return true
-        const item = { id, channelPubkey: record.channelPubkey, packet: structuredClone(record), code: error.code, macAttempts: error.code === 'INVALID_MAC' ? 1 : 0 }
+        const previous = await queue.getBy('byId', id)
+        if (previous) {
+          const updated = replaceErrorMetadata(previous, error)
+          if (JSON.stringify(updated) !== JSON.stringify(previous)) await queue.putBy('byId', updated, { existingOnly: true })
+          return true
+        }
+        const item = {
+          id,
+          channelPubkey: record.channelPubkey,
+          packet: structuredClone(record),
+          macAttempts: error.code === 'INVALID_MAC' ? 1 : 0,
+          ...replaceErrorMetadata({}, error)
+        }
         const requiredBytes = storedBytes(item)
         if (requiredBytes > maxBytes) {
           notify('discarded', { reason: 'oversized', channelPubkey: item.channelPubkey, id }); return true
@@ -115,7 +156,10 @@ export async function createPendingDecryption ({ prefix, indexedDB, maxBytes = P
         if (!isDeferredDecryptionError(error)) throw error
         const current = await queue.getBy('byId', item.id)
         if (!current) return
-        const updated = { ...current, code: error.code, macAttempts: current.macAttempts + (error.code === 'INVALID_MAC' ? 1 : 0) }
+        const updated = {
+          ...replaceErrorMetadata(current, error),
+          macAttempts: current.macAttempts + (error.code === 'INVALID_MAC' ? 1 : 0)
+        }
         await queue.putBy('byId', updated, { existingOnly: true })
         if (updated.macAttempts >= 3 && item.macAttempts < 3) notify('suspended', { id: item.id, code: error.code, channelPubkey: item.channelPubkey })
       })

package/private-messenger/session/README.md

@@ -9,6 +9,13 @@ the account messenger while available. Call after committed content-key changes;
 ordinary availability recovery already requests a pass. Ciphertext stays in the
 separate bounded FIFO until admitted to the normal inbox, evicted or explicitly
 cleared. This does not retry application storage/permission failures as crypto.
+Within one pass, records whose last failure proved the same
+`(receiverPubkey, ownContentPubkey)` is missing share one FIFO probe across all
+channels. An unchanged `CONTENT_KEY_NOT_FOUND` skips only that group's remaining
+records for the pass; none are removed or suspended. If the probe advances past
+the key lookup, including with `INVALID_MAC`, or fails with another error, all
+other records in the group are still attempted. Missing-key suppression never
+survives into another pass.
 
 Construction accepts `pendingDecryptionReady` (default `true`). Pass `false` to
 hold pending queue reads/replay until `setPendingDecryptionReady(true)` releases