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:
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();
+ });
+});