app

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

commit 9b6e3f0c99a0358bd17b72f7f5b179bbcba5922c
parent 0a2459f511569b34cfb547c8f322477b9e5bc0b4
Author: triesap <tyson@radroots.org>
Date:   Fri,  9 Oct 2026 10:55:40 +0000

messages: run explicit limited decryption batches (HCP-098)

- Require original owner generation and explicit Messages unlock for batch admission
- Reserve twenty envelope costs before nested validation and verified peer blocking
- Preserve ciphertext and actual SDK occupancy after refusal, wait expiry or Stop
- Verify continuation, malformed layers, hidden admission and foreign generation fences

Diffstat:
Mweb/src/lib/config/budgets.ts | 6++++++
Aweb/src/lib/messaging/decryption-queue.ts | 358+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/src/lib/messaging/inbox-state.ts | 18+++++++++++++++++-
Aweb/tests/e2e/decryption-queue.spec.ts | 350+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/tests/e2e/harness/decryption-queue.ts | 263+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/tests/unit/decryption-queue.test.ts | 52++++++++++++++++++++++++++++++++++++++++++++++++++++
6 files changed, 1046 insertions(+), 1 deletion(-)

diff --git a/web/src/lib/config/budgets.ts b/web/src/lib/config/budgets.ts @@ -113,3 +113,9 @@ export const PRIVATE_LIVE_BUDGETS = Object.freeze({ processedBytes: 2097152, windowMilliseconds: 60000 }); + +// Envelope costs include unsupported and blocked inner senders. Each explicit +// reviewed continuation gets at most twenty; provider waits never cancel calls. +export const PRIVATE_DECRYPTION_BUDGETS = Object.freeze({ + envelopesPerAction: 20 +}); diff --git a/web/src/lib/messaging/decryption-queue.ts b/web/src/lib/messaging/decryption-queue.ts @@ -0,0 +1,358 @@ +import { planDecryptBatch } from './inbox-state.ts'; +import { canonicalPublicKey } from '../contracts/public-key.ts'; +import { LOCAL_PERSISTENCE_BUDGETS } from '../config/budgets.ts'; +import { + privateSessionOwnership, + subscribePrivateSessionClose, + type PrivateSession +} from '../runtime/private-session.ts'; +import { + identityMessagingOwnership, + type IdentitySession +} from '../runtime/identity-session.ts'; +import { + getPrivateVisibilityScope, + privateVisibilitySnapshot +} from '../runtime/dispose.ts'; +import { + listPrivateReceivedRecords, + type PrivateStorageRepository +} from '../persistence/private-storage.ts'; +import { privateRecordIdentity } from '../persistence/private-records.ts'; +import { + captureReceivedUnwrap, + unwrapReceivedEnvelope, + stopReceivedUnwrap, + expireReceivedUnwrapWait, + type ReceivedUnwrap +} from '../nostr/unwrap-admission.ts'; +import { + admitReceivedConversation, + conversationSnapshot, + type AdmittedConversation +} from './admit-conversation.ts'; +import { + unlockedSessionOwnership, + subscribeUnlockedSessionClose, + acceptUnlockedConversation, + type UnlockedSession +} from './unlocked-session.ts'; +declare const queueBrand: unique symbol; +export type DecryptionQueue = Readonly<{ [queueBrand]: true }>; +type View = Readonly<{ + state: string; + reason: string | null; + queued: number; + attempted: number; + blocked: number; + admitted: number; + invalid: number; + busy: boolean; +}>; +type Controller = { + refresh(): Promise<boolean>; + run(review: unknown, blocked: readonly string[]): Promise<boolean>; + snapshot(): View; + rooms(): readonly AdmittedConversation[]; + stop(): void; + expire(): void; +}; +const controllers = new WeakMap<DecryptionQueue, Controller>(), + sessions = new WeakMap<PrivateSession, DecryptionQueue>(); +// Only original current owner-generation and actual explicit Messages unlock +// admit a controller. Construction/refresh never invoke an extension operation. +export function captureDecryptionQueue( + repository: PrivateStorageRepository, + session: PrivateSession, + identity: IdentitySession, + unlocked: UnlockedSession, + review: unknown +): DecryptionQueue | undefined { + if (typeof window === 'undefined' || review !== 'reviewed_inbox_unlock') + return undefined; + const observed = privateSessionOwnership(session), + owner = identityMessagingOwnership(identity), + cache = unlockedSessionOwnership(unlocked); + if ( + !observed?.current() || + !owner?.current() || + !cache?.current() || + observed.owner !== owner.owner || + observed.owner !== cache.owner || + observed.session !== owner.session || + observed.session !== cache.session + ) + return undefined; + const capture = observed, + identityOwner = owner, + unlockedOwner = cache; + let visibility; + try { + visibility = getPrivateVisibilityScope(session); + } catch { + return undefined; + } + if (!visibility || !privateVisibilitySnapshot(visibility).active) + return undefined; + const visible = visibility; + const prior = sessions.get(session); + if (prior) return prior; + const token = Object.freeze({}) as DecryptionQueue; + let stopped = false, + busy = false, + paused = false, + state = 'ready', + reason: string | null = null, + attempted = 0, + blocked = 0, + admitted = 0, + invalid = 0; + let pending = Array.from<string>([]), + processed = Array.from<string>([]), + accepted = Array.from<AdmittedConversation>([]), + readers = Array.from<ReceivedUnwrap>([]); + let active: ReceivedUnwrap | undefined, + off = () => {}, + unlockOff = () => {}; + function current() { + return ( + !stopped && + capture.current() && + identityOwner.current() && + unlockedOwner.current() && + privateVisibilitySnapshot(visible).active + ); + } + function stop() { + if (stopped) return; + stopped = true; + state = 'stopped'; + reason = 'stopped'; + if (active) stopReceivedUnwrap(active); + for (const reader of readers) stopReceivedUnwrap(reader); + readers = []; + accepted = []; + pending = []; + processed = []; + off(); + unlockOff(); + if (sessions.get(session) === token) sessions.delete(session); + // Actual pending SDK promise retains the shared slot until its settlement. + } + function expire() { + if (stopped || !busy) return; + paused = true; + state = 'paused'; + reason = 'wait_expired'; + if (active) expireReceivedUnwrapWait(active); + } + function pause(why: string) { + paused = true; + state = 'paused'; + reason = why; + } + async function load() { + if (!current()) { + stop(); + return false; + } + const result = await listPrivateReceivedRecords(repository); + if (!current()) { + stop(); + return false; + } + if (!result.ok) { + pause(result.reason); + return false; + } + let ids = Array.from<string>([]); + for (const handle of result.value) { + const record = privateRecordIdentity(handle); + if (record?.owner !== capture.owner) { + pause('invalid_scope'); + return false; + } + if (!processed.includes(record.id)) ids = ids.concat(record.id); + } + pending = ids; + return true; + } + const controller: Controller = { + snapshot: () => ({ + state, + reason, + queued: pending.length, + attempted, + blocked, + admitted, + invalid, + busy + }), + rooms: () => (current() ? accepted.slice() : []), + stop, + expire, + async refresh() { + if (busy || !current()) return false; + try { + return await load(); + } catch { + pause('unavailable'); + return false; + } + }, + async run(reviewed, blockedPeers) { + if (reviewed !== 'reviewed_decrypt_batch' || busy || !current()) + return false; + // Detached block values can only suppress an already authenticated inner + // peer's local projection; they never bypass envelope cost or confer SDK access. + if ( + !Array.isArray(blockedPeers) || + blockedPeers.length > LOCAL_PERSISTENCE_BUDGETS.receivedEnvelopes + ) + return false; + const exclusions = blockedPeers.slice(); + for (const peer of exclusions) + if (canonicalPublicKey(peer) !== peer) return false; + busy = true; + paused = false; + state = 'running'; + reason = null; + attempted = 0; + blocked = 0; + admitted = 0; + invalid = 0; + try { + if (!(await load()) || paused || !current()) return false; + const plan = planDecryptBatch(pending); + for (const id of plan.selected) { + if (!current()) { + stop(); + return false; + } + if (paused) return false; + // Cost reservation occurs before unwrap/admission/dedup/blocked sender. + attempted++; + active = captureReceivedUnwrap( + repository, + identity, + id, + 'reviewed_inbox_unlock' + ); + if (!active) { + pause('unavailable'); + return false; + } + const reader = active, + result = await unwrapReceivedEnvelope(reader); + if (!current()) { + stopReceivedUnwrap(reader); + stop(); + return false; + } + if (paused) { + stopReceivedUnwrap(reader); + return false; + } + if (result.status === 'authenticated') { + const room = + admitReceivedConversation(result.envelope, 'inbound') ?? + admitReceivedConversation(result.envelope, 'self_archive'); + const message = room && conversationSnapshot(room); + if (!room || !message) { + invalid++; + stopReceivedUnwrap(reader); + } else if (exclusions.includes(message.peer)) { + blocked++; + stopReceivedUnwrap(reader); + } else { + const projection = acceptUnlockedConversation(unlocked, room); + if (projection === 'added') { + accepted = accepted.concat(room); + readers = readers.concat(reader); + admitted++; + } else if (projection === 'duplicate') { + admitted++; + stopReceivedUnwrap(reader); + } else { + stopReceivedUnwrap(reader); + pause(projection); + return false; + } + } + } else if ( + result.status === 'mismatch' || + result.status === 'invalid' + ) { + invalid++; + stopReceivedUnwrap(reader); + } else { + stopReceivedUnwrap(reader); + pause(result.status); + return false; + } + active = undefined; + if (!current() || paused) return false; + processed = processed.concat(id); + pending = pending.filter((next) => next !== id); + } + if (!(await load()) || paused || !current()) return false; + state = pending.length ? 'needs_action' : 'idle'; + return true; + } catch { + if (current() && !paused) pause('unavailable'); + return false; + } finally { + active = undefined; + busy = false; + } + } + }; + controllers.set(token, controller); + sessions.set(session, token); + off = subscribePrivateSessionClose(session, stop); + unlockOff = subscribeUnlockedSessionClose(unlocked, stop); + if (!current()) { + stop(); + return undefined; + } + return token; +} +export function refreshDecryptionQueue( + token: DecryptionQueue +): Promise<boolean> { + return controllers.get(token)?.refresh() ?? Promise.resolve(false); +} +export function runDecryptionBatch( + token: DecryptionQueue, + review: unknown, + blockedPeers: readonly string[] = [] +): Promise<boolean> { + return ( + controllers.get(token)?.run(review, blockedPeers) ?? Promise.resolve(false) + ); +} +export function decryptionQueueSnapshot(token: DecryptionQueue): View { + return ( + controllers.get(token)?.snapshot() ?? { + state: 'stopped', + reason: 'invalid', + queued: 0, + attempted: 0, + blocked: 0, + admitted: 0, + invalid: 0, + busy: false + } + ); +} +export function decryptionQueueConversations( + token: DecryptionQueue +): readonly AdmittedConversation[] { + return controllers.get(token)?.rooms() ?? []; +} +export function stopDecryptionQueue(token: DecryptionQueue): void { + controllers.get(token)?.stop(); +} +export function expireDecryptionQueueWait(token: DecryptionQueue): void { + controllers.get(token)?.expire(); +} diff --git a/web/src/lib/messaging/inbox-state.ts b/web/src/lib/messaging/inbox-state.ts @@ -1,6 +1,7 @@ import { LOCAL_PERSISTENCE_BUDGETS, - PRIVATE_TRANSPORT_BUDGETS + PRIVATE_TRANSPORT_BUDGETS, + PRIVATE_DECRYPTION_BUDGETS } from '../config/budgets.ts'; export type OuterFact = Readonly<{ outerId: string; outerTime: number }>; export type OuterCursor = Readonly<{ @@ -91,3 +92,18 @@ export function advanceOuterPage( historyComplete: false }; } + +// A work plan is metadata, never an owner, unlock or SDK permission. +export function planDecryptBatch(ids: readonly string[]) { + if (ids.length > LOCAL_PERSISTENCE_BUDGETS.receivedEnvelopes) + throw Error('decryption_queue_capacity'); + for (const id of ids) + if (typeof id !== 'string' || !/^[0-9a-f]{64}$/.test(id)) + throw Error('decryption_queue_identity_invalid'); + const unique = ids.filter((id, index, all) => all.indexOf(id) === index); + const selected = unique.slice( + 0, + PRIVATE_DECRYPTION_BUDGETS.envelopesPerAction + ); + return { selected, remaining: unique.length - selected.length }; +} diff --git a/web/tests/e2e/decryption-queue.spec.ts b/web/tests/e2e/decryption-queue.spec.ts @@ -0,0 +1,350 @@ +import { test, expect } from '@playwright/test'; +import { build } from 'vite'; +import { fileURLToPath } from 'node:url'; +import { createStaticHarness } from '../integration/harness/static.ts'; +import type * as Fixture from './harness/decryption-queue.ts'; +declare global { + interface Window { + hcp098: typeof Fixture; + hcp098Fixture: Awaited<ReturnType<typeof Fixture.makeFixture>>; + hcp098Pending: Promise<unknown>; + } +} +let server: Awaited<ReturnType<typeof createStaticHarness>>, bundle: string; +test.beforeAll(async () => { + server = await createStaticHarness(); + const result = await build({ + configFile: false, + logLevel: 'silent', + build: { + write: false, + minify: false, + lib: { + entry: fileURLToPath( + new URL('./harness/decryption-queue.ts', import.meta.url) + ), + name: 'HCP098', + formats: ['iife'] + } + } + }); + const outputs = Array.isArray(result) ? result : [result]; + const chunk = outputs + .flatMap((output) => ('output' in output ? output.output : [])) + .find((x) => x.type === 'chunk'); + if (!chunk || chunk.type !== 'chunk') throw Error('no actual JS'); + bundle = chunk.code + '\nwindow.hcp098=HCP098;'; +}); +test.beforeEach(async ({ page }, testInfo) => { + await page.goto(server.url + '/messages'); + await page.addScriptTag({ content: bundle }); + await page.evaluate(async (unknown) => { + window.hcp098Fixture = await window.hcp098.makeFixture(21, unknown); + }, testInfo.title.startsWith('unknown authenticated blocked')); +}); +test.afterEach(async ({ page }) => { + await page.evaluate(() => window.hcp098Fixture?.close()); +}); +test.afterAll(async () => { + await server?.close(); +}); +test('21st envelope waits new explicit action after20 actual serialized nested decryptions', async ({ + page +}) => { + expect(await page.evaluate(() => window.hcp098Fixture.capture())).toBe(true); + await page.evaluate(() => window.hcp098Fixture.refresh()); + expect( + (await page.evaluate(() => window.hcp098Fixture.snapshot()))?.queued + ).toBe(21); + expect(await page.evaluate(() => window.hcp098Fixture.batch())).toBe(true); + expect(await page.evaluate(() => window.hcp098Fixture.delta())).toMatchObject( + { decrypts: 40, signs: 0, encrypts: 0 } + ); + expect( + await page.evaluate(() => window.hcp098Fixture.snapshot()) + ).toMatchObject({ state: 'needs_action', queued: 1, attempted: 20 }); + expect(await page.evaluate(() => window.hcp098Fixture.cache())).toMatchObject( + { count: 1 } + ); + expect( + await page.evaluate(() => window.hcp098Fixture.batch('not_reviewed')) + ).toBe(false); + expect( + (await page.evaluate(() => window.hcp098Fixture.delta())).decrypts + ).toBe(40); + expect(await page.evaluate(() => window.hcp098Fixture.batch())).toBe(true); + expect( + (await page.evaluate(() => window.hcp098Fixture.delta())).decrypts + ).toBe(42); + expect( + await page.evaluate(() => window.hcp098Fixture.snapshot()) + ).toMatchObject({ state: 'idle', queued: 0, attempted: 1 }); + expect( + await page.evaluate(() => window.hcp098Fixture.encryptedUnchanged()) + ).toBe(true); + expect(await page.evaluate(() => window.hcp098Fixture.publicContains())).toBe( + false + ); +}); +test('connect capture refresh and unreviewed batch never automatically decrypt', async ({ + page +}) => { + expect(await page.evaluate(() => window.hcp098Fixture.delta())).toMatchObject( + { decrypts: 0, signs: 0, encrypts: 0 } + ); + expect(await page.evaluate(() => window.hcp098Fixture.capture('wrong'))).toBe( + false + ); + expect(await page.evaluate(() => window.hcp098Fixture.capture())).toBe(true); + await page.evaluate(() => window.hcp098Fixture.refresh()); + expect(await page.evaluate(() => window.hcp098Fixture.batch('wrong'))).toBe( + false + ); + expect(await page.evaluate(() => window.hcp098Fixture.delta())).toMatchObject( + { decrypts: 0, signs: 0, encrypts: 0 } + ); + expect( + await page.evaluate(() => window.hcp098Fixture.snapshot()) + ).toMatchObject({ queued: 21, attempted: 0 }); +}); +test('actual provider refusal pauses scheduling and preserves every original ciphertext', async ({ + page +}) => { + await page.evaluate(() => { + window.hcp098Fixture.capture(); + window.hcp098Fixture.mode('declined_decrypt'); + }); + expect(await page.evaluate(() => window.hcp098Fixture.batch())).toBe(false); + expect( + await page.evaluate(() => window.hcp098Fixture.snapshot()) + ).toMatchObject({ + state: 'paused', + reason: 'refused', + queued: 21, + attempted: 1 + }); + expect( + (await page.evaluate(() => window.hcp098Fixture.delta())).decrypts + ).toBe(1); + expect( + await page.evaluate(() => window.hcp098Fixture.encryptedUnchanged()) + ).toBe(true); + await page.evaluate(() => window.hcp098Fixture.mode('normal')); + expect(await page.evaluate(() => window.hcp098Fixture.batch('wrong'))).toBe( + false + ); + expect( + (await page.evaluate(() => window.hcp098Fixture.delta())).decrypts + ).toBe(1); + expect(await page.evaluate(() => window.hcp098Fixture.batch())).toBe(true); + expect( + await page.evaluate(() => window.hcp098Fixture.snapshot()) + ).toMatchObject({ queued: 1, attempted: 20 }); +}); +test('unknown authenticated blocked inner peer still consumes20 envelope costs before hiding bodies', async ({ + page +}) => { + await page.evaluate(() => window.hcp098Fixture.capture()); + expect( + await page.evaluate(() => + window.hcp098Fixture.batch('reviewed_decrypt_batch', [ + window.hcp098Fixture.stranger + ]) + ) + ).toBe(true); + expect( + (await page.evaluate(() => window.hcp098Fixture.delta())).decrypts + ).toBe(40); + expect( + await page.evaluate(() => window.hcp098Fixture.snapshot()) + ).toMatchObject({ queued: 1, attempted: 20, blocked: 20 }); + expect(await page.evaluate(() => window.hcp098Fixture.cache())).toMatchObject( + { count: 0 } + ); + expect( + await page.evaluate(() => window.hcp098Fixture.encryptedUnchanged()) + ).toBe(true); +}); +test('blocking disposable outer author does not replace actual authenticated inner peer', async ({ + page +}) => { + await page.evaluate(() => window.hcp098Fixture.capture()); + expect( + await page.evaluate(() => + window.hcp098Fixture.batch('reviewed_decrypt_batch', [ + window.hcp098Fixture.disposable + ]) + ) + ).toBe(true); + expect( + await page.evaluate(() => window.hcp098Fixture.snapshot()) + ).toMatchObject({ queued: 1, attempted: 20, blocked: 0 }); + expect(await page.evaluate(() => window.hcp098Fixture.cache())).toMatchObject( + { count: 1 } + ); +}); +test('expired UI wait preserves actual occupied SDK slot until original provider settles', async ({ + page +}) => { + await page.evaluate(() => { + window.hcp098Fixture.capture(); + window.hcp098Fixture.mode('hold_decrypt'); + window.hcp098Pending = window.hcp098Fixture.batch(); + }); + await expect + .poll(() => page.evaluate(() => window.hcp098Fixture.scheduler())) + .toMatchObject({ state: 'active', pending: 'decrypt' }); + await page.evaluate(() => window.hcp098Fixture.expire()); + expect( + await page.evaluate(() => window.hcp098Fixture.snapshot()) + ).toMatchObject({ state: 'paused', reason: 'wait_expired', queued: 21 }); + expect( + await page.evaluate(() => window.hcp098Fixture.scheduler()) + ).toMatchObject({ + state: 'active', + pending: 'decrypt', + phase: 'wait_expired' + }); + expect( + await page.evaluate(() => window.hcp098Fixture.competing()) + ).toMatchObject({ status: 'busy' }); + expect(await page.evaluate(() => window.hcp098Fixture.batch())).toBe(false); + await page.evaluate(() => window.hcp098Fixture.settle()); + await page.evaluate(() => window.hcp098Pending); + expect( + await page.evaluate(() => window.hcp098Fixture.scheduler()) + ).toMatchObject({ state: 'idle' }); + expect( + (await page.evaluate(() => window.hcp098Fixture.delta())).decrypts + ).toBe(1); + expect(await page.evaluate(() => window.hcp098Fixture.cache())).toMatchObject( + { count: 0 } + ); + expect( + await page.evaluate(() => window.hcp098Fixture.encryptedUnchanged()) + ).toBe(true); +}); +test('logout during actual pending decrypt cannot cache a late result or schedule a second envelope', async ({ + page +}) => { + await page.evaluate(() => { + window.hcp098Fixture.capture(); + window.hcp098Fixture.mode('hold_decrypt'); + window.hcp098Pending = window.hcp098Fixture.batch(); + }); + await expect + .poll(() => page.evaluate(() => window.hcp098Fixture.scheduler())) + .toMatchObject({ state: 'active', pending: 'decrypt' }); + await page.evaluate(() => window.hcp098Fixture.disconnect()); + expect( + await page.evaluate(() => window.hcp098Fixture.scheduler()) + ).toMatchObject({ state: 'active', pending: 'decrypt' }); + await page.evaluate(() => window.hcp098Fixture.settle()); + await page.evaluate(() => window.hcp098Pending); + expect( + (await page.evaluate(() => window.hcp098Fixture.delta())).decrypts + ).toBe(1); + expect(await page.evaluate(() => window.hcp098Fixture.cache())).toMatchObject( + { closed: true, count: 0 } + ); + expect(await page.evaluate(() => window.hcp098Fixture.batch())).toBe(false); + expect( + await page.evaluate(() => window.hcp098Fixture.encryptedUnchanged()) + ).toBe(true); +}); +test('forged copied closed-unlock and invalid block metadata cannot gain SDK admission', async ({ + page +}) => { + await page.evaluate(() => window.hcp098Fixture.capture()); + expect(await page.evaluate(() => window.hcp098Fixture.forged())).toBe(false); + expect(await page.evaluate(() => window.hcp098Fixture.copied())).toBe(false); + expect( + await page.evaluate(() => + window.hcp098Fixture.batch('reviewed_decrypt_batch', ['wrong']) + ) + ).toBe(false); + await page.evaluate(() => window.hcp098Fixture.closeUnlock()); + expect(await page.evaluate(() => window.hcp098Fixture.batch())).toBe(false); + expect( + (await page.evaluate(() => window.hcp098Fixture.delta())).decrypts + ).toBe(0); + expect( + await page.evaluate(() => window.hcp098Fixture.encryptedUnchanged()) + ).toBe(true); +}); + +test('malformed decrypted layer is isolated but consumes the explicit envelope cap', async ({ + page +}) => { + await page.evaluate(() => { + window.hcp098Fixture.capture(); + window.hcp098Fixture.mode('wrong_plaintext'); + }); + expect(await page.evaluate(() => window.hcp098Fixture.batch())).toBe(true); + expect( + (await page.evaluate(() => window.hcp098Fixture.delta())).decrypts + ).toBe(20); + expect( + await page.evaluate(() => window.hcp098Fixture.snapshot()) + ).toMatchObject({ + state: 'needs_action', + queued: 1, + attempted: 20, + invalid: 20 + }); + expect(await page.evaluate(() => window.hcp098Fixture.cache())).toMatchObject( + { count: 0 } + ); + expect( + await page.evaluate(() => window.hcp098Fixture.encryptedUnchanged()) + ).toBe(true); +}); +test('explicit Stop during actual provider wait keeps SDK occupied and prevents the next envelope', async ({ + page +}) => { + await page.evaluate(() => { + window.hcp098Fixture.capture(); + window.hcp098Fixture.mode('hold_decrypt'); + window.hcp098Pending = window.hcp098Fixture.batch(); + }); + await expect + .poll(() => page.evaluate(() => window.hcp098Fixture.scheduler())) + .toMatchObject({ state: 'active', pending: 'decrypt' }); + await page.evaluate(() => window.hcp098Fixture.stop()); + expect( + await page.evaluate(() => window.hcp098Fixture.snapshot()) + ).toMatchObject({ state: 'stopped', busy: true }); + expect( + await page.evaluate(() => window.hcp098Fixture.competing()) + ).toMatchObject({ status: 'busy' }); + expect(await page.evaluate(() => window.hcp098Fixture.batch())).toBe(false); + await page.evaluate(() => window.hcp098Fixture.settle()); + await page.evaluate(() => window.hcp098Pending); + expect( + await page.evaluate(() => window.hcp098Fixture.scheduler()) + ).toMatchObject({ state: 'idle' }); + expect( + (await page.evaluate(() => window.hcp098Fixture.delta())).decrypts + ).toBe(1); + expect(await page.evaluate(() => window.hcp098Fixture.cache())).toMatchObject( + { count: 0 } + ); + expect( + await page.evaluate(() => window.hcp098Fixture.encryptedUnchanged()) + ).toBe(true); +}); +test('same-key genuine foreign identity generation cannot import original unlock authority', async ({ + page +}) => { + await page.evaluate(() => window.hcp098Fixture.capture()); + await page.evaluate(() => window.hcp098Fixture.refresh()); + expect( + await page.evaluate(() => window.hcp098Fixture.foreignCapture()) + ).toEqual({ captured: false, keys: 0, decrypts: 0, signs: 0 }); + expect( + await page.evaluate(() => window.hcp098Fixture.snapshot()) + ).toMatchObject({ queued: 21, attempted: 0 }); + expect( + await page.evaluate(() => window.hcp098Fixture.encryptedUnchanged()) + ).toBe(true); +}); diff --git a/web/tests/e2e/harness/decryption-queue.ts b/web/tests/e2e/harness/decryption-queue.ts @@ -0,0 +1,263 @@ +import { + captureDecryptionQueue, + refreshDecryptionQueue, + runDecryptionBatch, + decryptionQueueSnapshot, + stopDecryptionQueue, + expireDecryptionQueueWait, + type DecryptionQueue +} from '../../../src/lib/messaging/decryption-queue.ts'; +import { makeFixture as makeRecoveryFixture } from './resume-preparation.ts'; +import { + createPrivateSession, + closePrivateSession +} from '../../../src/lib/runtime/private-session.ts'; +import { + captureUnlockedSession, + closeUnlockedSession, + readUnlockedMessages, + unlockedSessionSnapshot +} from '../../../src/lib/messaging/unlocked-session.ts'; +import { + admitInboxEnvelope, + retainInboxEnvelope +} from '../../../src/lib/persistence/inbox-envelope-repository.ts'; +import { listPrivateReceivedRecords } from '../../../src/lib/persistence/private-storage.ts'; +import { + privateRecordWire, + privateRecordIdentity +} from '../../../src/lib/persistence/private-records.ts'; +import { + finalizeEvent, + getPublicKey, + getEventHash +} from 'applesauce-core/helpers'; +import { nip44 } from 'applesauce-core/helpers/encryption'; +import { + browserExtensionScheduler, + extensionSchedulerSnapshot, + runExtensionAction +} from '../../../src/lib/nostr/extension-scheduler.ts'; +import { + identityMessagingOwnership, + createIdentitySession, + connectIdentity, + probeIdentityMessaging, + disconnectIdentity, + identitySessionSnapshot +} from '../../../src/lib/runtime/identity-session.ts'; +import { + getPublicStore, + publicStoreEnvelope +} from '../../../src/lib/nostr/public-store.ts'; +export async function makeFixture(count = 21, unknownSender = false) { + const f = await makeRecoveryFixture(); + const session = await createPrivateSession( + f.identity, + 'reviewed_private_session' + ); + if (!session) throw Error('missing genuine original private session'); + const unlocked = captureUnlockedSession(session, 'reviewed_messages_unlock'); + if (!unlocked) throw Error('missing genuine original unlock'); + const initial = (await f.row())!; + const originalOutbox = JSON.stringify(initial.record); + const ownerSecret = new Uint8Array(32).fill(83), + outerSecret = new Uint8Array(32).fill(86), + strangerSecret = new Uint8Array(32).fill(85); + const stranger = getPublicKey(strangerSecret), + disposable = getPublicKey(outerSecret); + function encrypt(secret: Uint8Array, target: string, plain: string) { + const key = nip44.v2.utils.getConversationKey(secret, target); + try { + return nip44.v2.encrypt(plain, key); + } finally { + key.fill(0); + } + } + let sealWire: string; + try { + if (unknownSender) { + const template = { + pubkey: stranger, + kind: 14, + created_at: 1700000000, + tags: [['p', f.owner]], + content: 'Controlled unknown authenticated sender' + }; + const rumor = { id: getEventHash(template), ...template }; + sealWire = JSON.stringify( + finalizeEvent( + { + kind: 13, + created_at: 1699999900, + tags: [], + content: encrypt(strangerSecret, f.owner, JSON.stringify(rumor)) + }, + strangerSecret + ) + ); + } else { + const outer = JSON.parse(initial.record.self.wire) as { + pubkey: string; + content: string; + }; + const key = nip44.v2.utils.getConversationKey(ownerSecret, outer.pubkey); + try { + sealWire = nip44.v2.decrypt(outer.content, key); + } finally { + key.fill(0); + } + } + for (let i = 0; i < count; i++) { + const outer = finalizeEvent( + { + kind: 1059, + created_at: 1700000000 + i, + tags: [['p', f.owner]], + content: encrypt(outerSecret, f.owner, sealWire) + }, + outerSecret + ); + const admitted = admitInboxEnvelope( + JSON.stringify(outer), + f.owner, + 'wss://archive.example.org', + 100 + i + ); + if ( + !admitted || + (await retainInboxEnvelope(f.repository, session, admitted)).status !== + 'retained' + ) + throw Error('missing actual retained ciphertext'); + } + } finally { + ownerSecret.fill(0); + outerSecret.fill(0); + strangerSecret.fill(0); + } + const publicStore = getPublicStore()!; + async function retained() { + const rows = await listPrivateReceivedRecords(f.repository); + if (!rows.ok) throw Error('actual received scan failed'); + return rows.value.map((row) => + privateRecordWire(row, f.owner, privateRecordIdentity(row)?.id) + ); + } + const originalReceived = JSON.stringify(await retained()), + baseline = f.counts(); + let queue: DecryptionQueue | undefined; + return { + ...f, + stranger, + disposable, + capture(review: unknown = 'reviewed_inbox_unlock') { + queue = captureDecryptionQueue( + f.repository, + session, + f.identity, + unlocked, + review + ); + return !!queue; + }, + refresh: async () => queue && (await refreshDecryptionQueue(queue)), + batch: async ( + review: unknown = 'reviewed_decrypt_batch', + blocked: readonly string[] = [] + ) => queue && (await runDecryptionBatch(queue, review, blocked)), + snapshot: () => queue && decryptionQueueSnapshot(queue), + delta: () => ({ + decrypts: f.counts().decrypts - baseline.decrypts, + keys: f.counts().keys - baseline.keys, + signs: f.counts().signs - baseline.signs, + encrypts: f.counts().encrypts - baseline.encrypts + }), + cache: () => unlockedSessionSnapshot(unlocked), + messages: () => readUnlockedMessages(unlocked), + encryptedUnchanged: async () => + JSON.stringify(await retained()) === originalReceived && + JSON.stringify((await f.row())!.record) === originalOutbox, + count: async () => (await retained()).length, + publicContains: async () => { + const rows = await listPrivateReceivedRecords(f.repository); + return ( + rows.ok && + rows.value.some((row) => { + const wire = privateRecordWire( + row, + f.owner, + privateRecordIdentity(row)?.id + ); + return ( + wire && + publicStoreEnvelope( + publicStore, + (JSON.parse(wire) as { id: string }).id + ) !== undefined + ); + }) + ); + }, + forged: () => + runDecryptionBatch({} as DecryptionQueue, 'reviewed_decrypt_batch'), + copied: () => + queue && runDecryptionBatch({ ...queue }, 'reviewed_decrypt_batch'), + stop: () => { + if (queue) stopDecryptionQueue(queue); + }, + expire: () => { + if (queue) expireDecryptionQueueWait(queue); + }, + closeUnlock: () => closeUnlockedSession(unlocked), + scheduler: () => { + const sdk = browserExtensionScheduler(); + return sdk && extensionSchedulerSnapshot(sdk); + }, + identitySnapshot: () => identitySessionSnapshot(f.identity), + async foreignCapture() { + const other = createIdentitySession(); + await connectIdentity(other); + await probeIdentityMessaging(other, 'reviewed_self_copy'); + const before = f.counts(); + const candidate = captureDecryptionQueue( + f.repository, + session, + other, + unlocked, + 'reviewed_inbox_unlock' + ); + const after = f.counts(); + disconnectIdentity(other); + return { + captured: !!candidate, + keys: after.keys - before.keys, + decrypts: after.decrypts - before.decrypts, + signs: after.signs - before.signs + }; + }, + competing: async () => { + const sdk = browserExtensionScheduler(), + ownership = identityMessagingOwnership(f.identity); + return ( + sdk && + ownership && + (await runExtensionAction( + sdk, + { + owner: ownership.owner, + session: ownership.session, + operation: Symbol() + }, + ownership.current, + () => Promise.resolve(true) + )) + ); + }, + close() { + if (queue) stopDecryptionQueue(queue); + closePrivateSession(session); + f.close(); + } + }; +} diff --git a/web/tests/unit/decryption-queue.test.ts b/web/tests/unit/decryption-queue.test.ts @@ -0,0 +1,52 @@ +import { beforeAll, describe, expect, it } from 'vitest'; +import { planDecryptBatch } from '../../src/lib/messaging/inbox-state.ts'; +import { PRIVATE_DECRYPTION_BUDGETS } from '../../src/lib/config/budgets.ts'; +const ids = (n: number) => + Array.from({ length: n }, (_, i) => i.toString(16).padStart(64, '0')); +beforeAll(() => { + expect(planDecryptBatch).toBeTypeOf('function'); +}); +describe('explicit envelope decryption work plan', () => { + it('holds the21st for another explicit action', () => { + const input = ids(21); + expect(planDecryptBatch(input)).toEqual({ + selected: input.slice(0, 20), + remaining: 1 + }); + }); + it('keeps the approved20-envelope maximum for every large queue', () => { + expect(PRIVATE_DECRYPTION_BUDGETS.envelopesPerAction).toBe(20); + expect(planDecryptBatch(ids(2000)).selected).toHaveLength(20); + expect(planDecryptBatch(ids(2000)).remaining).toBe(1980); + }); + it('preserves opaque stored-ID order instead of inner message or author sorting', () => { + const input = ids(21).reverse(); + expect(planDecryptBatch(input).selected).toEqual(input.slice(0, 20)); + }); + it('does not schedule the same persisted outer ID twice', () => { + const input = ids(21); + expect(planDecryptBatch([input[0], ...input])).toEqual( + planDecryptBatch(input) + ); + }); + it('clones a frozen caller queue without mutation or aliases', () => { + const input = Object.freeze(ids(21)); + const next = planDecryptBatch(input); + next.selected[0] = 'a'.repeat(64); + expect(input[0]).toBe('0'.repeat(64)); + expect(planDecryptBatch(input).remaining).toBe(1); + }); + it('does not invent work for an empty queue', () => { + expect(planDecryptBatch([])).toEqual({ selected: [], remaining: 0 }); + }); + it('refuses malformed and uppercase ciphertext identities before selecting work', () => { + for (const value of ['wrong', 'A'.repeat(64), '0'.repeat(63)]) + expect(() => planDecryptBatch([value])).toThrow(); + }); + it('refuses an over-capacity queue without eviction or limit reset', () => { + expect(() => planDecryptBatch(ids(2001))).toThrow(); + }); + it('does not truncate unsupported IDs after an otherwise complete batch', () => { + expect(() => planDecryptBatch([...ids(20), 'wrong'])).toThrow(); + }); +});