libp2r2p 0.7.0 → 0.9.0

package/private-messenger/recovery/index.js

@@ -1,5 +1,6 @@
-import { getEventHash } from 'nostr-tools'
+import { getEventHash } from '../../event/index.js'
 import { bytesToBase64, base64ToBytes } from '../../base64/index.js'
+import { ValidationError } from '../../error/index.js'
 import { ASK_KIND, parseRumorContent } from '../../private-message/index.js'
 
 export const SEEDER_PRESENCE_CODE = 'seederPresence_8mj8'
@@ -37,7 +38,7 @@ function encodeJsonlRows (...rows) {
   return bytesToBase64(encoder.encode(rows.map(row => String(row).endsWith('\n') ? row : `${row}\n`).join('')))
 }
 
-function eventInRange (event, since, until) {
+function isEventInRange (event, since, until) {
   if (!Number.isFinite(event?.created_at)) return true
   if (since != null && event.created_at < since) return false
   if (until != null && event.created_at > until) return false
@@ -159,17 +160,17 @@ function routerWithSingleRow (router, payloadRow, row) {
   }
 }
 
-function seedRowInRange (seed, since, until) {
+function isSeedRowInRange (seed, since, until) {
   const firstSeenAt = seed.firstSeenAt ?? seed.router?.created_at
   const lastSeenAt = seed.lastSeenAt ?? seed.router?.created_at
-  if (!Number.isFinite(firstSeenAt) || !Number.isFinite(lastSeenAt)) return eventInRange(seed.router, since, until)
+  if (!Number.isFinite(firstSeenAt) || !Number.isFinite(lastSeenAt)) return isEventInRange(seed.router, since, until)
   if (since != null && lastSeenAt < since) return false
   if (until != null && firstSeenAt > until) return false
   return true
 }
 
 function compactRoutersFromSeed (seed, { receiverPubkey, since, until }) {
-  if (!seed?.payloadRow || !seed?.row || !seed?.router || !seedRowInRange(seed, since, until)) return []
+  if (!seed?.payloadRow || !seed?.row || !seed?.router || !isSeedRowInRange(seed, since, until)) return []
   if (receiverPubkey && seed.receiverPubkey !== receiverPubkey) return []
   return [{
     recordType: ROUTER_SEED_RECORD_TYPE,
@@ -185,7 +186,7 @@ function compactNymCarriersFromSeed (seed, { since, until }) {
   // eslint-disable-next-line camelcase
   const created_at = nymCarrierRecordTime(seed)
   // eslint-disable-next-line camelcase
-  if (!seed?.carriers?.length || !eventInRange({ created_at }, since, until)) return []
+  if (!seed?.carriers?.length || !isEventInRange({ created_at }, since, until)) return []
   return [{
     recordType: NYM_CARRIER_SEED_RECORD_TYPE,
     carriers: compactSeedNymCarriers(seed.carriers)
@@ -226,10 +227,10 @@ export function createEventReplyPacker ({
   recordsFromInput = eventRecordFromInput,
   sendEmptyReply = false
 }) {
-  if (!messenger?.reply) throw new Error('MESSENGER_REQUIRED')
-  if (!question?.id) throw new Error('QUESTION_REQUIRED')
-  if (!receiverPubkey) throw new Error('RECEIVER_PUBKEY_REQUIRED')
-  if (!Number.isSafeInteger(eventsPerChunk) || eventsPerChunk < 1) throw new Error('INVALID_EVENTS_PER_CHUNK')
+  if (!messenger?.reply) throw new ValidationError('MESSENGER_REQUIRED')
+  if (!question?.id) throw new ValidationError('QUESTION_REQUIRED')
+  if (!receiverPubkey) throw new ValidationError('RECEIVER_PUBKEY_REQUIRED')
+  if (!Number.isSafeInteger(eventsPerChunk) || eventsPerChunk < 1) throw new ValidationError('INVALID_EVENTS_PER_CHUNK')
 
   let chunk = ''
   let chunkEvents = 0
@@ -298,10 +299,10 @@ export function createMissingMessageReplyPacker ({
   eventsPerChunk = DEFAULT_EVENTS_PER_CHUNK,
   sendEmptyReply = false
 }) {
-  if (!messenger?.reply) throw new Error('MESSENGER_REQUIRED')
-  if (!question?.id) throw new Error('QUESTION_REQUIRED')
-  if (!receiverPubkey) throw new Error('RECEIVER_PUBKEY_REQUIRED')
-  if (!Number.isSafeInteger(eventsPerChunk) || eventsPerChunk < 1) throw new Error('INVALID_EVENTS_PER_CHUNK')
+  if (!messenger?.reply) throw new ValidationError('MESSENGER_REQUIRED')
+  if (!question?.id) throw new ValidationError('QUESTION_REQUIRED')
+  if (!receiverPubkey) throw new ValidationError('RECEIVER_PUBKEY_REQUIRED')
+  if (!Number.isSafeInteger(eventsPerChunk) || eventsPerChunk < 1) throw new ValidationError('INVALID_EVENTS_PER_CHUNK')
 
   const range = backfillRequestRange(question, since, until)
   return createEventReplyPacker({

package/private-messenger/services/channel-state.js

@@ -1,4 +1,5 @@
 import { run } from '../../idb/index.js'
+import { ValidationError } from '../../error/index.js'
 
 const DATABASE_VERSION = 1
 const CHANNELS_STORE = 'channels'
@@ -11,12 +12,14 @@ database `${prefix}:state:idb`, version 1
 channels, keyPath "pubkey"
   pubkey  watched channel public key
   value   evolving channel-recovery state, including last-seen/watched times,
-          mode, relays, seeders, effective offline-recovery retention, offline
+          mode, relays, seeders, requested offline-recovery retention, offline
           ranges, active offline-range start,
           per-seeder activity, and sent/received content-key usage
 
-The complete channels snapshot is replaced atomically on each persisted state
-change; value remains an extensible internal object rather than a public schema.
+Changed channel records are upserted individually and explicit removals are
+applied in the same transaction. This prevents one active instance from
+clearing state owned by another instance of the same principal identity.
+`value` remains an extensible internal object rather than a public schema.
 */
 
 function deferred () {
@@ -78,7 +81,7 @@ function cloneChannels (channels) {
 }
 
 export async function createChannelStateStore ({ prefix, indexedDB = globalThis.indexedDB } = {}) {
-  if (!prefix) throw new Error('PRIVATE_MESSENGER_STATE_PREFIX_REQUIRED')
+  if (!prefix) throw new ValidationError('PRIVATE_MESSENGER_STATE_PREFIX_REQUIRED')
   const db = await openDatabase(indexedDB, `${prefix}:state:idb`)
   let closed = false
   let activeTransactions = 0
@@ -108,16 +111,34 @@ export async function createChannelStateStore ({ prefix, indexedDB = globalThis.
     })
   }
 
-  async function replace (channels) {
+  async function update (channels, removedPubkeys = []) {
     const snapshot = cloneChannels(channels)
+    const removals = [...new Set(removedPubkeys || [])]
     await runTransaction('readwrite', async tx => {
-      await run('clear', [], CHANNELS_STORE, null, { tx })
+      for (const pubkey of removals) await run('delete', [pubkey], CHANNELS_STORE, null, { tx })
       for (const [pubkey, value] of Object.entries(snapshot)) {
         await run('put', [{ pubkey, value }], CHANNELS_STORE, null, { tx })
       }
     })
   }
 
+  async function touch (pubkeys, lastWatchedAt) {
+    const uniquePubkeys = [...new Set(pubkeys || [])]
+    if (!uniquePubkeys.length) return
+    await runTransaction('readwrite', async tx => {
+      for (const pubkey of uniquePubkeys) {
+        const current = (await run('get', [pubkey], CHANNELS_STORE, null, { tx })).result
+        await run('put', [{
+          pubkey,
+          value: {
+            ...(current?.value && typeof current.value === 'object' ? current.value : {}),
+            lastWatchedAt
+          }
+        }], CHANNELS_STORE, null, { tx })
+      }
+    })
+  }
+
   function close () {
     if (closePromise) return closePromise
     closed = true
@@ -128,5 +149,5 @@ export async function createChannelStateStore ({ prefix, indexedDB = globalThis.
     return closePromise
   }
 
-  return { load, replace, close }
+  return { load, update, touch, close }
 }

package/private-messenger/services/storage-maintenance.js

@@ -1,14 +1,16 @@
 import { run } from '../../idb/index.js'
 import { cleanupReceivedChunkStorage } from '../../private-channel/services/received-chunks.js'
 import { cleanupTemporaryStorage } from '../../temporary-storage/index.js'
+import { DEFAULT_STALE_CHANNEL_SECONDS } from '../constants/index.js'
 
 const REGISTRY_DATABASE = 'libp2r2p:private-messenger:registry:idb'
 const REGISTRY_VERSION = 1
-const BUNDLES_STORE = 'bundles'
+const STORAGE_SETS_STORE = 'storageSets'
 const LEASES_STORE = 'leases'
 const LOCK_NAME = 'libp2r2p:private-messenger:storage-maintenance'
 const LEASE_MS = 2 * 60 * 60 * 1000 // 2 hours
-const RETENTION_MS = 60 * 24 * 60 * 60 * 1000 // 60 days
+const DEFAULT_IDENTITY_STORAGE_RETENTION_SECONDS = 60 * 24 * 60 * 60
+const MAX_RETENTION_SECONDS = Math.floor(Number.MAX_SAFE_INTEGER / 1000)
 const MAX_RETRY_MS = 5 * 60 * 1000
 
 const localLocks = new WeakMap()
@@ -19,19 +21,23 @@ IndexedDB schema, shared by every PrivateMessenger instance on this origin:
 
 database "libp2r2p:private-messenger:registry:idb", version 1
 
-bundles, keyPath "userPubkey"
+storageSets, keyPath "userPubkey"
   userPubkey    primary signer public key and storage-set coordinate
   lastUsedAt    most recent durable activity in milliseconds
   leaseUntil    active-instance lease expiry in milliseconds
   status        "ready" or "delete_pending"
   attempts      consecutive failed storage-set deletions
   nextAttemptAt earliest retry time in milliseconds
+  staleChannelSeconds channel-state retention requested by the last configuring instance
+  identityStorageRetentionSeconds identity database-set retention after its last activity
+  policyRevision monotonically increasing storage-policy revision
 
 leases, keyPath "key"
   key         `${userPubkey}:${leaseId}`
   userPubkey  principal signer public key
   leaseId     per-PrivateMessenger instance identifier
   leaseUntil  instance lease expiry in milliseconds
+  activeChannelPubkeys channels currently administered by that instance
 
 leases indexes
   byUserPubkey  userPubkey
@@ -53,8 +59,8 @@ function openRegistry (indexedDB) {
     request.onblocked = () => reject(new Error('IDB_DATABASE_BLOCKED'))
     request.onupgradeneeded = () => {
       const db = request.result
-      if (!db.objectStoreNames.contains(BUNDLES_STORE)) {
-        db.createObjectStore(BUNDLES_STORE, { keyPath: 'userPubkey' })
+      if (!db.objectStoreNames.contains(STORAGE_SETS_STORE)) {
+        db.createObjectStore(STORAGE_SETS_STORE, { keyPath: 'userPubkey' })
       }
       if (!db.objectStoreNames.contains(LEASES_STORE)) {
         const leases = db.createObjectStore(LEASES_STORE, { keyPath: 'key' })
@@ -72,7 +78,7 @@ function openRegistry (indexedDB) {
 async function withRegistryTransaction (indexedDB, mode, work) {
   const db = await openRegistry(indexedDB)
   try {
-    const tx = db.transaction([BUNDLES_STORE, LEASES_STORE], mode)
+    const tx = db.transaction([STORAGE_SETS_STORE, LEASES_STORE], mode)
     const done = transactionDone(tx)
     try {
       const result = await work(tx)
@@ -100,9 +106,20 @@ async function readLeases (tx, userPubkey) {
   return records.filter(record => record?.userPubkey === userPubkey)
 }
 
-async function refreshLeaseUntil (tx, bundle, now, { removeExpired = false } = {}) {
-  const leases = await readLeases(tx, bundle.userPubkey)
+function normalizeRetentionSeconds (value, fallback) {
+  return Number.isSafeInteger(value) && value >= 0 && value <= MAX_RETENTION_SECONDS
+    ? value
+    : fallback
+}
+
+function normalizeActiveChannelPubkeys (values) {
+  return [...new Set((values || []).filter(value => typeof value === 'string' && value))].sort()
+}
+
+async function refreshLeaseState (tx, storageSet, now, { removeExpired = false } = {}) {
+  const leases = await readLeases(tx, storageSet.userPubkey)
   let leaseUntil = 0
+  const activeChannelPubkeys = new Set()
   for (const lease of leases) {
     const expiresAt = Math.max(0, Number(lease.leaseUntil) || 0)
     if (expiresAt <= now) {
@@ -110,12 +127,18 @@ async function refreshLeaseUntil (tx, bundle, now, { removeExpired = false } = {
       continue
     }
     leaseUntil = Math.max(leaseUntil, expiresAt)
+    for (const pubkey of normalizeActiveChannelPubkeys(lease.activeChannelPubkeys)) {
+      activeChannelPubkeys.add(pubkey)
+    }
+  }
+  storageSet.leaseUntil = leaseUntil
+  return {
+    leaseUntil,
+    activeChannelPubkeys: [...activeChannelPubkeys].sort()
   }
-  bundle.leaseUntil = leaseUntil
-  return leaseUntil
 }
 
-function normalizeBundle (record) {
+function normalizeStorageSet (record) {
   if (!record?.userPubkey) return null
   return {
     userPubkey: String(record.userPubkey),
@@ -123,7 +146,24 @@ function normalizeBundle (record) {
     leaseUntil: Math.max(0, Number(record.leaseUntil) || 0),
     status: record.status === 'delete_pending' ? 'delete_pending' : 'ready',
     attempts: Math.max(0, Math.floor(Number(record.attempts) || 0)),
-    nextAttemptAt: Math.max(0, Number(record.nextAttemptAt) || 0)
+    nextAttemptAt: Math.max(0, Number(record.nextAttemptAt) || 0),
+    staleChannelSeconds: normalizeRetentionSeconds(
+      record.staleChannelSeconds,
+      DEFAULT_STALE_CHANNEL_SECONDS
+    ),
+    identityStorageRetentionSeconds: normalizeRetentionSeconds(
+      record.identityStorageRetentionSeconds,
+      DEFAULT_IDENTITY_STORAGE_RETENTION_SECONDS
+    ),
+    policyRevision: Math.max(0, Math.floor(Number(record.policyRevision) || 0))
+  }
+}
+
+function storagePolicy (storageSet) {
+  return {
+    staleChannelSeconds: storageSet.staleChannelSeconds,
+    identityStorageRetentionSeconds: storageSet.identityStorageRetentionSeconds,
+    policyRevision: storageSet.policyRevision
   }
 }
 
@@ -178,23 +218,29 @@ function retryDelay (attempts) {
   return Math.min(MAX_RETRY_MS, 1000 * (2 ** Math.min(9, Math.max(0, attempts - 1))))
 }
 
-async function markAndListDueBundles (indexedDB, now) {
+async function markAndListDueStorageSets (indexedDB, now) {
   return withRegistryTransaction(indexedDB, 'readwrite', async tx => {
-    const records = (await run('getAll', [], BUNDLES_STORE, null, { tx })).result
+    const records = (await run('getAll', [], STORAGE_SETS_STORE, null, { tx })).result
     const due = []
     for (const raw of records) {
-      const bundle = normalizeBundle(raw)
-      if (!bundle) continue
-      await refreshLeaseUntil(tx, bundle, now, { removeExpired: true })
-      const leaseActive = bundle.leaseUntil > now
-      if (bundle.status === 'ready' && !leaseActive && bundle.lastUsedAt + RETENTION_MS <= now) {
-        bundle.status = 'delete_pending'
-        bundle.attempts = 0
-        bundle.nextAttemptAt = now
+      const storageSet = normalizeStorageSet(raw)
+      if (!storageSet) continue
+      await refreshLeaseState(tx, storageSet, now, { removeExpired: true })
+      const leaseActive = storageSet.leaseUntil > now
+      const retentionMs = storageSet.identityStorageRetentionSeconds * 1000
+      const expired = storageSet.lastUsedAt + retentionMs <= now
+      if (leaseActive || !expired) {
+        storageSet.status = 'ready'
+        storageSet.attempts = 0
+        storageSet.nextAttemptAt = 0
+      } else if (storageSet.status === 'ready') {
+        storageSet.status = 'delete_pending'
+        storageSet.attempts = 0
+        storageSet.nextAttemptAt = now
       }
-      await run('put', [bundle], BUNDLES_STORE, null, { tx })
-      if (bundle.status === 'delete_pending' && !leaseActive && bundle.nextAttemptAt <= now) {
-        due.push(bundle)
+      await run('put', [storageSet], STORAGE_SETS_STORE, null, { tx })
+      if (storageSet.status === 'delete_pending' && !leaseActive && storageSet.nextAttemptAt <= now) {
+        due.push(storageSet)
       }
     }
     return due
@@ -203,35 +249,43 @@ async function markAndListDueBundles (indexedDB, now) {
 
 async function finishDeleteAttempt (indexedDB, attempted, deleted, now) {
   return withRegistryTransaction(indexedDB, 'readwrite', async tx => {
-    const current = normalizeBundle((await run('get', [attempted.userPubkey], BUNDLES_STORE, null, { tx })).result)
-    if (!current || current.status !== 'delete_pending' || current.leaseUntil > now) return false
+    const current = normalizeStorageSet((await run('get', [attempted.userPubkey], STORAGE_SETS_STORE, null, { tx })).result)
+    if (!current || current.status !== 'delete_pending') return false
+    await refreshLeaseState(tx, current, now, { removeExpired: true })
+    if (current.leaseUntil > now) {
+      current.status = 'ready'
+      current.attempts = 0
+      current.nextAttemptAt = 0
+      await run('put', [current], STORAGE_SETS_STORE, null, { tx })
+      return false
+    }
     if (deleted) {
       for (const lease of await readLeases(tx, attempted.userPubkey)) {
         await run('delete', [lease.key], LEASES_STORE, null, { tx })
       }
-      await run('delete', [attempted.userPubkey], BUNDLES_STORE, null, { tx })
+      await run('delete', [attempted.userPubkey], STORAGE_SETS_STORE, null, { tx })
       return true
     }
     current.attempts++
     current.nextAttemptAt = now + retryDelay(current.attempts)
-    await run('put', [current], BUNDLES_STORE, null, { tx })
+    await run('put', [current], STORAGE_SETS_STORE, null, { tx })
     return false
   })
 }
 
 async function maintainRegistry (indexedDB, now) {
-  const due = await markAndListDueBundles(indexedDB, now)
-  for (const bundle of due) {
-    const deleted = await deleteStorageSet(indexedDB, bundle.userPubkey)
-    await finishDeleteAttempt(indexedDB, bundle, deleted, now)
+  const due = await markAndListDueStorageSets(indexedDB, now)
+  for (const storageSet of due) {
+    const deleted = await deleteStorageSet(indexedDB, storageSet.userPubkey)
+    await finishDeleteAttempt(indexedDB, storageSet, deleted, now)
   }
   const nextAttemptAt = await withRegistryTransaction(indexedDB, 'readonly', async tx => {
-    const records = (await run('getAll', [], BUNDLES_STORE, null, { tx })).result
+    const records = (await run('getAll', [], STORAGE_SETS_STORE, null, { tx })).result
     let earliest = Infinity
     for (const raw of records) {
-      const bundle = normalizeBundle(raw)
-      if (bundle?.status !== 'delete_pending' || bundle.leaseUntil > now) continue
-      earliest = Math.min(earliest, bundle.nextAttemptAt)
+      const storageSet = normalizeStorageSet(raw)
+      if (storageSet?.status !== 'delete_pending' || storageSet.leaseUntil > now) continue
+      earliest = Math.min(earliest, storageSet.nextAttemptAt)
     }
     return Number.isFinite(earliest) ? earliest : null
   })
@@ -268,6 +322,8 @@ export async function maintainPrivateMessengerStorage ({
 export function activatePrivateMessengerStorage ({
   userPubkey,
   leaseId,
+  activeChannelPubkeys,
+  storagePolicy: nextPolicy,
   indexedDB = globalThis.indexedDB,
   now = Date.now()
 } = {}) {
@@ -276,22 +332,61 @@ export function activatePrivateMessengerStorage ({
   return withMaintenanceLock(indexedDB, () => withRegistryTransaction(indexedDB, 'readwrite', async tx => {
     userPubkey = String(userPubkey)
     leaseId = String(leaseId)
-    const current = normalizeBundle((await run('get', [userPubkey], BUNDLES_STORE, null, { tx })).result)
+    const current = normalizeStorageSet((await run('get', [userPubkey], STORAGE_SETS_STORE, null, { tx })).result)
+    const currentLease = (await run('get', [leaseKey(userPubkey, leaseId)], LEASES_STORE, null, { tx })).result
+    const channels = activeChannelPubkeys === undefined
+      ? normalizeActiveChannelPubkeys(currentLease?.activeChannelPubkeys)
+      : normalizeActiveChannelPubkeys(activeChannelPubkeys)
     await run('put', [{
       key: leaseKey(userPubkey, leaseId),
       userPubkey,
       leaseId,
-      leaseUntil: now + LEASE_MS
+      leaseUntil: now + LEASE_MS,
+      activeChannelPubkeys: channels
     }], LEASES_STORE, null, { tx })
-    const bundle = {
+    const hasPolicy = nextPolicy !== undefined
+    const storageSet = {
       userPubkey,
       lastUsedAt: now,
       leaseUntil: Math.max(current?.leaseUntil || 0, now + LEASE_MS),
       status: 'ready',
       attempts: 0,
-      nextAttemptAt: 0
+      nextAttemptAt: 0,
+      staleChannelSeconds: hasPolicy
+        ? nextPolicy.staleChannelSeconds
+        : current?.staleChannelSeconds ?? DEFAULT_STALE_CHANNEL_SECONDS,
+      identityStorageRetentionSeconds: hasPolicy
+        ? nextPolicy.identityStorageRetentionSeconds
+        : current?.identityStorageRetentionSeconds ?? DEFAULT_IDENTITY_STORAGE_RETENTION_SECONDS,
+      policyRevision: hasPolicy
+        ? (current?.policyRevision || 0) + 1
+        : current?.policyRevision || 0
+    }
+    await run('put', [storageSet], STORAGE_SETS_STORE, null, { tx })
+    const leaseState = await refreshLeaseState(tx, storageSet, now)
+    return {
+      ...storagePolicy(storageSet),
+      activeChannelPubkeys: leaseState.activeChannelPubkeys
+    }
+  }))
+}
+
+export function readPrivateMessengerStorage ({
+  userPubkey,
+  indexedDB = globalThis.indexedDB,
+  now = Date.now()
+} = {}) {
+  if (!userPubkey) return Promise.reject(new Error('USER_PUBKEY_REQUIRED'))
+  return withMaintenanceLock(indexedDB, () => withRegistryTransaction(indexedDB, 'readwrite', async tx => {
+    userPubkey = String(userPubkey)
+    const storageSet = normalizeStorageSet((await run('get', [userPubkey], STORAGE_SETS_STORE, null, { tx })).result)
+    if (!storageSet) return null
+    const leaseState = await refreshLeaseState(tx, storageSet, now, { removeExpired: true })
+    await run('put', [storageSet], STORAGE_SETS_STORE, null, { tx })
+    return {
+      ...storagePolicy(storageSet),
+      activeChannelPubkeys: leaseState.activeChannelPubkeys
     }
-    await run('put', [bundle], BUNDLES_STORE, null, { tx })
   }))
 }
 
@@ -306,19 +401,20 @@ export function releasePrivateMessengerStorage ({
   return withMaintenanceLock(indexedDB, () => withRegistryTransaction(indexedDB, 'readwrite', async tx => {
     userPubkey = String(userPubkey)
     leaseId = String(leaseId)
-    const current = normalizeBundle((await run('get', [userPubkey], BUNDLES_STORE, null, { tx })).result)
+    const current = normalizeStorageSet((await run('get', [userPubkey], STORAGE_SETS_STORE, null, { tx })).result)
     if (!current) return false
     await run('delete', [leaseKey(userPubkey, leaseId)], LEASES_STORE, null, { tx })
-    await refreshLeaseUntil(tx, current, now, { removeExpired: true })
+    await refreshLeaseState(tx, current, now, { removeExpired: true })
     current.lastUsedAt = now
     current.status = 'ready'
     current.attempts = 0
     current.nextAttemptAt = 0
-    await run('put', [current], BUNDLES_STORE, null, { tx })
+    await run('put', [current], STORAGE_SETS_STORE, null, { tx })
     return true
   }))
 }
 
 export const PRIVATE_MESSENGER_STORAGE_HEARTBEAT_MS = 60 * 60 * 1000
 export const PRIVATE_MESSENGER_STORAGE_MAINTENANCE_MS = 6 * 60 * 60 * 1000
-export const PRIVATE_MESSENGER_STORAGE_RETENTION_MS = RETENTION_MS
+export const PRIVATE_MESSENGER_IDENTITY_STORAGE_RETENTION_MS = DEFAULT_IDENTITY_STORAGE_RETENTION_SECONDS * 1000
+export { DEFAULT_IDENTITY_STORAGE_RETENTION_SECONDS }

package/relay/helpers/hll.js

@@ -1,9 +1,11 @@
+import { ValidationError } from '../../error/index.js'
+
 const REGISTER_COUNT = 256
 const HLL_HEX_LENGTH = REGISTER_COUNT * 2
 
 function assertRegisters (registers) {
   if (!(registers instanceof Uint8Array) || registers.length !== REGISTER_COUNT) {
-    throw new Error('INVALID_HLL_REGISTERS')
+    throw new ValidationError('INVALID_HLL_REGISTERS')
   }
 }
 

package/relay/services/query.js

@@ -52,7 +52,7 @@ function relayListCreatedAt (event) {
   return Number.isFinite(event?.created_at) ? event.created_at : 0
 }
 
-function relaySetsEqual (a, b) {
+function areRelaySetsEqual (a, b) {
   const left = new Set(a || [])
   const right = new Set(b || [])
   if (left.size !== right.size) return false
@@ -61,8 +61,8 @@ function relaySetsEqual (a, b) {
 }
 
 function relaySetChanges (previous, next) {
-  const read = !relaySetsEqual(previous?.read, next?.read)
-  const write = !relaySetsEqual(previous?.write, next?.write)
+  const read = !areRelaySetsEqual(previous?.read, next?.read)
+  const write = !areRelaySetsEqual(previous?.write, next?.write)
   return {
     read,
     write,