app

Local-first trade for farms and co-ops
git clone https://radroots.dev/git/app.git
Log | Files | Refs | README | LICENSE

commit 2803f5e293b86e862b982fae573351124097a6a9
parent 4aa071680a994c2e6c66d6d9fa120ef5cc9e90bd
Author: triesap <tyson@radroots.org>
Date:   Wed, 14 Oct 2026 02:27:12 +0000

harvestcircle: reuse exact private validation and fence stopped retention

- Cache bounded genuine whole-wire proofs while checking every current owner row and quota.
- Merge received ciphertext in one completed native transaction with exact readback.
- Preserve verified history metadata and fence in-flight and stale Stop ownership.
- Verify actual capacity corruption controls, 35 unit, 94 browser and 28 output tests.

Diffstat:
Mweb/src/lib/messaging/history-pagination.ts | 26+++++++++++++++++---------
Mweb/src/lib/persistence/history-metadata-repository.ts | 25++++++++++++++-----------
Mweb/src/lib/persistence/inbox-envelope-repository.ts | 66++++++++++++++++++------------------------------------------------
Mweb/src/lib/persistence/private-records.ts | 39+++++++++++++++++++++++++++++++++------
Mweb/src/lib/persistence/private-storage.ts | 276+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++------------
Mweb/tests/e2e/harness/history-pagination.ts | 103++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-
Aweb/tests/e2e/harness/private-validation-cache.ts | 322+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/tests/e2e/history-pagination.spec.ts | 118+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--
Aweb/tests/e2e/private-validation-cache.spec.ts | 211+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/tests/provenance/output.test.mjs | 4++++
Mweb/tests/unit/private-records.test.ts | 64++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/tools/check-output.mjs | 26+++++++++++++++++++-------
12 files changed, 1153 insertions(+), 127 deletions(-)

diff --git a/web/src/lib/messaging/history-pagination.ts b/web/src/lib/messaging/history-pagination.ts @@ -16,6 +16,7 @@ import { } from '../nostr/private-pool.ts'; import { admitInboxEnvelope, + inboxEnvelopeSnapshot, retainInboxEnvelope } from '../persistence/inbox-envelope-repository.ts'; import { @@ -48,6 +49,7 @@ export function captureOlderInbox( if (!ownership?.current()) return undefined; const original: InboxHistoryOwnership = ownership; const token = Object.freeze({}) as OlderInbox; + const cancellation = new AbortController(); let stopped = false, busy = false, cleanupRequired = false, @@ -59,6 +61,7 @@ export function captureOlderInbox( const current = () => !stopped && original.current(); function stop() { stopped = true; + cancellation.abort(); state = 'stopped'; let failure = false; try { @@ -73,7 +76,7 @@ export function captureOlderInbox( } cursors = []; cleanupRequired = failure; - if (!failure) syncs.delete(sync); + if (!failure && syncs.get(sync) === token) syncs.delete(sync); if (failure) throw Error('private_history_cleanup_required'); } async function page( @@ -85,8 +88,8 @@ export function captureOlderInbox( let queue = Promise.resolve(), finished = false, failure: string | undefined; - let ids = Array.from<string>([]), - acceptedDeliveries = 0; + const ids = new Map<string, true>(); + let acceptedDeliveries = 0; function receive(message: PrivatePageMessage) { if (finished) return; if (message.type === 'end') { @@ -99,8 +102,8 @@ export function captureOlderInbox( acceptedDeliveries < (message.deliveries ?? acceptedDeliveries) ? 'unsupported' : message.reason), - deliveries: message.deliveries ?? ids.length, - ids: ids.slice() + deliveries: message.deliveries ?? ids.size, + ids: Array.from(ids.keys()) }) ); return; @@ -128,7 +131,8 @@ export function captureOlderInbox( const retained = await retainInboxEnvelope( original.repository, original.session, - admitted + admitted, + cancellation.signal ); if (!current()) return; if ( @@ -139,8 +143,12 @@ export function captureOlderInbox( return; } acceptedDeliveries++; - const parsed = JSON.parse(message.wire) as { id: string }; - if (!ids.includes(parsed.id)) ids = ids.concat(parsed.id); + const parsed = inboxEnvelopeSnapshot(admitted); + if (!parsed) { + failure = 'unsupported'; + return; + } + ids.set(parsed.id, true); }) .catch(() => { failure = 'unknown_completion'; @@ -264,7 +272,7 @@ export function captureOlderInbox( ? 'partial' : 'older_available'; } - return true; + return current(); } catch { if (!stopped) { state = 'needs_action'; diff --git a/web/src/lib/persistence/history-metadata-repository.ts b/web/src/lib/persistence/history-metadata-repository.ts @@ -4,16 +4,14 @@ import { } from '../runtime/private-session.ts'; import { listPrivateReceivedRecords, + privateStorageOwner, type PrivateStorageRepository } from './private-storage.ts'; import { + privateReceivedOuterMetadata, privateRecordIdentity, privateRecordSnapshot } from './private-records.ts'; -import { - verifyEnvelope, - verifiedEnvelopeSnapshot -} from '../nostr/verified-envelope.ts'; export type RetainedOuterMetadata = Readonly<{ source: string; outerId: string; @@ -28,10 +26,12 @@ export async function readRetainedOuterMetadata( > { const ownership = privateSessionOwnership(session); if (!ownership?.current()) return { ok: false, reason: 'stopped' }; + if (privateStorageOwner(repository) !== ownership.owner) + return { ok: false, reason: 'invalid_scope' }; const loaded = await listPrivateReceivedRecords(repository); if (!ownership.current()) return { ok: false, reason: 'stopped' }; if (!loaded.ok) return loaded; - let rows = Array.from<RetainedOuterMetadata>([]); + const rows = new Map<number, RetainedOuterMetadata>(); for (const token of loaded.value) { const identity = privateRecordIdentity(token); if (identity?.owner !== ownership.owner) @@ -39,18 +39,21 @@ export async function readRetainedOuterMetadata( const record = privateRecordSnapshot(token, ownership.owner, identity.id); if (record?.family !== 'received_envelope') return { ok: false, reason: 'corrupt_record' }; - const verified = verifyEnvelope(record.outer), - event = verified.ok && verifiedEnvelopeSnapshot(verified.value); - if (!event || event.kind !== 1059 || event.id !== record.id) + const event = privateReceivedOuterMetadata( + token, + ownership.owner, + identity.id + ); + if (!event || event.id !== record.id) return { ok: false, reason: 'corrupt_record' }; for (const source of record.sources) - rows = rows.concat({ + rows.set(rows.size, { source, outerId: event.id, - outerTime: event.created_at + outerTime: event.createdAt }); } return ownership.current() - ? { ok: true, rows } + ? { ok: true, rows: Array.from(rows.values()) } : { ok: false, reason: 'stopped' }; } diff --git a/web/src/lib/persistence/inbox-envelope-repository.ts b/web/src/lib/persistence/inbox-envelope-repository.ts @@ -1,6 +1,6 @@ import { canonicalPublicKey } from '../contracts/public-key.ts'; import { canonicalRelayOrigin } from '../config/relays.ts'; -import { PRIVATE_TRANSPORT_BUDGETS, RELAY_BUDGETS } from '../config/budgets.ts'; +import { PRIVATE_TRANSPORT_BUDGETS } from '../config/budgets.ts'; import { boundedUtf8 } from '../contracts/food-availability-v1/text.ts'; import { safeUnsignedInteger } from '../nostr/envelope-bounds.ts'; import { @@ -19,7 +19,7 @@ import { } from './private-records.ts'; import { loadPrivateRecord, - commitPrivateRecord, + retainPrivateReceivedRecord, type PrivateStorageRepository, type PrivateStorageFailure } from './private-storage.ts'; @@ -92,7 +92,8 @@ export type InboxRetentionResult = Readonly<{ export async function retainInboxEnvelope( repository: PrivateStorageRepository, session: PrivateSession, - envelope: InboxEnvelope + envelope: InboxEnvelope, + cancellation?: AbortSignal ): Promise<InboxRetentionResult> { const admitted = envelopes.get(envelope), ownership = privateSessionOwnership(session); @@ -104,70 +105,39 @@ export async function retainInboxEnvelope( !navigator.locks?.request ) return { status: 'invalid' }; + if (cancellation?.aborted) return { status: 'stopped' }; try { return await navigator.locks.request( 'harvestcircle:owner:' + admitted.owner, { mode: 'exclusive', ifAvailable: true }, async (lock) => { if (!lock) return { status: 'busy' }; - if (!ownership.current()) return { status: 'stopped' }; - const loaded = await loadPrivateRecord( + if (!ownership.current() || cancellation?.aborted) + return { status: 'stopped' }; + const committed = await retainPrivateReceivedRecord( repository, - 'received_envelopes', - admitted.id + session, + admitted.record, + cancellation ); - if (!ownership.current()) return { status: 'stopped' }; - let next = admitted.record, - base: PrivateRecordHandle | null = null, - duplicate = false; - if (loaded.ok) { - const row = privateRecordSnapshot( - loaded.value, - admitted.owner, - admitted.id - ); - if (!row || row.family !== 'received_envelope') - return { status: 'conflict' }; - // Keep the first valid signed outer and first observation. Equal outer - // IDs are deduplication, not trusted inner-message identity/display. - duplicate = true; - base = loaded.value; - if (row.sources.includes(admitted.source)) - return { status: 'duplicate' }; - if ( - row.sources.length >= RELAY_BUDGETS.inbox || - row.revision === Number.MAX_SAFE_INTEGER - ) - return { status: 'capacity' }; - const decoded = decodePrivateRecord( - JSON.stringify({ - ...row, - revision: row.revision + 1, - sources: [...row.sources, admitted.source] - }), - admitted.owner, - admitted.id - ); - if (!decoded.ok) return { status: 'invalid' }; - next = decoded.value; - } else if (loaded.reason !== 'invalid_record') - return { status: loaded.reason }; - if (!ownership.current()) return { status: 'stopped' }; - const committed = await commitPrivateRecord(repository, next, base); + if (!ownership.current() || cancellation?.aborted) + return { status: 'stopped' }; if (!committed.ok) return { status: committed.reason }; + if (!committed.value.changed) return { status: committed.value.status }; const readback = await loadPrivateRecord( repository, 'received_envelopes', admitted.id ); - if (!ownership.current()) return { status: 'stopped' }; + if (!ownership.current() || cancellation?.aborted) + return { status: 'stopped' }; if (!readback.ok) return { status: 'unknown_completion' }; if ( privateRecordWire(readback.value, admitted.owner, admitted.id) !== - privateRecordWire(next, admitted.owner, admitted.id) + privateRecordWire(committed.value.record, admitted.owner, admitted.id) ) return { status: 'conflict' }; - return { status: duplicate ? 'duplicate' : 'retained' }; + return { status: committed.value.status }; } ); } catch { diff --git a/web/src/lib/persistence/private-records.ts b/web/src/lib/persistence/private-records.ts @@ -83,7 +83,12 @@ declare const recordBrand: unique symbol; export type PrivateRecordHandle = Readonly<{ [recordBrand]: true }>; const records = new WeakMap< PrivateRecordHandle, - Readonly<{ owner: string; id: string; wire: string }> + Readonly<{ + owner: string; + id: string; + wire: string; + outerMetadata?: Readonly<{ id: string; createdAt: number }>; + }> >(); export type PrivateRecordFailure = | 'invalid_scope' @@ -331,7 +336,7 @@ function outer( raw: unknown, destination: string, received = false -): string | undefined { +): Readonly<{ id: string; createdAt: number }> | undefined { if ( typeof raw !== 'string' || !boundedUtf8(raw, PRIVATE_TRANSPORT_BUDGETS.envelopeBytes) @@ -376,7 +381,7 @@ function outer( } catch { return undefined; } - return event.id; + return { id: event.id, createdAt: event.created_at }; } function artifact( value: unknown, @@ -385,7 +390,7 @@ function artifact( return ( exactLocalFields(value, ['eventId', 'wire']) && hash(value.eventId) && - outer(value.wire, destination) === value.eventId + outer(value.wire, destination)?.id === value.eventId ); } function receipt( @@ -465,6 +470,7 @@ export function decodePrivateRecord( if (fields.owner !== owner) return failed('owner_mismatch'); if (fields.id !== id) return failed('id_mismatch'); let record: PrivateRecord; + let outerMetadata: Readonly<{ id: string; createdAt: number }> | undefined; if (fields.family === 'private_send_reservation') { const reservation = inspectPrivateSendReservation(raw, owner, id); if (!reservation) return failed('malformed'); @@ -532,6 +538,7 @@ export function decodePrivateRecord( : { receipts: fields.receipts as PrivateTargetReceipt[] }) }; } else if (fields.family === 'received_envelope') { + outerMetadata = outer(fields.outer, owner, true); if ( !hash(id) || !exactLocalFields(fields, [ @@ -546,7 +553,7 @@ export function decodePrivateRecord( 'read' ]) || !unsigned(fields.revision) || - outer(fields.outer, owner, true) !== id || + outerMetadata?.id !== id || !unsigned(fields.observedAtMilliseconds) || !Array.isArray(fields.sources) || fields.sources.length === 0 || @@ -582,7 +589,12 @@ export function decodePrivateRecord( }; } else return failed('malformed'); const token = Object.freeze({}) as PrivateRecordHandle; - records.set(token, { owner, id, wire: JSON.stringify(record) }); + records.set(token, { + owner, + id, + wire: JSON.stringify(record), + ...(outerMetadata ? { outerMetadata } : {}) + }); return { ok: true, value: token }; } catch { return failed('malformed'); @@ -606,6 +618,21 @@ export function privateRecordSnapshot( const wire = privateRecordWire(token, owner, id); return wire === undefined ? undefined : (JSON.parse(wire) as PrivateRecord); } +// Strict original codec transport metadata only. A detached record or wrong +// owner/ID cannot borrow a verified outer; this is never inner/room permission. +export function privateReceivedOuterMetadata( + token: PrivateRecordHandle, + owner: unknown, + id: unknown +): Readonly<{ id: string; createdAt: number }> | undefined { + const saved = records.get(token); + return saved && + saved.owner === owner && + saved.id === id && + saved.outerMetadata + ? { ...saved.outerMetadata } + : undefined; +} // Handle identity contains no private body; callers must still match namespace. export function privateRecordIdentity( token: PrivateRecordHandle diff --git a/web/src/lib/persistence/private-storage.ts b/web/src/lib/persistence/private-storage.ts @@ -5,7 +5,7 @@ import { } from '../runtime/private-session.ts'; import { canonicalPublicKey } from '../contracts/public-key.ts'; import { exactLocalFields } from '../contracts/local-records.ts'; -import { LOCAL_PERSISTENCE_BUDGETS } from '../config/budgets.ts'; +import { LOCAL_PERSISTENCE_BUDGETS, RELAY_BUDGETS } from '../config/budgets.ts'; import { privateRecordSettlement } from './local-inventory.ts'; import { browserDatabaseState, @@ -39,19 +39,80 @@ type Scope = Readonly<{ database: BrowserDatabase; owner: string }>; type Row = Readonly<{ store: Store; record: PrivateRecord; + handle: PrivateRecordHandle; wire: string; bytes: number; }>; const repositories = new WeakMap<PrivateStorageRepository, Scope>(); +type ValidatedWire = Readonly<{ + wire: string; + handle: PrivateRecordHandle; + bytes: number; +}>; +type ValidationState = Readonly<{ + entries: Map<string, ValidatedWire>; + bytes: number; +}>; +// Ephemeral ciphertext proofs belong to the genuine repository scope. Every +// operation still visits every native owner row and checks all keys/headers and +// quotas. Neither persisted summaries nor cached count/absence is trusted. +const validations = new WeakMap< + Scope, + Readonly<Record<Store, ValidationState>> +>(); +function remember( + scope: Scope, + store: Store, + id: string, + value: ValidatedWire +): void { + const countCap = + store === 'private_sends' + ? LOCAL_PERSISTENCE_BUDGETS.unfinishedPrivateSends + : LOCAL_PERSISTENCE_BUDGETS.receivedEnvelopes, + byteCap = + store === 'private_sends' + ? LOCAL_PERSISTENCE_BUDGETS.privateSendBytes + : LOCAL_PERSISTENCE_BUDGETS.receivedCiphertextBytes; + if (value.bytes > byteCap) return; + const stores = validations.get(scope) ?? { + private_sends: { entries: new Map<string, ValidatedWire>(), bytes: 0 }, + received_envelopes: { + entries: new Map<string, ValidatedWire>(), + bytes: 0 + } + }, + state = stores[store], + entries = state.entries; + let bytes = state.bytes; + const old = entries.get(id); + if (old) { + entries.delete(id); + bytes -= old.bytes; + } + while (entries.size >= countCap || bytes + value.bytes > byteCap) { + const first = entries.keys().next().value; + if (first === undefined) break; + bytes -= entries.get(first)!.bytes; + entries.delete(first); + } + entries.set(id, value); + validations.set(scope, { + ...stores, + [store]: { entries, bytes: bytes + value.bytes } + }); +} + const failed = ( reason: PrivateStorageFailure ): PrivateStorageResult<never> => ({ ok: false, reason }); function scopeOf(repository: PrivateStorageRepository): Scope | undefined { const scope = repositories.get(repository); try { - return scope && browserDatabaseState(scope.database).state === 'ready' - ? scope - : undefined; + if (scope && browserDatabaseState(scope.database).state === 'ready') + return scope; + if (scope) validations.delete(scope); + return undefined; } catch { return undefined; } @@ -72,7 +133,13 @@ export function createPrivateStorageRepository( return undefined; } } +export function privateStorageOwner( + repository: PrivateStorageRepository +): string | undefined { + return scopeOf(repository)?.owner; +} function stored( + scope: Scope, value: unknown, store: Store, owner: string, @@ -82,10 +149,15 @@ function stored( !exactLocalFields(value, ['owner', 'id', 'wire']) || value.owner !== owner || value.id !== id || - typeof value.wire !== 'string' + typeof value.wire !== 'string' || + typeof id !== 'string' ) return undefined; - const decoded = decodePrivateRecord(value.wire, owner, id); + const cached = validations.get(scope)?.[store].entries.get(id); + const decoded = + cached?.wire === value.wire + ? { ok: true as const, value: cached.handle } + : decodePrivateRecord(value.wire, owner, id); if (!decoded.ok) return undefined; const record = privateRecordSnapshot(decoded.value, owner, id); if ( @@ -93,12 +165,19 @@ function stored( (record.family === 'received_envelope') !== (store === 'received_envelopes') ) return undefined; - return { - store, - record, - wire: value.wire, - bytes: new TextEncoder().encode(JSON.stringify(value)).length - }; + // Equal original wire plus the three exact validated header fields fixes the + // encoded row length; property ordering does not change that length. + const bytes = + cached?.wire === value.wire + ? cached.bytes + : new TextEncoder().encode(JSON.stringify(value)).length; + if (cached?.wire !== value.wire) + remember(scope, store, id, { + wire: value.wire, + handle: decoded.value, + bytes + }); + return { store, record, handle: decoded.value, wire: value.wire, bytes }; } // Each store has an independent owner-scoped scan/quota. A corrupt received // namespace cannot reset or consume the outbox, and no uncertain row is evicted. @@ -130,7 +209,7 @@ function transaction<T>( return new Promise((resolve) => { let result: PrivateStorageResult<T> | undefined, bytes = 0; - let rows = Array.from<Row>([]); + const rows = new Map<number, Row>(); function refuse(reason: PrivateStorageFailure) { if (result && !result.ok) return; result = failed(reason); @@ -171,22 +250,22 @@ function transaction<T>( try { const cursor = cursorRequest.result; if (!cursor) { - const outcome = finish(rows, tx, refuse); + const outcome = finish(Array.from(rows.values()), tx, refuse); if (outcome) result = outcome; return; } const key = cursor.primaryKey; const row = Array.isArray(key) && key.length === 2 && key[0] === scope.owner - ? stored(cursor.value, store, scope.owner, key[1]) + ? stored(scope, cursor.value, store, scope.owner, key[1]) : undefined; if (!row) { refuse('corrupt_record'); return; } - rows = rows.concat(row); + rows.set(rows.size, row); bytes += row.bytes; - if (rows.length > countCap || bytes > byteCap) { + if (rows.size > countCap || bytes > byteCap) { refuse('capacity'); return; } @@ -331,6 +410,140 @@ export function commitPrivateRecord( }; }); } +// Combine received lookup/merge/write only. The caller holds the actual owner +// lock. Complete namespace validation and native completion remain mandatory; +// changed writes require the caller's later exact readonly verification. +export function retainPrivateReceivedRecord( + repository: PrivateStorageRepository, + session: PrivateSession, + incoming: PrivateRecordHandle, + cancellation?: AbortSignal +): Promise< + PrivateStorageResult< + Readonly<{ + record: PrivateRecordHandle; + status: 'retained' | 'duplicate'; + changed: boolean; + }> + > +> { + const scope = scopeOf(repository), + ownership = privateSessionOwnership(session), + identity = privateRecordIdentity(incoming), + candidate = + scope && + identity && + privateRecordSnapshot(incoming, scope.owner, identity.id); + // Pre-admission cancellation is not evidence of a native rollback. + if (cancellation?.aborted) return Promise.resolve(failed('invalid_scope')); + if (!scope || !ownership?.current() || ownership.owner !== scope.owner) + return Promise.resolve(failed('invalid_scope')); + if ( + !identity || + candidate?.family !== 'received_envelope' || + candidate.revision !== 0 || + candidate.read !== null || + candidate.sources.length !== 1 + ) + return Promise.resolve(failed('invalid_record')); + return transaction< + Readonly<{ + record: PrivateRecordHandle; + status: 'retained' | 'duplicate'; + changed: boolean; + }> + >( + scope, + 'received_envelopes', + 'readwrite', + (rows, tx, refuse) => { + if (cancellation?.aborted) { + refuse('aborted'); + return; + } + if (!ownership.current()) { + refuse('invalid_scope'); + return; + } + const previous = rows.find((row) => row.record.id === identity.id); + let record = incoming, + status: 'retained' | 'duplicate' = 'retained'; + if (previous) { + if (previous.record.family !== 'received_envelope') { + refuse('conflict'); + return; + } + status = 'duplicate'; + if (previous.record.sources.includes(candidate.sources[0])) + return { + ok: true, + value: { record: previous.handle, status, changed: false } + }; + if ( + previous.record.sources.length >= RELAY_BUDGETS.inbox || + previous.record.revision === Number.MAX_SAFE_INTEGER + ) { + refuse('capacity'); + return; + } + const decoded = decodePrivateRecord( + JSON.stringify({ + ...previous.record, + revision: previous.record.revision + 1, + sources: [...previous.record.sources, candidate.sources[0]] + }), + scope.owner, + identity.id + ); + if (!decoded.ok) { + refuse('invalid_record'); + return; + } + record = decoded.value; + } + const wire = privateRecordWire(record, scope.owner, identity.id); + if (!wire) { + refuse('invalid_record'); + return; + } + const row = { owner: scope.owner, id: identity.id, wire }, + bytes = new TextEncoder().encode(JSON.stringify(row)).length; + if ( + (!previous && + rows.length >= LOCAL_PERSISTENCE_BUDGETS.receivedEnvelopes) || + rows.reduce((total, item) => total + item.bytes, bytes) - + (previous?.bytes ?? 0) > + LOCAL_PERSISTENCE_BUDGETS.receivedCiphertextBytes + ) { + refuse('capacity'); + return; + } + if (cancellation?.aborted) { + refuse('aborted'); + return; + } + if (!ownership.current()) { + refuse('invalid_scope'); + return; + } + tx.objectStore('received_envelopes').put(row); + return { ok: true, value: { record, status, changed: true } }; + }, + (refuse) => { + const abort = () => refuse('aborted'), + off = subscribePrivateSessionClose(session, () => + refuse('invalid_scope') + ); + cancellation?.addEventListener('abort', abort, { once: true }); + if (cancellation?.aborted) abort(); + return () => { + off(); + cancellation?.removeEventListener('abort', abort); + }; + } + ); +} + export function loadPrivateRecord( repository: PrivateStorageRepository, store: Store, @@ -343,11 +556,10 @@ export function loadPrivateRecord( typeof id !== 'string' ) return Promise.resolve(failed('invalid_record')); - return transaction(scope, store, 'readonly', (rows) => { + return transaction<PrivateRecordHandle>(scope, store, 'readonly', (rows) => { const row = rows.find((row) => row.record.id === id); if (!row) return failed('invalid_record'); - const decoded = decodePrivateRecord(row.wire, scope.owner, id); - return decoded.ok ? decoded : failed('corrupt_record'); + return { ok: true, value: row.handle }; }); } export function inspectPrivateStorage( @@ -379,17 +591,7 @@ export function listPrivateReceivedRecords( 'received_envelopes', 'readonly', (rows) => { - let handles = Array.from<PrivateRecordHandle>([]); - for (const row of rows) { - const decoded = decodePrivateRecord( - row.wire, - scope.owner, - row.record.id - ); - if (!decoded.ok) return failed('corrupt_record'); - handles = handles.concat(decoded.value); - } - return { ok: true, value: handles }; + return { ok: true, value: rows.map((row) => row.handle) }; } ); } @@ -405,17 +607,7 @@ export function listPrivateSendRecords( 'private_sends', 'readonly', (rows) => { - let handles = Array.from<PrivateRecordHandle>([]); - for (const row of rows) { - const decoded = decodePrivateRecord( - row.wire, - scope.owner, - row.record.id - ); - if (!decoded.ok) return failed('corrupt_record'); - handles = handles.concat(decoded.value); - } - return { ok: true, value: handles }; + return { ok: true, value: rows.map((row) => row.handle) }; } ); } diff --git a/web/tests/e2e/harness/history-pagination.ts b/web/tests/e2e/harness/history-pagination.ts @@ -18,6 +18,12 @@ import { import { createInboxResolver } from '../../../src/lib/messaging/resolve-inbox.ts'; import { outerHistoryPlan } from '../../../src/lib/messaging/history-cursor.ts'; import { finalizeEvent } from 'applesauce-core/helpers'; +import { + browserDatabaseTransaction, + openBrowserDatabase, + closeBrowserDatabase +} from '../../../src/lib/persistence/database.ts'; +import { decodePrivateRecord } from '../../../src/lib/persistence/private-records.ts'; import { nip44 } from 'applesauce-core/helpers/encryption'; import { captureUnlockedSession, @@ -45,7 +51,10 @@ import { inboxSyncSnapshot, type InboxSync } from '../../../src/lib/messaging/inbox-sync.ts'; -import { loadPrivateRecord } from '../../../src/lib/persistence/private-storage.ts'; +import { + loadPrivateRecord, + inspectPrivateStorage +} from '../../../src/lib/persistence/private-storage.ts'; import { privateRecordSnapshot } from '../../../src/lib/persistence/private-records.ts'; import { getPublicStore, @@ -136,6 +145,8 @@ export async function makeFixture( const self = (await f.row())!.record.self; let ingress: InboxSync | undefined; let older: OlderInbox | undefined; + let capacityWires: string[] = [], + capacityWrites = 0; let authorized = true; let restoreFault = () => {}; let releaseKey: (() => void) | undefined; @@ -216,6 +227,22 @@ export async function makeFixture( loadOlder(review: unknown = 'reviewed_load_older') { return older ? loadOlderInbox(older, review) : Promise.resolve(false); }, + oldStopAfterSuccessor() { + if (!older || !ingress) throw Error('original history controller absent'); + const old = older; + stopOlderInbox(old); + const successor = captureOlderInbox(ingress, 'reviewed_load_older'); + if (!successor) throw Error('genuine successor absent'); + older = successor; + stopOlderInbox(old); + const third = captureOlderInbox(ingress, 'reviewed_load_older'); + if (third) stopOlderInbox(third); + return { + successor: !!successor, + third: !!third, + current: olderInboxSnapshot(successor) + }; + }, copiedOlderStart() { return older ? loadOlderInbox(Object.freeze({ ...older }), 'reviewed_load_older') @@ -225,6 +252,80 @@ export async function makeFixture( stopOlder() { if (older) stopOlderInbox(older); }, + // Source-only bulk strict ciphertext, not new inner-message/delivery proof. + async seedCapacity(source = 'wss://archive.example.org') { + const records = Array.from({ length: 2000 }, (_, index) => { + const outer = + index === 0 + ? self.wire + : this.oldSignedOuter(Math.floor(Date.now() / 1000) - index), + event = JSON.parse(outer) as { id: string }; + const wire = JSON.stringify({ + schema: 1, + family: 'received_envelope', + owner: f.owner, + id: event.id, + revision: 0, + outer, + observedAtMilliseconds: Date.now(), + sources: [source], + read: null + }); + if (!decodePrivateRecord(wire, f.owner, event.id).ok) + throw Error('strict capacity outer rejected'); + return { owner: f.owner, id: event.id, wire }; + }); + capacityWires = records.map( + (row) => (JSON.parse(row.wire) as { outer: string }).outer + ); + if (new Set(records.map((row) => row.id)).size !== 2000) + throw Error('capacity fixture IDs collide'); + const opened = await openBrowserDatabase(); + if (opened.state !== 'ready') + throw Error('owned capacity connection unavailable'); + try { + const tx = browserDatabaseTransaction( + opened.owner, + ['received_envelopes'], + 'readwrite' + ); + for (const row of records) + tx.objectStore('received_envelopes').put(row); + await new Promise<void>((resolve, reject) => { + tx.addEventListener('complete', () => resolve()); + tx.addEventListener('abort', () => + reject(Error('capacity seed aborted')) + ); + }); + } finally { + closeBrowserDatabase(opened.owner); + } + const checked = await inspectPrivateStorage( + f.repository, + 'received_envelopes' + ); + if (!checked.ok || checked.value.count !== 2000) + throw Error('actual committed capacity absent'); + return checked.value; + }, + capacityOuterWires: () => capacityWires.slice(0, 500), + capacityWriteCount: () => capacityWrites, + observeCapacityWrites() { + const nativePut = Reflect.get<IDBObjectStore, 'put'>( + IDBObjectStore.prototype, + 'put' + ), + priorRestore = restoreFault; + IDBObjectStore.prototype.put = function (...args) { + const request = Reflect.apply(nativePut, this, args); + if (this.name === 'received_envelopes') capacityWrites++; + return request; + }; + restoreFault = () => { + IDBObjectStore.prototype.put = nativePut; + priorRestore(); + }; + }, async seed(wire: string, origin = 'wss://archive.example.org') { const envelope = admitInboxEnvelope(wire, f.owner, origin, Date.now()); if (!envelope) throw Error('invalid genuinefixture envelope'); diff --git a/web/tests/e2e/harness/private-validation-cache.ts b/web/tests/e2e/harness/private-validation-cache.ts @@ -0,0 +1,322 @@ +// CR005_TEST_ONLY: real IDB/validator, no nested/extension/operator/fullQ proof. +import { finalizeEvent, generateSecretKey } from 'applesauce-core/helpers'; +import { nip44 } from 'applesauce-core/helpers/encryption'; +import { makeFixture as makeSigner } from './approved-signing.ts'; +import { + openBrowserDatabase, + closeBrowserDatabase, + browserDatabaseTransaction +} from '../../../src/lib/persistence/database.ts'; +import { + createPrivateStorageRepository, + loadPrivateRecord, + listPrivateSendRecords, + listPrivateReceivedRecords +} from '../../../src/lib/persistence/private-storage.ts'; +import { + decodePrivateRecord, + privateRecordSnapshot +} from '../../../src/lib/persistence/private-records.ts'; +import { readRetainedOuterMetadata } from '../../../src/lib/persistence/history-metadata-repository.ts'; +import { + createIdentitySession, + connectIdentity, + probeIdentityMessaging, + disconnectIdentity +} from '../../../src/lib/runtime/identity-session.ts'; +import { createPrivateSession } from '../../../src/lib/runtime/private-session.ts'; +declare global { + var __cr005VerifyCalls: number | undefined; +} +type Store = 'private_sends' | 'received_envelopes'; +type Row = { owner: string; id: string; wire: string }; +export async function createFixture() { + const signer = makeSigner(), + peer = makeSigner(), + prior = Object.getOwnPropertyDescriptor(window, 'nostr'), + owner = signer.owner; + Object.defineProperty(window, 'nostr', { + configurable: true, + value: { + getPublicKey: () => Promise.resolve(owner), + signEvent: (t: Parameters<typeof signer.sign>[0]) => + Promise.resolve(signer.sign(t)), + nip44: { + encrypt: (p: string, t: string) => + Promise.resolve(signer.encrypt(p, t)), + decrypt: (p: string, t: string) => Promise.resolve(signer.decrypt(p, t)) + } + } + }); + const identity = createIdentitySession(); + await connectIdentity(identity); + await probeIdentityMessaging(identity, 'reviewed_self_copy'); + const session = await createPrivateSession( + identity, + 'reviewed_private_session' + ), + opened = await openBrowserDatabase(); + if (!session || opened.state !== 'ready') + throw Error('genuine fixture session/database absent'); + const database = opened.owner, + repository = createPrivateStorageRepository(database, owner), + foreign = createPrivateStorageRepository(database, peer.owner); + if (!repository || !foreign) throw Error('genuine repositories absent'); + const repo = repository, + foreignRepo = foreign, + rows: Row[] = [], + sends: Row[] = [], + observed = Date.now(); + for (let index = 0; index < 2000; index++) { + const secret = generateSecretKey(), + conversation = nip44.v2.utils.getConversationKey(secret, owner); + let outer; + try { + outer = finalizeEvent( + { + kind: 1059, + created_at: Math.floor(observed / 1000) - index, + tags: [['p', owner]], + content: nip44.v2.encrypt( + 'CR005_TEST_ONLY_opaque_transport_seal', + conversation + ) + }, + secret + ); + } finally { + secret.fill(0); + conversation.fill(0); + } + const record = { + schema: 1, + family: 'received_envelope', + owner, + id: outer.id, + revision: 0, + outer: JSON.stringify(outer), + observedAtMilliseconds: observed, + sources: ['wss://archive.example.org'], + read: null + }, + wire = JSON.stringify(record); + if (!decodePrivateRecord(wire, owner, record.id).ok) + throw Error('strict outer rejected'); + rows.push({ owner, id: record.id, wire }); + } + for (let index = 0; index < 100; index++) { + const id = crypto.randomUUID(), + wire = JSON.stringify({ + schema: 1, + family: 'private_send_reservation', + owner, + id, + revision: 0, + peer: peer.owner, + rumorHash: 'a'.repeat(64), + createdAt: Math.floor(observed / 1000) + }); + if (!decodePrivateRecord(wire, owner, id).ok) + throw Error('strict reservation rejected'); + sends.push({ owner, id, wire }); + } + rows.sort((a, b) => a.id.localeCompare(b.id)); + const nativeCursor = Reflect.get<IDBIndex, 'openCursor'>( + IDBIndex.prototype, + 'openCursor' + ); + let visits = 0; + IDBIndex.prototype.openCursor = function (...args) { + const request = Reflect.apply(nativeCursor, this, args); + request.addEventListener('success', () => { + if (request.result) visits++; + }); + return request; + }; + async function put(store: Store, records: readonly unknown[], other = false) { + const openedOther = other ? await openBrowserDatabase() : undefined; + if (openedOther && openedOther.state !== 'ready') + throw Error('second connection absent'); + const db = openedOther?.state === 'ready' ? openedOther.owner : database; + try { + const tx = browserDatabaseTransaction(db, [store], 'readwrite'); + for (const row of records) tx.objectStore(store).put(row); + await new Promise<void>((resolve, reject) => { + tx.addEventListener('complete', () => resolve()); + tx.addEventListener('abort', () => + reject(Error('actual fixture write aborted')) + ); + }); + } finally { + if (openedOther?.state === 'ready') + closeBrowserDatabase(openedOther.owner); + } + } + await put('received_envelopes', rows); + await put('private_sends', sends); + function reset() { + visits = 0; + globalThis.__cr005VerifyCalls = 0; + } + function measured(start: number) { + return { + cursorVisits: visits, + verificationCalls: globalThis.__cr005VerifyCalls ?? 0, + milliseconds: performance.now() - start + }; + } + async function sample(store: Store = 'received_envelopes') { + reset(); + const start = performance.now(), + row = store === 'private_sends' ? sends[0] : rows[0], + result = await loadPrivateRecord(repo, store, row.id); + return { + ...measured(start), + ok: result.ok, + reason: result.ok ? null : result.reason, + revision: result.ok + ? privateRecordSnapshot(result.value, owner, row.id)?.revision + : null + }; + } + return { + owner, + sample, + async inventory() { + reset(); + const start = performance.now(), + result = await listPrivateReceivedRecords(repo); + return { + ...measured(start), + ok: result.ok, + count: result.ok ? result.value.length : null + }; + }, + async metadata(other = false) { + reset(); + const start = performance.now(), + result = await readRetainedOuterMetadata( + other ? foreignRepo : repo, + session + ); + return { + ...measured(start), + ok: result.ok, + count: result.ok ? result.rows.length : null, + reason: result.ok ? null : result.reason + }; + }, + bytes: () => ({ + received: rows.reduce( + (n, row) => n + new TextEncoder().encode(JSON.stringify(row)).length, + 0 + ), + sends: sends.reduce( + (n, row) => n + new TextEncoder().encode(JSON.stringify(row)).length, + 0 + ) + }), + async changeTail( + kind: 'valid' | 'metadata' | 'corrupt' | 'summary' | 'id', + other = false + ) { + const original = rows.at(-1)!; + let next: unknown; + if (kind === 'summary') + next = { ...original, untrustedSummary: { count: 0, bytes: 0 } }; + else { + const record = JSON.parse(original.wire) as Record<string, unknown>; + if (kind === 'valid' || kind === 'metadata') record.revision = 1; + if (kind === 'metadata') { + record.sources = [ + 'wss://archive.example.org', + 'wss://peer.example.org' + ]; + record.read = { + rumorHash: 'b'.repeat(64), + atMilliseconds: Date.now() + }; + } + if (kind === 'corrupt') record.outer = 'corrupt signed tail'; + if (kind === 'id') record.id = '0'.repeat(64); + next = { ...original, wire: JSON.stringify(record) }; + } + await put('received_envelopes', [next], other); + }, + restoreTail: () => put('received_envelopes', [rows.at(-1)!]), + async overfillReceived() { + const secret = generateSecretKey(), + conversation = nip44.v2.utils.getConversationKey(secret, owner); + let event; + try { + event = finalizeEvent( + { + kind: 1059, + created_at: Math.floor(Date.now() / 1000), + tags: [['p', owner]], + content: nip44.v2.encrypt( + 'CR005_TEST_ONLY_EXTRA_2001', + conversation + ) + }, + secret + ); + } finally { + secret.fill(0); + conversation.fill(0); + } + const prior = JSON.parse(rows[0].wire) as Record<string, unknown>; + const record = { + ...prior, + id: event.id, + outer: JSON.stringify(event) + }, + wire = JSON.stringify(record); + if (!decodePrivateRecord(wire, owner, event.id).ok) + throw Error('actual2001record invalid'); + await put('received_envelopes', [{ owner, id: event.id, wire }], true); + const result = await listPrivateReceivedRecords(repo); + return { ok: result.ok, reason: result.ok ? null : result.reason }; + }, + async overfillSends() { + const extra = { ...sends[0], id: crypto.randomUUID() }, + record = JSON.parse(extra.wire) as Record<string, unknown>; + record.id = extra.id; + extra.wire = JSON.stringify(record); + await put('private_sends', [extra], true); + const result = await listPrivateSendRecords(repo); + return { ok: result.ok, reason: result.ok ? null : result.reason }; + }, + async oversizeReceived() { + const padded = rows.map((row) => { + const record = JSON.parse(row.wire) as Record<string, unknown>; + record.outer = String(record.outer) + '\n'.repeat(9000); + return { ...row, wire: JSON.stringify(record) }; + }), + bytes = padded.reduce( + (n, row) => n + new TextEncoder().encode(JSON.stringify(row)).length, + 0 + ); + await put('received_envelopes', padded, true); + const result = await listPrivateReceivedRecords(repo); + return { bytes, ok: result.ok, reason: result.ok ? null : result.reason }; + }, + async foreignRead() { + const result = await loadPrivateRecord( + foreignRepo, + 'received_envelopes', + rows[0].id + ); + return { ok: result.ok, reason: result.ok ? null : result.reason }; + }, + close() { + IDBIndex.prototype.openCursor = nativeCursor; + disconnectIdentity(identity); + closeBrowserDatabase(database); + signer.close(); + peer.close(); + if (prior) Object.defineProperty(window, 'nostr', prior); + else delete window.nostr; + } + }; +} diff --git a/web/tests/e2e/history-pagination.spec.ts b/web/tests/e2e/history-pagination.spec.ts @@ -21,7 +21,8 @@ let requests: { origin: string; frame: unknown[] }[] = [], let frames: Record<string, unknown>[][] = [[], []], fault: number | undefined, hold: number | undefined, - ignoreLimit = false; + ignoreLimit = false, + ignoreWindow = false; test.beforeAll(async () => { server = await createStaticHarness(); for (let i = 0; i < 2; i++) { @@ -63,8 +64,9 @@ test.beforeAll(async () => { const rows = frames[i] .filter( (e) => - (f.since === undefined || Number(e.created_at) >= f.since) && - (f.until === undefined || Number(e.created_at) <= f.until) + ignoreWindow || + ((f.since === undefined || Number(e.created_at) >= f.since) && + (f.until === undefined || Number(e.created_at) <= f.until)) ) .sort( (a, b) => @@ -112,6 +114,7 @@ test.beforeEach(async ({ page }) => { fault = undefined; hold = undefined; ignoreLimit = false; + ignoreWindow = false; await page.addInitScript( ({ origins, endpoints }) => { const Native = window.WebSocket; @@ -424,3 +427,112 @@ test('budget pause requires a new explicit review and starts a fresh bounded act historyComplete: false }); }); + +test('CR005500 retained-capacity duplicate deliveries keep bounded budget facts', async ({ + page +}) => { + const capacity = await page.evaluate(() => + window.hcp097Fixture.seedCapacity() + ); + expect(capacity.count).toBe(2000); + expect(capacity.bytes).toBeLessThanOrEqual(50331648); + const wire = await page.evaluate(() => window.hcp097Fixture.outer); + frames[0] = Array.from({ length: 501 }, () => event(wire)); + ignoreLimit = true; + ignoreWindow = true; + const started = performance.now(); + await page.evaluate(async () => { + window.hcp097Fixture.captureOlder(); + await window.hcp097Fixture.loadOlder(); + }); + const snapshot = await page.evaluate(() => + window.hcp097Fixture.olderSnapshot() + ); + expect(requests).toHaveLength(1); + expect(snapshot).toMatchObject({ + state: 'needs_action', + reason: 'budget', + historyComplete: false + }); + console.log( + JSON.stringify({ + fixture: 'CR005_TEST_ONLY_500_DELIVERIES_AT_2000_CAPACITY', + capacity, + wireDeliveriesSent: 501, + logicalActionCap: 500, + milliseconds: performance.now() - started, + snapshot, + qualification: + 'Actual source controller/IDB; hostile controlled relay ignores window/limit to charge500 before dedup; no access/operator/fullQ' + }) + ); +}); +test('CR005 stop during capacity-scale queued history fences remaining writes and owns teardown', async ({ + page +}) => { + await page.evaluate(() => + window.hcp097Fixture.seedCapacity('wss://peer.example.org') + ); + const wires = await page.evaluate(() => + window.hcp097Fixture.capacityOuterWires() + ); + expect(wires).toHaveLength(500); + frames[0] = wires.map((wire) => event(wire)); + await page.evaluate(() => window.hcp097Fixture.observeCapacityWrites()); + ignoreLimit = true; + hold = 0; + await page.evaluate(() => { + window.hcp097Fixture.captureOlder(); + window.hcp097Pending = window.hcp097Fixture.loadOlder(); + }); + await expect.poll(() => requests.length).toBeGreaterThan(0); + await expect + .poll(() => page.evaluate(() => window.hcp097Fixture.capacityWriteCount())) + .toBeGreaterThan(0); + const result = await page.evaluate(async () => { + const started = performance.now(), + writesBeforeStop = window.hcp097Fixture.capacityWriteCount(); + window.hcp097Fixture.stopOlder(); + const immediate = window.hcp097Fixture.olderSnapshot(); + const completed = await window.hcp097Pending; + return { + immediate, + completed, + writesBeforeStop, + writesAfterDrain: window.hcp097Fixture.capacityWriteCount(), + milliseconds: performance.now() - started + }; + }); + expect(result.immediate).toMatchObject({ + state: 'stopped', + historyComplete: false + }); + expect(result.completed).toBe(false); + expect(result.writesBeforeStop).toBeGreaterThan(0); + expect(result.writesBeforeStop).toBeLessThan(500); + expect(result.writesAfterDrain).toBe(result.writesBeforeStop); + await expect.poll(() => closes.length).toBeGreaterThan(0); + console.log( + JSON.stringify({ + fixture: 'CR005_TEST_ONLY_CAPACITY_STOP', + deliveriesSent: 500, + ...result, + qualification: + 'Stop/owned controller teardown only, no rolled-back in-flight write or operator/fullQ claim' + }) + ); +}); + +test('CR005 retained old Stop cannot retire the genuine successor history registry owner', async ({ + page +}) => { + const result = await page.evaluate(() => { + window.hcp097Fixture.captureOlder(); + return window.hcp097Fixture.oldStopAfterSuccessor(); + }); + expect(result).toMatchObject({ + successor: true, + third: false, + current: { state: 'ready', historyComplete: false } + }); +}); diff --git a/web/tests/e2e/private-validation-cache.spec.ts b/web/tests/e2e/private-validation-cache.spec.ts @@ -0,0 +1,211 @@ +import { expect, test } from '@playwright/test'; +import { build } from 'vite'; +import { fileURLToPath } from 'node:url'; +import { createHash } from 'node:crypto'; +import { createStaticHarness } from '../integration/harness/static.ts'; +import type * as Fixture from './harness/private-validation-cache.ts'; +declare global { + interface Window { + cr005: typeof Fixture; + cr005Fixture: Awaited<ReturnType<typeof Fixture.createFixture>>; + } +} +let server: Awaited<ReturnType<typeof createStaticHarness>>, bundle: string; +const baseline = process.env.HCP_CR005_PHASE === 'baseline'; +test.beforeAll(async () => { + server = await createStaticHarness(); + const entry = fileURLToPath( + new URL('./harness/private-validation-cache.ts', import.meta.url) + ), + result = await build({ + configFile: false, + logLevel: 'silent', + plugins: [ + { + name: 'cr005-count-real-validator', + enforce: 'pre', + transform(code, id) { + if (!id.endsWith('/src/lib/nostr/verified-envelope.ts')) return; + const marker = ' if (\n typeof raw'; + expect(code.split(marker)).toHaveLength(2); + return { + code: code.replace( + marker, + ' globalThis.__cr005VerifyCalls = (globalThis.__cr005VerifyCalls ?? 0) + 1;\n' + + marker + ), + map: null + }; + } + } + ], + build: { + write: false, + minify: false, + lib: { entry, name: 'cr005', formats: ['iife'] } + } + }); + const output = Array.isArray(result) ? result[0] : result; + if (!('output' in output)) throw Error('fixture bundle absent'); + const chunks = output.output.filter((row) => row.type === 'chunk'); + expect(chunks).toHaveLength(1); + bundle = chunks[0].code; + console.log( + JSON.stringify({ + fixture: 'CR005_TEST_ONLY_ACTUAL_IDB_REAL_VALIDATOR_COUNT', + phase: baseline ? 'baseline' : 'candidate', + bundleSha256: createHash('sha256').update(bundle).digest('hex'), + moduleIds: Object.keys(chunks[0].modules), + qualification: + 'Counter before unchanged real validator, no fabricated proofs/operator/fullQ' + }) + ); +}); +test.afterAll(async () => server?.close()); +test.beforeEach(async ({ page }) => { + await page.goto(server.url + '/about'); + await page.addScriptTag({ content: bundle }); + await page.evaluate(async () => { + window.cr005Fixture = await window.cr005.createFixture(); + }); +}); +test.afterEach(async ({ page }) => { + if (!page.isClosed()) await page.evaluate(() => window.cr005Fixture?.close()); +}); +test('CR005 actual capacity sample retains complete cursor checks while reusing unchanged validation', async ({ + page +}) => { + const result = await page.evaluate(async () => { + const f = window.cr005Fixture; + return { + first: await f.sample(), + second: await f.sample(), + inventory: await f.inventory(), + metadata: await f.metadata(), + outboxFirst: await f.sample('private_sends'), + outboxSecond: await f.sample('private_sends'), + bytes: f.bytes() + }; + }); + console.log( + JSON.stringify({ + fixture: 'CR005_ACTUAL_CAPACITY_COUNTS', + phase: baseline ? 'baseline' : 'candidate', + ...result + }) + ); + for (const row of [ + result.first, + result.second, + result.inventory, + result.metadata + ]) + expect(row).toMatchObject({ ok: true, cursorVisits: 2000 }); + expect(result.inventory.count).toBe(2000); + expect(result.metadata.count).toBe(2000); + expect(result.outboxFirst).toMatchObject({ ok: true, cursorVisits: 100 }); + expect(result.outboxSecond).toMatchObject({ ok: true, cursorVisits: 100 }); + expect(result.bytes.received).toBeLessThanOrEqual(50331648); + expect(result.bytes.sends).toBeLessThanOrEqual(8388608); + if (baseline) { + expect(result.first.verificationCalls).toBe(2001); + expect(result.second.verificationCalls).toBe(2001); + expect(result.inventory.verificationCalls).toBe(4000); + expect(result.metadata.verificationCalls).toBe(6000); + } else { + expect(result.first.verificationCalls).toBe(2000); + expect(result.second.verificationCalls).toBe(0); + expect(result.inventory.verificationCalls).toBe(0); + expect(result.metadata.verificationCalls).toBe(0); + } +}); +for (const change of ['valid', 'corrupt', 'summary', 'id'] as const) + test( + 'CR005 warm complete namespace rejects or revalidates changed ' + + change + + ' tail through a second connection', + async ({ page }) => { + const result = await page.evaluate(async (change) => { + const f = window.cr005Fixture; + await f.sample(); + await f.changeTail(change, true); + return await f.sample(); + }, change); + if (change === 'valid') + expect(result).toMatchObject({ + ok: true, + cursorVisits: 2000, + verificationCalls: 1 + }); + else + expect(result).toMatchObject({ + ok: false, + reason: 'corrupt_record', + cursorVisits: 2000 + }); + } + ); +test('CR005 wrong namespace cannot borrow warm validation or claim empty owner history', async ({ + page +}) => { + const result = await page.evaluate(async () => { + const f = window.cr005Fixture; + await f.sample(); + return { read: await f.foreignRead(), metadata: await f.metadata(true) }; + }); + expect(result.read).toMatchObject({ ok: false }); + expect(result.metadata).toMatchObject({ ok: false, reason: 'invalid_scope' }); +}); +test('CR005 warm outbox still rejects actual101rows without eviction', async ({ + page +}) => { + const result = await page.evaluate(async () => { + const f = window.cr005Fixture; + await f.sample('private_sends'); + return await f.overfillSends(); + }); + expect(result).toMatchObject({ ok: false, reason: 'capacity' }); +}); +test('CR005 encoded byte accounting rejects changed oversized received namespace', async ({ + page +}) => { + const result = await page.evaluate(async () => { + const f = window.cr005Fixture; + await f.sample(); + return await f.oversizeReceived(); + }); + expect(result.bytes).toBeGreaterThan(50331648); + expect(result).toMatchObject({ ok: false, reason: 'capacity' }); +}); + +test('CR005 warm received namespace rejects actual2001rows without eviction', async ({ + page +}) => { + const result = await page.evaluate(async () => { + const f = window.cr005Fixture; + await f.sample(); + return await f.overfillReceived(); + }); + expect(result).toMatchObject({ ok: false, reason: 'capacity' }); +}); +test('CR005 changed current read/source metadata is revalidated and reflected in original history', async ({ + page +}) => { + const result = await page.evaluate(async () => { + const f = window.cr005Fixture; + await f.sample(); + await f.changeTail('metadata', true); + return { read: await f.sample(), metadata: await f.metadata() }; + }); + expect(result.read).toMatchObject({ + ok: true, + cursorVisits: 2000, + verificationCalls: 1 + }); + expect(result.metadata).toMatchObject({ + ok: true, + cursorVisits: 2000, + verificationCalls: 0, + count: 2001 + }); +}); diff --git a/web/tests/provenance/output.test.mjs b/web/tests/provenance/output.test.mjs @@ -1958,6 +1958,10 @@ import { auditOutput } from '../../tools/check-output.mjs'; 'src/lib/persistence/local-inventory.ts', 'src/lib/persistence/private-storage.ts', 'src/lib/persistence/private-outbox-cleanup.ts', + 'src/lib/persistence/private-records.ts', + 'src/lib/persistence/inbox-envelope-repository.ts', + 'src/lib/persistence/history-metadata-repository.ts', + 'src/lib/messaging/history-pagination.ts', 'src/lib/runtime/private-session.ts', 'src/lib/components/LocalDataReview.svelte' ]) { diff --git a/web/tests/unit/private-records.test.ts b/web/tests/unit/private-records.test.ts @@ -7,6 +7,8 @@ import { import { nip44 } from 'applesauce-core/helpers/encryption'; import { decodePrivateRecord, + privateReceivedOuterMetadata, + type PrivateRecordHandle, privateRecordSnapshot, privateRecordWire, inspectPrivateSendReservation @@ -92,6 +94,68 @@ function fixture(extended = false) { } } describe('ciphertext-only private local codecs, not nested authenticity or effect authority', () => { + it('CR005 transport metadata belongs only to the genuine received handle and exact owner/id', () => { + const f = fixture(true), + decoded = decodePrivateRecord( + JSON.stringify(f.received), + f.owner, + f.received.id + ); + expect(decoded.ok).toBe(true); + if (!decoded.ok) throw Error('strict fixture rejected'); + expect( + privateReceivedOuterMetadata(decoded.value, f.owner, f.received.id) + ).toEqual({ id: f.received.id, createdAt: 1700000000 }); + expect( + privateReceivedOuterMetadata(decoded.value, f.peer, f.received.id) + ).toBeUndefined(); + expect( + privateReceivedOuterMetadata(decoded.value, f.owner, command) + ).toBeUndefined(); + expect( + privateReceivedOuterMetadata( + Object.freeze({ ...decoded.value }) as PrivateRecordHandle, + f.owner, + f.received.id + ) + ).toBeUndefined(); + expect( + privateReceivedOuterMetadata( + Object.freeze({}) as PrivateRecordHandle, + undefined, + undefined + ) + ).toBeUndefined(); + const copy = privateReceivedOuterMetadata( + decoded.value, + f.owner, + f.received.id + )!; + Object.assign(copy, { createdAt: 0 }); + const detached = privateRecordSnapshot( + decoded.value, + f.owner, + f.received.id + )!; + Object.assign(detached, { outer: 'untrusted changed snapshot' }); + expect( + privateReceivedOuterMetadata(decoded.value, f.owner, f.received.id) + ).toEqual({ id: f.received.id, createdAt: 1700000000 }); + const sender = fixture(); + for (const record of [sender.operation, sender.reservation]) { + const other = decodePrivateRecord( + JSON.stringify(record), + sender.owner, + record.id + ); + expect(other.ok).toBe(true); + if (!other.ok) throw Error('strict sender fixture rejected'); + expect( + privateReceivedOuterMetadata(other.value, sender.owner, record.id) + ).toBeUndefined(); + } + }); + it('retains original receive hints/inert tags but keeps stored outgoing artifacts strict', () => { const f = fixture(true), decoded = decodePrivateRecord( diff --git a/web/tools/check-output.mjs b/web/tools/check-output.mjs @@ -366,6 +366,12 @@ async function operationalFlagsAdmission(web) { '8bcc73be03321e60a6fbbe7ba58de14eb8fb34db5d5cdce0adee31b5467d7bb9', 'src/lib/persistence/local-data-review.ts': '90379b183d0a1d8885076fbfc593d7c9ac1e351b16ce7800890107014e5cb0e4', + 'src/lib/persistence/inbox-envelope-repository.ts': + 'd3613a098c93c8881d53de12f91ffb689827926217cabcba66894885d49cb095', + 'src/lib/persistence/history-metadata-repository.ts': + 'afe4656e59bd6b365444fbda64fe6572ffa4c5323c474ee862e3cf19252b6f6d', + 'src/lib/messaging/history-pagination.ts': + '79b22b312a126b55c80a3c6ca22724bd2c5f3ad766f8600f3647028a2624c255', 'src/lib/persistence/private-outbox-cleanup.ts': '13f4e7d771b3a8d4ec7703f2026a1c8ff71582a2d2a810b9d402d58684b2e2b6', 'src/lib/persistence/local-inventory.ts': @@ -375,9 +381,9 @@ async function operationalFlagsAdmission(web) { 'src/lib/persistence/local-public-hides.ts': '4f0e64ed0fabbe9f86014a0512e7dbd3c81711f28ca2c626e2dafa5cda349f83', 'src/lib/persistence/private-records.ts': - '3389fe2fc5b9b84b292b4340fe1edda16a2eb365c1b0fb00d965827dd9b02ce6', + 'a9a7c450808ea363594f2cce5d50c48b8a614197dd0b9690c4860d8387419dcf', 'src/lib/persistence/private-storage.ts': - 'a5587d3d1e8af689355e170e19d3b8572eba35b0698dab15f0b97294a0ad6e1e', + '49b9ef328e569e93c2e88f4c0e8e3e927985fb9ac53daa6814b7471451b81104', 'src/lib/persistence/public-publications.ts': 'be99c4114fb32880e0a9b48ab3593645532853fb4166fb506f398416db41a194', 'src/lib/persistence/public-receipts.ts': @@ -610,6 +616,12 @@ async function privacyDataAdmission(web) { '8bcc73be03321e60a6fbbe7ba58de14eb8fb34db5d5cdce0adee31b5467d7bb9', 'src/lib/persistence/local-data-review.ts': '90379b183d0a1d8885076fbfc593d7c9ac1e351b16ce7800890107014e5cb0e4', + 'src/lib/persistence/inbox-envelope-repository.ts': + 'd3613a098c93c8881d53de12f91ffb689827926217cabcba66894885d49cb095', + 'src/lib/persistence/history-metadata-repository.ts': + 'afe4656e59bd6b365444fbda64fe6572ffa4c5323c474ee862e3cf19252b6f6d', + 'src/lib/messaging/history-pagination.ts': + '79b22b312a126b55c80a3c6ca22724bd2c5f3ad766f8600f3647028a2624c255', 'src/lib/persistence/private-outbox-cleanup.ts': '13f4e7d771b3a8d4ec7703f2026a1c8ff71582a2d2a810b9d402d58684b2e2b6', 'src/lib/persistence/local-inventory.ts': @@ -619,9 +631,9 @@ async function privacyDataAdmission(web) { 'src/lib/persistence/local-public-hides.ts': '4f0e64ed0fabbe9f86014a0512e7dbd3c81711f28ca2c626e2dafa5cda349f83', 'src/lib/persistence/private-records.ts': - '3389fe2fc5b9b84b292b4340fe1edda16a2eb365c1b0fb00d965827dd9b02ce6', + 'a9a7c450808ea363594f2cce5d50c48b8a614197dd0b9690c4860d8387419dcf', 'src/lib/persistence/private-storage.ts': - 'a5587d3d1e8af689355e170e19d3b8572eba35b0698dab15f0b97294a0ad6e1e', + '49b9ef328e569e93c2e88f4c0e8e3e927985fb9ac53daa6814b7471451b81104', 'src/lib/persistence/public-publications.ts': 'be99c4114fb32880e0a9b48ab3593645532853fb4166fb506f398416db41a194', 'src/lib/persistence/public-receipts.ts': @@ -824,7 +836,7 @@ async function supportReportingAdmission(web) { 'src/lib/persistence/local-public-hides.ts': '4f0e64ed0fabbe9f86014a0512e7dbd3c81711f28ca2c626e2dafa5cda349f83', 'src/lib/persistence/private-storage.ts': - 'a5587d3d1e8af689355e170e19d3b8572eba35b0698dab15f0b97294a0ad6e1e', + '49b9ef328e569e93c2e88f4c0e8e3e927985fb9ac53daa6814b7471451b81104', 'src/lib/persistence/public-publications.ts': 'be99c4114fb32880e0a9b48ab3593645532853fb4166fb506f398416db41a194', 'src/lib/persistence/public-receipts.ts': @@ -1011,7 +1023,7 @@ async function privateBlockingAdmission(web) { 'src/lib/persistence/local-public-hides.ts': '4f0e64ed0fabbe9f86014a0512e7dbd3c81711f28ca2c626e2dafa5cda349f83', 'src/lib/persistence/private-storage.ts': - 'a5587d3d1e8af689355e170e19d3b8572eba35b0698dab15f0b97294a0ad6e1e', + '49b9ef328e569e93c2e88f4c0e8e3e927985fb9ac53daa6814b7471451b81104', 'src/lib/persistence/public-publications.ts': 'be99c4114fb32880e0a9b48ab3593645532853fb4166fb506f398416db41a194', 'src/lib/persistence/public-receipts.ts': @@ -2134,7 +2146,7 @@ async function inboxPresentationAdmission(web) { 'src/lib/messaging/conversation-thread.ts': '7367f0e6d96a9f249514f66c2459274e856eb83462523e37264d4cd97d2e36d1', 'src/lib/persistence/private-storage.ts': - 'a5587d3d1e8af689355e170e19d3b8572eba35b0698dab15f0b97294a0ad6e1e', + '49b9ef328e569e93c2e88f4c0e8e3e927985fb9ac53daa6814b7471451b81104', 'src/routes/messages/[conversationId=local_id]/+page.svelte': 'b06c6189adee80b68bc6657fa0e8504551fe9a8b1655a6d81807ebee9930a5e7', 'src/lib/components/MessageComposer.svelte':