app

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

commit 1bcdb56ed84aaa84b8c047a229f39147f92d3c73
parent e4e61993484bff26f5a64c9d12b2eae9010e0a6b
Author: triesap <tyson@radroots.org>
Date:   Wed, 14 Oct 2026 21:49:34 +0000

web: Persist genuine inbox probe nonce facts

- Verify recovered probes through the shared strict nonce reader.
- Bind nonce facts to genuine applied readback lineage and native completion.
- Preserve protected outcomes and reject forged or stale acknowledgements.
- Cover original and recovered flows with native browser regressions.

Diffstat:
Mweb/src/lib/nostr/self-recovery-reader.ts | 313++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-----------------
Mweb/src/lib/persistence/inbox-probes.ts | 384++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-
Aweb/tests/e2e/harness/inbox-probe-nonce-facts.ts | 298+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/tests/e2e/inbox-probe-nonce-facts.spec.ts | 1295+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/tests/unit/inbox-probe-nonce-facts.test.ts | 104+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/tools/check-output.mjs | 10+++++-----
6 files changed, 2330 insertions(+), 74 deletions(-)

diff --git a/web/src/lib/nostr/self-recovery-reader.ts b/web/src/lib/nostr/self-recovery-reader.ts @@ -10,6 +10,7 @@ import { } from './private-pool.ts'; import { inboxProbePublicationBinding, + recoveredInboxProbePublicationBinding, type InboxProbeAcknowledgement } from '../persistence/inbox-probes.ts'; import { inboxProbeRumorWire, inboxProbeRumorMatches } from './inbox-access.ts'; @@ -420,11 +421,30 @@ export type InboxProbeNonceResult = | 'mismatch' | 'lost_evidence'; }>; +declare const recoveredProbeNonceReaderBrand: unique symbol; +export type RecoveredInboxProbeNonceReader = Readonly<{ + [recoveredProbeNonceReaderBrand]: true; +}>; +declare const recoveredProbeNonceProofBrand: unique symbol; +export type RecoveredInboxProbeNonceProof = Readonly<{ + [recoveredProbeNonceProofBrand]: true; +}>; +export type RecoveredInboxProbeNonceResult = + | Exclude<InboxProbeNonceResult, { status: 'nonce_verified' }> + | Readonly<{ + status: 'nonce_verified'; + proof: RecoveredInboxProbeNonceProof; + }>; +type NonceResult = InboxProbeNonceResult | RecoveredInboxProbeNonceResult; +type NonceReader = InboxProbeNonceReader | RecoveredInboxProbeNonceReader; +type NonceProof = InboxProbeNonceProof | RecoveredInboxProbeNonceProof; +type NonceSource = 'construction' | 'recovered'; type ProbeReader = { - run(): Promise<InboxProbeNonceResult>; + source: NonceSource; + run(): Promise<NonceResult>; stop(expired: boolean): void; }; -const probeReaders = new WeakMap<InboxProbeNonceReader, ProbeReader>(); +const probeReaders = new WeakMap<NonceReader, ProbeReader>(); const probeObservationReaders = new WeakMap< InboxProbeReadbackAttemptResult, Readonly<{ @@ -432,20 +452,24 @@ const probeObservationReaders = new WeakMap< identity: IdentitySession; session: PrivateSession; policy: RelayPolicy; - reader: InboxProbeNonceReader; + source: NonceSource; + reader: NonceReader; }> >(); -const probeNonceProofs = new WeakMap< - InboxProbeNonceProof, - Readonly<{ - repository: PrivateStorageRepository; - session: PrivateSession; - policy: RelayPolicy; - observation: InboxProbeReadbackAttemptResult; - acknowledgement: InboxProbeAcknowledgement; - original: string; - current(): boolean; - }> +type SavedNonceProof = Readonly<{ + repository: PrivateStorageRepository; + session: PrivateSession; + policy: RelayPolicy; + observation: InboxProbeReadbackAttemptResult; + acknowledgement: InboxProbeAcknowledgement; + original: string; + verifiedAtMilliseconds: number; + current(): boolean; +}>; +const probeNonceProofs = new WeakMap<InboxProbeNonceProof, SavedNonceProof>(); +const recoveredNonceProofs = new WeakMap< + RecoveredInboxProbeNonceProof, + SavedNonceProof >(); function immutableProbe( record: import('../persistence/private-records.ts').PrivateAccessProbe @@ -461,14 +485,15 @@ function immutableProbe( } // Genuine positive source transport, actual identity/private session, original // nonce and native custody are all required. Capture never calls the provider. -export function captureInboxProbeNonceReader( +function captureProbeNonceReader( + source: NonceSource, repository: PrivateStorageRepository, identity: IdentitySession, session: PrivateSession, policy: RelayPolicy, observation: InboxProbeReadbackAttemptResult, review: unknown -): InboxProbeNonceReader | undefined { +): NonceReader | undefined { if ( typeof window === 'undefined' || review !== 'reviewed_inbox_probe_nonce_decryption' @@ -478,13 +503,32 @@ export function captureInboxProbeNonceReader( const effect = inboxProbeReadbackAttemptEvidence(observation); if (!effect || effect.repository !== repository) return undefined; const acknowledgement = effect.acknowledgement, - binding = inboxProbePublicationBinding( + lookup = + source === 'construction' + ? inboxProbePublicationBinding + : recoveredInboxProbePublicationBinding, + binding = lookup(repository, session, acknowledgement, policy); + if (!binding?.record.self) return undefined; + function expectedRumor(): string | undefined { + if (source === 'construction') + return inboxProbeRumorWire( + binding!.identity as Parameters<typeof inboxProbeRumorWire>[0], + session + ); + const recovered = binding!.identity as RecoveredInboxProbe, + original = recoveredProbes.get(recovered); + if (!original || original.identity !== identity) return undefined; + return recoveredInboxProbeRumorWire( + recovered, repository, session, - acknowledgement, - policy + original.access, + policy, + original.operator ); - if (!binding?.record.self) return undefined; + } + // Strong recovered associations precede passive private-session ownership. + if (!expectedRumor()) return undefined; const identityOwner = identityMessagingOwnership(identity); if ( !identityOwner?.current() || @@ -511,33 +555,29 @@ export function captureInboxProbeNonceReader( binding.record.owner, fact.readbackWire ) || - !inboxProbeRumorWire(binding.identity, session) + !expectedRumor() ) return undefined; const previous = probeObservationReaders.get(observation); if (previous) - return previous.repository === repository && + return previous.source === source && + previous.repository === repository && previous.identity === identity && previous.session === session && previous.policy === policy ? previous.reader : undefined; const original = immutableProbe(binding.record), - token = Object.freeze({}) as InboxProbeNonceReader; + token = Object.freeze({}) as NonceReader; let stopped = false, started = false, pending = false, active: ExtensionAction | undefined, - proof: InboxProbeNonceProof | undefined, - last: InboxProbeNonceResult | undefined; + proof: NonceProof | undefined, + last: NonceResult | undefined; const listeners = new Map<symbol, () => void>(); function current() { - const fresh = inboxProbePublicationBinding( - repository, - session, - acknowledgement, - policy - ); + const fresh = lookup(repository, session, acknowledgement, policy); return ( !stopped && identityOwner!.current() && @@ -545,7 +585,7 @@ export function captureInboxProbeNonceReader( !!fresh && fresh.identity === binding!.identity && immutableProbe(fresh.record) === original && - !!inboxProbeRumorWire(fresh.identity, session) + !!expectedRumor() ); } function stop(expired: boolean) { @@ -554,7 +594,10 @@ export function captureInboxProbeNonceReader( if (expired) markExtensionWaitExpired(active); else stopExtensionAction(active); } - if (proof) probeNonceProofs.delete(proof); + if (proof) { + probeNonceProofs.delete(proof as InboxProbeNonceProof); + recoveredNonceProofs.delete(proof as RecoveredInboxProbeNonceProof); + } proof = undefined; for (const [id, off] of listeners) { off(); @@ -571,7 +614,7 @@ export function captureInboxProbeNonceReader( identityOwner.owner, current ); - async function run(): Promise<InboxProbeNonceResult> { + async function run(): Promise<NonceResult> { if (!current()) { stop(false); return { status: 'stopped' }; @@ -586,10 +629,10 @@ export function captureInboxProbeNonceReader( last = await navigator.locks.request( 'harvestcircle:owner:' + identityOwner!.owner, { mode: 'exclusive', ifAvailable: true }, - async (lock): Promise<InboxProbeNonceResult> => { + async (lock): Promise<NonceResult> => { if (!lock) return { status: 'busy' }; if (!current()) return { status: 'stopped' }; - const captured = inboxProbePublicationBinding( + const captured = lookup( repository, session, acknowledgement, @@ -610,12 +653,8 @@ export function captureInboxProbeNonceReader( captured.record.owner, captured.record.id ) !== captured.wire || - inboxProbePublicationBinding( - repository, - session, - acknowledgement, - policy - )?.wire !== captured.wire + lookup(repository, session, acknowledgement, policy)?.wire !== + captured.wire ) return { status: 'conflict' }; const checked = verifyEnvelope(captured.record.self.wire), @@ -648,15 +687,12 @@ export function captureInboxProbeNonceReader( operation: Symbol() }, current, - async (action): Promise<InboxProbeNonceResult> => { + async (action): Promise<NonceResult> => { active = action; const opened = await decryptor.open(action, outer); if (!current()) return { status: 'stopped' }; if (opened.status !== 'opened') return opened; - const expected = inboxProbeRumorWire( - captured.identity, - session - ); + const expected = expectedRumor(); if (!expected || opened.rumorWire !== expected) return { status: 'mismatch' }; const rumor = JSON.parse(opened.rumorWire) as { @@ -674,6 +710,13 @@ export function captureInboxProbeNonceReader( // final physical read. No extension callback follows that read. if (!(await decryptor.fresh(action))) return { status: 'stopped' }; + const verifiedAtMilliseconds = Date.now(); + if (!current()) return { status: 'stopped' }; + if ( + !Number.isSafeInteger(verifiedAtMilliseconds) || + verifiedAtMilliseconds < 0 + ) + return { status: 'mismatch' }; const after = await observePrivateRecord( repository, 'private_sends', @@ -688,31 +731,40 @@ export function captureInboxProbeNonceReader( captured.record.owner, captured.record.id ) !== captured.wire || - inboxProbePublicationBinding( - repository, - session, - acknowledgement, - policy - )?.wire !== captured.wire + lookup(repository, session, acknowledgement, policy)?.wire !== + captured.wire ) return { status: 'conflict' }; - if ( - !current() || - inboxProbeRumorWire(captured.identity, session) !== expected - ) + if (!current() || expectedRumor() !== expected) return { status: 'stopped' }; - const issued = Object.freeze({}) as InboxProbeNonceProof; - probeNonceProofs.set(issued, { + const issued = Object.freeze({}) as NonceProof; + const saved = { repository, session, policy, observation, acknowledgement, original, + verifiedAtMilliseconds, current - }); + }; + if (source === 'construction') + probeNonceProofs.set(issued as InboxProbeNonceProof, saved); + else + recoveredNonceProofs.set( + issued as RecoveredInboxProbeNonceProof, + saved + ); proof = issued; - return { status: 'nonce_verified', proof: issued }; + return source === 'construction' + ? { + status: 'nonce_verified', + proof: issued as InboxProbeNonceProof + } + : { + status: 'nonce_verified', + proof: issued as RecoveredInboxProbeNonceProof + }; } ); if (!current()) return { status: 'stopped' }; @@ -732,10 +784,11 @@ export function captureInboxProbeNonceReader( pending = false; } } - probeReaders.set(token, { run, stop }); + probeReaders.set(token, { source, run, stop }); // Reserve before callback-capable subscriptions; reentrant capture reuses // this exact original reader and cannot reset or start another SDK action. probeObservationReaders.set(observation, { + source, repository, identity, session, @@ -753,18 +806,77 @@ export function captureInboxProbeNonceReader( return undefined; } } +export function captureInboxProbeNonceReader( + repository: PrivateStorageRepository, + identity: IdentitySession, + session: PrivateSession, + policy: RelayPolicy, + observation: InboxProbeReadbackAttemptResult, + review: unknown +): InboxProbeNonceReader | undefined { + return captureProbeNonceReader( + 'construction', + repository, + identity, + session, + policy, + observation, + review + ) as InboxProbeNonceReader | undefined; +} +export function captureRecoveredInboxProbeNonceReader( + repository: PrivateStorageRepository, + identity: IdentitySession, + session: PrivateSession, + policy: RelayPolicy, + observation: InboxProbeReadbackAttemptResult, + review: unknown +): RecoveredInboxProbeNonceReader | undefined { + return captureProbeNonceReader( + 'recovered', + repository, + identity, + session, + policy, + observation, + review + ) as RecoveredInboxProbeNonceReader | undefined; +} export function readInboxProbeNonce( reader: InboxProbeNonceReader ): Promise<InboxProbeNonceResult> { - return ( - probeReaders.get(reader)?.run() ?? Promise.resolve({ status: 'invalid' }) - ); + const saved = probeReaders.get(reader); + return saved?.source === 'construction' + ? (saved.run() as Promise<InboxProbeNonceResult>) + : Promise.resolve({ status: 'invalid' }); } export function stopInboxProbeNonceReader(reader: InboxProbeNonceReader) { - probeReaders.get(reader)?.stop(false); + const saved = probeReaders.get(reader); + if (saved?.source === 'construction') saved.stop(false); } export function expireInboxProbeNonceReaderWait(reader: InboxProbeNonceReader) { - probeReaders.get(reader)?.stop(true); + const saved = probeReaders.get(reader); + if (saved?.source === 'construction') saved.stop(true); +} +export function readRecoveredInboxProbeNonce( + reader: RecoveredInboxProbeNonceReader +): Promise<RecoveredInboxProbeNonceResult> { + const saved = probeReaders.get(reader); + return saved?.source === 'recovered' + ? (saved.run() as Promise<RecoveredInboxProbeNonceResult>) + : Promise.resolve({ status: 'invalid' }); +} +export function stopRecoveredInboxProbeNonceReader( + reader: RecoveredInboxProbeNonceReader +) { + const saved = probeReaders.get(reader); + if (saved?.source === 'recovered') saved.stop(false); +} +export function expireRecoveredInboxProbeNonceReaderWait( + reader: RecoveredInboxProbeNonceReader +) { + const saved = probeReaders.get(reader); + if (saved?.source === 'recovered') saved.stop(true); } export function inboxProbeNonceProofBinding( proof: InboxProbeNonceProof, @@ -801,6 +913,73 @@ export function inboxProbeNonceProofBinding( }; } +export function recoveredInboxProbeNonceProofBinding( + proof: RecoveredInboxProbeNonceProof, + repository: PrivateStorageRepository, + session: PrivateSession, + policy: RelayPolicy +) { + const saved = recoveredNonceProofs.get(proof); + if ( + !saved || + saved.repository !== repository || + saved.session !== session || + saved.policy !== policy || + !saved.current() + ) + return undefined; + const binding = recoveredInboxProbePublicationBinding( + repository, + session, + saved.acknowledgement, + policy + ); + if (!binding || immutableProbe(binding.record) !== saved.original) + return undefined; + return { + acknowledgement: saved.acknowledgement, + observation: saved.observation, + identity: binding.identity, + owner: binding.record.owner, + command: binding.record.id, + rumorHash: binding.record.rumorHash, + eventId: binding.record.self!.eventId, + current: () => saved.current() + }; +} +// Local genuine nonce verification only; caller copies of this projection are +// never accepted by the append owner in place of the original opaque proof. +export function inboxProbeNonceVerificationEvidence( + proof: InboxProbeNonceProof | RecoveredInboxProbeNonceProof, + repository: PrivateStorageRepository, + session: PrivateSession, + policy: RelayPolicy +) { + const original = probeNonceProofs.get(proof as InboxProbeNonceProof), + recovered = recoveredNonceProofs.get( + proof as RecoveredInboxProbeNonceProof + ), + saved = original ?? recovered, + binding = original + ? inboxProbeNonceProofBinding( + proof as InboxProbeNonceProof, + repository, + session, + policy + ) + : recovered + ? recoveredInboxProbeNonceProofBinding( + proof as RecoveredInboxProbeNonceProof, + repository, + session, + policy + ) + : undefined; + return saved && binding && binding.current() + ? { ...binding, verifiedAtMilliseconds: saved.verifiedAtMilliseconds } + : undefined; +} + declare const probeRecoveryReaderBrand: unique symbol; export type InboxProbeRecoveryReader = Readonly<{ [probeRecoveryReaderBrand]: true; diff --git a/web/src/lib/persistence/inbox-probes.ts b/web/src/lib/persistence/inbox-probes.ts @@ -7,7 +7,10 @@ import { import { inboxProbePolicyMatches } from '../nostr/inbox-access.ts'; import { recoveredInboxProbeBinding, - type RecoveredInboxProbe + inboxProbeNonceVerificationEvidence, + type RecoveredInboxProbe, + type InboxProbeNonceProof, + type RecoveredInboxProbeNonceProof } from '../nostr/self-recovery-reader.ts'; import type { InboxAccessController } from '../messaging/inbox-access-controller.ts'; import type { InboxOperatorQualification } from '../config/inbox-operators.ts'; @@ -40,7 +43,9 @@ import { decodePrivateRecord, privateRecordWire, privateRecordSnapshot, - type PrivateAccessProbe + type PrivateAccessProbe, + type PrivateAccessProbeReceipt, + type PrivateRecordHandle } from './private-records.ts'; import { verifyEnvelope, @@ -794,3 +799,378 @@ export function commitInboxProbeReadbackAttempt( ): Promise<InboxProbeArchiveCommitResult> { return commitProbeAttempt(repository, result, 'access_readback'); } + +declare const nonceAcknowledgementBrand: unique symbol; +export type InboxProbeNonceAcknowledgement = Readonly<{ + [nonceAcknowledgementBrand]: true; +}>; +export type InboxProbeNonceCommitResult = Readonly<{ + status: + | 'saved' + | 'existing' + | 'reconciled' + | PrivateStorageFailure + | 'invalid' + | 'busy' + | 'stopped'; + disposition: 'original_protected'; + acknowledgement?: InboxProbeNonceAcknowledgement; + provenance?: 'current' | 'historical_only'; +}>; +type NonceProof = InboxProbeNonceProof | RecoveredInboxProbeNonceProof; +type NonceOperationInput = Readonly<{ + repository: PrivateStorageRepository; + session: PrivateSession; + policy: RelayPolicy; + proof: NonceProof; + acknowledgement: InboxProbeAcknowledgement; + observation: InboxProbeReadbackAttemptResult; + lineage: Lineage; + baseWire: string; + nextWire: string; + nextRecord: PrivateAccessProbe; + nextHandle: PrivateRecordHandle; +}>; +type NonceOperation = NonceOperationInput & + Readonly<{ + uncertain(): boolean; + applied(): boolean; + markAttempted(): void; + markDefiniteFailure(): void; + markApplied(): void; + acknowledgementToken(): InboxProbeNonceAcknowledgement | undefined; + issueAcknowledgement(): InboxProbeNonceAcknowledgement; + }>; +function createNonceOperation(input: NonceOperationInput): NonceOperation { + let uncertain = false, + applied = false, + acknowledgement: InboxProbeNonceAcknowledgement | undefined; + return { + ...input, + uncertain: () => uncertain, + applied: () => applied, + markAttempted() { + uncertain = true; + }, + markDefiniteFailure() { + uncertain = false; + }, + markApplied() { + applied = true; + }, + acknowledgementToken: () => acknowledgement, + issueAcknowledgement() { + return (acknowledgement ??= Object.freeze( + {} + ) as InboxProbeNonceAcknowledgement); + } + }; +} +const nonceOperations = new WeakMap<NonceProof, NonceOperation>(); +const nonceAcknowledgements = new WeakMap< + InboxProbeNonceAcknowledgement, + NonceOperation +>(); +function currentNonceOperation(operation: NonceOperation): boolean { + const evidence = inboxProbeNonceVerificationEvidence( + operation.proof, + operation.repository, + operation.session, + operation.policy + ); + return ( + !!evidence && + evidence.acknowledgement === operation.acknowledgement && + evidence.observation === operation.observation && + evidence.current() && + acknowledgements.get(evidence.acknowledgement)?.lineage === + operation.lineage && + appliedArchiveEvidence.get(evidence.observation) === operation.lineage + ); +} +function nonceSuccess( + operation: NonceOperation, + status: 'saved' | 'existing' | 'reconciled' +): InboxProbeNonceCommitResult { + if (!currentNonceOperation(operation)) + return { + status, + disposition: 'original_protected', + provenance: 'historical_only' + }; + let acknowledgement = operation.acknowledgementToken(); + if (!acknowledgement) { + acknowledgement = operation.issueAcknowledgement(); + nonceAcknowledgements.set(acknowledgement, operation); + } + return { + status, + disposition: 'original_protected', + provenance: 'current', + acknowledgement + }; +} + +// Persist a genuine local nonce observation, never a caller receipt/status. +// A source-admitted native operation may settle after loss as history only. +export async function commitInboxProbeNonceVerification( + repository: PrivateStorageRepository, + session: PrivateSession, + policy: RelayPolicy, + proof: NonceProof +): Promise<InboxProbeNonceCommitResult> { + const refuse = ( + status: InboxProbeNonceCommitResult['status'] + ): InboxProbeNonceCommitResult => ({ + status, + disposition: 'original_protected' + }); + try { + if (typeof window === 'undefined') return refuse('invalid'); + const evidence = inboxProbeNonceVerificationEvidence( + proof, + repository, + session, + policy + ), + saved = evidence && acknowledgements.get(evidence.acknowledgement), + effect = + evidence && inboxProbeReadbackAttemptEvidence(evidence.observation); + // All strong nonce/read/ACK associations precede passive ownership or DB. + if ( + !evidence || + !saved || + !effect || + effect.repository !== repository || + effect.acknowledgement !== evidence.acknowledgement || + saved.repository !== repository || + saved.session !== session || + appliedArchiveEvidence.get(evidence.observation) !== saved.lineage || + !evidence.current() + ) + return refuse('invalid'); + const fact = JSON.parse(effect.receiptWire) as PrivateAccessProbeReceipt; + const lineage = saved.lineage; + if ( + fact.role !== 'access_readback' || + fact.status !== 'readback' || + fact.eventId !== evidence.eventId || + !lineage.record().self || + evidence.command !== lineage.record().id || + evidence.owner !== lineage.record().owner || + !Number.isSafeInteger(evidence.verifiedAtMilliseconds) || + evidence.verifiedAtMilliseconds < 0 + ) + return refuse('invalid'); + const original = lineage; + if (!original.begin()) return refuse('busy'); + // Only the owner that actually acquired begin may finish this lineage. + try { + if (!navigator.locks?.request) return refuse('unavailable'); + return await navigator.locks.request( + 'harvestcircle:owner:' + evidence.owner, + { mode: 'exclusive', ifAvailable: true }, + async (lock): Promise<InboxProbeNonceCommitResult> => { + if (!lock) return refuse('busy'); + if (!evidence.current()) return refuse('stopped'); + const job = await withIdlePrivateLocalStorage( + session, + async (): Promise<InboxProbeNonceCommitResult> => { + if (!evidence.current()) return refuse('stopped'); + const observed = await observePrivateRecord( + repository, + 'private_sends', + evidence.command + ); + if (!evidence.current()) return refuse('stopped'); + if (!observed.ok) return refuse(observed.reason); + let operation = nonceOperations.get(proof); + if ( + operation && + (operation.repository !== repository || + operation.session !== session || + operation.policy !== policy || + operation.lineage !== original || + operation.acknowledgement !== evidence.acknowledgement || + operation.observation !== evidence.observation) + ) + return refuse('invalid_scope'); + if ( + privateRecordWire( + observed.value.handle, + evidence.owner, + evidence.command + ) !== observed.value.wire + ) + return refuse('conflict'); + if (operation?.applied()) { + if (observed.value.wire !== original.wire()) + return refuse('conflict'); + return nonceSuccess(operation, 'existing'); + } + if ( + operation?.uncertain() && + observed.value.wire === operation.nextWire + ) { + if (original.wire() !== operation.baseWire) + return refuse('conflict'); + original.admit(operation.nextRecord, operation.nextWire); + operation.markApplied(); + return nonceSuccess(operation, 'reconciled'); + } + if ( + observed.value.wire !== original.wire() || + (operation && operation.baseWire !== original.wire()) + ) + return refuse('conflict'); + if (!operation) { + if (original.record().revision === Number.MAX_SAFE_INTEGER) + return refuse('invalid_record'); + const candidate = decodePrivateRecord( + JSON.stringify({ + ...original.record(), + revision: original.record().revision + 1, + receipts: [ + ...original.record().receipts, + { + ...fact, + status: 'nonce_verified', + observedAtMilliseconds: evidence.verifiedAtMilliseconds + } + ] + }), + evidence.owner, + evidence.command + ); + if (!candidate.ok) return refuse('invalid_record'); + const nextWire = privateRecordWire( + candidate.value, + evidence.owner, + evidence.command + ), + nextRecord = privateRecordSnapshot( + candidate.value, + evidence.owner, + evidence.command + ); + if ( + !nextWire || + !nextRecord || + nextRecord.family !== 'private_access_probe' + ) + return refuse('invalid_record'); + operation = createNonceOperation({ + repository, + session, + policy, + proof, + acknowledgement: evidence.acknowledgement, + observation: evidence.observation, + lineage: original, + baseWire: original.wire(), + nextWire, + nextRecord, + nextHandle: candidate.value + }); + } + // This is the actual append-admission boundary. Before it, stale + // proof has no write. After it, only bounded history may settle. + if (!currentNonceOperation(operation)) return refuse('stopped'); + nonceOperations.set(proof, operation); + const previousUncertainty = operation.uncertain(); + operation.markAttempted(); + const committed = await commitPrivateRecord( + repository, + operation.nextHandle, + observed.value.handle + ); + if (!committed.ok && committed.reason !== 'unknown_completion') { + operation.markDefiniteFailure(); + return refuse(committed.reason); + } + if ( + committed.ok && + committed.value.state === 'existing' && + !previousUncertainty + ) { + // A matching handwritten successor is not our completed append. + operation.markDefiniteFailure(); + return refuse('conflict'); + } + const after = await observePrivateRecord( + repository, + 'private_sends', + evidence.command + ); + if (!after.ok) return refuse('unknown_completion'); + if ( + after.value.wire !== operation.nextWire || + privateRecordWire( + after.value.handle, + evidence.owner, + evidence.command + ) !== operation.nextWire + ) + return refuse('conflict'); + original.admit(operation.nextRecord, operation.nextWire); + operation.markApplied(); + return nonceSuccess( + operation, + !committed.ok + ? 'reconciled' + : committed.value.state === 'existing' + ? 'existing' + : 'saved' + ); + } + ); + if (!job.ok) return refuse(evidence.current() ? 'busy' : 'stopped'); + if (job.value.acknowledgement && !evidence.current()) + return { + status: job.value.status, + disposition: 'original_protected', + provenance: 'historical_only' + }; + return job.value; + } + ); + } finally { + original.finish(); + } + } catch { + return refuse('unknown_completion'); + } +} + +// Local source provenance only. Later cleanup/readiness must independently +// reobserve native custody and all required genuine current target effects. +export function inboxProbeNonceAcknowledgementBinding( + repository: PrivateStorageRepository, + session: PrivateSession, + acknowledgement: InboxProbeNonceAcknowledgement, + policy: RelayPolicy +) { + const saved = nonceAcknowledgements.get(acknowledgement); + if ( + !saved || + saved.repository !== repository || + saved.session !== session || + saved.policy !== policy || + !saved.applied() || + !currentNonceOperation(saved) + ) + return undefined; + return { + owner: saved.lineage.record().owner, + command: saved.lineage.record().id, + eventId: saved.lineage.record().self!.eventId, + probeAcknowledgement: saved.acknowledgement, + proof: saved.proof, + observation: saved.observation, + record: JSON.parse( + JSON.stringify(saved.lineage.record()) + ) as PrivateAccessProbe, + wire: saved.lineage.wire(), + current: () => currentNonceOperation(saved) + }; +} diff --git a/web/tests/e2e/harness/inbox-probe-nonce-facts.ts b/web/tests/e2e/harness/inbox-probe-nonce-facts.ts @@ -0,0 +1,298 @@ +import { makeRetryFixture } from './inbox-probe-retry.ts'; +import { + captureInboxProbeNonceReader, + captureRecoveredInboxProbeNonceReader, + readInboxProbeNonce, + readRecoveredInboxProbeNonce, + stopInboxProbeNonceReader, + stopRecoveredInboxProbeNonceReader, + expireInboxProbeNonceReaderWait, + expireRecoveredInboxProbeNonceReaderWait, + type InboxProbeNonceReader, + type RecoveredInboxProbeNonceReader, + type InboxProbeNonceProof, + type RecoveredInboxProbeNonceProof +} from '../../../src/lib/nostr/self-recovery-reader.ts'; +import { inboxProbeNonceVerificationEvidence } from '../../../src/lib/nostr/self-recovery-reader.ts'; +import { inboxProbeReadbackAttemptEvidence } from '../../../src/lib/nostr/private-pool.ts'; +import { + decodePrivateRecord, + privateRecordWire, + type PrivateAccessProbeReceipt +} from '../../../src/lib/persistence/private-records.ts'; +import { + commitInboxProbeNonceVerification, + inboxProbeNonceAcknowledgementBinding, + type InboxProbeNonceAcknowledgement +} from '../../../src/lib/persistence/inbox-probes.ts'; +import { closePrivateSession } from '../../../src/lib/runtime/private-session.ts'; +import type { InboxProbeReadbackAttemptResult } from '../../../src/lib/nostr/private-pool.ts'; +export * from './inbox-probe-retry.ts'; +export * from '../../../src/lib/nostr/self-recovery-reader.ts'; +export * from '../../../src/lib/persistence/inbox-probes.ts'; +export { createPrivateStorageRepository } from '../../../src/lib/persistence/private-storage.ts'; +export { privateRecordSettlement } from '../../../src/lib/persistence/local-inventory.ts'; +export { inboxProbeReadbackAttemptEvidence } from '../../../src/lib/nostr/private-pool.ts'; +export { capturePrivateOutboxCleanup } from '../../../src/lib/persistence/private-outbox-cleanup.ts'; +export { + createIdentitySession, + connectIdentity, + probeIdentityMessaging, + disconnectIdentity +} from '../../../src/lib/runtime/identity-session.ts'; +export { createPrivateSession } from '../../../src/lib/runtime/private-session.ts'; +export { + openBrowserDatabase, + closeBrowserDatabase, + browserDatabaseTransaction +} from '../../../src/lib/persistence/database.ts'; + +export async function makeNonceFactsFixture() { + const base = await makeRetryFixture(); + let recovered = false, + observation: InboxProbeReadbackAttemptResult | undefined, + reader: InboxProbeNonceReader | RecoveredInboxProbeNonceReader | undefined, + proof: InboxProbeNonceProof | RecoveredInboxProbeNonceProof | undefined, + acknowledgement: InboxProbeNonceAcknowledgement | undefined; + const restores = new Set<() => void>(); + function retain(off: () => void) { + restores.add(off); + return () => { + off(); + restores.delete(off); + }; + } + function capture(review: unknown = 'reviewed_inbox_probe_nonce_decryption') { + if (!observation) return undefined; + const a = base.actors(); + return ( + recovered + ? captureRecoveredInboxProbeNonceReader + : captureInboxProbeNonceReader + )( + base.repository, + a.identity, + a.session, + base.host.policy, + observation, + review + ); + } + function stop(expired = false) { + if (!reader) return; + if (recovered) { + if (expired) + expireRecoveredInboxProbeNonceReaderWait( + reader as RecoveredInboxProbeNonceReader + ); + else + stopRecoveredInboxProbeNonceReader( + reader as RecoveredInboxProbeNonceReader + ); + } else if (expired) + expireInboxProbeNonceReaderWait(reader as InboxProbeNonceReader); + else stopInboxProbeNonceReader(reader as InboxProbeNonceReader); + } + function lose(kind: 'reader' | 'expiry' | 'controller' | 'head' | 'session') { + if (kind === 'reader' || kind === 'expiry') stop(kind === 'expiry'); + else if (kind === 'head') base.actors().churnHead(); + else if (kind === 'session') closePrivateSession(base.actors().session); + else base.stop(); + } + return { + ...base, + observation: () => observation, + nonceReader: () => reader, + nonceProof: () => proof, + nonceAcknowledgement: () => acknowledgement, + captureNonce: capture, + lose, + async prepareRead(useRecovered: boolean, apply = true) { + stop(); + reader = undefined; + proof = undefined; + acknowledgement = undefined; + recovered = useRecovered; + if (recovered) { + await base.freshSession(); + if ( + (await base.recover())?.status !== 'recovered' || + (await base.adopt()).status !== 'adopted' || + !(await base.captureAction()) + ) + throw Error('actual recovered original Retry setup'); + } + const pub = recovered + ? await base.publish() + : await base.originalPublish(); + if ( + pub?.status !== 'accepted' || + (await base.append(pub)).status !== 'saved' + ) + throw Error('actual original archive effect and native append'); + observation = recovered ? await base.read() : await base.originalRead(); + if (observation?.status !== 'readback') + throw Error('actual original B2 readback'); + if (apply && (await base.appendRead(observation)).status !== 'saved') + throw Error('actual original B2 native append'); + return observation; + }, + applyRead: () => observation && base.appendRead(observation), + async nonce(selected = (reader ??= capture())) { + if (!selected) return { status: 'invalid' as const }; + reader ??= selected; + const result = recovered + ? await readRecoveredInboxProbeNonce( + selected as RecoveredInboxProbeNonceReader + ) + : await readInboxProbeNonce(selected as InboxProbeNonceReader); + if ('proof' in result) proof = result.proof; + return result; + }, + async appendNonce() { + if (!proof) throw Error('actual nonce proof required'); + const result = await commitInboxProbeNonceVerification( + base.repository, + base.actors().session, + base.host.policy, + proof + ); + if (result.acknowledgement) acknowledgement = result.acknowledgement; + return result; + }, + nonceBinding: () => + acknowledgement && + inboxProbeNonceAcknowledgementBinding( + base.repository, + base.actors().session, + acknowledgement, + base.host.policy + ), + async storedRow() { + const row = (await base.host.stored()).find( + (x) => x.id === base.command() + ); + if (!row) throw Error('actual selected native row missing'); + return row; + }, + async handwrittenNonceSuccessor() { + if (!proof || !observation) + throw Error('actual genuine nonce and read evidence required'); + const evidence = inboxProbeNonceVerificationEvidence( + proof, + base.repository, + base.actors().session, + base.host.policy + ), + effect = inboxProbeReadbackAttemptEvidence(observation), + row = (await base.host.stored()).find((x) => x.id === base.command()); + if (!evidence || !effect || !row) + throw Error('actual current fixture source associations'); + const record = JSON.parse(row.wire) as { + revision: number; + receipts: PrivateAccessProbeReceipt[]; + }, + fact = JSON.parse(effect.receiptWire) as PrivateAccessProbeReceipt, + candidate = decodePrivateRecord( + JSON.stringify({ + ...record, + revision: record.revision + 1, + receipts: [ + ...record.receipts, + { + ...fact, + status: 'nonce_verified', + observedAtMilliseconds: evidence.verifiedAtMilliseconds + } + ] + }), + row.owner, + row.id + ); + if (!candidate.ok) + throw Error('actual strict codec handwritten successor'); + const wire = privateRecordWire(candidate.value, row.owner, row.id); + if (!wire) throw Error('actual strict canonical successor wire'); + return { ...row, wire }; + }, + nativeReadonlyHook( + hit: number, + kind: 'before_abort' | 'after_abort' | 'callback', + callback = () => {} + ) { + const original = Object.getOwnPropertyDescriptor( + IDBIndex.prototype, + 'openCursor' + )!.value as IDBIndex['openCursor']; + let hits = 0, + faults = 0; + IDBIndex.prototype.openCursor = function ( + ...args: Parameters<IDBIndex['openCursor']> + ) { + const request = original.apply(this, args); + if ( + this.objectStore.name === 'private_sends' && + this.objectStore.transaction.mode === 'readonly' && + ++hits === hit + ) { + faults++; + const tx = this.objectStore.transaction; + if (kind === 'before_abort') tx.abort(); + else if (kind === 'after_abort') + request.addEventListener('success', () => { + if (!request.result) tx.abort(); + }); + else callback(); + } + return request; + }; + return { + faults: () => faults, + restore: retain(() => { + IDBIndex.prototype.openCursor = original; + }) + }; + }, + nativeWriteHook(callback: () => void) { + const original = Object.getOwnPropertyDescriptor( + IDBObjectStore.prototype, + 'put' + )!.value as IDBObjectStore['put']; + let hits = 0; + IDBObjectStore.prototype.put = function ( + ...args: Parameters<IDBObjectStore['put']> + ) { + const request = original.apply(this, args); + if (this.name === 'private_sends' && !hits++) + request.addEventListener('success', callback, { once: true }); + return request; + }; + return { + hits: () => hits, + restore: retain(() => { + IDBObjectStore.prototype.put = original; + }) + }; + }, + clockHook(callback: () => void) { + const original = Date.now; + let hits = 0; + Date.now = () => { + if (!hits++) callback(); + return original(); + }; + return { + hits: () => hits, + restore: retain(() => { + Date.now = original; + }) + }; + }, + close() { + for (const off of restores) off(); + restores.clear(); + stop(); + base.close(); + } + }; +} diff --git a/web/tests/e2e/inbox-probe-nonce-facts.spec.ts b/web/tests/e2e/inbox-probe-nonce-facts.spec.ts @@ -0,0 +1,1295 @@ +import { test, expect, type Page } from '@playwright/test'; +import { build } from 'vite'; +import { once } from 'node:events'; +import { fileURLToPath } from 'node:url'; +import { WebSocketServer, type WebSocket } from 'ws'; +import { createStaticHarness } from '../integration/harness/static.ts'; +import type * as Fixture from './harness/inbox-probe-nonce-facts.ts'; +declare global { + interface Window { + nf: typeof Fixture; + nfFixture: Awaited<ReturnType<typeof Fixture.makeNonceFactsFixture>>; + nfPending?: Promise<unknown>; + nfRestore?: () => void; + } +} +let server: Awaited<ReturnType<typeof createStaticHarness>>, + sockets: WebSocketServer, + endpoint: string, + bundle: string, + head = ''; +const origins = [ + 'wss://inbox.example.org', + 'wss://peer.example.org', + 'wss://archive.example.org' + ], + physical = new Set<WebSocket>(), + archived = new Map<string, unknown>(), + frames: { origin: string; frame: unknown[] }[] = []; +test.beforeAll(async () => { + server = await createStaticHarness(); + sockets = new WebSocketServer({ + host: '127.0.0.1', + port: 0, + maxPayload: 65536 + }); + await once(sockets, 'listening'); + const address = sockets.address(); + if (!address || typeof address === 'string') + throw Error('actual loopback endpoint'); + endpoint = 'ws://127.0.0.1:' + address.port; + sockets.on('connection', (socket, request) => { + physical.add(socket); + socket.on('close', () => physical.delete(socket)); + const origin = new URL(request.url!, 'http://127.0.0.1').searchParams.get( + 'origin' + )!; + socket.on('message', (bytes) => { + const raw = Buffer.isBuffer(bytes) + ? bytes + : Array.isArray(bytes) + ? Buffer.concat(bytes) + : Buffer.from(bytes), + frame = JSON.parse(raw.toString()) as unknown[]; + if (frames.length >= 1000) throw Error('controlled fixture frame bound'); + frames.push({ origin, frame }); + if (frame[0] === 'REQ') { + const filter = frame[2] as { kinds?: number[]; ids?: string[] }; + if (filter.kinds?.includes(10050) && head) + socket.send(JSON.stringify(['EVENT', frame[1], JSON.parse(head)])); + if (filter.kinds?.includes(1059)) { + const event = archived.get(JSON.stringify([origin, filter.ids?.[0]])); + if (event) socket.send(JSON.stringify(['EVENT', frame[1], event])); + } + socket.send(JSON.stringify(['EOSE', frame[1]])); + } else if (frame[0] === 'EVENT') { + const event = frame[1] as { id: string }; + archived.set(JSON.stringify([origin, event.id]), event); + socket.send(JSON.stringify(['OK', event.id, true, ''])); + } + }); + }); + const result = await build({ + configFile: false, + logLevel: 'silent', + build: { + write: false, + minify: false, + lib: { + entry: fileURLToPath( + new URL('./harness/inbox-probe-nonce-facts.ts', import.meta.url) + ), + name: 'nf', + formats: ['iife'] + } + } + }); + const output = Array.isArray(result) ? result[0] : result; + if (!('output' in output)) throw Error('actual compiled nonce-facts harness'); + const chunks = output.output.filter((x) => x.type === 'chunk'); + expect(chunks).toHaveLength(1); + bundle = chunks[0].code; +}); +test.afterAll(async () => { + for (const socket of sockets.clients) socket.terminate(); + await new Promise<void>((resolve) => sockets.close(() => resolve())); + await server.close(); +}); +test.beforeEach(async ({ page }) => { + await expect.poll(() => physical.size).toBe(0); + archived.clear(); + frames.length = 0; + head = ''; + await page.addInitScript( + ({ endpoint, origins }) => { + const Native = window.WebSocket; + window.WebSocket = class extends Native { + constructor(url: string | URL, protocols?: string | string[]) { + const origin = new URL(String(url)).origin; + if (!['wss://discovery.example.org', ...origins].includes(origin)) + throw Error('unapproved fixture origin'); + super(endpoint + '/?origin=' + encodeURIComponent(origin), protocols); + } + }; + }, + { endpoint, origins } + ); + await page.goto(server.url + '/search'); + await page.addScriptTag({ content: bundle }); + head = await page.evaluate(async (origins) => { + window.nfFixture = await window.nf.makeNonceFactsFixture(); + return window.nfFixture.host.preferenceWire(origins); + }, origins); + await page.evaluate(async () => { + const f = window.nfFixture; + await f.open(); + if ((await f.prepareOriginal()).status !== 'prepared') + throw Error('actual original S3/R1'); + }); +}); +test.afterEach(async ({ page }) => { + if (!page.isClosed()) + await page.evaluate(async () => { + window.nfRestore?.(); + window.nfFixture.host.mode('normal'); + window.nfFixture.host.settle(); + window.nfFixture.close(); + await window.nfPending; + }); +}); +async function setup(page: Page, recovered = true, apply = true) { + expect( + await page.evaluate( + async ({ recovered, apply }) => + (await window.nfFixture.prepareRead(recovered, apply)).status, + { recovered, apply } + ) + ).toBe('readback'); +} +async function verify(page: Page) { + expect( + await page.evaluate(async () => (await window.nfFixture.nonce()).status) + ).toBe('nonce_verified'); +} +async function wire(page: Page) { + return page.evaluate(async () => (await window.nfFixture.storedRow()).wire); +} +const traffic = () => + frames.filter( + (x) => + x.origin !== 'wss://discovery.example.org' && + ['EVENT', 'REQ', 'AUTH'].includes(String(x.frame[0])) + ); + +for (const recovered of [false, true]) { + test(`${recovered ? 'recovered' : 'current-original'} genuine nonce fact has exact native lineage, idempotence and separate opaque acknowledgement`, async ({ + page + }) => { + await setup(page, recovered); + const predecessor = await wire(page), + net = traffic().length; + const result = await page.evaluate(async (recovered) => { + const f = window.nfFixture, + before = f.host.counts(), + first = f.captureNonce()!, + second = f.captureNonce(), + read = await f.nonce(first), + afterRead = f.host.counts(), + again = await f.nonce(first), + firstSave = await f.appendNonce(), + afterSave = (await f.storedRow()).wire, + secondSave = await f.appendNonce(), + binding = f.nonceBinding(), + proof = f.nonceProof()!, + ack = f.nonceAcknowledgement()!, + a = f.actors(); + return { + sameReader: first === second, + read: read.status, + again: again.status, + before, + afterRead, + afterSaveCounts: f.host.counts(), + firstSave: firstSave.status, + secondSave: secondSave.status, + sameAck: firstSave.acknowledgement === secondSave.acknowledgement, + provenance: firstSave.provenance, + afterSave, + final: (await f.storedRow()).wire, + proofKeys: Object.keys(proof), + ackKeys: Object.keys(ack), + current: binding?.current(), + copy: !!window.nf.inboxProbeNonceAcknowledgementBinding( + f.repository, + a.session, + { ...ack }, + f.host.policy + ), + crossReader: recovered + ? ( + await window.nf.readInboxProbeNonce( + first as unknown as Parameters< + typeof window.nf.readInboxProbeNonce + >[0] + ) + ).status + : ( + await window.nf.readRecoveredInboxProbeNonce( + first as unknown as Parameters< + typeof window.nf.readRecoveredInboxProbeNonce + >[0] + ) + ).status, + crossProof: recovered + ? !!window.nf.inboxProbeNonceProofBinding( + proof as unknown as Parameters< + typeof window.nf.inboxProbeNonceProofBinding + >[0], + f.repository, + a.session, + f.host.policy + ) + : !!window.nf.recoveredInboxProbeNonceProofBinding( + proof as unknown as Parameters< + typeof window.nf.recoveredInboxProbeNonceProofBinding + >[0], + f.repository, + a.session, + f.host.policy + ), + crossCapture: recovered + ? !!window.nf.captureInboxProbeNonceReader( + f.repository, + a.identity, + a.session, + f.host.policy, + f.observation()!, + 'reviewed_inbox_probe_nonce_decryption' + ) + : !!window.nf.captureRecoveredInboxProbeNonceReader( + f.repository, + a.identity, + a.session, + f.host.policy, + f.observation()!, + 'reviewed_inbox_probe_nonce_decryption' + ), + settlement: window.nf.privateRecordSettlement(binding!.record), + ordinaryCleanup: !!(await window.nf.capturePrivateOutboxCleanup( + f.repository, + a.session, + [f.command()], + 'reviewed_settled_outbox_selection' + )), + readiness: window.nf.inboxAccessControllerSnapshot(a.access)?.readiness + }; + }, recovered); + const before = JSON.parse(predecessor) as { + revision: number; + receipts: Record<string, unknown>[]; + self: unknown; + }, + after = JSON.parse(result.final) as typeof before; + expect(result.sameReader && result.sameAck && result.current).toBe(true); + expect(result.read).toBe('nonce_verified'); + expect(result.again).toBe('nonce_verified'); + expect(result.firstSave).toBe('saved'); + expect(result.secondSave).toBe('existing'); + expect(result.provenance).toBe('current'); + expect(result.afterRead).toEqual({ + ...result.before, + keys: result.before.keys + 3, + decrypts: result.before.decrypts + 2 + }); + expect(result.afterSaveCounts).toEqual(result.afterRead); + expect(result.afterSave).toBe(result.final); + expect(after).toEqual({ + ...before, + revision: before.revision + 1, + receipts: [ + ...before.receipts, + { + ...before.receipts.at(-1), + status: 'nonce_verified', + observedAtMilliseconds: expect.any(Number) + } + ] + }); + expect(result.proofKeys).toEqual([]); + expect(result.ackKeys).toEqual([]); + expect( + result.copy || + result.crossProof || + result.crossCapture || + result.ordinaryCleanup + ).toBe(false); + expect(result.crossReader).toBe('invalid'); + expect(result.settlement).toBe('protected'); + expect(result.readiness).toBe('unavailable'); + expect(traffic()).toHaveLength(net); + }); + + test(`${recovered ? 'recovered' : 'original'} genuinely decrypted but un-applied B2 cannot append until that exact source observation commits`, async ({ + page + }) => { + await setup(page, recovered, false); + await verify(page); + const predecessor = await wire(page); + const first = await page.evaluate(async () => { + const f = window.nfFixture, + before = f.host.counts(), + result = await f.appendNonce(); + return { + status: result.status, + ack: !!result.acknowledgement, + before, + after: f.host.counts() + }; + }); + expect(first.status).toBe('invalid'); + expect(first.ack).toBe(false); + expect(first.after).toEqual(first.before); + expect(await wire(page)).toBe(predecessor); + expect( + await page.evaluate( + async () => (await window.nfFixture.applyRead())?.status + ) + ).toBe('saved'); + expect( + await page.evaluate( + async () => (await window.nfFixture.appendNonce()).status + ) + ).toBe('saved'); + }); +} + +for (const review of [undefined, null, false, 'reviewed_private_decryption']) + test(`recovered nonce capture refuses wrong explicit consent ${String(review)}`, async ({ + page + }) => { + await setup(page); + const result = await page.evaluate((review) => { + const f = window.nfFixture, + a = f.actors(), + before = f.host.counts(); + return { + accepted: !!window.nf.captureRecoveredInboxProbeNonceReader( + f.repository, + a.identity, + a.session, + f.host.policy, + f.observation()!, + review + ), + before, + after: f.host.counts() + }; + }, review); + expect(result.accepted).toBe(false); + expect(result.after).toEqual(result.before); + }); + +for (const recovered of [false, true]) + for (const fault of ['repository', 'session', 'policy'] as const) + test(`${recovered ? 'recovered' : 'original'} genuine nonce proof and acknowledgement reject foreign ${fault} at the actual issuer`, async ({ + page + }) => { + await setup(page, recovered); + await verify(page); + const predecessor = await wire(page), + net = traffic().length; + const result = await page.evaluate(async (fault) => { + const f = window.nfFixture, + a = f.actors(), + identity = window.nf.createIdentitySession(); + await window.nf.connectIdentity(identity); + await window.nf.probeIdentityMessaging(identity, 'reviewed_self_copy'); + const foreignSession = await window.nf.createPrivateSession( + identity, + 'reviewed_private_session' + ); + if (!foreignSession) throw Error('actual foreign same-owner session'); + const repository = fault === 'repository' ? a.repository : f.repository, + session = fault === 'session' ? foreignSession : a.session, + policy = fault === 'policy' ? f.host.copiedPolicy() : f.host.policy, + before = f.host.counts(), + writes = f.nativeWriteHook(() => {}); + window.nfRestore = writes.restore; + const refused = await window.nf.commitInboxProbeNonceVerification( + repository, + session, + policy, + f.nonceProof()! + ), + refusedWire = (await f.storedRow()).wire, + refusedWrites = writes.hits(), + saved = await f.appendNonce(), + acknowledgement = f.nonceAcknowledgement(); + if (!acknowledgement) + throw Error('actual legitimate nonce acknowledgement'); + const wrong = window.nf.inboxProbeNonceAcknowledgementBinding( + repository, + session, + acknowledgement, + policy + ), + copied = window.nf.inboxProbeNonceAcknowledgementBinding( + f.repository, + a.session, + { ...acknowledgement }, + f.host.policy + ), + current = f.nonceBinding()?.current(), + after = f.host.counts(), + totalWrites = writes.hits(); + writes.restore(); + window.nf.closePrivateSession(foreignSession); + window.nf.disconnectIdentity(identity); + return { + refused: refused.status, + refusedAck: !!refused.acknowledgement, + refusedWire, + refusedWrites, + saved: saved.status, + wrong: !!wrong, + copied: !!copied, + current, + before, + after, + totalWrites + }; + }, fault); + expect(result.refused).toBe('invalid'); + expect(result.refusedAck || result.wrong || result.copied).toBe(false); + expect(result.refusedWire).toBe(predecessor); + expect(result.refusedWrites).toBe(0); + expect(result.saved).toBe('saved'); + expect(result.totalWrites).toBe(1); + expect(result.current).toBe(true); + expect(result.after).toEqual(result.before); + expect(traffic()).toHaveLength(net); + }); + +test('copied proof, C2A recovery proof, recovered ACK and nonce status labels have no nonce-fact authority', async ({ + page +}) => { + await setup(page); + await verify(page); + const predecessor = await wire(page), + net = traffic().length; + const result = await page.evaluate(async () => { + const f = window.nfFixture, + before = f.host.counts(), + answers: boolean[] = []; + for (const fake of [ + { ...f.nonceProof()! }, + f.proof(), + f.acknowledgement(), + { status: 'nonce_verified', proof: f.nonceProof(), current: () => true } + ]) { + const result = await window.nf.commitInboxProbeNonceVerification( + f.repository, + f.actors().session, + f.host.policy, + fake as Parameters< + typeof window.nf.commitInboxProbeNonceVerification + >[3] + ); + answers.push( + !!result.acknowledgement || + ['saved', 'reconciled', 'existing'].includes(result.status) + ); + } + return { answers, before, after: f.host.counts() }; + }); + expect(result.answers).toEqual([false, false, false, false]); + expect(result.after).toEqual(result.before); + expect(await wire(page)).toBe(predecessor); + expect(traffic()).toHaveLength(net); +}); + +for (const fault of ['repository', 'policy', 'identity', 'session'] as const) + test(`genuine recovered observation rejects same-owner foreign ${fault} association`, async ({ + page + }) => { + await setup(page); + const result = await page.evaluate(async (fault) => { + const f = window.nfFixture, + a = f.actors(), + identity = window.nf.createIdentitySession(); + await window.nf.connectIdentity(identity); + await window.nf.probeIdentityMessaging(identity, 'reviewed_self_copy'); + const session = await window.nf.createPrivateSession( + identity, + 'reviewed_private_session' + ); + if (!session) throw Error('genuine foreign same-owner private session'); + const before = f.host.counts(); + const reader = window.nf.captureRecoveredInboxProbeNonceReader( + fault === 'repository' ? a.repository : f.repository, + fault === 'identity' ? identity : a.identity, + fault === 'session' ? session : a.session, + fault === 'policy' ? f.host.copiedPolicy() : f.host.policy, + f.observation()!, + 'reviewed_inbox_probe_nonce_decryption' + ); + const after = f.host.counts(); + window.nf.closePrivateSession(session); + window.nf.disconnectIdentity(identity); + return { accepted: !!reader, before, after }; + }, fault); + expect(result.accepted).toBe(false); + expect(result.after).toEqual(result.before); + }); + +for (const mode of ['wrong_key', 'refuse_decrypt', 'wrong_decrypt'] as const) + test(`recovered nonce provider ${mode} cannot issue proof or fact`, async ({ + page + }) => { + await setup(page); + const predecessor = await wire(page); + const result = await page.evaluate(async (mode) => { + const f = window.nfFixture, + reader = f.captureNonce()!; + f.host.mode(mode); + const result = await f.nonce(reader); + return { status: result.status, proof: !!f.nonceProof() }; + }, mode); + expect(result.status).not.toBe('nonce_verified'); + expect(result.proof).toBe(false); + expect(await wire(page)).toBe(predecessor); + }); + +for (const fault of [ + 'seal_tags', + 'seal_kind', + 'seal_signature', + 'rumor_nonce', + 'rumor_hash', + 'rumor_time', + 'rumor_owner', + 'rumor_serialization' +] as const) + test(`actual recovered decrypted ${fault} refuses nonce proof`, async ({ + page + }) => { + await setup(page); + const predecessor = await wire(page); + const result = await page.evaluate(async (fault) => { + const f = window.nfFixture, + restore = f.host.decryptCallback( + fault.startsWith('seal_') ? 1 : 2, + (wire) => { + if (fault === 'seal_tags') + return f.host.signSeal(wire, { tags: [['p', f.host.owner]] }); + if (fault === 'seal_kind') + return f.host.signSeal(wire, { kind: 14 }); + if (fault === 'rumor_serialization') return wire + '\n'; + const data = JSON.parse(wire) as { + sig?: string; + content?: string; + id?: string; + created_at?: number; + pubkey?: string; + }; + if (fault === 'seal_signature') data.sig = '0'.repeat(128); + if (fault === 'rumor_nonce') + data.content = 'different diagnostic nonce'; + if (fault === 'rumor_hash') data.id = 'f'.repeat(64); + if (fault === 'rumor_time') + data.created_at = (data.created_at ?? 0) + 1; + if (fault === 'rumor_owner') data.pubkey = 'f'.repeat(64); + return JSON.stringify(data); + } + ); + window.nfRestore = () => restore.restore(); + return { + status: (await f.nonce()).status, + proof: !!f.nonceProof(), + receivers: restore.receivers() + }; + }, fault); + expect(result.status).not.toBe('nonce_verified'); + expect(result.proof).toBe(false); + expect(result.receivers).toBeGreaterThan(0); + expect(await wire(page)).toBe(predecessor); + }); + +for (const mutation of [ + 'alias', + 'own_tail', + 'foreign_tail', + 'missing' +] as const) + test(`nonce initial complete physical namespace handles ${mutation}`, async ({ + page + }) => { + await setup(page); + const result = await page.evaluate(async (mutation) => { + const f = window.nfFixture, + reader = f.captureNonce()!, + row = await f.storedRow(); + if (mutation === 'alias') + await f.host.inject([{ ...row, wire: row.wire + '\n' }]); + else if (mutation === 'own_tail' || mutation === 'foreign_tail') + await f.host.inject([ + { + owner: mutation === 'own_tail' ? row.owner : 'f'.repeat(64), + id: crypto.randomUUID(), + wire: 'unknown owner tail' + } + ]); + else { + const opened = await window.nf.openBrowserDatabase(); + if (opened.state !== 'ready') + throw Error('actual fixture native deletion'); + const tx = window.nf.browserDatabaseTransaction( + opened.owner, + ['private_sends'], + 'readwrite' + ); + tx.objectStore('private_sends').delete([row.owner, row.id]); + await new Promise<void>((resolve, reject) => { + tx.addEventListener('complete', () => resolve()); + tx.addEventListener('abort', () => + reject(Error('actual fixture delete abort')) + ); + }); + window.nf.closeBrowserDatabase(opened.owner); + } + const before = f.host.counts(), + raw = await f.host.stored(), + result = await f.nonce(reader); + return { + status: result.status, + before, + after: f.host.counts(), + raw, + final: await f.host.stored() + }; + }, mutation); + expect(result.status === 'nonce_verified').toBe( + mutation === 'foreign_tail' + ); + if (mutation !== 'foreign_tail') + expect(result.after).toEqual(result.before); + expect(result.final).toEqual(result.raw); + }); + +for (const hit of [1, 2, 3]) + for (const fault of ['head', 'session', 'native'] as const) + test(`recovered nonce actual key${hit} ${fault} churn fences proof mint`, async ({ + page + }) => { + await setup(page); + const result = await page.evaluate( + async ({ hit, fault }) => { + const f = window.nfFixture, + row = await f.storedRow(), + reader = f.captureNonce()!; + window.nfRestore = f.host.keyCallback(hit, async () => { + if (fault === 'native') + await f.host.inject([{ ...row, wire: row.wire + '\n' }]); + else f.lose(fault); + }); + return { + status: (await f.nonce(reader)).status, + proof: !!f.nonceProof() + }; + }, + { hit, fault } + ); + expect(result.status).not.toBe('nonce_verified'); + expect(result.proof).toBe(false); + }); + +for (const hit of [1, 2]) + for (const fault of ['before_abort', 'after_abort'] as const) + test(`recovered nonce readonly${hit} ${fault} requires actual native completion`, async ({ + page + }) => { + await setup(page); + const predecessor = await wire(page); + const result = await page.evaluate( + async ({ hit, fault }) => { + const f = window.nfFixture, + reader = f.captureNonce()!, + hook = f.nativeReadonlyHook(hit, fault); + window.nfRestore = hook.restore; + return { + status: (await f.nonce(reader)).status, + proof: !!f.nonceProof(), + faults: hook.faults() + }; + }, + { hit, fault } + ); + expect(result.faults).toBe(1); + expect(result.status).not.toBe('nonce_verified'); + expect(result.proof).toBe(false); + expect(await wire(page)).toBe(predecessor); + }); + +for (const kind of [ + 'reader', + 'expiry', + 'controller', + 'head', + 'session' +] as const) { + test(`stopped ${kind} proof BEFORE append admission has zero native write`, async ({ + page + }) => { + await setup(page); + await verify(page); + const predecessor = await wire(page); + const result = await page.evaluate(async (kind) => { + const f = window.nfFixture, + before = f.host.counts(); + f.lose(kind); + const saved = await f.appendNonce(); + return { + status: saved.status, + ack: !!saved.acknowledgement, + before, + after: f.host.counts() + }; + }, kind); + expect(['saved', 'existing', 'reconciled']).not.toContain(result.status); + expect(result.ack).toBe(false); + expect(result.after).toEqual(result.before); + expect(await wire(page)).toBe(predecessor); + }); + test(`actual ${kind} loss AFTER native append admission can retain history but no current acknowledgement`, async ({ + page + }) => { + await setup(page); + await verify(page); + const result = await page.evaluate(async (kind) => { + const f = window.nfFixture, + hook = f.nativeWriteHook(() => f.lose(kind)); + window.nfRestore = hook.restore; + const saved = await f.appendNonce(), + row = JSON.parse((await f.storedRow()).wire) as { + receipts: { status: string }[]; + }; + return { + status: saved.status, + ack: !!saved.acknowledgement, + binding: !!f.nonceBinding(), + provenance: saved.provenance, + last: row.receipts.at(-1)?.status, + hits: hook.hits() + }; + }, kind); + expect(result.hits).toBe(1); + expect(result.last).toBe('nonce_verified'); + expect(result.ack || result.binding).toBe(false); + expect(result.provenance).not.toBe('current'); + }); + test(`actual ${kind} loss DURING initial native read precedes append admission and has zero put`, async ({ + page + }) => { + await setup(page); + await verify(page); + const predecessor = await wire(page); + const result = await page.evaluate(async (kind) => { + const f = window.nfFixture, + genuineBefore = !!window.nf.inboxProbeNonceVerificationEvidence( + f.nonceProof()!, + f.repository, + f.actors().session, + f.host.policy + ), + before = f.host.counts(), + writes = f.nativeWriteHook(() => {}), + read = f.nativeReadonlyHook(1, 'callback', () => f.lose(kind)); + window.nfRestore = () => { + read.restore(); + writes.restore(); + }; + const result = await f.appendNonce(); + read.restore(); + const after = f.host.counts(), + puts = writes.hits(); + writes.restore(); + return { + genuineBefore, + faults: read.faults(), + puts, + status: result.status, + ack: !!result.acknowledgement, + binding: !!f.nonceBinding(), + before, + after + }; + }, kind); + expect(result.genuineBefore).toBe(true); + expect(result.faults).toBe(1); + expect(result.puts).toBe(0); + expect(result.ack || result.binding).toBe(false); + expect(['saved', 'reconciled', 'existing']).not.toContain(result.status); + expect(result.after).toEqual(result.before); + expect(await wire(page)).toBe(predecessor); + }); +} + +for (const timing of ['after_confirmed_abort', 'between_read_and_cas'] as const) + test(`exact handwritten nonce successor ${timing} cannot acquire genuine operation provenance`, async ({ + page + }) => { + await setup(page); + await verify(page); + const predecessor = await wire(page), + net = traffic().length; + const result = await page.evaluate(async (timing) => { + const f = window.nfFixture, + candidate = await f.handwrittenNonceSuccessor(), + before = f.host.counts(); + let aborted = 0, + firstWire: string | undefined, + readHook: ReturnType<typeof f.nativeReadonlyHook> | undefined; + if (timing === 'after_confirmed_abort') { + const hook = f.installCommitFault('aborted'); + window.nfRestore = hook.restore; + const first = await f.appendNonce(); + hook.restore(); + if (first.acknowledgement) + throw Error('aborted append cannot acknowledge'); + firstWire = (await f.storedRow()).wire; + // The port can report failure before native abort dispatch. Observe + // the following real readonly completion before sampling its event. + aborted = hook.counts().aborted; + await f.host.inject([candidate]); + } else { + readHook = f.nativeReadonlyHook(1, 'callback', () => { + window.nfPending = f.host.inject([candidate]); + }); + window.nfRestore = readHook.restore; + } + const genuineBefore = !!window.nf.inboxProbeNonceVerificationEvidence( + f.nonceProof()!, + f.repository, + f.actors().session, + f.host.policy + ), + saved = await f.appendNonce(); + await window.nfPending; + window.nfRestore?.(); + return { + genuineBefore, + aborted, + firstWire, + faults: readHook?.faults(), + status: saved.status, + ack: !!saved.acknowledgement, + binding: !!f.nonceBinding(), + candidate: candidate.wire, + actual: (await f.storedRow()).wire, + before, + after: f.host.counts() + }; + }, timing); + expect(result.genuineBefore).toBe(true); + if (timing === 'after_confirmed_abort') { + expect(result.aborted).toBe(1); + expect(result.firstWire).toBe(predecessor); + } else expect(result.faults).toBe(1); + expect(result.status).toBe('conflict'); + expect(result.ack || result.binding).toBe(false); + expect(result.actual).toBe(result.candidate); + expect(result.actual).not.toBe(predecessor); + expect(result.after).toEqual(result.before); + expect(traffic()).toHaveLength(net); + }); + +for (const fault of ['aborted', 'uncertain', 'changed_successor'] as const) + test(`nonce append actual native ${fault} preserves exact outcome and genuine reconciliation`, async ({ + page + }) => { + await setup(page); + await verify(page); + const predecessor = await wire(page); + const result = await page.evaluate(async (fault) => { + const f = window.nfFixture, + hook = f.installCommitFault(fault); + window.nfRestore = hook.restore; + const result = await f.appendNonce(); + hook.restore(); + const first = (await f.storedRow()).wire, + again = await f.appendNonce(); + return { + status: result.status, + ack: !!result.acknowledgement, + provenance: result.provenance, + first, + counts: hook.counts(), + again: again.status, + againAck: !!again.acknowledgement + }; + }, fault); + expect(result.counts.putSuccess).toBe(1); + if (fault === 'aborted') { + expect(result.ack).toBe(false); + expect(result.first).toBe(predecessor); + expect(result.counts.aborted).toBe(1); + expect(result.again).toBe('saved'); + expect(result.againAck).toBe(true); + } else if (fault === 'uncertain') { + expect(result.status).toBe('reconciled'); + expect(result.ack).toBe(true); + expect(result.counts.complete).toBe(1); + expect(result.again).toBe('existing'); + expect(result.againAck).toBe(true); + } else { + expect(result.status).toBe('conflict'); + expect(result.ack || result.againAck).toBe(false); + } + }); + +for (const hit of [1, 2]) + for (const fault of ['before_abort', 'after_abort'] as const) + test(`nonce fact readonly${hit} ${fault} cannot fabricate completion and later exact operation may reconcile`, async ({ + page + }) => { + await setup(page); + await verify(page); + const predecessor = await wire(page); + const result = await page.evaluate( + async ({ hit, fault }) => { + const f = window.nfFixture, + hook = f.nativeReadonlyHook(hit, fault); + window.nfRestore = hook.restore; + const result = await f.appendNonce(); + hook.restore(); + const first = (await f.storedRow()).wire, + next = await f.appendNonce(); + return { + status: result.status, + ack: !!result.acknowledgement, + first, + faults: hook.faults(), + next: next.status, + nextAck: !!next.acknowledgement + }; + }, + { hit, fault } + ); + expect(result.faults).toBe(1); + expect(result.ack).toBe(false); + if (hit === 1) { + expect(result.first).toBe(predecessor); + expect(result.next).toBe('saved'); + } else { + expect(result.first).not.toBe(predecessor); + expect(result.next).toBe('reconciled'); + } + expect(result.nextAck).toBe(true); + }); + +for (const recovered of [false, true]) + for (const contention of ['owner_lock', 'shared_sdk_job'] as const) + test(`${recovered ? 'recovered' : 'original'} genuine nonce append respects actual occupied ${contention} and preserves explicit same-proof retry`, async ({ + page + }) => { + await setup(page, recovered); + await verify(page); + const predecessor = await wire(page), + net = traffic().length; + const result = await page.evaluate(async (contention) => { + const f = window.nfFixture, + a = f.actors(), + proof = f.nonceProof()!; + let entered: (() => void) | undefined, + release: (() => void) | undefined; + const ready = new Promise<void>((resolve) => { + entered = resolve; + }); + async function hold() { + entered?.(); + await new Promise<void>((resolve) => { + release = resolve; + }); + } + const held = + contention === 'owner_lock' + ? navigator.locks.request( + 'harvestcircle:owner:' + f.host.owner, + { mode: 'exclusive' }, + hold + ) + : window.nf.withIdlePrivateLocalStorage(a.session, hold); + window.nfPending = held; + await ready; + const genuineBefore = !!window.nf.inboxProbeNonceVerificationEvidence( + proof, + f.repository, + a.session, + f.host.policy + ), + before = f.host.counts(), + reads = f.nativeReadonlyHook(1, 'callback'), + writes = f.nativeWriteHook(() => {}); + window.nfRestore = () => { + reads.restore(); + writes.restore(); + release?.(); + }; + let refused; + try { + const saved = await f.appendNonce(); + refused = { + status: saved.status, + ack: !!saved.acknowledgement, + binding: !!f.nonceBinding(), + reads: reads.faults(), + puts: writes.hits(), + after: f.host.counts() + }; + } finally { + reads.restore(); + writes.restore(); + release?.(); + await held; + } + const refusedWire = (await f.storedRow()).wire, + sameProof = + f.nonceProof() === proof && + !!window.nf.inboxProbeNonceVerificationEvidence( + proof, + f.repository, + a.session, + f.host.policy + ), + writesAfterRelease = f.nativeWriteHook(() => {}); + window.nfRestore = writesAfterRelease.restore; + const first = await f.appendNonce(), + again = await f.appendNonce(), + putsAfterRelease = writesAfterRelease.hits(); + writesAfterRelease.restore(); + return { + genuineBefore, + before, + refused, + refusedWire, + sameProof, + first: first.status, + again: again.status, + sameAck: first.acknowledgement === again.acknowledgement, + current: f.nonceBinding()?.current(), + putsAfterRelease, + after: f.host.counts() + }; + }, contention); + expect(result.genuineBefore && result.sameProof).toBe(true); + expect(result.refused).toEqual({ + status: 'busy', + ack: false, + binding: false, + reads: 0, + puts: 0, + after: result.before + }); + expect(result.refusedWire).toBe(predecessor); + expect(result.first).toBe('saved'); + expect(result.again).toBe('existing'); + expect(result.sameAck && result.current).toBe(true); + expect(result.putsAfterRelease).toBe(1); + expect(result.after).toEqual(result.before); + expect(traffic()).toHaveLength(net); + }); + +test('genuine proof and native admission serialize parallel nonce append without extra SDK work', async ({ + page +}) => { + await setup(page); + await verify(page); + const result = await page.evaluate(async () => { + const f = window.nfFixture, + before = f.host.counts(), + pair = await Promise.all([f.appendNonce(), f.appendNonce()]), + row = JSON.parse((await f.storedRow()).wire) as { + receipts: { status: string }[]; + }; + return { + states: pair.map((x) => x.status).sort(), + facts: row.receipts.filter((x) => x.status === 'nonce_verified').length, + before, + after: f.host.counts() + }; + }); + expect(result.states).toEqual(['busy', 'saved']); + expect(result.facts).toBe(1); + expect(result.after).toEqual(result.before); +}); + +for (const loss of ['reader', 'head', 'session'] as const) + test(`actual pending decrypt ${loss} loss keeps original slot until settlement and never revives nonce proof`, async ({ + page + }) => { + await setup(page); + await page.evaluate(() => { + const f = window.nfFixture; + f.host.mode('hold_decrypt'); + window.nfPending = f.nonce(); + }); + await expect + .poll(() => page.evaluate(() => window.nfFixture.host.waiting())) + .toBe('decrypt'); + const result = await page.evaluate(async (loss) => { + const f = window.nfFixture; + f.lose(loss); + const before = f.host.counts(), + busy = await window.nf.withIdlePrivateLocalStorage( + f.actors().session, + () => Promise.resolve('unreachable') + ); + const after = f.host.counts(); + f.host.mode('normal'); + f.host.settle(); + await window.nfPending; + return { + busy: busy.ok, + before, + after, + proof: !!f.nonceProof(), + binding: !!f.nonceBinding() + }; + }, loss); + expect(result.busy || result.proof || result.binding).toBe(false); + expect(result.after).toEqual(result.before); + }); + +for (const kind of ['head', 'native', 'reentry'] as const) + test(`actual final nonce clock ${kind} callback is fenced before physical read and proof mint`, async ({ + page + }) => { + await setup(page); + const result = await page.evaluate(async (kind) => { + const f = window.nfFixture, + row = await f.storedRow(), + reader = f.captureNonce()!; + let same = false; + const hook = f.clockHook(() => { + if (kind === 'head') f.lose('head'); + else if (kind === 'native') + window.nfPending = f.host.inject([{ ...row, wire: row.wire + '\n' }]); + else same = f.captureNonce() === reader; + }); + window.nfRestore = hook.restore; + const result = await f.nonce(reader); + await window.nfPending; + return { + status: result.status, + proof: !!f.nonceProof(), + hits: hook.hits(), + same + }; + }, kind); + expect(result.hits).toBeGreaterThan(0); + expect(result.status === 'nonce_verified').toBe(kind === 'reentry'); + expect(result.proof).toBe(kind === 'reentry'); + if (kind === 'reentry') expect(result.same).toBe(true); + }); + +test('nonce append at full100 native rows preserves all protected rows and no automatic cleanup', async ({ + page +}) => { + await setup(page); + await verify(page); + const result = await page.evaluate(async () => { + const f = window.nfFixture, + row = await f.storedRow(), + record = JSON.parse(row.wire) as { id: string; receipts: unknown[] }, + others = Array.from({ length: 99 }, () => { + const id = crypto.randomUUID(); + return { + ...row, + id, + wire: JSON.stringify({ ...record, id, receipts: [] }) + }; + }); + await f.host.inject(others); + const saved = await f.appendNonce(), + final = await f.host.stored(); + return { + status: saved.status, + ack: !!saved.acknowledgement, + count: final.length, + preserved: others.every((x) => + final.some((y) => y.id === x.id && y.wire === x.wire) + ) + }; + }); + expect(result).toEqual({ + status: 'saved', + ack: true, + count: 100, + preserved: true + }); +}); + +test('actual8MiB capacity refuses nonce growth while preserving current proof and every original wire', async ({ + page +}) => { + await setup(page); + await verify(page); + const result = await page.evaluate(async () => { + const f = window.nfFixture, + row = await f.storedRow(), + record = JSON.parse(row.wire) as { + id: string; + receipts: Record<string, unknown>[]; + }, + cap = 8 * 1024 * 1024, + bytes = (x: unknown) => + new TextEncoder().encode(JSON.stringify(x)).length, + id = crypto.randomUUID(), + fact = { ...record.receipts[0], status: 'unknown' }, + make = (n: number) => ({ + ...row, + id, + wire: JSON.stringify({ + ...record, + id, + receipts: Array.from({ length: n }, () => fact) + }) + }), + zero = bytes(make(0)), + one = bytes(make(1)), + increment = bytes(make(2)) - one, + nonceDelta = + bytes({ + ...row, + wire: JSON.stringify({ + ...record, + receipts: [ + ...record.receipts, + { ...record.receipts.at(-1), status: 'nonce_verified' } + ] + }) + }) - bytes(row), + n = Math.floor((cap - bytes(row) - nonceDelta / 2 - one) / increment) + 1, + filler = make(n), + remaining = cap - bytes(row) - bytes(filler); + if (!(remaining > 0 && remaining < nonceDelta && zero < one)) + throw Error('actual bounded native quota fixture'); + await f.host.inject([filler]); + const saved = await f.appendNonce(), + final = await f.host.stored(); + return { + status: saved.status, + ack: !!saved.acknowledgement, + remaining, + nonceDelta, + preserved: + final.some((x) => x.id === row.id && x.wire === row.wire) && + final.some((x) => x.id === filler.id && x.wire === filler.wire) + }; + }); + expect(result.status).toBe('capacity'); + expect(result.ack).toBe(false); + expect(result.preserved).toBe(true); + expect(result.remaining).toBeLessThan(result.nonceDelta); +}); + +test('actual maximum revision cannot append a nonce fact after genuine recovered PUB and B2', async ({ + page +}) => { + await page.evaluate(async () => { + const f = window.nfFixture, + row = await f.storedRow(), + record = JSON.parse(row.wire) as { revision: number }; + record.revision = Number.MAX_SAFE_INTEGER - 2; + await f.host.inject([{ ...row, wire: JSON.stringify(record) }]); + }); + await setup(page); + await verify(page); + const predecessor = await wire(page); + const result = await page.evaluate(async () => { + const saved = await window.nfFixture.appendNonce(); + return { status: saved.status, ack: !!saved.acknowledgement }; + }); + expect(result).toEqual({ status: 'invalid_record', ack: false }); + expect(await wire(page)).toBe(predecessor); +}); diff --git a/web/tests/unit/inbox-probe-nonce-facts.test.ts b/web/tests/unit/inbox-probe-nonce-facts.test.ts @@ -0,0 +1,104 @@ +import { afterEach, expect, it, vi } from 'vitest'; +import type { IdentitySession } from '../../src/lib/runtime/identity-session.ts'; +import type { PrivateSession } from '../../src/lib/runtime/private-session.ts'; +import type { PrivateStorageRepository } from '../../src/lib/persistence/private-storage.ts'; +import type { RelayPolicy } from '../../src/lib/config/relays.ts'; +import type { + InboxProbeNonceProof, + RecoveredInboxProbeNonceProof, + InboxProbeNonceReader, + RecoveredInboxProbeNonceReader +} from '../../src/lib/nostr/self-recovery-reader.ts'; +import type { InboxProbeReadbackAttemptResult } from '../../src/lib/nostr/private-pool.ts'; +import type { InboxProbeNonceAcknowledgement } from '../../src/lib/persistence/inbox-probes.ts'; + +afterEach(() => vi.unstubAllGlobals()); +for (const browser of [false, true]) + it(`cold ${browser ? 'browser-shaped' : 'SSR'} nonce facts reject forged provenance before native SDK or cleanup work`, async () => { + vi.resetModules(); + let effects = 0; + const trap = () => { + effects++; + throw Error('unadmitted nonce effect'); + }; + if (browser) { + vi.stubGlobal('window', { + get nostr() { + return trap(); + } + }); + vi.stubGlobal('navigator', { + get locks() { + return trap(); + } + }); + vi.stubGlobal('indexedDB', { open: trap }); + vi.stubGlobal('WebSocket', trap); + } + const reader = await import('../../src/lib/nostr/self-recovery-reader.ts'), + journal = await import('../../src/lib/persistence/inbox-probes.ts'); + const repository = {} as PrivateStorageRepository, + identity = {} as IdentitySession, + session = {} as PrivateSession, + policy = {} as RelayPolicy; + for (const fake of [ + undefined, + null, + false, + 0, + '', + Symbol(), + {}, + { status: 'nonce_verified', proof: {}, current: () => true }, + { source: 'recovered', acknowledgement: {}, nonce_verified: true } + ]) { + expect( + reader.captureRecoveredInboxProbeNonceReader( + repository, + identity, + session, + policy, + fake as InboxProbeReadbackAttemptResult, + 'reviewed_inbox_probe_nonce_decryption' + ) + ).toBeUndefined(); + expect( + await reader.readInboxProbeNonce(fake as InboxProbeNonceReader) + ).toEqual({ status: 'invalid' }); + expect( + await reader.readRecoveredInboxProbeNonce( + fake as RecoveredInboxProbeNonceReader + ) + ).toEqual({ status: 'invalid' }); + expect( + reader.inboxProbeNonceVerificationEvidence( + fake as InboxProbeNonceProof | RecoveredInboxProbeNonceProof, + repository, + session, + policy + ) + ).toBeUndefined(); + const result = await journal.commitInboxProbeNonceVerification( + repository, + session, + policy, + fake as InboxProbeNonceProof | RecoveredInboxProbeNonceProof + ); + expect('acknowledgement' in result).toBe(false); + expect( + journal.inboxProbeNonceAcknowledgementBinding( + repository, + session, + fake as InboxProbeNonceAcknowledgement, + policy + ) + ).toBeUndefined(); + reader.stopRecoveredInboxProbeNonceReader( + fake as RecoveredInboxProbeNonceReader + ); + reader.expireRecoveredInboxProbeNonceReaderWait( + fake as RecoveredInboxProbeNonceReader + ); + } + expect(effects).toBe(0); + }); diff --git a/web/tools/check-output.mjs b/web/tools/check-output.mjs @@ -317,7 +317,7 @@ async function operationalFlagsAdmission(web) { 'src/lib/messaging/inbox-setup-operation.ts': '245c6ce88b146dc731e7ace4f16dc9b5002a87a997f5568e4811b0c4a2daf035', 'src/lib/nostr/self-recovery-reader.ts': - '51758a11383ca5851f16d99628470cef333afbdc37e794e25f9891762c531b8b', + 'a7a5b0e874c65620cd80ccb9a6a50f82a31833adb496a88f9f0daa5b74c06dfd', 'src/lib/nostr/private-publisher.ts': 'e02cdbba35b8a9c7fc5f805c8c21432d4f6eab42c6d098411613189cb6ac7caf', 'src/lib/nostr/private-pool.ts': @@ -325,7 +325,7 @@ async function operationalFlagsAdmission(web) { 'src/lib/nostr/inbox-ingress.ts': 'f860a094a8ba767585124c795d44b7620064f73a5b3a0170041c581c0fc64ecb', 'src/lib/persistence/inbox-probes.ts': - '77949b8350b33182bdd226e4f5507600e220dbfc571410ecdd8210f523d1a5c8', + '6f359ac6f6184d8bf52745b2d1ea79654e55e272c89c62a48d8a1a5605a2dcb0', 'src/lib/nostr/inbox-access.ts': '16eef55d0ffcf2c3291573ddcb0b6a1432bb77abce0017a69e9b6f82414609a7', 'src/lib/nostr/seal-builder.ts': @@ -595,7 +595,7 @@ async function privacyDataAdmission(web) { 'src/lib/messaging/inbox-list.ts': '9cc82877bfa8dbb2a7fa41bceb842793349416271f19569f49fdd5cfc1de07e5', 'src/lib/nostr/self-recovery-reader.ts': - '51758a11383ca5851f16d99628470cef333afbdc37e794e25f9891762c531b8b', + 'a7a5b0e874c65620cd80ccb9a6a50f82a31833adb496a88f9f0daa5b74c06dfd', 'src/lib/nostr/private-publisher.ts': 'e02cdbba35b8a9c7fc5f805c8c21432d4f6eab42c6d098411613189cb6ac7caf', 'src/lib/nostr/private-pool.ts': @@ -603,7 +603,7 @@ async function privacyDataAdmission(web) { 'src/lib/nostr/inbox-ingress.ts': 'f860a094a8ba767585124c795d44b7620064f73a5b3a0170041c581c0fc64ecb', 'src/lib/persistence/inbox-probes.ts': - '77949b8350b33182bdd226e4f5507600e220dbfc571410ecdd8210f523d1a5c8', + '6f359ac6f6184d8bf52745b2d1ea79654e55e272c89c62a48d8a1a5605a2dcb0', 'src/lib/nostr/inbox-access.ts': '16eef55d0ffcf2c3291573ddcb0b6a1432bb77abce0017a69e9b6f82414609a7', 'src/lib/nostr/seal-builder.ts': @@ -2171,7 +2171,7 @@ async function inboxProbeStorageAdmission(web) { 'src/lib/persistence/private-storage.ts': 'ba4a61dd1fa08fc89d00adac3c258c1f6ae7e5c1b15165facffe76ddd71d5e91', 'src/lib/persistence/inbox-probes.ts': - '77949b8350b33182bdd226e4f5507600e220dbfc571410ecdd8210f523d1a5c8' + '6f359ac6f6184d8bf52745b2d1ea79654e55e272c89c62a48d8a1a5605a2dcb0' }; for (const [name, pin] of Object.entries(producers)) { const bytes = await readOwned(web, name);