libp2r2p 0.11.30 → 0.11.32

package/README.md

@@ -1278,3 +1278,15 @@ 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.
+
+The 0.11.32 local recovery-seed queue serializes incoming and outgoing writes
+within one PrivateMessenger. Duplicate `bySeedKey` races retry up to five times:
+NYM rows remain idempotent and router rows re-read the winning timestamps before
+replacement. External event-store seed adapters retain their independent batched
+writes.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libp2r2p",
-  "version": "0.11.30",
+  "version": "0.11.32",
   "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'
@@ -108,6 +108,7 @@ export {
 const DEFAULT_OFFLINE_RECOVERY_SECONDS = 7 * 24 * 60 * 60
 const MAX_OFFLINE_RECOVERY_SECONDS = Math.floor(Number.MAX_SAFE_INTEGER / 1000)
 const RECOVERY_STORAGE_BATCH_SIZE = 100
+const SEED_QUEUE_UPSERT_ATTEMPTS = 5
 const STORAGE_POLICY_BROADCAST_CHANNEL = 'libp2r2p:private-messenger:storage-policy'
 const DEFAULT_OFFLINE_SKEW_SECONDS = 30
 const DEFAULT_RELOAD_GAP_DELAY_MS = 500
@@ -374,6 +375,7 @@ export class PrivateMessenger {
     this.watchRevisionByChannel = new Map()
     this.presenceTimers = new Map()
     this.presenceJobs = new Map()
+    this.seedQueueOperationTail = Promise.resolve()
     this.stopRelayListWatcher = null
     this.relayListWatcherPubkey = ''
     this.relayListRefreshPromise = null
@@ -686,6 +688,13 @@ export class PrivateMessenger {
     return this.runQueueOperation(operation)
   }
 
+  runSeedQueueOperation (operation) {
+    if (this.closePromise) return Promise.reject(new Error('PRIVATE_MESSENGER_CLOSED'))
+    const run = this.seedQueueOperationTail.then(operation)
+    this.seedQueueOperationTail = run.catch(() => {})
+    return run
+  }
+
   debug (action, detail = {}) {
     try {
       this.onDebug?.({ source: 'private-messenger', action, ...detail })
@@ -2140,8 +2149,8 @@ export class PrivateMessenger {
 
   async enqueueSeed (channelPubkey, seed) {
     if (!this.offlineRecoverySecondsFor(channelPubkey)) return
-    const receivedAt = nowSeconds()
     if (this.seedStorage) {
+      const receivedAt = nowSeconds()
       const rows = seed.recordType === NYM_CARRIER_SEED_RECORD_TYPE || seed.carriers?.length
         ? [{ recordType: NYM_CARRIER_SEED_RECORD_TYPE, carriers: compactSeedNymCarriers(seed.carriers) }]
         : compactSeedRouterRows(seed)
@@ -2155,22 +2164,37 @@ export class PrivateMessenger {
       }
       return
     }
+    return this.runSeedQueueOperation(() => this.enqueueQueueSeed(channelPubkey, seed))
+  }
+
+  async enqueueQueueSeed (channelPubkey, seed) {
+    this.assertOpen()
+    if (!this.channels.has(channelPubkey) || !this.offlineRecoverySecondsFor(channelPubkey)) return
+    const receivedAt = nowSeconds()
     if (seed.recordType === NYM_CARRIER_SEED_RECORD_TYPE || seed.carriers?.length) {
       const carriers = compactSeedNymCarriers(seed.carriers)
       const recordTime = nymCarrierRecordTime({ carriers }) || seed.outer?.created_at || receivedAt
       const key = nymCarrierSeedKey({ channelPubkey, carriers })
       const seedKey = key ? `nym:${key}` : ''
-      if (seedKey && await this.seedQueue.someBy('bySeedKey', seedKey)) return
-      await this.seedQueue.enqueue({
-        type: 'seed',
-        recordType: NYM_CARRIER_SEED_RECORD_TYPE,
-        channelPubkey,
-        receivedAt,
-        carriers,
-        meta: { channelPubkey: seed.channelPubkey },
-        [SEED_KEY]: seedKey || undefined,
-        [SEED_TIME]: recordTime
-      })
+      for (let attempt = 0; attempt < SEED_QUEUE_UPSERT_ATTEMPTS; attempt++) {
+        if (seedKey && await this.seedQueue.someBy('bySeedKey', seedKey)) break
+        try {
+          await this.seedQueue.enqueue({
+            type: 'seed',
+            recordType: NYM_CARRIER_SEED_RECORD_TYPE,
+            channelPubkey,
+            receivedAt,
+            carriers,
+            meta: { channelPubkey: seed.channelPubkey },
+            [SEED_KEY]: seedKey || undefined,
+            [SEED_TIME]: recordTime
+          })
+          break
+        } catch (error) {
+          if (error?.name !== 'ConstraintError') throw error
+          if (attempt === SEED_QUEUE_UPSERT_ATTEMPTS - 1) throw error
+        }
+      }
       await this.pruneStoredSeeds(channelPubkey)
       return
     }
@@ -2180,21 +2204,29 @@ export class PrivateMessenger {
       const rowTime = row.lastSeenAt || row.router?.created_at || receivedAt
       const rowKey = routerSeedRowKey({ ...row, channelPubkey })
       const seedKey = `router:${rowKey}`
-      const [previous] = await this.seedQueue.removeBy('bySeedKey', seedKey)
-      const firstSeenAt = Math.min(previous?.firstSeenAt ?? rowTime, row.firstSeenAt ?? rowTime)
-      const lastSeenAt = Math.max(previous?.lastSeenAt ?? rowTime, row.lastSeenAt ?? rowTime)
-      await this.seedQueue.enqueue({
-        ...row,
-        type: 'seed',
-        recordType: ROUTER_SEED_RECORD_TYPE,
-        channelPubkey,
-        receivedAt,
-        firstSeenAt,
-        lastSeenAt,
-        meta: { channelPubkey: seed.channelPubkey },
-        [SEED_KEY]: seedKey,
-        [SEED_TIME]: lastSeenAt || rowTime
-      })
+      for (let attempt = 0; attempt < SEED_QUEUE_UPSERT_ATTEMPTS; attempt++) {
+        const [previous] = await this.seedQueue.removeBy('bySeedKey', seedKey)
+        const firstSeenAt = Math.min(previous?.firstSeenAt ?? rowTime, row.firstSeenAt ?? rowTime)
+        const lastSeenAt = Math.max(previous?.lastSeenAt ?? rowTime, row.lastSeenAt ?? rowTime)
+        try {
+          await this.seedQueue.enqueue({
+            ...row,
+            type: 'seed',
+            recordType: ROUTER_SEED_RECORD_TYPE,
+            channelPubkey,
+            receivedAt,
+            firstSeenAt,
+            lastSeenAt,
+            meta: { channelPubkey: seed.channelPubkey },
+            [SEED_KEY]: seedKey,
+            [SEED_TIME]: lastSeenAt || rowTime
+          })
+          break
+        } catch (error) {
+          if (error?.name !== 'ConstraintError') throw error
+          if (attempt === SEED_QUEUE_UPSERT_ATTEMPTS - 1) throw error
+        }
+      }
     }
     await this.pruneStoredSeeds(channelPubkey)
   }
@@ -3259,12 +3291,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 +3329,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