app

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

commit f2fd85be92f048fd964dbc9fe86cce24c829a503
parent af032995af12f4b3e575224514abb2288fa19499
Author: triesap <tyson@radroots.org>
Date:   Fri,  9 Oct 2026 02:36:44 +0000

messages: implement bounded exact-artifact private retries (HCP-087)

- Requalify stored pair custody from genuine authenticated self recovery
- Retry unchanged persisted1059 artifacts within one bounded network action
- Skip current accepted targets and retain canonical named outcomes
- Preserve recovered state across successful same-owner observations

Diffstat:
Mweb/src/lib/messaging/resume-preparation.ts | 65+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--
Aweb/src/lib/messaging/retry-send.ts | 283+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/src/lib/messaging/rumor-plan.ts | 6+++---
Mweb/src/lib/nostr/private-pool.ts | 29+++++++++++++++++++++++------
Mweb/src/lib/nostr/private-publisher.ts | 193+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--
Mweb/src/lib/nostr/self-recovery-reader.ts | 4+++-
Mweb/src/lib/persistence/private-sends.ts | 139+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/tests/e2e/harness/retry-send.ts | 217+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/tests/e2e/retry-send.spec.ts | 500+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/tests/unit/retry-send.test.ts | 144+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10 files changed, 1564 insertions(+), 16 deletions(-)

diff --git a/web/src/lib/messaging/resume-preparation.ts b/web/src/lib/messaging/resume-preparation.ts @@ -24,12 +24,21 @@ import { stopRumorPlan, type RumorPlan } from './rumor-plan.ts'; -import { restoreRecoveredSendIdentity } from './send-identity.ts'; +import { + restoreRecoveredSendIdentity, + type ReservedSendIdentity +} from './send-identity.ts'; +import { + acknowledgeRecoveredPairedDelivery, + type PairedDeliveryCommitResult +} from '../persistence/private-sends.ts'; import { verifyRecoveredSelfEnvelope } from '../nostr/verify-outbound-envelope.ts'; import { captureSelfRecoveryPreparation, prepareSelfRecovery, preparePairedDelivery, + preparedSelfRecovery, + preparedPairedDelivery, stopSelfRecoveryPreparation, type SelfRecoveryPreparation, type PairedDeliveryContext, @@ -66,6 +75,10 @@ type Controller = { ): Promise<ResumePreparationResult>; snapshot(): Snapshot | undefined; rumor(): RumorPlan | undefined; + qualify( + context: PairedDeliveryContext, + review: unknown + ): Promise<PairedDeliveryCommitResult | Readonly<{ status: 'busy' }>>; stop(expired: boolean): void; }; const resumes = new WeakMap<ResumePreparation, Controller>(); @@ -92,6 +105,7 @@ export function captureResumePreparation( reader: SelfRecoveryReader | undefined, plan: RumorPlan | undefined, preparation: SelfRecoveryPreparation | undefined, + recoveredIdentity: ReservedSendIdentity | undefined, alreadyPaired = false, peerOnly = false, originalWire: string | undefined, @@ -110,6 +124,7 @@ export function captureResumePreparation( preparation = undefined; plan = undefined; originalWire = undefined; + recoveredIdentity = undefined; unsubscribe(); unsubscribe = () => {}; } @@ -190,6 +205,7 @@ export function captureResumePreparation( return { status: 'stopped' }; } originalWire = source.storedWire; + recoveredIdentity = reserved; alreadyPaired = !!source.record.peerArtifact && !!source.record.deliveryPlan; peerOnly = !!source.record.peerArtifact && !source.record.deliveryPlan; @@ -268,9 +284,44 @@ export function captureResumePreparation( run, snapshot, rumor: () => (current() ? plan : undefined), + async qualify(context, review) { + if (review !== 'reviewed_stored_private_retry') + return { status: 'invalid' }; + if (!current()) return { status: 'stopped' }; + if (busy) return { status: 'busy' }; + if (!preparation || !recoveredIdentity) return { status: 'invalid' }; + busy = true; + try { + const freshPair = preparedPairedDelivery(preparation); + if (freshPair) return { status: 'existing', receipt: freshPair }; + if (!alreadyPaired) return { status: 'invalid' }; + const saved = await prepareSelfRecovery( + preparation, + 'reviewed_self_recovery' + ); + if (!current()) return { status: 'stopped' }; + if (!['saved', 'existing', 'reconciled'].includes(saved.status)) + return { status: saved.status === 'stopped' ? 'stopped' : 'invalid' }; + const self = preparedSelfRecovery(preparation); + if (!self) return { status: 'invalid' }; + const qualified = await acknowledgeRecoveredPairedDelivery( + repository, + session, + recoveredIdentity, + self, + context, + review + ); + return current() ? qualified : { status: 'stopped' }; + } finally { + busy = false; + } + }, stop }); - unsubscribe = subscribeIdentityInvalidation(session, () => stop(false)); + unsubscribe = subscribeIdentityInvalidation(session, () => { + if (!ownership.current()) stop(false); + }); return current() ? token : undefined; } export function resumeEncryptedPreparation( @@ -283,6 +334,16 @@ export function resumeEncryptedPreparation( Promise.resolve({ status: 'invalid' }) ); } +export function qualifyRecoveredPrivatePair( + token: ResumePreparation, + context: PairedDeliveryContext, + review: unknown +): Promise<PairedDeliveryCommitResult | Readonly<{ status: 'busy' }>> { + return ( + resumes.get(token)?.qualify(context, review) ?? + Promise.resolve({ status: 'invalid' }) + ); +} export function resumePreparationSnapshot(token: ResumePreparation) { return resumes.get(token)?.snapshot(); } diff --git a/web/src/lib/messaging/retry-send.ts b/web/src/lib/messaging/retry-send.ts @@ -0,0 +1,283 @@ +import { + privateRecordSnapshot, + type PrivateRecordHandle +} from '../persistence/private-records.ts'; +import { + loadPrivateRecord, + type PrivateStorageRepository +} from '../persistence/private-storage.ts'; +import { + pairedDeliveryAcknowledgementSnapshot, + pairedDeliveryRecordMatches, + pairedDeliveryTargetAccepted, + verifyPairedDeliveryAcknowledgement, + commitPairedDeliveryReceipt, + type PairedDeliveryAcknowledgement +} from '../persistence/private-sends.ts'; +import { + privateSessionOwnership, + type PrivateSession +} from '../runtime/private-session.ts'; +import { + capturePrivatePublicationAction, + capturePrivatePublication +} from '../nostr/private-publisher.ts'; +import { + publishPrivateGiftWrapAttempt, + type PrivatePool +} from '../nostr/private-pool.ts'; +import { PRIVATE_PUBLICATION_BUDGETS } from '../config/budgets.ts'; +import type { PairedDeliveryContext } from './prepare-send.ts'; +// Codec readback metadata alone is not a qualified authenticated remote query. +// Only named acceptance suppresses retry here; separate readback remains visible. +export function privateRetryTargets( + handle: PrivateRecordHandle, + owner: unknown, + id: unknown +) { + const row = privateRecordSnapshot(handle, owner, id); + if ( + !row || + row.family !== 'private_send_operation' || + !row.peerArtifact || + !row.deliveryPlan + ) + return undefined; + const pair = row.peerArtifact; + return [ + row.deliveryPlan.routes.peer, + row.deliveryPlan.routes.archive + ].flatMap((route) => { + const eventId = route.role === 'peer' ? pair.eventId : row.self.eventId; + return route.targets + .filter( + (origin) => + !(row.receipts ?? []).some( + (f) => + f.role === route.role && + f.origin === origin && + f.eventId === eventId && + f.status === 'accepted' + ) + ) + .map((origin) => ({ role: route.role, origin, eventId })); + }); +} +declare const retryBrand: unique symbol; +export type PrivateRetry = Readonly<{ [retryBrand]: true }>; +type Result = Readonly<{ + status: 'completed' | 'needs_action' | 'stopped' | 'invalid' | 'busy'; +}>; +type Controller = { + run(review: unknown): Promise<Result>; + stop(): void; + snapshot(): Readonly<{ + owner: string; + command: string; + state: Result['status'] | 'ready'; + attempts: number; + }>; +}; +const retries = new WeakMap<PrivateRetry, Controller>(); +// Capture is explicit, memory-only and opens no socket. Genuine custody and +// actual whole-wire readback are rechecked before every externally visible step. +export function capturePrivateRetry( + repository: PrivateStorageRepository, + session: PrivateSession, + receipt: PairedDeliveryAcknowledgement, + context: PairedDeliveryContext, + pool: PrivatePool, + review: unknown +): PrivateRetry | undefined { + if (typeof window === 'undefined' || review !== 'reviewed_private_retry') + return undefined; + const ownership = privateSessionOwnership(session), + row = pairedDeliveryAcknowledgementSnapshot(receipt); + if (!ownership?.current() || !row || row.owner !== ownership.owner) + return undefined; + const action = capturePrivatePublicationAction( + repository, + session, + receipt, + context, + review + ); + if (!action) return undefined; + const abort = new AbortController(); + let consumed = false, + busy = false, + attempts = 0, + state: Result['status'] | 'ready' = 'ready'; + const token = Object.freeze({}) as PrivateRetry; + function finish(status: Result['status']): Result { + state = status; + return { status }; + } + retries.set(token, { + stop() { + abort.abort(); + state = 'stopped'; + }, + snapshot() { + return { owner: row.owner, command: row.id, state, attempts }; + }, + async run(reviewed) { + if (reviewed !== 'reviewed_private_retry') return { status: 'invalid' }; + if (abort.signal.aborted || !ownership.current()) + return finish('stopped'); + if (busy) return { status: 'busy' }; + if (consumed) return { status: 'invalid' }; + consumed = true; + busy = true; + try { + if (!(await verifyPairedDeliveryAcknowledgement(repository, receipt))) + return finish('needs_action'); + const loaded = await loadPrivateRecord( + repository, + 'private_sends', + row.id + ); + if (abort.signal.aborted || !ownership.current()) + return finish('stopped'); + if ( + !loaded.ok || + !pairedDeliveryRecordMatches(receipt, loaded.value) || + !(await verifyPairedDeliveryAcknowledgement(repository, receipt)) + ) + return finish('needs_action'); + if (abort.signal.aborted || !ownership.current()) + return finish('stopped'); + const targets = + loaded.ok && privateRetryTargets(loaded.value, row.owner, row.id); + if (!targets) return finish('needs_action'); + for (const target of targets) { + let accepted = false; + for ( + let index = 0; + index < PRIVATE_PUBLICATION_BUDGETS.attemptsPerTargetAction; + index++ + ) { + if (abort.signal.aborted || !ownership.current()) + return finish('stopped'); + if ( + pairedDeliveryTargetAccepted( + receipt, + target.role, + target.origin, + target.eventId + ) + ) { + if ( + !(await verifyPairedDeliveryAcknowledgement( + repository, + receipt + )) + ) + return finish('needs_action'); + if (abort.signal.aborted || !ownership.current()) + return finish('stopped'); + accepted = true; + break; + } + const permission = capturePrivatePublication( + repository, + session, + receipt, + context, + target.role, + target.origin, + 'reviewed_private_delivery', + action + ); + if (!permission) return finish('needs_action'); + const result = await publishPrivateGiftWrapAttempt( + pool, + permission, + abort.signal + ); + if (abort.signal.aborted || !ownership.current()) + return finish('stopped'); + if ( + !result.actionId && + pairedDeliveryTargetAccepted( + receipt, + target.role, + target.origin, + target.eventId + ) && + (await verifyPairedDeliveryAcknowledgement(repository, receipt)) + ) { + if (abort.signal.aborted || !ownership.current()) + return finish('stopped'); + accepted = true; + break; + } + if ( + !result.actionId || + !result.attempt || + result.role !== target.role || + result.origin !== target.origin || + result.eventId !== target.eventId + ) + return finish('needs_action'); + attempts++; + const observedAtMilliseconds = Date.now(); + if ( + !Number.isSafeInteger(observedAtMilliseconds) || + observedAtMilliseconds < 0 + ) + return finish('needs_action'); + const saved = await commitPairedDeliveryReceipt( + repository, + receipt, + JSON.stringify({ + actionId: result.actionId, + role: target.role, + origin: target.origin, + eventId: target.eventId, + attempt: result.attempt, + status: result.status, + observedAtMilliseconds, + readbackWire: null + }) + ); + if (abort.signal.aborted || !ownership.current()) + return finish('stopped'); + if (!('record' in saved)) return finish('needs_action'); + if (result.status === 'accepted') { + accepted = true; + break; + } + if (result.status === 'refused' || result.status === 'stopped') + return finish('needs_action'); + } + if (!accepted) return finish('needs_action'); + } + return finish('completed'); + } catch { + return finish( + abort.signal.aborted || !ownership.current() + ? 'stopped' + : 'needs_action' + ); + } finally { + busy = false; + } + } + }); + return token; +} +export function runPrivateRetry( + token: PrivateRetry, + review: unknown +): Promise<Result> { + return ( + retries.get(token)?.run(review) ?? Promise.resolve({ status: 'invalid' }) + ); +} +export function stopPrivateRetry(token: PrivateRetry): void { + retries.get(token)?.stop(); +} +export function privateRetrySnapshot(token: PrivateRetry) { + return retries.get(token)?.snapshot(); +} diff --git a/web/src/lib/messaging/rumor-plan.ts b/web/src/lib/messaging/rumor-plan.ts @@ -117,9 +117,9 @@ export function restoreRecoveredRumor( const token = Object.freeze({}) as RumorPlan; const current = () => ownership.current() && !!recoveredSelfEnvelopeSnapshot(recovered); - const unsubscribe = subscribeIdentityInvalidation(session, () => - stopRumorPlan(token) - ); + const unsubscribe = subscribeIdentityInvalidation(session, () => { + if (!current()) stopRumorPlan(token); + }); plans.set(token, { owner: snapshot.record.owner, peer: snapshot.record.peer, diff --git a/web/src/lib/nostr/private-pool.ts b/web/src/lib/nostr/private-pool.ts @@ -39,6 +39,8 @@ export type PrivateGiftWrapAttemptResult = Readonly<{ role?: PrivateDeliveryRole; origin?: string; eventId?: string; + actionId?: string; + attempt?: number; }>; export type PrivatePageMessage = | Readonly<{ type: 'candidate'; from: string; wire: string }> @@ -215,6 +217,9 @@ export function getPrivatePool( !admitted.current() ) return { status: 'stopped' as const }; + const network = admitted.beginNetwork(); + if (admitted.networkMetered && !network) + return { status: 'stopped' as const }; return await new Promise<PrivateGiftWrapAttemptResult>( (resolve) => { let ended = false, @@ -225,6 +230,7 @@ export function getPrivatePool( ) { if (ended) return; ended = true; + network?.finish(); clearTimeout(timer); if (fenceTimer !== undefined) clearTimeout(fenceTimer); signal.removeEventListener('abort', stop); @@ -239,7 +245,10 @@ export function getPrivatePool( status, role: admitted!.role, origin: admitted!.origin, - eventId: admitted!.eventId + eventId: admitted!.eventId, + ...(network + ? { actionId: network.actionId, attempt: network.attempt } + : {}) }); } function stop() { @@ -252,6 +261,10 @@ export function getPrivatePool( } function fence() { if (ended) return; + if (network && network.remaining() <= 0) { + finish('timed_out'); + return; + } if ( closed || signal.aborted || @@ -264,13 +277,13 @@ export function getPrivatePool( fenceTimer = setTimeout(() => fence(), 50); } const relay = sdk.relay(view.origin); + const allowance = + network?.remaining() ?? + PRIVATE_PUBLICATION_BUDGETS.networkActionMilliseconds; const timeout = Number.isFinite(relay.eventTimeout) && relay.eventTimeout > 0 - ? Math.min( - PRIVATE_PUBLICATION_BUDGETS.networkActionMilliseconds, - relay.eventTimeout - ) - : PRIVATE_PUBLICATION_BUDGETS.networkActionMilliseconds; + ? Math.min(allowance, relay.eventTimeout) + : allowance; const timer = setTimeout(() => finish('timed_out'), timeout); signal.addEventListener('abort', stop, { once: true }); publicationStops.set(stop, true); @@ -291,6 +304,10 @@ export function getPrivatePool( .subscribe({ next(response) { if (ended) return; + if (network && network.remaining() <= 0) { + finish('timed_out'); + return; + } if ( (response.from !== view.origin && response.from !== view.origin + '/') || diff --git a/web/src/lib/nostr/private-publisher.ts b/web/src/lib/nostr/private-publisher.ts @@ -4,6 +4,7 @@ import { } from '../runtime/private-session.ts'; import { pairedDeliveryAcknowledgementSnapshot, + pairedDeliveryTargetAccepted, verifyPairedDeliveryAcknowledgement, type PairedDeliveryAcknowledgement } from '../persistence/private-sends.ts'; @@ -14,7 +15,11 @@ import { recheckInboxRoutePlan } from '../messaging/inbox-routing.ts'; import { readRelayPolicy, type RelayPolicy } from '../config/relays.ts'; -import { PRIVATE_TRANSPORT_BUDGETS } from '../config/budgets.ts'; +import { + PRIVATE_TRANSPORT_BUDGETS, + PRIVATE_PUBLICATION_BUDGETS +} from '../config/budgets.ts'; +import { newLocalId } from '../private-handles.ts'; import { boundedUtf8 } from '../contracts/food-availability-v1/text.ts'; import { verifyEnvelope, @@ -23,6 +28,158 @@ import { declare const publicationBrand: unique symbol; export type PrivatePublication = Readonly<{ [publicationBrand]: true }>; export type PrivateDeliveryRole = 'peer' | 'self_archive'; +declare const actionBrand: unique symbol; +export type PrivatePublicationAction = Readonly<{ [actionBrand]: true }>; +type NetworkAttempt = Readonly<{ + actionId: string; + attempt: number; + remaining(): number; + finish(): void; +}>; +type Action = { + session: PrivateSession; + receipt: PairedDeliveryAcknowledgement; + context: PairedDeliveryContext; + current(): boolean; + begin( + role: PrivateDeliveryRole, + origin: string, + eventId: string + ): NetworkAttempt | undefined; +}; +const actions = new WeakMap<PrivatePublicationAction, Action>(); +function immutablePair(receipt: PairedDeliveryAcknowledgement) { + const row = pairedDeliveryAcknowledgementSnapshot(receipt); + return ( + row && + JSON.stringify({ + owner: row.owner, + id: row.id, + peer: row.peer, + rumorHash: row.rumorHash, + createdAt: row.createdAt, + self: row.self, + peerArtifact: row.peerArtifact, + deliveryPlan: row.deliveryPlan + }) + ); +} +// One explicit action has one network meter, including all artifacts/targets. +// SDK identity approval and persisted readback happen before an attempt starts. +export function capturePrivatePublicationAction( + repository: PrivateStorageRepository, + session: PrivateSession, + receipt: PairedDeliveryAcknowledgement, + context: PairedDeliveryContext, + review: unknown +): PrivatePublicationAction | undefined { + if (review !== 'reviewed_private_retry') return undefined; + const row = pairedDeliveryAcknowledgementSnapshot(receipt), + original = immutablePair(receipt), + ownership = privateSessionOwnership(session); + if (!row || !original || !ownership?.current()) return undefined; + for (const route of [ + row.deliveryPlan.routes.peer, + row.deliveryPlan.routes.archive + ]) + for (const origin of route.targets) { + if ( + !capturePrivatePublication( + repository, + session, + receipt, + context, + route.role, + origin, + 'reviewed_private_delivery' + ) + ) + return undefined; + } + const actionId = newLocalId(); + if (!actionId) return undefined; + const counts = new Map<string, number>(); + let used = 0, + running = false, + broken = false, + last = -1; + function clock() { + const now = performance.now(); + if (!Number.isFinite(now) || now < 0 || now < last) { + broken = true; + return undefined; + } + last = now; + return now; + } + function current() { + return ( + !broken && + ownership!.current() && + immutablePair(receipt) === original && + recheckInboxRoutePlan( + context.plan, + context.policy, + context.own, + context.other + ) === 'unchanged' + ); + } + const token = Object.freeze({}) as PrivatePublicationAction; + actions.set(token, { + session, + receipt, + context, + current, + begin(role, origin, eventId) { + if ( + !current() || + running || + used >= PRIVATE_PUBLICATION_BUDGETS.networkActionMilliseconds + ) + return undefined; + const key = JSON.stringify([role, origin, eventId]), + count = counts.get(key) ?? 0; + if (count >= PRIVATE_PUBLICATION_BUDGETS.attemptsPerTargetAction) + return undefined; + const start = clock(); + if (start === undefined) return undefined; + counts.set(key, count + 1); + running = true; + let finished = false; + function remaining() { + const now = clock(); + return finished || now === undefined || !current() + ? 0 + : Math.max( + 0, + PRIVATE_PUBLICATION_BUDGETS.networkActionMilliseconds - + used - + (now - start!) + ); + } + return { + actionId, + attempt: count + 1, + remaining, + finish() { + if (finished) return; + const now = clock(); + finished = true; + running = false; + used = + now === undefined + ? PRIVATE_PUBLICATION_BUDGETS.networkActionMilliseconds + : Math.min( + PRIVATE_PUBLICATION_BUDGETS.networkActionMilliseconds, + used + now - start + ); + } + }; + } + }); + return token; +} type Admission = { session: PrivateSession; policy: RelayPolicy; @@ -37,6 +194,7 @@ type Admission = { destination: string; current(): boolean; take(): boolean; + action?: Action; }; const permissions = new WeakMap<PrivatePublication, Admission>(); // Genuine current local pair custody plus its frozen routes is necessary, but @@ -49,7 +207,8 @@ export function capturePrivatePublication( context: PairedDeliveryContext, role: PrivateDeliveryRole, origin: string, - review: unknown + review: unknown, + action?: PrivatePublicationAction ): PrivatePublication | undefined { if ( typeof window === 'undefined' || @@ -60,7 +219,17 @@ export function capturePrivatePublication( return undefined; try { const ownership = privateSessionOwnership(session), - saved = pairedDeliveryAcknowledgementSnapshot(receipt); + saved = pairedDeliveryAcknowledgementSnapshot(receipt), + budget = action && actions.get(action); + if ( + action && + (!budget || + budget.session !== session || + budget.receipt !== receipt || + budget.context !== context || + !budget.current()) + ) + return undefined; if (!ownership || !saved || ownership.owner !== saved.owner) return undefined; const policy = context.policy, @@ -131,6 +300,7 @@ export function capturePrivatePublication( wire: artifact.wire, destination, current, + ...(budget ? { action: budget } : {}), take() { if (consumed) return false; consumed = true; @@ -182,6 +352,16 @@ export async function takePrivatePublication( !saved.current() ) return undefined; + if ( + saved.action && + pairedDeliveryTargetAccepted( + saved.receipt, + saved.role, + saved.origin, + saved.eventId + ) + ) + return undefined; const verified = verifyEnvelope(saved.wire), event = verified.ok && verifiedEnvelopeSnapshot(verified.value); if ( @@ -202,7 +382,12 @@ export async function takePrivatePublication( command: saved.command, role: saved.role, origin: saved.origin, - eventId: saved.eventId + eventId: saved.eventId, + beginNetwork: () => + saved.action + ? saved.action.begin(saved.role, saved.origin, saved.eventId) + : undefined, + networkMetered: !!saved.action }; } catch { return undefined; diff --git a/web/src/lib/nostr/self-recovery-reader.ts b/web/src/lib/nostr/self-recovery-reader.ts @@ -321,7 +321,9 @@ export function captureSelfRecoveryReader( } const token = Object.freeze({}) as SelfRecoveryReader; readers.set(token, { run, stop }); - unsubscribe = subscribeIdentityInvalidation(session, () => stop(false)); + unsubscribe = subscribeIdentityInvalidation(session, () => { + if (!ownership.current()) stop(false); + }); return current() ? token : undefined; } export function readSelfRecoveryEnvelope( diff --git a/web/src/lib/persistence/private-sends.ts b/web/src/lib/persistence/private-sends.ts @@ -1,5 +1,6 @@ import { identityMessagingOwnership, + recheckIdentityOwner, type IdentitySession } from '../runtime/identity-session.ts'; import { @@ -25,8 +26,10 @@ import { } from './private-records.ts'; import { inboxRoutePlanSnapshot, + recheckInboxRoutePlan, type InboxRoutePlan } from '../messaging/inbox-routing.ts'; +import type { PairedDeliveryContext } from '../messaging/prepare-send.ts'; import { loadPrivateRecord, commitPrivateRecord, @@ -316,6 +319,108 @@ const pairedAcknowledgements = new WeakMap< PairedDeliveryAcknowledgement, Paired >(); +// Explicit restart admission authenticates the self recovery copy and verifies +// exact durable pair custody. It does not decrypt or newly authenticate the +// nested peer ciphertext, regenerate either artifact, or perform publication. +export async function acknowledgeRecoveredPairedDelivery( + repository: PrivateStorageRepository, + session: IdentitySession, + reserved: ReservedSendIdentity, + self: SelfRecoveryAcknowledgement, + context: PairedDeliveryContext, + review: unknown +): Promise<PairedDeliveryCommitResult> { + if ( + typeof window === 'undefined' || + review !== 'reviewed_stored_private_retry' || + !navigator.locks?.request + ) + return { status: 'invalid' }; + const saved = acknowledgements.get(self), + original = reservedSendSnapshot(reserved), + ownership = identityMessagingOwnership(session); + if ( + !saved?.current() || + !original || + !ownership?.current() || + JSON.stringify(saved.record) !== JSON.stringify(original) || + original.owner !== ownership.owner + ) + return { status: 'invalid' }; + const current = () => + ownership.current() && + saved.current() && + !!reservedSendSnapshot(reserved) && + recheckInboxRoutePlan( + context.plan, + context.policy, + context.own, + context.other + ) === 'unchanged'; + try { + const checked = await recheckIdentityOwner(session); + if ( + checked.state !== 'messaging_capable' || + checked.publicKey !== ownership.owner || + checked.admission === 'busy' || + !current() + ) + return { status: 'stopped' }; + return await navigator.locks.request( + 'harvestcircle:owner:' + ownership.owner, + { mode: 'exclusive', ifAvailable: true }, + async (lock) => { + if (!lock || !current()) return { status: 'stopped' as const }; + const loaded = await loadPrivateRecord( + repository, + 'private_sends', + original.id + ); + if (!current()) return { status: 'stopped' as const }; + if (!loaded.ok) return { status: loaded.reason }; + const row = privateRecordSnapshot( + loaded.value, + original.owner, + original.id + ), + wire = privateRecordWire(loaded.value, original.owner, original.id), + routes = inboxRoutePlanSnapshot(context.plan); + if ( + !row || + row.family !== 'private_send_operation' || + !row.peerArtifact || + !row.deliveryPlan || + !wire || + wire !== saved.wire || + JSON.stringify(row.deliveryPlan.routes) !== JSON.stringify(routes) + ) + return { status: 'conflict' as const }; + const verified = verifyEnvelope(row.peerArtifact.wire), + event = verified.ok && verifiedEnvelopeSnapshot(verified.value); + if ( + !event || + event.kind !== 1059 || + event.id !== row.peerArtifact.eventId || + event.tags.length !== 1 || + event.tags[0].length !== 2 || + event.tags[0][0] !== 'p' || + event.tags[0][1] !== row.peer || + !current() + ) + return { status: 'invalid' as const }; + const receipt = Object.freeze({}) as PairedDeliveryAcknowledgement; + pairedAcknowledgements.set(receipt, { + record: row, + wire, + current: () => ownership.current() + }); + return { status: 'existing' as const, receipt }; + } + ); + } catch { + return { status: current() ? 'unavailable' : 'stopped' }; + } +} export type PairedDeliveryCommitResult = | Readonly<{ status: 'prepared' | 'existing' | 'reconciled'; @@ -525,6 +630,40 @@ export async function verifyPairedDeliveryAcknowledgement( saved.wire ); } +// A separately decoded row cannot supply acceptance facts merely because the +// owner and local ID match. Require the full wire acknowledged by this genuine +// current custody, then let the workflow recheck actual storage before use. +export function pairedDeliveryRecordMatches( + receipt: PairedDeliveryAcknowledgement, + record: PrivateRecordHandle +): boolean { + const saved = pairedAcknowledgements.get(receipt); + return ( + !!saved?.current() && + privateRecordWire(record, saved.record.owner, saved.record.id) === + saved.wire + ); +} +// Pure genuine custody metadata. A workflow must still verify full readback +// under the owner lock before suppressing or admitting a network effect. +export function pairedDeliveryTargetAccepted( + receipt: PairedDeliveryAcknowledgement, + role: 'peer' | 'self_archive', + origin: string, + eventId: string +): boolean { + const saved = pairedAcknowledgements.get(receipt); + return ( + !!saved?.current() && + (saved.record.receipts ?? []).some( + (fact) => + fact.role === role && + fact.origin === origin && + fact.eventId === eventId && + fact.status === 'accepted' + ) + ); +} // Only the already genuine current pair can renew its exact custody after a // controlled append of named receipt metadata. A decoded namespace row alone // cannot mint this acknowledgment. Earlier permissions invalidate on revision. diff --git a/web/tests/e2e/harness/retry-send.ts b/web/tests/e2e/harness/retry-send.ts @@ -0,0 +1,217 @@ +import { makeFixture as makeRecoveryFixture } from './resume-preparation.ts'; +import { + validateRelayPolicy, + readRelayPolicy +} from '../../../src/lib/config/relays.ts'; +import { createInboxRoutePlan } from '../../../src/lib/messaging/inbox-routing.ts'; +import { + createPrivateSession, + closePrivateSession +} from '../../../src/lib/runtime/private-session.ts'; +import { + getPrivatePool, + closePrivatePool +} from '../../../src/lib/nostr/private-pool.ts'; +import { + resumeEncryptedPreparation, + qualifyRecoveredPrivatePair, + resumePreparationSnapshot, + resumeRecoveredRumor, + stopResumePreparation +} from '../../../src/lib/messaging/resume-preparation.ts'; +import { rumorPlanSnapshot } from '../../../src/lib/messaging/rumor-plan.ts'; +import { decodePrivateRecord } from '../../../src/lib/persistence/private-records.ts'; +import { + capturePrivateRetry, + runPrivateRetry, + stopPrivateRetry, + privateRetrySnapshot, + type PrivateRetry +} from '../../../src/lib/messaging/retry-send.ts'; +import { + pairedDeliveryAcknowledgementSnapshot, + commitPairedDeliveryReceipt, + type PairedDeliveryAcknowledgement +} from '../../../src/lib/persistence/private-sends.ts'; +export async function makeFixture(initialise = true) { + const f = await makeRecoveryFixture(initialise); + const policy = validateRelayPolicy( + JSON.stringify({ + ...readRelayPolicy(f.context.policy), + messagingEnabled: true + }) + ); + if (!policy) throw Error('invalid private fixture policy'); + const plan = createInboxRoutePlan( + policy, + f.owner, + f.peer, + f.context.own, + f.context.other + ); + if (!plan) throw Error('missing private route plan'); + const context = { ...f.context, policy, plan }; + const session = await createPrivateSession( + f.identity, + 'reviewed_private_session' + ); + if (!session) throw Error('missing genuine private session'); + const pool = getPrivatePool(session, policy, [ + 'wss://peer.example.org', + 'wss://archive.example.org' + ]); + if (!pool) throw Error('missing private pool'); + const resume = f.capture(); + let receipt: PairedDeliveryAcknowledgement | undefined, + retry: PrivateRetry | undefined; + let restoreFault = () => {}, + injected = 0; + async function prepare() { + const recovered = await resumeEncryptedPreparation( + resume, + context, + 'reviewed_private_resume' + ); + if (!['prepared', 'already_prepared'].includes(recovered.status)) + return recovered; + const qualified = await qualifyRecoveredPrivatePair( + resume, + context, + 'reviewed_stored_private_retry' + ); + if ('receipt' in qualified) receipt = qualified.receipt; + return { status: qualified.status }; + } + function capture(review: unknown = 'reviewed_private_retry') { + retry = receipt + ? capturePrivateRetry( + f.repository, + session!, + receipt, + context, + pool!, + review + ) + : undefined; + return !!retry; + } + return { + ...f, + async row() { + const value = await f.row(); + if (!value) throw Error('missing actual paired row'); + return value; + }, + prepare, + capture, + run: (review: unknown = 'reviewed_private_retry') => + retry + ? runPrivateRetry(retry, review) + : Promise.resolve({ status: 'invalid' as const }), + snapshot: () => retry && privateRetrySnapshot(retry), + proof: () => receipt && pairedDeliveryAcknowledgementSnapshot(receipt), + recovered: () => ({ + snapshot: resumePreparationSnapshot(resume), + rumor: !!rumorPlanSnapshot(resumeRecoveredRumor(resume)!) + }), + stop: () => { + if (retry) stopPrivateRetry(retry); + }, + clearRecovery: () => stopResumePreparation(resume), + countsValue: () => f.counts(), + async controlledArchiveSuccessor() { + if (!receipt) throw Error('missing genuine custody'); + const row = (await f.row())?.record; + if (!row) throw Error('missing actual ciphertext'); + // Controlled metadata race, not a claim of an additional relay ACK. + return commitPairedDeliveryReceipt( + f.repository, + receipt, + JSON.stringify({ + actionId: '12345678-1234-4234-8234-123456789abe', + role: 'self_archive', + origin: 'wss://archive.example.org', + attempt: 1, + eventId: row.self.eventId, + status: 'accepted', + observedAtMilliseconds: 100, + readbackWire: null + }) + ); + }, + async injectUnacknowledgedSuccessBetweenReads() { + const stored = await f.row(); + if (!stored?.record.peerArtifact || !stored.record.deliveryPlan) + throw Error('missing real paired record'); + const row = stored.record; + const facts = [ + row.deliveryPlan!.routes.peer, + row.deliveryPlan!.routes.archive + ].flatMap((route) => + route.targets.map((origin) => ({ + actionId: '12345678-1234-4234-8234-123456789abf', + role: route.role, + origin, + attempt: 1, + eventId: + route.role === 'peer' + ? row.peerArtifact!.eventId + : row.self.eventId, + status: 'accepted', + observedAtMilliseconds: 100, + readbackWire: null + })) + ); + const wire = JSON.stringify({ + ...row, + revision: row.revision + 1, + receipts: [...(row.receipts ?? []), ...facts] + }); + if (!decodePrivateRecord(wire, f.owner, f.command).ok) + throw Error('invalid controlled race row'); + const native = Reflect.get<IDBIndex, 'openCursor'>( + IDBIndex.prototype, + 'openCursor' + ); + IDBIndex.prototype.openCursor = function ( + ...args: Parameters<IDBIndex['openCursor']> + ) { + const request = native.apply(this, args); + if (this.objectStore.name === 'private_sends' && injected === 0) { + injected++; + // Queue real RW behind first genuine verification and ahead of the + // next load. No opaque acknowledgement is renewed by this mutation. + const transaction = this.objectStore.transaction.db.transaction( + ['private_sends'], + 'readwrite' + ); + transaction + .objectStore('private_sends') + .put({ owner: f.owner, id: f.command, wire }); + } + return request; + }; + restoreFault = () => { + IDBIndex.prototype.openCursor = native; + }; + return { + originalWire: stored.wire, + changedWire: wire, + revision: row.revision + }; + }, + injected: () => injected, + clearFault() { + restoreFault(); + restoreFault = () => {}; + }, + close() { + restoreFault(); + if (retry) stopPrivateRetry(retry); + stopResumePreparation(resume); + closePrivatePool(pool); + closePrivateSession(session); + f.close(); + } + }; +} diff --git a/web/tests/e2e/retry-send.spec.ts b/web/tests/e2e/retry-send.spec.ts @@ -0,0 +1,500 @@ +import { test, expect } from '@playwright/test'; +import { build } from 'vite'; +import { fileURLToPath } from 'node:url'; +import { once } from 'node:events'; +import { WebSocketServer } from 'ws'; +import { createStaticHarness } from '../integration/harness/static.ts'; +import type * as Fixture from './harness/retry-send.ts'; +declare global { + interface Window { + hcp087: typeof Fixture; + hcp087Fixture: Awaited<ReturnType<typeof Fixture.makeFixture>>; + hcp087Pending: ReturnType< + Awaited<ReturnType<typeof Fixture.makeFixture>>['run'] + >; + hcp087Advance: () => void; + hcp087Release: () => void; + hcp087Waiting: boolean; + } +} +let server: Awaited<ReturnType<typeof createStaticHarness>>, + sockets: WebSocketServer, + endpoint: string, + bundle: string; +let events: { origin: string; wire: string }[] = [], + response: 'accepted' | 'refused' | 'unknown' | 'silent' = 'accepted'; +let archiveResponse: 'accepted' | 'refused' | 'unknown' | 'silent' | undefined; +let pendingAcks: { socket: import('ws').WebSocket; id: string }[] = []; +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('loopback unavailable'); + endpoint = 'ws://127.0.0.1:' + address.port; + sockets.on('connection', (socket, request) => + 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 (frame[0] !== 'EVENT') return; + const event = frame[1] as { id: string }; + pendingAcks.push({ socket, id: event.id }); + events.push({ + origin: new URL(request.url!, 'http://localhost').searchParams.get( + 'origin' + )!, + wire: JSON.stringify(event) + }); + const outcome = + events.at(-1)!.origin === 'wss://archive.example.org' + ? (archiveResponse ?? response) + : response; + if (outcome !== 'silent') + socket.send( + JSON.stringify([ + 'OK', + event.id, + outcome === 'accepted', + outcome === 'unknown' + ? 'Timeout' + : outcome === 'refused' + ? 'auth-required: fixture refusal' + : '' + ]) + ); + }) + ); + const result = await build({ + configFile: false, + logLevel: 'silent', + build: { + write: false, + minify: false, + lib: { + entry: fileURLToPath( + new URL('./harness/retry-send.ts', import.meta.url) + ), + name: 'hcp087', + formats: ['iife'] + } + } + }); + const output = Array.isArray(result) ? result[0] : result; + if (!('output' in output)) throw Error('bundle unavailable'); + 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(); +}); +async function load(page: import('@playwright/test').Page, initialise = true) { + await page.goto(server.url + '/search'); + await page.addScriptTag({ content: bundle }); + await page.evaluate(async (initialise) => { + window.hcp087Fixture = await window.hcp087.makeFixture(initialise); + }, initialise); +} +test.beforeEach(async ({ page }) => { + events = []; + response = 'accepted'; + archiveResponse = undefined; + pendingAcks = []; + await page.addInitScript( + ({ endpoint }) => { + 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://peer.example.org', 'wss://archive.example.org'].includes( + origin + ) + ) + throw Error('unapproved destination'); + super(endpoint + '/?origin=' + encodeURIComponent(origin), protocols); + } + }; + }, + { endpoint } + ); + await load(page); +}); +test.afterEach(async ({ page }) => { + if (!page.isClosed()) + await page.evaluate(() => window.hcp087Fixture?.close()); +}); +test('successful same-owner observations preserve recovered rumor and both original artifacts', async ({ + page +}) => { + const r = await page.evaluate(async () => { + const f = window.hcp087Fixture, + prepared = await f.prepare(); + f.capture(); + const before = f.countsValue(), + result = await f.run(); + return { + prepared, + result, + before, + after: f.countsValue(), + recovered: f.recovered(), + row: await f.row() + }; + }); + expect(r.prepared.status).toBe('existing'); + expect(r.result.status).toBe('completed'); + expect(r.recovered.rumor).toBe(true); + expect(r.after.encrypts).toBe(r.before.encrypts); + expect(r.after.signs).toBe(r.before.signs); + expect(events.map((e) => e.wire)).toEqual([ + r.row.record.peerArtifact!.wire, + r.row.record.self.wire + ]); +}); +test('actual reload retries only the remaining original artifact with no re-sign or rewrap', async ({ + page +}) => { + archiveResponse = 'unknown'; + const original = await page.evaluate(async () => { + const f = window.hcp087Fixture; + await f.prepare(); + f.capture(); + const result = await f.run(); + if (result.status !== 'needs_action') + throw Error('missing real archive uncertainty'); + return (await f.row()).record; + }); + await page.evaluate(() => window.hcp087Fixture.close()); + await page.reload(); + await load(page, false); + response = 'accepted'; + archiveResponse = undefined; + events = []; + const r = await page.evaluate(async () => { + const f = window.hcp087Fixture, + baseline = f.countsValue(), + prepared = await f.prepare(); + f.capture(); + const before = f.countsValue(), + result = await f.run(); + return { + prepared, + result, + baseline, + before, + after: f.countsValue(), + row: (await f.row()).record + }; + }); + expect(r.result.status).toBe('completed'); + // The existing fixture's genuine capability probe already exercised crypto. + // Recovery and publication must add no encryption/signing to that baseline. + expect(r.before.encrypts).toBe(r.baseline.encrypts); + expect(r.before.signs).toBe(r.baseline.signs); + expect(r.before.decrypts - r.baseline.decrypts).toBe(2); + expect(r.after.encrypts).toBe(r.baseline.encrypts); + expect(r.after.signs).toBe(r.baseline.signs); + expect(r.row.self).toEqual(original.self); + expect(r.row.peerArtifact).toEqual(original.peerArtifact); + expect(events.map((e) => e.wire)).toEqual([original.self.wire]); + expect(r.row.receipts).toHaveLength(5); +}); +test('a second explicit action performs no duplicate accepted target work', async ({ + page +}) => { + const r = await page.evaluate(async () => { + const f = window.hcp087Fixture; + await f.prepare(); + f.capture(); + const first = await f.run(); + f.capture(); + const second = await f.run(); + return { first, second, row: (await f.row()).record }; + }); + expect(r.first.status).toBe('completed'); + expect(r.second.status).toBe('completed'); + expect(events).toHaveLength(2); + expect(r.row.receipts).toHaveLength(2); +}); +test('three real unknown attempts share one action and never schedule a fourth', async ({ + page +}) => { + response = 'unknown'; + const r = await page.evaluate(async () => { + const f = window.hcp087Fixture; + await f.prepare(); + f.capture(); + return { result: await f.run(), row: (await f.row()).record }; + }); + expect(r.result.status).toBe('needs_action'); + expect(events).toHaveLength(3); + expect(new Set(events.map((e) => e.wire)).size).toBe(1); + expect(r.row.receipts?.map((r) => r.attempt)).toEqual([1, 2, 3]); + expect(new Set(r.row.receipts?.map((r) => r.actionId)).size).toBe(1); +}); +test('authoritative auth refusal pauses without spinning or touching archive', async ({ + page +}) => { + response = 'refused'; + const r = await page.evaluate(async () => { + const f = window.hcp087Fixture; + await f.prepare(); + f.capture(); + return { result: await f.run(), row: (await f.row()).record }; + }); + expect(r.result.status).toBe('needs_action'); + expect(events).toHaveLength(1); + expect(r.row.receipts?.[0].status).toBe('refused'); +}); +test('wrong review and reused completed action cannot silently start another effect', async ({ + page +}) => { + const r = await page.evaluate(async () => { + const f = window.hcp087Fixture; + await f.prepare(); + const wrong = f.capture('unreviewed'); + f.capture(); + const refused = await f.run('unreviewed'); + const first = await f.run(); + const second = await f.run(); + return { wrong, refused, first, second }; + }); + expect(r.wrong).toBe(false); + expect(r.refused.status).toBe('invalid'); + expect(r.first.status).toBe('completed'); + expect(r.second.status).toBe('invalid'); + expect(events).toHaveLength(2); +}); +test('changed stored revision prevents all retry effects', async ({ page }) => { + const r = await page.evaluate(async () => { + const f = window.hcp087Fixture; + await f.prepare(); + f.capture(); + await f.write('revision'); + return f.run(); + }); + expect(r.status).toBe('needs_action'); + expect(events).toEqual([]); +}); +test('Stop before execution fences every effect and preserves ciphertext', async ({ + page +}) => { + const r = await page.evaluate(async () => { + const f = window.hcp087Fixture; + await f.prepare(); + f.capture(); + const before = await f.row(); + f.stop(); + return { result: await f.run(), before, after: await f.row() }; + }); + expect(r.result.status).toBe('stopped'); + expect(r.after.wire).toBe(r.before.wire); + expect(events).toEqual([]); +}); +test('actual changed owner retires recovered private body before any EVENT', async ({ + page +}) => { + const r = await page.evaluate(async () => { + const f = window.hcp087Fixture; + await f.prepare(); + f.capture(); + f.mode('changed_key'); + return { result: await f.run(), recovered: f.recovered() }; + }); + expect(r.result.status).toBe('stopped'); + expect(r.recovered.rumor).toBe(false); + expect(events).toEqual([]); +}); +test('missing persisted ciphertext cannot become a successful retry', async ({ + page +}) => { + const r = await page.evaluate(async () => { + const f = window.hcp087Fixture; + await f.prepare(); + f.capture(); + await f.write('erase'); + return f.run(); + }); + expect(r.status).toBe('needs_action'); + expect(events).toEqual([]); +}); +test('the shared 45 second network budget ends a real silent attempt without another EVENT', async ({ + page +}) => { + response = 'silent'; + await page.evaluate(async () => { + const f = window.hcp087Fixture; + await f.prepare(); + f.capture(); + const native = performance.now.bind(performance); + let offset = 0; + Object.defineProperty(performance, 'now', { + configurable: true, + value: () => native() + offset + }); + window.hcp087Advance = () => { + offset += 45001; + }; + window.hcp087Pending = f.run(); + }); + await expect.poll(() => events.length).toBe(1); + await page.evaluate(() => window.hcp087Advance()); + const r = await page.evaluate(() => window.hcp087Pending); + expect(r.status).toBe('needs_action'); + expect(events).toHaveLength(1); +}); +test('time spent awaiting the genuine provider observation is outside network budget', async ({ + page +}) => { + await page.evaluate(async () => { + const f = window.hcp087Fixture; + await f.prepare(); + f.capture(); + const native = performance.now.bind(performance); + let offset = 0; + Object.defineProperty(performance, 'now', { + configurable: true, + value: () => native() + offset + }); + const provider = window.nostr as { getPublicKey(): Promise<string> }; + const original = provider.getPublicKey.bind(provider); + let held = true; + provider.getPublicKey = async () => { + if (held) { + held = false; + window.hcp087Waiting = true; + await new Promise<void>((resolve) => { + window.hcp087Release = resolve; + }); + } + return original(); + }; + window.hcp087Advance = () => { + offset += 60000; + }; + window.hcp087Pending = f.run(); + }); + await expect.poll(() => page.evaluate(() => window.hcp087Waiting)).toBe(true); + expect(events).toEqual([]); + await page.evaluate(() => { + window.hcp087Advance(); + window.hcp087Release(); + }); + const r = await page.evaluate(() => window.hcp087Pending); + expect(r.status).toBe('completed'); + expect(events).toHaveLength(2); +}); +test('a controlled genuine receipt successor accepted during key wait suppresses duplicate target publication', async ({ + page +}) => { + await page.evaluate(async () => { + const f = window.hcp087Fixture; + await f.prepare(); + f.capture(); + const provider = window.nostr as { getPublicKey(): Promise<string> }, + original = provider.getPublicKey.bind(provider); + let calls = 0; + provider.getPublicKey = async () => { + calls++; + if (calls === 2) { + window.hcp087Waiting = true; + await new Promise<void>((resolve) => { + window.hcp087Release = resolve; + }); + } + return original(); + }; + window.hcp087Pending = f.run(); + }); + await expect.poll(() => page.evaluate(() => window.hcp087Waiting)).toBe(true); + expect(events).toHaveLength(1); + const successor = await page.evaluate(() => + window.hcp087Fixture.controlledArchiveSuccessor() + ); + expect(successor.status).toBe('saved'); + await page.evaluate(() => window.hcp087Release()); + const result = await page.evaluate(() => window.hcp087Pending); + expect(result.status).toBe('completed'); + expect(events).toHaveLength(1); +}); +test('network time consumed by earlier real attempts reduces the remaining action allowance', async ({ + page +}) => { + response = 'silent'; + await page.evaluate(async () => { + const f = window.hcp087Fixture; + await f.prepare(); + f.capture(); + const native = performance.now.bind(performance); + let offset = 0; + Object.defineProperty(performance, 'now', { + configurable: true, + value: () => native() + offset + }); + window.hcp087Advance = () => { + offset += 30000; + }; + window.hcp087Pending = f.run(); + }); + await expect.poll(() => events.length).toBe(1); + await page.evaluate(() => window.hcp087Advance()); + pendingAcks[0].socket.send( + JSON.stringify(['OK', pendingAcks[0].id, false, 'Timeout']) + ); + await expect.poll(() => events.length).toBe(2); + await page.evaluate(() => window.hcp087Advance()); + pendingAcks[1].socket.send( + JSON.stringify(['OK', pendingAcks[1].id, false, 'Timeout']) + ); + const r = await page.evaluate(async () => ({ + result: await window.hcp087Pending, + row: (await window.hcp087Fixture.row()).record + })); + expect(r.result.status).toBe('needs_action'); + expect(events).toHaveLength(2); + expect(events[1].wire).toBe(events[0].wire); + expect(r.row.receipts?.map((f) => f.status)).toEqual([ + 'unknown', + 'timed_out' + ]); +}); +test('a codec-valid success row inserted between verification and load cannot claim genuine completion', async ({ + page +}) => { + const r = await page.evaluate(async () => { + const f = window.hcp087Fixture; + await f.prepare(); + f.capture(); + const mutation = await f.injectUnacknowledgedSuccessBetweenReads(), + proofBefore = f.proof(), + result = await f.run(), + injected = f.injected(); + f.clearFault(); + return { + mutation, + proofBefore, + proofAfter: f.proof(), + result, + injected, + row: await f.row() + }; + }); + expect(r.injected).toBe(1); + expect(r.row.wire).toBe(r.mutation.changedWire); + expect(r.proofAfter).toEqual(r.proofBefore); + expect(r.proofAfter?.revision).toBe(r.mutation.revision); + expect(r.result.status).toBe('needs_action'); + expect(events).toEqual([]); +}); diff --git a/web/tests/unit/retry-send.test.ts b/web/tests/unit/retry-send.test.ts @@ -0,0 +1,144 @@ +import { describe, it, expect } from 'vitest'; +import { + generateSecretKey, + getPublicKey, + finalizeEvent +} from 'applesauce-core/helpers'; +import { nip44 } from 'applesauce-core/helpers/encryption'; +import { + decodePrivateRecord, + type PrivateRecordHandle +} from '../../src/lib/persistence/private-records.ts'; +import { + privateRetryTargets, + runPrivateRetry, + type PrivateRetry +} from '../../src/lib/messaging/retry-send.ts'; +function fixture(status?: string, role = 'peer') { + const key = generateSecretKey(), + other = generateSecretKey(); + try { + const owner = getPublicKey(key), + peer = getPublicKey(other), + id = '12345678-1234-4234-8234-123456789abc'; + function artifact(destination: string) { + const conversation = nip44.v2.utils.getConversationKey(key, destination); + try { + const event = finalizeEvent( + { + kind: 1059, + created_at: 1700000000, + tags: [['p', destination]], + content: nip44.v2.encrypt('Structural fixture only', conversation) + }, + key + ); + return { eventId: event.id, wire: JSON.stringify(event) }; + } finally { + conversation.fill(0); + } + } + function route(author: string, role: string, origin: string) { + return { + author, + role, + targets: [origin], + knownBase: { author, id: 'b'.repeat(64), createdAt: 1 }, + sources: [{ source: 'wss://discovery.example.org', state: 'eose' }] + }; + } + const self = artifact(owner), + peerArtifact = artifact(peer); + const row = { + schema: 1, + family: 'private_send_operation', + owner, + id, + revision: 2, + peer, + rumorHash: 'a'.repeat(64), + createdAt: 1700000000, + self, + peerArtifact, + deliveryPlan: { + state: 'prepared', + routes: { + peer: route(peer, 'peer', 'wss://peer.example.org'), + archive: route(owner, 'self_archive', 'wss://archive.example.org') + } + }, + ...(status + ? { + receipts: [ + { + actionId: '12345678-1234-4234-8234-123456789abd', + role, + origin: + role === 'peer' + ? 'wss://peer.example.org' + : 'wss://archive.example.org', + attempt: 1, + eventId: role === 'peer' ? peerArtifact.eventId : self.eventId, + status, + observedAtMilliseconds: 100, + readbackWire: status === 'readback' ? peerArtifact.wire : null + } + ] + } + : {}) + }; + const decoded = decodePrivateRecord(JSON.stringify(row), owner, id); + if (!decoded.ok) throw Error('invalid structural fixture'); + return { owner, id, handle: decoded.value, row }; + } finally { + key.fill(0); + other.fill(0); + } +} +describe('explicit exact-artifact retry target selection', () => { + it('retains the exact stored role event IDs and target order', () => { + const f = fixture(); + expect(privateRetryTargets(f.handle, f.owner, f.id)).toEqual([ + { + role: 'peer', + origin: 'wss://peer.example.org', + eventId: f.row.peerArtifact.eventId + }, + { + role: 'self_archive', + origin: 'wss://archive.example.org', + eventId: f.row.self.eventId + } + ]); + }); + it('skips only the exact accepted role and preserves the other artifact target', () => { + for (const role of ['peer', 'self_archive']) { + const f = fixture('accepted', role), + targets = privateRetryTargets(f.handle, f.owner, f.id)!; + expect(targets).toHaveLength(1); + expect(targets[0].role).toBe(role === 'peer' ? 'self_archive' : 'peer'); + } + }); + it('codec-only readback does not impersonate authenticated remote retrieval or ACK', () => { + const f = fixture('readback'); + expect(privateRetryTargets(f.handle, f.owner, f.id)).toHaveLength(2); + }); + it('unknown timeout refusal and stopped facts do not supply success', () => { + for (const status of ['unknown', 'timed_out', 'refused', 'stopped']) { + const f = fixture(status); + expect(privateRetryTargets(f.handle, f.owner, f.id)).toHaveLength(2); + } + }); + it('forged handles and a foreign owner cannot select private targets', () => { + const f = fixture(); + expect( + privateRetryTargets({} as PrivateRecordHandle, f.owner, f.id) + ).toBeUndefined(); + expect(privateRetryTargets(f.handle, 'b'.repeat(64), f.id)).toBeUndefined(); + }); + it('an arbitrary object cannot start a retry or cause an implicit action', async () => { + expect( + await runPrivateRetry({} as PrivateRetry, 'reviewed_private_retry') + ).toEqual({ status: 'invalid' }); + }); +});