app

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

commit f67de70481779c3396f987637a334f146dc3de76
parent 3393cea8fea012be30906959fe44a1d6f6061a10
Author: triesap <tyson@radroots.org>
Date:   Thu,  8 Oct 2026 22:55:55 +0000

messages: atomically retain the paired delivery plan (HCP-082)

- Persist both ciphertext artifacts with frozen role routes and preference versions.
- Require genuine current self evidence and verified peer preparation.
- Reconcile exact retries and reject competing paired command writes.
- Verify real storage interruption and preserve source-only qualification boundaries.

Diffstat:
Mweb/src/lib/messaging/prepare-send.ts | 193++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-
Mweb/src/lib/persistence/private-records.ts | 100++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++---
Mweb/src/lib/persistence/private-sends.ts | 230++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-
Aweb/tests/e2e/harness/paired-delivery.ts | 220+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/tests/e2e/paired-delivery.spec.ts | 583+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/tests/unit/paired-delivery.test.ts | 47+++++++++++++++++++++++++++++++++++++++++++++++
6 files changed, 1367 insertions(+), 6 deletions(-)

diff --git a/web/src/lib/messaging/prepare-send.ts b/web/src/lib/messaging/prepare-send.ts @@ -17,6 +17,13 @@ import { } from './envelope-preparation.ts'; import { privateRecordSnapshot } from '../persistence/private-records.ts'; import { + inboxRoutePlanSnapshot, + recheckInboxRoutePlan, + type InboxRoutePlan +} from './inbox-routing.ts'; +import type { InboxResolver } from './resolve-inbox.ts'; +import type { RelayPolicy } from '../config/relays.ts'; +import { type PrivateStorageRepository, type PrivateStorageFailure } from '../persistence/private-storage.ts'; @@ -25,7 +32,11 @@ import { commitSelfRecovery, selfRecoveryAcknowledgementSnapshot, verifySelfRecoveryAcknowledgement, - type SelfRecoveryAcknowledgement + commitPairedDelivery, + pairedDeliveryAcknowledgementSnapshot, + verifyPairedDeliveryAcknowledgement, + type SelfRecoveryAcknowledgement, + type PairedDeliveryAcknowledgement } from '../persistence/private-sends.ts'; declare const preparationBrand: unique symbol; @@ -44,6 +55,19 @@ export type SelfRecoveryPreparationResult = Readonly<{ | 'mismatch' | 'out_of_order'; }>; +export type PairedDeliveryContext = Readonly<{ + plan: InboxRoutePlan; + policy: RelayPolicy; + own: InboxResolver; + other: InboxResolver; +}>; +export type PairedDeliveryPreparationResult = Readonly<{ + status: + | SelfRecoveryPreparationResult['status'] + | 'self_required' + | 'review_required' + | 'prepared'; +}>; type Phase = 'unsaved' | 'preparing' | 'saved' | 'unknown_completion' | 'needs_action'; type Snapshot = Readonly<{ @@ -55,6 +79,11 @@ type Snapshot = Readonly<{ }>; type Controller = { run(review: unknown): Promise<SelfRecoveryPreparationResult>; + runPair( + context: PairedDeliveryContext, + review: unknown + ): Promise<PairedDeliveryPreparationResult>; + pairReceipt(): PairedDeliveryAcknowledgement | undefined; snapshot(): Snapshot | undefined; receipt(): SelfRecoveryAcknowledgement | undefined; peer( @@ -96,12 +125,14 @@ export function captureSelfRecoveryPreparation( busy = false, phase: Phase = 'unsaved', acknowledgement: SelfRecoveryAcknowledgement | undefined, + pairedAcknowledgement: PairedDeliveryAcknowledgement | undefined, unsubscribe = () => {}; function stop() { if (!active) return; active = false; generation++; acknowledgement = undefined; + pairedAcknowledgement = undefined; closeEnvelopePreparation(pair); unsubscribe(); unsubscribe = () => {}; @@ -186,6 +217,41 @@ export function captureSelfRecoveryPreparation( return { status: base.reason }; } if (acknowledgement) { + // A genuine committed pair is the exact legitimate successor to our + // self-only record. Reconcile through that receipt's full wire, never + // treat arbitrary edits to a self record as acknowledged advancement. + if (pairedAcknowledgement) { + const paired = pairedDeliveryAcknowledgementSnapshot( + pairedAcknowledgement + ), + originalSelf = + selfRecoveryAcknowledgementSnapshot(acknowledgement); + const matches = + paired && + originalSelf && + paired.owner === record.owner && + paired.id === record.id && + paired.peer === record.peer && + paired.rumorHash === record.rumorHash && + paired.createdAt === record.createdAt && + paired.self.eventId === originalSelf.self.eventId && + paired.self.wire === originalSelf.self.wire; + const valid = + matches && + (await verifyPairedDeliveryAcknowledgement( + repository, + pairedAcknowledgement + )); + if (!admitted()) return { status: 'stopped' }; + if (valid) { + phase = 'saved'; + return { status: 'saved' }; + } + pairedAcknowledgement = undefined; + acknowledgement = undefined; + phase = 'needs_action'; + return { status: 'conflict' }; + } const valid = await verifySelfRecoveryAcknowledgement( repository, acknowledgement @@ -263,8 +329,118 @@ export function captureSelfRecoveryPreparation( busy = false; } } + function pairReceipt() { + return current() && + pairedAcknowledgement && + pairedDeliveryAcknowledgementSnapshot(pairedAcknowledgement) + ? pairedAcknowledgement + : undefined; + } + async function runPair( + context: PairedDeliveryContext, + reviewed: unknown + ): Promise<PairedDeliveryPreparationResult> { + if (reviewed !== 'reviewed_pair_preparation') return { status: 'invalid' }; + if (!current()) return { status: 'stopped' }; + if (busy) return { status: 'busy' }; + const self = receipt(); + if (!self) return { status: 'self_required' }; + busy = true; + const attempt = generation; + try { + const { plan, policy, own, other } = context, + routes = inboxRoutePlanSnapshot(plan); + if ( + !routes || + routes.peer.author !== record.peer || + routes.archive.author !== record.owner + ) + return { status: 'invalid' }; + const routeWire = JSON.stringify(routes); + const routesCurrent = () => + recheckInboxRoutePlan(plan, policy, own, other) === 'unchanged' && + JSON.stringify(inboxRoutePlanSnapshot(plan)) === routeWire; + const admitted = () => current() && attempt === generation; + if (!routesCurrent()) return { status: 'review_required' }; + if (!admitted()) return { status: 'stopped' }; + if (pairedAcknowledgement) { + const valid = await verifyPairedDeliveryAcknowledgement( + repository, + pairedAcknowledgement + ); + if (!admitted()) return { status: 'stopped' }; + if (!routesCurrent()) return { status: 'review_required' }; + const saved = pairedDeliveryAcknowledgementSnapshot( + pairedAcknowledgement + ); + return valid && + saved && + JSON.stringify(saved.deliveryPlan.routes) === routeWire + ? { status: 'prepared' } + : { status: 'conflict' }; + } + const durableSelf = await verifySelfRecoveryAcknowledgement( + repository, + self + ); + if (!admitted()) return { status: 'stopped' }; + if (!routesCurrent()) return { status: 'review_required' }; + if (!admitted()) return { status: 'stopped' }; + if (!durableSelf) return { status: 'conflict' }; + phase = 'preparing'; + // The existing lower crypto factory owns the owner lock during SDK work. + const prepared = await prepareEnvelopeRole( + pair, + 'peer', + 'reviewed_pair_role' + ); + if (!admitted()) return { status: 'stopped' }; + if (!routesCurrent()) return { status: 'review_required' }; + if (!admitted()) return { status: 'stopped' }; + if (prepared.status !== 'complete') return { status: prepared.status }; + const proof = preparedEnvelopeProof(pair, 'peer'); + if (!proof) return { status: 'mismatch' }; + const saved = await navigator.locks.request( + 'harvestcircle:owner:' + record.owner, + { mode: 'exclusive', ifAvailable: true }, + async (lock) => { + if (!lock) return { status: 'busy' as const }; + if (!routesCurrent()) return { status: 'review_required' as const }; + if (!admitted()) return { status: 'stopped' as const }; + return await commitPairedDelivery( + repository, + session, + reserved, + self, + proof, + plan, + 'reviewed_pair_commit' + ); + } + ); + if (!admitted()) return { status: 'stopped' }; + if (!routesCurrent()) return { status: 'review_required' }; + if (!admitted()) return { status: 'stopped' }; + if ('receipt' in saved) pairedAcknowledgement = saved.receipt; + phase = 'saved'; + return { status: saved.status }; + } catch { + return { status: current() ? 'unavailable' : 'stopped' }; + } finally { + busy = false; + if (current()) phase = 'saved'; + } + } const token = Object.freeze({}) as SelfRecoveryPreparation; - preparations.set(token, { run, snapshot, receipt, peer, stop }); + preparations.set(token, { + run, + runPair, + pairReceipt, + snapshot, + receipt, + peer, + stop + }); unsubscribe = subscribeIdentityInvalidation(session, stop); return current() ? token : undefined; } @@ -296,3 +472,16 @@ export function stopSelfRecoveryPreparation( ): void { preparations.get(token)?.stop(); } +export function preparePairedDelivery( + token: SelfRecoveryPreparation, + context: PairedDeliveryContext, + review: unknown +): Promise<PairedDeliveryPreparationResult> { + return ( + preparations.get(token)?.runPair(context, review) ?? + Promise.resolve({ status: 'invalid' }) + ); +} +export function preparedPairedDelivery(token: SelfRecoveryPreparation) { + return preparations.get(token)?.pairReceipt(); +} diff --git a/web/src/lib/persistence/private-records.ts b/web/src/lib/persistence/private-records.ts @@ -8,6 +8,7 @@ import { verifiedEnvelopeSnapshot } from '../nostr/verified-envelope.ts'; import { canonicalRelayOrigin } from '../config/relays.ts'; +import type { InboxRouteSnapshot } from '../messaging/inbox-routing.ts'; import { LOCAL_PERSISTENCE_BUDGETS, PRIVATE_TRANSPORT_BUDGETS, @@ -38,6 +39,13 @@ export type PrivateSendOperation = Readonly<{ createdAt: number; self: PrivateCiphertextArtifact; peerArtifact: PrivateCiphertextArtifact | null; + // Absent in original self-only records; never an implicit migration or an + // effect capability. Both ciphertext roles are required for a paired plan. + deliveryPlan?: PrivateDeliveryPlan; +}>; +export type PrivateDeliveryPlan = Readonly<{ + state: 'prepared'; + routes: InboxRouteSnapshot; }>; export type ReceivedEnvelopeRecord = Readonly<{ schema: 1; @@ -86,6 +94,85 @@ const reservationFields = [ 'rumorHash', 'createdAt' ]; +function routeHead(value: unknown): boolean { + return ( + exactLocalFields(value, ['id', 'createdAt']) && + hash(value.id) && + unsigned(value.createdAt) + ); +} +function persistedRoute( + value: unknown, + author: string, + role: 'peer' | 'self_archive' +): boolean { + if ( + !exactLocalFields(value, [ + 'role', + 'author', + 'targets', + 'knownBase', + 'sources' + ]) || + value.role !== role || + value.author !== author || + !Array.isArray(value.targets) || + value.targets.length < 1 || + value.targets.length > RELAY_BUDGETS.inbox || + new Set(value.targets).size !== value.targets.length || + !value.targets.every( + (origin) => + typeof origin === 'string' && canonicalRelayOrigin(origin) === origin + ) || + !exactLocalFields(value.knownBase, ['author', 'id', 'createdAt']) || + value.knownBase.author !== author || + !hash(value.knownBase.id) || + !unsigned(value.knownBase.createdAt) || + !Array.isArray(value.sources) || + value.sources.length < 1 || + value.sources.length > RELAY_BUDGETS.public + ) + return false; + const origins = new Set<string>(); + function acceptOrigin(origin: string): boolean { + if (origins.has(origin)) return false; + origins.add(origin); + return true; + } + for (const source of value.sources) { + if (typeof source !== 'object' || source === null || Array.isArray(source)) + return false; + const row = source as Record<string, unknown>; + if ( + !exactLocalFields( + row, + row.head === undefined + ? ['source', 'state'] + : ['source', 'state', 'head'] + ) || + row.state !== 'eose' || + typeof row.source !== 'string' || + canonicalRelayOrigin(row.source) !== row.source || + !acceptOrigin(row.source) || + (row.head !== undefined && !routeHead(row.head)) + ) + return false; + } + return true; +} +function deliveryPlan( + value: unknown, + owner: string, + peer: string +): value is PrivateDeliveryPlan { + return ( + exactLocalFields(value, ['state', 'routes']) && + value.state === 'prepared' && + exactLocalFields(value.routes, ['peer', 'archive']) && + persistedRoute(value.routes.peer, peer, 'peer') && + persistedRoute(value.routes.archive, owner, 'self_archive') + ); +} // JSON.parse keeps only the last duplicate key. Retaining the original outer // bytes therefore requires a separate syntax-only duplicate check, including // escaped key aliases and nested local metadata. JSON validity/semantics remain @@ -294,14 +381,18 @@ export function decodePrivateRecord( !exactLocalFields(fields, [ ...reservationFields, 'self', - 'peerArtifact' + 'peerArtifact', + ...(fields.deliveryPlan === undefined ? [] : ['deliveryPlan']) ]) || !sendMetadata(fields, owner, id) || !unsigned(fields.revision) || fields.revision < 1 || !artifact(fields.self, owner) || (fields.peerArtifact !== null && - !artifact(fields.peerArtifact, fields.peer as string)) + !artifact(fields.peerArtifact, fields.peer as string)) || + (fields.deliveryPlan !== undefined && + (fields.peerArtifact === null || + !deliveryPlan(fields.deliveryPlan, owner, fields.peer as string))) ) return failed('malformed'); record = { @@ -320,7 +411,10 @@ export function decodePrivateRecord( : { eventId: fields.peerArtifact.eventId, wire: fields.peerArtifact.wire - } + }, + ...(fields.deliveryPlan === undefined + ? {} + : { deliveryPlan: fields.deliveryPlan }) }; } else if (fields.family === 'received_envelope') { if ( diff --git a/web/src/lib/persistence/private-sends.ts b/web/src/lib/persistence/private-sends.ts @@ -19,9 +19,14 @@ import { privateRecordSnapshot, privateRecordWire, type PrivateRecordHandle, - type PrivateSendReservation + type PrivateSendReservation, + type PrivateSendOperation } from './private-records.ts'; import { + inboxRoutePlanSnapshot, + type InboxRoutePlan +} from '../messaging/inbox-routing.ts'; +import { loadPrivateRecord, commitPrivateRecord, type PrivateStorageRepository, @@ -281,3 +286,226 @@ export async function verifySelfRecoveryAcknowledgement( saved.wire ); } + +declare const pairedAcknowledgementBrand: unique symbol; +export type PairedDeliveryAcknowledgement = Readonly<{ + [pairedAcknowledgementBrand]: true; +}>; +type Paired = Readonly<{ + record: PrivateSendOperation; + wire: string; + current(): boolean; +}>; +const pairedAcknowledgements = new WeakMap< + PairedDeliveryAcknowledgement, + Paired +>(); +export type PairedDeliveryCommitResult = + | Readonly<{ + status: 'prepared' | 'existing' | 'reconciled'; + receipt: PairedDeliveryAcknowledgement; + }> + | Readonly<{ status: PrivateStorageFailure | 'invalid' | 'stopped' }>; + +// Requires genuine current self acknowledgement, peer factory proof and route +// capture. Structural local record admission alone cannot mint this receipt. +// Caller owns WebLock and current route recheck; this function owns short CAS. +export async function commitPairedDelivery( + repository: PrivateStorageRepository, + session: IdentitySession, + reserved: ReservedSendIdentity, + self: SelfRecoveryAcknowledgement, + peer: VerifiedOutboundEnvelope, + plan: InboxRoutePlan, + review: unknown +): Promise<PairedDeliveryCommitResult> { + if (typeof window === 'undefined' || review !== 'reviewed_pair_commit') + return { status: 'invalid' }; + const savedSelf = acknowledgements.get(self), + original = reservedSendSnapshot(reserved), + ownership = identityMessagingOwnership(session), + proof = verifiedOutboundSnapshot(peer), + routes = inboxRoutePlanSnapshot(plan); + if ( + !savedSelf?.current() || + !original || + !ownership?.current() || + !proof || + !routes || + original.owner !== ownership.owner || + savedSelf.record.owner !== original.owner || + savedSelf.record.id !== original.id || + savedSelf.record.peer !== original.peer || + savedSelf.record.rumorHash !== original.rumorHash || + savedSelf.record.createdAt !== original.createdAt || + proof.role !== 'peer' || + proof.destination !== original.peer || + proof.owner !== original.owner || + proof.command !== original.id || + proof.peer !== original.peer || + proof.rumorHash !== original.rumorHash || + routes.peer.author !== original.peer || + routes.archive.author !== original.owner + ) + return { status: 'invalid' }; + const verified = verifyEnvelope(proof.wire), + event = verified.ok && verifiedEnvelopeSnapshot(verified.value); + if (!event || event.kind !== 1059) return { status: 'invalid' }; + const current = () => { + const fresh = reservedSendSnapshot(reserved), + peerNow = verifiedOutboundSnapshot(peer); + return ( + ownership.current() && + savedSelf.current() && + fresh?.owner === original.owner && + fresh.id === original.id && + fresh.peer === original.peer && + fresh.rumorHash === original.rumorHash && + fresh.createdAt === original.createdAt && + peerNow?.role === 'peer' && + peerNow.wire === proof.wire + ); + }; + try { + const loaded = await readSelfRecoveryBase(repository, reserved); + if (!current()) return { status: 'stopped' }; + if (!loaded.ok) return { status: loaded.reason }; + const base = privateRecordSnapshot( + loaded.value, + original.owner, + original.id + ), + baseWire = privateRecordWire(loaded.value, original.owner, original.id); + if ( + !base || + base.family !== 'private_send_operation' || + base.self.eventId !== savedSelf.self.eventId || + base.self.wire !== savedSelf.self.wire + ) + return { status: 'conflict' }; + const peerArtifact = { eventId: event.id, wire: proof.wire }, + deliveryPlan = { state: 'prepared' as const, routes }; + let expected: PrivateRecordHandle, + status: 'prepared' | 'existing' | 'reconciled'; + if (base.peerArtifact || base.deliveryPlan) { + if ( + base.peerArtifact?.eventId !== peerArtifact.eventId || + base.peerArtifact.wire !== peerArtifact.wire || + JSON.stringify(base.deliveryPlan) !== JSON.stringify(deliveryPlan) + ) + return { status: 'conflict' }; + expected = loaded.value; + status = 'existing'; + } else { + if (baseWire !== savedSelf.wire) return { status: 'conflict' }; + const decoded = decodePrivateRecord( + JSON.stringify({ + schema: 1, + family: 'private_send_operation', + owner: base.owner, + id: base.id, + revision: base.revision + 1, + peer: base.peer, + rumorHash: base.rumorHash, + createdAt: base.createdAt, + self: { eventId: base.self.eventId, wire: base.self.wire }, + peerArtifact, + deliveryPlan + }), + base.owner, + base.id + ); + if (!decoded.ok) return { status: 'invalid_record' }; + expected = decoded.value; + if (!current()) return { status: 'stopped' }; + const committed = await commitPrivateRecord( + repository, + expected, + loaded.value + ); + if (!current()) return { status: 'stopped' }; + if (!committed.ok && committed.reason !== 'unknown_completion') + return { status: committed.reason }; + status = !committed.ok + ? 'reconciled' + : committed.value.state === 'existing' + ? 'existing' + : 'prepared'; + } + const wire = privateRecordWire(expected, original.owner, original.id), + readback = await loadPrivateRecord( + repository, + 'private_sends', + original.id + ); + if (!current()) return { status: 'stopped' }; + if (!readback.ok) return { status: 'unknown_completion' }; + const observed = privateRecordSnapshot( + readback.value, + original.owner, + original.id + ); + if ( + !wire || + privateRecordWire(readback.value, original.owner, original.id) !== wire || + !observed || + observed.family !== 'private_send_operation' || + !observed.peerArtifact || + !observed.deliveryPlan + ) + return { status: 'conflict' }; + const receipt = Object.freeze({}) as PairedDeliveryAcknowledgement; + pairedAcknowledgements.set(receipt, { + record: observed, + wire, + current: () => ownership.current() + }); + return { status, receipt }; + } catch { + return { status: current() ? 'unavailable' : 'stopped' }; + } +} +export function pairedDeliveryAcknowledgementSnapshot( + receipt: PairedDeliveryAcknowledgement +) { + const saved = pairedAcknowledgements.get(receipt); + if ( + !saved?.current() || + !saved.record.peerArtifact || + !saved.record.deliveryPlan + ) + return undefined; + const row = saved.record; + return { + owner: row.owner, + id: row.id, + revision: row.revision, + peer: row.peer, + rumorHash: row.rumorHash, + createdAt: row.createdAt, + self: { ...row.self }, + peerArtifact: { ...saved.record.peerArtifact }, + deliveryPlan: JSON.parse( + JSON.stringify(saved.record.deliveryPlan) + ) as NonNullable<PrivateSendOperation['deliveryPlan']>, + fact: 'acknowledged_local_pair_only' as const + }; +} +export async function verifyPairedDeliveryAcknowledgement( + repository: PrivateStorageRepository, + receipt: PairedDeliveryAcknowledgement +): Promise<boolean> { + const saved = pairedAcknowledgements.get(receipt); + if (!saved?.current()) return false; + const loaded = await loadPrivateRecord( + repository, + 'private_sends', + saved.record.id + ); + return ( + saved.current() && + loaded.ok && + privateRecordWire(loaded.value, saved.record.owner, saved.record.id) === + saved.wire + ); +} diff --git a/web/tests/e2e/harness/paired-delivery.ts b/web/tests/e2e/harness/paired-delivery.ts @@ -0,0 +1,220 @@ +import { makeFixture as makeSelfFixture } from './self-recovery.ts'; +import type { finalizeEvent, EventTemplate } from 'applesauce-core/helpers'; +import { validateRelayPolicy } from '../../../src/lib/config/relays.ts'; +import { + createPublicScheduler, + createPublicRun, + openInboxRequest, + closePublicScheduler +} from '../../../src/lib/nostr/request-scope.ts'; +import { createInboxResolver } from '../../../src/lib/messaging/resolve-inbox.ts'; +import { + createInboxRoutePlan, + inboxRoutePlanSnapshot +} from '../../../src/lib/messaging/inbox-routing.ts'; +import { verifiedOutboundSnapshot } from '../../../src/lib/nostr/verify-outbound-envelope.ts'; +export { verifiedOutboundSnapshot, inboxRoutePlanSnapshot }; +import { + prepareSelfRecovery, + preparedSelfRecovery, + selfRecoveryPeerPreparation, + preparePairedDelivery, + preparedPairedDelivery +} from '../../../src/lib/messaging/prepare-send.ts'; +import { + commitPairedDelivery, + pairedDeliveryAcknowledgementSnapshot, + selfRecoveryAcknowledgementSnapshot +} from '../../../src/lib/persistence/private-sends.ts'; +import { + decodePrivateRecord, + privateRecordSnapshot +} from '../../../src/lib/persistence/private-records.ts'; +import { loadPrivateRecord } from '../../../src/lib/persistence/private-storage.ts'; +import { browserDatabaseTransaction } from '../../../src/lib/persistence/database.ts'; +import { createPrivateSendReservationRepository } from '../../../src/lib/persistence/private-send-reservations.ts'; +import { + reserveSendIdentity, + reservedSendSnapshot +} from '../../../src/lib/messaging/send-identity.ts'; +export { + prepareSelfRecovery, + preparedSelfRecovery, + selfRecoveryPeerPreparation, + preparePairedDelivery, + preparedPairedDelivery, + commitPairedDelivery, + pairedDeliveryAcknowledgementSnapshot, + selfRecoveryAcknowledgementSnapshot, + decodePrivateRecord +}; +const discovery = 'wss://discovery.example.org', + peerOrigin = 'wss://peer.example.org', + archiveOrigin = 'wss://archive.example.org'; +// Disposable existing source fixture provider signs actual public10050 facts; +// local discovery observations qualify route semantics only, never relay Q. +export async function makeFixture() { + const f = await makeSelfFixture(), + policy = validateRelayPolicy( + JSON.stringify({ + schemaVersion: 1, + public: [{ origin: discovery, read: true, write: false, nip50: false }], + inbox: [peerOrigin, archiveOrigin].map((origin) => ({ + origin, + read: true, + write: true + })), + postingEnabled: false, + messagingEnabled: false, + operatorDenylist: [] + }) + ); + if (!policy || !window.nostr) throw Error('missing fixture policy/provider'); + const provider = window.nostr as Readonly<{ + signEvent( + template: EventTemplate + ): Promise<ReturnType<typeof finalizeEvent>>; + }>; + const schedulers: ReturnType<typeof createPublicScheduler>[] = []; + let current = true; + async function preference(peer: boolean) { + f.mode(peer ? 'wrong_author' : 'normal'); + const signed = await provider.signEvent({ + kind: 10050, + created_at: 100, + tags: [['relay', peer ? peerOrigin : archiveOrigin]], + content: '' + }); + f.mode('normal'); + return { + id: signed.id, + pubkey: signed.pubkey, + sig: signed.sig, + kind: signed.kind, + created_at: signed.created_at, + tags: signed.tags, + content: signed.content + }; + } + const ownEvent = await preference(false), + peerEvent = await preference(true); + function resolve(event: typeof ownEvent) { + const scheduler = createPublicScheduler({ + now: () => 0, + schedule: () => () => {} + }); + schedulers.push(scheduler); + const run = createPublicRun(scheduler, policy!); + return createInboxResolver( + run, + event.pubkey, + (next) => + openInboxRequest( + run, + event.pubkey, + (sink) => { + sink({ type: 'EVENT', from: discovery, id: 'fixture', event }); + sink({ type: 'EOSE', from: discovery, id: 'fixture' }); + return () => {}; + }, + next + ), + () => current + ); + } + const own = resolve(ownEvent), + other = resolve(peerEvent), + plan = createInboxRoutePlan(policy, f.owner, f.peer, own, other); + if (!plan) { + f.close(); + throw Error('missing genuine route plan'); + } + async function distinctIntent() { + const repository = createPrivateSendReservationRepository( + f.database, + f.owner + ); + const observed = Date.now(), + realNow = Date.now; + Date.now = () => observed; + try { + const rumor = f.textPlan(f.marker); + if (!repository || !rumor) throw Error('missing distinct intent fixture'); + const result = await reserveSendIdentity( + repository, + f.identity, + '22345678-1234-4234-8234-123456789abc', + rumor, + 'reviewed_private_intent' + ); + return { + status: result.status, + identity: 'identity' in result ? result.identity : undefined, + id: + 'identity' in result + ? reservedSendSnapshot(result.identity)?.id + : undefined + }; + } finally { + Date.now = realNow; + } + } + async function changePairRevision() { + const identity = reservedSendSnapshot(f.reserved); + if (!identity) throw Error('missing original fixture command'); + const loaded = await loadPrivateRecord( + f.repository, + 'private_sends', + identity.id + ); + const row = + loaded.ok && privateRecordSnapshot(loaded.value, f.owner, identity.id); + if (!row || row.family !== 'private_send_operation' || !row.deliveryPlan) + throw Error('missing original pair'); + const wire = JSON.stringify({ ...row, revision: row.revision + 1 }); + if (!decodePrivateRecord(wire, f.owner, identity.id).ok) + throw Error('invalid competing fixture row'); + const tx = browserDatabaseTransaction( + f.database, + ['private_sends'], + 'readwrite' + ); + tx.objectStore('private_sends').put({ + owner: f.owner, + id: identity.id, + wire + }); + await new Promise<void>((resolve, reject) => { + tx.addEventListener('complete', () => resolve()); + tx.addEventListener('abort', () => + reject(Error('competing fixture write aborted')) + ); + }); + } + async function storedPair() { + const identity = reservedSendSnapshot(f.reserved); + if (!identity) return undefined; + const loaded = await loadPrivateRecord( + f.repository, + 'private_sends', + identity.id + ); + const row = + loaded.ok && privateRecordSnapshot(loaded.value, f.owner, identity.id); + return row && row.family === 'private_send_operation' ? row : undefined; + } + return { + ...f, + context: { policy, own, other, plan }, + distinctIntent, + changePairRevision, + storedPair, + staleRoutes() { + current = false; + }, + close() { + for (const scheduler of schedulers) closePublicScheduler(scheduler); + f.close(); + } + }; +} diff --git a/web/tests/e2e/paired-delivery.spec.ts b/web/tests/e2e/paired-delivery.spec.ts @@ -0,0 +1,583 @@ +import { expect, test, type Page } from '@playwright/test'; +import { build } from 'vite'; +import { fileURLToPath } from 'node:url'; +import { createHash } from 'node:crypto'; +import { createStaticHarness } from '../integration/harness/static.ts'; +import type * as Pair from './harness/paired-delivery.ts'; +declare global { + interface Window { + hcp082: typeof Pair; + hcp082Fixture: Awaited<ReturnType<typeof Pair.makeFixture>>; + } +} +let server: Awaited<ReturnType<typeof createStaticHarness>>, bundle: string; +test.beforeAll(async () => { + server = await createStaticHarness(); + const built = await build({ + configFile: false, + logLevel: 'silent', + build: { + write: false, + minify: false, + lib: { + entry: fileURLToPath( + new URL('./harness/paired-delivery.ts', import.meta.url) + ), + name: 'hcp082', + formats: ['iife'] + } + } + }); + const output = Array.isArray(built) ? built[0] : built; + if (!('output' in output)) throw Error('missing pair bundle'); + const chunks = output.output.filter((entry) => entry.type === 'chunk'); + expect(chunks).toHaveLength(1); + bundle = chunks[0].code; + console.log( + JSON.stringify({ + fixture: 'HCP082_REAL_PAIRED_IDB_PLAN', + bundleSha256: createHash('sha256').update(bundle).digest('hex'), + moduleIds: Object.keys(chunks[0].modules), + qualification: + 'Source-only actual SDK/IDB/WebLocks; controlled public preference observations, no operator Q' + }) + ); +}); +test.afterAll(async () => server.close()); +async function load(page: Page) { + await page.goto(server.url + '/search'); + await page.addScriptTag({ content: bundle }); + await page.evaluate(async () => { + window.hcp082Fixture = await window.hcp082.makeFixture(); + }); +} + +test('no paired permission before self acknowledgement; complete artifacts and frozen routes commit before local readiness', async ({ + page +}) => { + await load(page); + const result = await page.evaluate(async () => { + const f = window.hcp082Fixture, + s = window.hcp082; + try { + const before = f.counts(), + refused = await s.preparePairedDelivery( + f.preparation, + f.context, + 'reviewed_pair_preparation' + ), + inert = JSON.stringify(before) === JSON.stringify(f.counts()); + await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery'); + const self = await f.stored(), + prepared = await s.preparePairedDelivery( + f.preparation, + f.context, + 'reviewed_pair_preparation' + ), + token = s.preparedPairedDelivery(f.preparation), + row = token && s.pairedDeliveryAcknowledgementSnapshot(token), + raw = await f.stored(); + return { + refused: refused.status, + inert, + prepared: prepared.status, + ack: !!row, + state: row?.deliveryPlan.state, + roles: row && [ + row.deliveryPlan.routes.peer.role, + row.deliveryPlan.routes.archive.role + ], + sameRumor: + row?.rumorHash === + s.selfRecoveryAcknowledgementSnapshot( + s.preparedSelfRecovery(f.preparation)! + )?.rumorHash, + twoArtifacts: !!row?.self.wire && !!row.peerArtifact.wire, + changed: raw !== self, + plaintext: + raw.includes(f.marker) || + (await f.publicDraftRows()).includes(f.marker) + }; + } finally { + f.close(); + } + }); + expect(result).toEqual({ + refused: 'self_required', + inert: true, + prepared: 'prepared', + ack: true, + state: 'prepared', + roles: ['peer', 'self_archive'], + sameRumor: true, + twoArtifacts: true, + changed: true, + plaintext: false + }); +}); +test('same paired command retry keeps both exact wires and routes without more SDK work', async ({ + page +}) => { + await load(page); + const result = await page.evaluate(async () => { + const f = window.hcp082Fixture, + s = window.hcp082; + try { + await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery'); + await s.preparePairedDelivery( + f.preparation, + f.context, + 'reviewed_pair_preparation' + ); + const token = s.preparedPairedDelivery(f.preparation), + before = f.counts(), + bytes = await f.stored(), + again = await s.preparePairedDelivery( + f.preparation, + f.context, + 'reviewed_pair_preparation' + ); + return { + status: again.status, + same: token === s.preparedPairedDelivery(f.preparation), + bytes: bytes === (await f.stored()), + counts: JSON.stringify(before) === JSON.stringify(f.counts()) + }; + } finally { + f.close(); + } + }); + expect(result).toEqual({ + status: 'prepared', + same: true, + bytes: true, + counts: true + }); +}); +test('genuine paired acknowledgement cannot reconcile arbitrary structurally valid stored advancement', async ({ + page +}) => { + await load(page); + const result = await page.evaluate(async () => { + const f = window.hcp082Fixture, + s = window.hcp082; + try { + await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery'); + await s.preparePairedDelivery( + f.preparation, + f.context, + 'reviewed_pair_preparation' + ); + await f.changePairRevision(); + const changed = await f.stored(), + before = f.counts(), + self = await s.prepareSelfRecovery( + f.preparation, + 'reviewed_self_recovery' + ), + pair = await s.preparePairedDelivery( + f.preparation, + f.context, + 'reviewed_pair_preparation' + ); + return { + self: self.status, + pair: pair.status, + selfAck: !!s.preparedSelfRecovery(f.preparation), + pairAck: !!s.preparedPairedDelivery(f.preparation), + preserved: changed === (await f.stored()), + counts: JSON.stringify(before) === JSON.stringify(f.counts()) + }; + } finally { + f.close(); + } + }); + expect(result).toEqual({ + self: 'conflict', + pair: 'self_required', + selfAck: false, + pairAck: false, + preserved: true, + counts: true + }); +}); +for (const fault of ['abort', 'unknown'] as const) + test( + 'actual ' + fault + ' pair write preserves truthful atomic acknowledgement', + async ({ page }) => { + await load(page); + const result = await page.evaluate(async (mode) => { + const f = window.hcp082Fixture, + s = window.hcp082; + try { + await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery'); + const old = await f.stored(), + hits = f.fault(mode), + result = await s.preparePairedDelivery( + f.preparation, + f.context, + 'reviewed_pair_preparation' + ), + receipt = s.preparedPairedDelivery(f.preparation), + stored = await f.stored(); + return { + status: result.status, + hits: hits(), + ack: !!receipt, + unchanged: old === stored, + plaintext: stored.includes(f.marker) + }; + } finally { + f.close(); + } + }, fault); + expect(result).toEqual( + fault === 'abort' + ? { + status: 'aborted', + hits: 1, + ack: false, + unchanged: true, + plaintext: false + } + : { + status: 'reconciled', + hits: 1, + ack: true, + unchanged: false, + plaintext: false + } + ); + } + ); +test('peer interruption after actual encryption entry leaves only acknowledged self recovery ciphertext', async ({ + page +}) => { + await load(page); + const result = await page.evaluate(async () => { + const f = window.hcp082Fixture, + s = window.hcp082; + try { + await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery'); + const bytes = await f.stored(); + f.mode('hold_encrypt'); + const pending = s.preparePairedDelivery( + f.preparation, + f.context, + 'reviewed_pair_preparation' + ); + let entered = false; + for (let i = 0; i < 1800; i++) { + if (f.pendingEncryption()) { + entered = true; + break; + } + await new Promise((resolve) => setTimeout(resolve, 50)); + } + if (!entered) throw Error('peer encryption did not enter'); + f.disconnect(); + f.settle(); + const result = await pending; + return { + status: result.status, + ack: !!s.preparedPairedDelivery(f.preparation), + unchanged: bytes === (await f.stored()) + }; + } finally { + f.close(); + } + }); + expect(result).toEqual({ status: 'stopped', ack: false, unchanged: true }); +}); +test('changed route ownership after actual peer crypto blocks pair commit and preserves self', async ({ + page +}) => { + await load(page); + const result = await page.evaluate(async () => { + const f = window.hcp082Fixture, + s = window.hcp082; + try { + await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery'); + const bytes = await f.stored(); + f.mode('hold_encrypt'); + const pending = s.preparePairedDelivery( + f.preparation, + f.context, + 'reviewed_pair_preparation' + ); + let entered = false; + for (let i = 0; i < 1800; i++) { + if (f.pendingEncryption()) { + entered = true; + break; + } + await new Promise((resolve) => setTimeout(resolve, 50)); + } + if (!entered) throw Error('peer encryption did not enter'); + f.staleRoutes(); + f.settle(); + const result = await pending; + return { + status: result.status, + ack: !!s.preparedPairedDelivery(f.preparation), + unchanged: bytes === (await f.stored()) + }; + } finally { + f.close(); + } + }); + expect(result).toEqual({ + status: 'review_required', + ack: false, + unchanged: true + }); +}); +test('different genuine peer ciphertext for the same committed command conflicts without overwriting either artifact', async ({ + page +}) => { + await load(page); + const result = await page.evaluate(async () => { + const f = window.hcp082Fixture, + s = window.hcp082; + try { + await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery'); + const self = s.preparedSelfRecovery(f.preparation)!; + await s.preparePairedDelivery( + f.preparation, + f.context, + 'reviewed_pair_preparation' + ); + const old = await f.stored(), + peer = await f.peerProof(); + if (!peer) throw Error('missing competing genuine peer proof'); + const changed = await s.commitPairedDelivery( + f.repository, + f.identity, + f.reserved, + self, + peer, + f.context.plan, + 'reviewed_pair_commit' + ); + return { status: changed.status, unchanged: old === (await f.stored()) }; + } finally { + f.close(); + } + }); + expect(result).toEqual({ status: 'conflict', unchanged: true }); +}); +test('stored route metadata rejects unknown plaintext and missing paired artifacts instead of fabricating readiness', async ({ + page +}) => { + await load(page); + const result = await page.evaluate(async () => { + const f = window.hcp082Fixture, + s = window.hcp082; + try { + await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery'); + await s.preparePairedDelivery( + f.preparation, + f.context, + 'reviewed_pair_preparation' + ); + const token = s.preparedPairedDelivery(f.preparation)!, + row = s.pairedDeliveryAcknowledgementSnapshot(token)!; + const raw = { + schema: 1, + family: 'private_send_operation', + owner: row.owner, + id: row.id, + revision: row.revision, + peer: row.peer, + rumorHash: row.rumorHash, + createdAt: row.createdAt, + self: row.self, + peerArtifact: row.peerArtifact, + deliveryPlan: row.deliveryPlan + }; + return { + valid: s.decodePrivateRecord(JSON.stringify(raw), row.owner, row.id).ok, + unknown: s.decodePrivateRecord( + JSON.stringify({ + ...raw, + deliveryPlan: { ...raw.deliveryPlan, body: f.marker } + }), + row.owner, + row.id + ).ok, + missing: s.decodePrivateRecord( + JSON.stringify({ ...raw, peerArtifact: null }), + row.owner, + row.id + ).ok + }; + } finally { + f.close(); + } + }); + expect(result).toEqual({ valid: true, unknown: false, missing: false }); +}); +test('distinct intentional identical text is not collapsed into the prior paired command', async ({ + page +}) => { + await load(page); + const result = await page.evaluate(async () => { + const f = window.hcp082Fixture, + s = window.hcp082; + try { + await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery'); + const self = s.preparedSelfRecovery(f.preparation)!; + await s.preparePairedDelivery( + f.preparation, + f.context, + 'reviewed_pair_preparation' + ); + const peer = await f.peerProof(), + intent = await f.distinctIntent(); + if (!peer) throw Error('missing genuine prior peer'); + const before = await f.stored(); + const refused = intent.identity + ? await s.commitPairedDelivery( + f.repository, + f.identity, + intent.identity, + self, + peer, + f.context.plan, + 'reviewed_pair_commit' + ) + : undefined; + return { + safe: + intent.status === 'clock_conflict' || + (intent.status === 'reserved' && + intent.id !== s.selfRecoveryAcknowledgementSnapshot(self)?.id), + refused: !intent.identity || refused?.status === 'invalid', + unchanged: before === (await f.stored()) + }; + } finally { + f.close(); + } + }); + expect(result).toEqual({ safe: true, refused: true, unchanged: true }); +}); +test('concurrent genuine paired commits from the same self-only base produce one exact durable winner and one conflict', async ({ + page +}) => { + await load(page); + const result = await page.evaluate(async () => { + const f = window.hcp082Fixture, + s = window.hcp082; + try { + await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery'); + const self = s.preparedSelfRecovery(f.preparation)!, + left = await f.peerProof(), + right = await f.peerProof(); + if (!left || !right) throw Error('missing genuine competing peer proofs'); + const a = s.verifiedOutboundSnapshot(left), + b = s.verifiedOutboundSnapshot(right); + if (!a || !b || a.wire === b.wire) + throw Error('competing wrappers were not distinct'); + const outcomes = await Promise.all([ + s.commitPairedDelivery( + f.repository, + f.identity, + f.reserved, + self, + left, + f.context.plan, + 'reviewed_pair_commit' + ), + s.commitPairedDelivery( + f.repository, + f.identity, + f.reserved, + self, + right, + f.context.plan, + 'reviewed_pair_commit' + ) + ]); + const winner = outcomes.find((value) => 'receipt' in value); + if (!winner || !('receipt' in winner)) + throw Error('missing actual acknowledged winner'); + const expected = winner === outcomes[0] ? a : b, + ack = s.pairedDeliveryAcknowledgementSnapshot(winner.receipt), + stored = await f.storedPair(), + original = s.selfRecoveryAcknowledgementSnapshot(self), + wire = await f.stored(); + return { + statuses: outcomes.map((value) => value.status).sort(), + oneReceipt: outcomes.filter((value) => 'receipt' in value).length === 1, + peer: + stored?.peerArtifact?.wire === expected.wire && + ack?.peerArtifact.wire === expected.wire, + self: stored?.self.wire === original?.self.wire, + routes: + JSON.stringify(stored?.deliveryPlan?.routes) === + JSON.stringify(s.inboxRoutePlanSnapshot(f.context.plan)), + revision: stored?.revision === ack?.revision, + plaintext: wire.includes(f.marker) + }; + } finally { + f.close(); + } + }); + expect(result).toEqual({ + statuses: ['conflict', 'prepared'], + oneReceipt: true, + peer: true, + self: true, + routes: true, + revision: true, + plaintext: false + }); +}); +test('explicit self then pair retry after pair commit retains genuine successor evidence and exact ciphertext', async ({ + page +}) => { + await load(page); + const result = await page.evaluate(async () => { + const f = window.hcp082Fixture, + s = window.hcp082; + try { + await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery'); + const self = s.preparedSelfRecovery(f.preparation); + await s.preparePairedDelivery( + f.preparation, + f.context, + 'reviewed_pair_preparation' + ); + const token = s.preparedPairedDelivery(f.preparation), + bytes = await f.stored(), + before = f.counts(), + selfAgain = await s.prepareSelfRecovery( + f.preparation, + 'reviewed_self_recovery' + ), + pairAgain = await s.preparePairedDelivery( + f.preparation, + f.context, + 'reviewed_pair_preparation' + ); + return { + self: selfAgain.status, + pair: pairAgain.status, + sameSelf: self === s.preparedSelfRecovery(f.preparation), + samePair: token === s.preparedPairedDelivery(f.preparation), + bytes: bytes === (await f.stored()), + counts: JSON.stringify(before) === JSON.stringify(f.counts()) + }; + } finally { + f.close(); + } + }); + expect(result).toEqual({ + self: 'saved', + pair: 'prepared', + sameSelf: true, + samePair: true, + bytes: true, + counts: true + }); +}); diff --git a/web/tests/unit/paired-delivery.test.ts b/web/tests/unit/paired-delivery.test.ts @@ -0,0 +1,47 @@ +import { describe, it, expect } from 'vitest'; +import type { SelfRecoveryPreparation } from '../../src/lib/messaging/prepare-send.ts'; +import { + preparePairedDelivery, + preparedPairedDelivery +} from '../../src/lib/messaging/prepare-send.ts'; +import { + pairedDeliveryAcknowledgementSnapshot, + type PairedDeliveryAcknowledgement +} from '../../src/lib/persistence/private-sends.ts'; +import type { PairedDeliveryContext } from '../../src/lib/messaging/prepare-send.ts'; + +describe('paired delivery is acknowledged local evidence only', () => { + it('SSR forged preparation cannot perform crypto, persistence or acquire a ready receipt', async () => { + const token = {} as SelfRecoveryPreparation; + expect( + await preparePairedDelivery( + token, + {} as PairedDeliveryContext, + 'reviewed_pair_preparation' + ) + ).toEqual({ status: 'invalid' }); + expect(preparedPairedDelivery(token)).toBeUndefined(); + }); + it('a detached paired receipt grants no local acknowledgement', () => { + expect( + pairedDeliveryAcknowledgementSnapshot({} as PairedDeliveryAcknowledgement) + ).toBeUndefined(); + }); + it('unreviewed input is inert without coercion', async () => { + let calls = 0; + const review = { + toString() { + calls++; + return 'reviewed_pair_preparation'; + } + }; + expect( + await preparePairedDelivery( + {} as SelfRecoveryPreparation, + {} as PairedDeliveryContext, + review + ) + ).toEqual({ status: 'invalid' }); + expect(calls).toBe(0); + }); +});