commit 81142cb775c0e4b2d48033a238e979793824d59a
parent c308a5f7d60dfae874957da9dc60327f61dafc0d
Author: triesap <tyson@radroots.org>
Date: Wed, 7 Oct 2026 17:51:39 +0000
messages: build recipient-encrypted sender-signed seals (HCP-075)
- Bind seal preparation to genuine current owner and reserved rumor
- Serialize reviewed encryption and signing through existing ownership ports
- Verify immutable signed fields independently of provider cache markers
- Exercise bounded admission and pending-call lifecycle in real Chromium
Diffstat:
5 files changed, 1191 insertions(+), 0 deletions(-)
diff --git a/web/src/lib/nostr/seal-builder.ts b/web/src/lib/nostr/seal-builder.ts
@@ -0,0 +1,273 @@
+import { ExtensionSigner } from 'applesauce-signers';
+import type { UnsignedEvent } from 'applesauce-core/helpers';
+import {
+ reservedSendSnapshot,
+ reservedSendRumorWire,
+ type ReservedSendIdentity
+} from '../messaging/send-identity.ts';
+import {
+ identityMessagingOwnership,
+ disconnectIdentity,
+ type IdentitySession
+} from '../runtime/identity-session.ts';
+import {
+ browserExtensionScheduler,
+ runExtensionAction,
+ callExtension,
+ stopExtensionAction,
+ markExtensionWaitExpired,
+ type ExtensionAction
+} from './extension-scheduler.ts';
+import { safeUnsignedInteger } from './envelope-bounds.ts';
+import {
+ sealCiphertextV2,
+ captureSealTemplate,
+ bindSealResponse
+} from './seal-template.ts';
+declare const operationBrand: unique symbol;
+declare const sealBrand: unique symbol;
+export type PrivateSealOperation = Readonly<{ [operationBrand]: true }>;
+export type PrivateRecipientSeal = Readonly<{ [sealBrand]: true }>;
+export type PrivateSealResult =
+ | Readonly<{ status: 'sealed'; seal: PrivateRecipientSeal }>
+ | Readonly<{
+ status:
+ 'invalid' | 'busy' | 'unavailable' | 'refused' | 'stopped' | 'mismatch';
+ }>;
+type State = {
+ run(): Promise<PrivateSealResult>;
+ stop(expired: boolean): void;
+};
+type SavedSeal = Readonly<{
+ owner: string;
+ peer: string;
+ destination: string;
+ role: 'peer' | 'self';
+ command: string;
+ rumorHash: string;
+ wire: string;
+ current(): boolean;
+}>;
+const operations = new WeakMap<PrivateSealOperation, State>();
+const seals = new WeakMap<PrivateRecipientSeal, SavedSeal>();
+// Explicit lower-level crypto preparation, not inbox readiness, durable CAS,
+// saved-encrypted evidence, a Send controller or a public/private publisher.
+export function capturePrivateSealOperation(
+ session: IdentitySession,
+ reserved: ReservedSendIdentity,
+ role: unknown,
+ review: unknown
+): PrivateSealOperation | undefined {
+ if (
+ review !== 'reviewed_private_seal' ||
+ (role !== 'peer' && role !== 'self')
+ )
+ return undefined;
+ const inputRecord = reservedSendSnapshot(reserved),
+ inputOwnership = identityMessagingOwnership(session);
+ if (
+ !inputRecord ||
+ !inputOwnership ||
+ inputRecord.owner !== inputOwnership.owner ||
+ !inputOwnership.current()
+ )
+ return undefined;
+ const record = inputRecord,
+ ownership = inputOwnership,
+ capturedRole = role;
+ const target = capturedRole === 'self' ? record.owner : record.peer;
+ let stopped = false,
+ started = false,
+ active: ExtensionAction | undefined;
+ const current = () => {
+ const observed = reservedSendSnapshot(reserved);
+ return (
+ !stopped &&
+ ownership.current() &&
+ observed?.owner === record.owner &&
+ observed.id === record.id &&
+ observed.peer === record.peer &&
+ observed.rumorHash === record.rumorHash
+ );
+ };
+ function stop(expired: boolean) {
+ stopped = true;
+ if (active) {
+ if (expired) markExtensionWaitExpired(active);
+ else stopExtensionAction(active);
+ }
+ }
+ function cipherPort() {
+ try {
+ if (!current()) return undefined;
+ const cipher = new ExtensionSigner().nip44;
+ if (!current() || !cipher) return undefined;
+ const encryptMethod = cipher.encrypt;
+ if (!current()) return undefined;
+ const decryptMethod = cipher.decrypt;
+ if (
+ !current() ||
+ typeof encryptMethod !== 'function' ||
+ typeof decryptMethod !== 'function'
+ )
+ return undefined;
+ const encrypt = encryptMethod.bind(cipher);
+ if (!current()) return undefined;
+ const decrypt = decryptMethod.bind(cipher);
+ if (!current()) return undefined;
+ // Owned plain port: the provider's getters are never re-read inside a
+ // scheduled invocation with the captured private rumor.
+ return { encrypt, decrypt };
+ } catch {
+ return undefined;
+ }
+ }
+ async function fresh(action: ExtensionAction): Promise<boolean> {
+ if (!current()) return false;
+ const result = await callExtension(action, 'key', () =>
+ new ExtensionSigner().getPublicKey()
+ );
+ if (!current()) return false;
+ if (
+ result.status !== 'settled' ||
+ !result.current ||
+ result.value !== record.owner
+ ) {
+ disconnectIdentity(session);
+ return false;
+ }
+ const cipher = cipherPort();
+ if (!current()) return false;
+ if (!cipher) {
+ disconnectIdentity(session);
+ return false;
+ }
+ return current();
+ }
+ async function work(action: ExtensionAction): Promise<PrivateSealResult> {
+ active = action;
+ const initial = cipherPort();
+ if (!current()) return { status: 'stopped' };
+ if (!initial) {
+ disconnectIdentity(session);
+ return { status: 'unavailable' };
+ }
+ if (!(await fresh(action))) return { status: 'stopped' };
+ const wire = reservedSendRumorWire(reserved),
+ cipher = cipherPort();
+ if (!cipher && current()) disconnectIdentity(session);
+ if (!wire || !cipher || !current()) return { status: 'stopped' };
+ const encrypted = await callExtension(action, 'encrypt', () =>
+ cipher.encrypt(target, wire)
+ );
+ if (!current()) return { status: 'stopped' };
+ if (encrypted.status !== 'settled' || !encrypted.current)
+ return { status: encrypted.status === 'denied' ? 'refused' : 'stopped' };
+ if (!sealCiphertextV2(encrypted.value)) return { status: 'mismatch' };
+ if (!(await fresh(action))) return { status: 'stopped' };
+ const milliseconds = safeUnsignedInteger(Date.now());
+ if (milliseconds === undefined || !current()) return { status: 'stopped' };
+ // Public randomized timing metadata only. Never change the reserved inner
+ // timestamp. No identity key, crypto implementation or future time created.
+ const random = crypto.getRandomValues(new Uint32Array(1))[0],
+ now = Math.floor(milliseconds / 1000),
+ time = Math.max(0, now - (random % 3600));
+ const captured = captureSealTemplate(record.owner, encrypted.value, time);
+ if (!captured || !current()) return { status: 'mismatch' };
+ const response = await callExtension(action, 'sign', () =>
+ new ExtensionSigner().signEvent(JSON.parse(captured) as UnsignedEvent)
+ );
+ if (!current()) return { status: 'stopped' };
+ if (response.status !== 'settled' || !response.current)
+ return { status: response.status === 'denied' ? 'refused' : 'stopped' };
+ const signed = bindSealResponse(captured, response.value);
+ if (!signed) return { status: 'mismatch' };
+ if (!(await fresh(action))) return { status: 'stopped' };
+ if (!current()) return { status: 'stopped' };
+ const seal = Object.freeze({}) as PrivateRecipientSeal;
+ seals.set(seal, {
+ owner: record.owner,
+ peer: record.peer,
+ destination: target,
+ role: capturedRole,
+ command: record.id,
+ rumorHash: record.rumorHash,
+ wire: signed,
+ current
+ });
+ return { status: 'sealed', seal };
+ }
+ async function run(): Promise<PrivateSealResult> {
+ if (started || !current()) return { status: 'stopped' };
+ started = true;
+ if (typeof window === 'undefined' || !navigator.locks?.request)
+ return { status: 'unavailable' };
+ try {
+ return await navigator.locks.request(
+ 'harvestcircle:owner:' + record.owner,
+ { mode: 'exclusive', ifAvailable: true },
+ async (lock): Promise<PrivateSealResult> => {
+ if (!lock) return { status: 'busy' };
+ if (!current()) return { status: 'stopped' };
+ const scheduler = browserExtensionScheduler();
+ if (!scheduler) return { status: 'unavailable' };
+ const result = await runExtensionAction(
+ scheduler,
+ {
+ owner: record.owner,
+ session: ownership.session,
+ operation: Symbol()
+ },
+ current,
+ work
+ );
+ if (!current()) return { status: 'stopped' };
+ if (result.status === 'busy') return { status: 'busy' };
+ return result.status === 'completed' &&
+ 'value' in result &&
+ result.value
+ ? result.value
+ : { status: result.status === 'denied' ? 'refused' : 'stopped' };
+ }
+ );
+ } catch {
+ return { status: current() ? 'refused' : 'stopped' };
+ } finally {
+ active = undefined;
+ }
+ }
+ const operation = Object.freeze({}) as PrivateSealOperation;
+ operations.set(operation, { run, stop });
+ return operation;
+}
+export function buildPrivateSeal(
+ operation: PrivateSealOperation
+): Promise<PrivateSealResult> {
+ return (
+ operations.get(operation)?.run() ?? Promise.resolve({ status: 'invalid' })
+ );
+}
+export function stopPrivateSeal(operation: PrivateSealOperation): void {
+ operations.get(operation)?.stop(false);
+}
+export function expirePrivateSealWait(operation: PrivateSealOperation): void {
+ operations.get(operation)?.stop(true);
+}
+// Detached signed ciphertext only; a cast/copy is not a private seal token.
+// Future wrapper/nested owners must retain exact original operation binding.
+export function privateSealSnapshot(
+ seal: PrivateRecipientSeal
+): Readonly<Omit<SavedSeal, 'current'>> | undefined {
+ const saved = seals.get(seal);
+ return saved?.current()
+ ? {
+ owner: saved.owner,
+ peer: saved.peer,
+ destination: saved.destination,
+ role: saved.role,
+ command: saved.command,
+ rumorHash: saved.rumorHash,
+ wire: saved.wire
+ }
+ : undefined;
+}
diff --git a/web/src/lib/nostr/seal-template.ts b/web/src/lib/nostr/seal-template.ts
@@ -0,0 +1,104 @@
+import { getEventHash, type UnsignedEvent } from 'applesauce-core/helpers';
+import { canonicalPublicKey } from '../contracts/public-key.ts';
+import { boundedUtf8 } from '../contracts/food-availability-v1/text.ts';
+import { safeUnsignedInteger } from './envelope-bounds.ts';
+import { verifyEnvelope } from './verified-envelope.ts';
+// Encoded version/size preflight only. Authentication/decryption is owned by
+// the SDK and later nested validation, never inferred from base64 structure.
+export function sealCiphertextV2(value: unknown): value is string {
+ if (
+ typeof value !== 'string' ||
+ value.length < 132 ||
+ !boundedUtf8(value, 16384) ||
+ !/^[A-Za-z0-9+/]+={0,2}$/.test(value)
+ )
+ return false;
+ try {
+ const decoded = atob(value);
+ return (
+ decoded.length >= 99 &&
+ decoded.charCodeAt(0) === 2 &&
+ btoa(decoded) === value
+ );
+ } catch {
+ return false;
+ }
+}
+// Detached pure data, not an operation/signing/publication capability.
+export function captureSealTemplate(
+ author: unknown,
+ ciphertext: unknown,
+ timestamp: unknown
+): string | undefined {
+ const owner = canonicalPublicKey(author),
+ time = safeUnsignedInteger(timestamp);
+ if (!owner || time === undefined || !sealCiphertextV2(ciphertext))
+ return undefined;
+ const wire = JSON.stringify({
+ pubkey: owner,
+ kind: 13,
+ created_at: time,
+ tags: [],
+ content: ciphertext
+ });
+ return boundedUtf8(wire, 16384) ? wire : undefined;
+}
+function own(value: object, name: string): unknown {
+ const property = Object.getOwnPropertyDescriptor(value, name);
+ return property && 'value' in property ? property.value : undefined;
+}
+// Reconstruct only fixed own data fields. No raw spread, getters, toJSON,
+// iterators, extra fields or SDK cache symbols enter the retained private wire.
+export function bindSealResponse(
+ captured: unknown,
+ response: unknown
+): string | undefined {
+ try {
+ if (
+ typeof captured !== 'string' ||
+ !boundedUtf8(captured, 16384) ||
+ typeof response !== 'object' ||
+ response === null ||
+ Array.isArray(response)
+ )
+ return undefined;
+ const template = JSON.parse(captured) as UnsignedEvent;
+ if (
+ captureSealTemplate(
+ template.pubkey,
+ template.content,
+ template.created_at
+ ) !== captured
+ )
+ return undefined;
+ for (const name of ['pubkey', 'kind', 'created_at', 'content'] as const)
+ if (own(response, name) !== template[name]) return undefined;
+ const tags = own(response, 'tags'),
+ id = own(response, 'id'),
+ sig = own(response, 'sig');
+ if (
+ !Array.isArray(tags) ||
+ own(tags, 'length') !== 0 ||
+ typeof id !== 'string' ||
+ !/^[0-9a-f]{64}$/.test(id) ||
+ typeof sig !== 'string' ||
+ !/^[0-9a-f]{128}$/.test(sig) ||
+ id !== getEventHash(template)
+ )
+ return undefined;
+ const wire = JSON.stringify({
+ pubkey: template.pubkey,
+ kind: 13,
+ created_at: template.created_at,
+ tags: [],
+ content: template.content,
+ id,
+ sig
+ });
+ return boundedUtf8(wire, 16384) && verifyEnvelope(wire).ok
+ ? wire
+ : undefined;
+ } catch {
+ return undefined;
+ }
+}
diff --git a/web/tests/e2e/harness/seal-builder.ts b/web/tests/e2e/harness/seal-builder.ts
@@ -0,0 +1,290 @@
+import {
+ finalizeEvent,
+ generateSecretKey,
+ getPublicKey,
+ verifiedSymbol,
+ type UnsignedEvent
+} from 'applesauce-core/helpers';
+import { nip44 } from 'applesauce-core/helpers/encryption';
+import { verifyEnvelope } from '../../../src/lib/nostr/verified-envelope.ts';
+import { captureEnquiryContext } from '../../../src/lib/messaging/enquiry-context.ts';
+import { captureEnquiryRumor } from '../../../src/lib/messaging/rumor-plan.ts';
+import {
+ openBrowserDatabase,
+ closeBrowserDatabase,
+ browserDatabaseTransaction
+} from '../../../src/lib/persistence/database.ts';
+import { createPrivateSendReservationRepository } from '../../../src/lib/persistence/private-send-reservations.ts';
+import {
+ reserveSendIdentity,
+ reservedSendRumorWire
+} from '../../../src/lib/messaging/send-identity.ts';
+import {
+ createIdentitySession,
+ connectIdentity,
+ probeIdentityMessaging,
+ identitySessionSnapshot,
+ disconnectIdentity
+} from '../../../src/lib/runtime/identity-session.ts';
+import {
+ capturePrivateSealOperation,
+ buildPrivateSeal,
+ stopPrivateSeal,
+ expirePrivateSealWait,
+ privateSealSnapshot
+} from '../../../src/lib/nostr/seal-builder.ts';
+import {
+ browserExtensionScheduler,
+ extensionSchedulerSnapshot
+} from '../../../src/lib/nostr/extension-scheduler.ts';
+export {
+ capturePrivateSealOperation,
+ buildPrivateSeal,
+ stopPrivateSeal,
+ expirePrivateSealWait,
+ privateSealSnapshot
+};
+export type Mode =
+ | 'normal'
+ | 'wrong_cipher'
+ | 'wrong_author'
+ | 'wrong_tags'
+ | 'wrong_time'
+ | 'cached_bad_id'
+ | 'missing'
+ | 'declined'
+ | 'changed_key'
+ | 'hold_encrypt'
+ | 'hold_sign'
+ | 'getter_reentry'
+ | 'stop_capability_getter'
+ | 'stop_capability_after_key';
+// Ephemeral source-only provider: actual stock SDK encryption/signature and real
+// Chromium IDB/WebLocks. No installed extension/relay/client qualification.
+export async function makeFixture() {
+ const secret = generateSecretKey(),
+ peerSecret = generateSecretKey(),
+ owner = getPublicKey(secret),
+ peer = getPublicKey(peerSecret);
+ let mode: Mode = 'normal',
+ keys = 0,
+ encrypts = 0,
+ signs = 0,
+ capabilityReads = 0,
+ reentrantReads = 0,
+ postStopEncrypts = 0,
+ getterStopped = false,
+ watched: ReturnType<typeof capturePrivateSealOperation>,
+ release: (() => void) | undefined;
+ function encryptTo(target: string, text: string) {
+ const conversation = nip44.v2.utils.getConversationKey(secret, target);
+ try {
+ return nip44.v2.encrypt(text, conversation);
+ } finally {
+ conversation.fill(0);
+ }
+ }
+ function sign(template: UnsignedEvent) {
+ const input =
+ mode === 'wrong_cipher'
+ ? { ...template, content: encryptTo(peer, 'different immutable rumor') }
+ : mode === 'wrong_tags'
+ ? { ...template, tags: [['client', 'leak']] }
+ : mode === 'wrong_time'
+ ? { ...template, created_at: template.created_at + 1 }
+ : template;
+ const signed = finalizeEvent(
+ input,
+ mode === 'wrong_author' ? peerSecret : secret
+ );
+ return mode === 'cached_bad_id'
+ ? { ...signed, id: '0'.repeat(64), [verifiedSymbol]: true }
+ : {
+ ...signed,
+ plaintext: 'never retained sentinel',
+ toJSON: () => {
+ throw Error('unexpected provider conversion');
+ }
+ };
+ }
+ const provider = {
+ getPublicKey: () => {
+ keys++;
+ return Promise.resolve(mode === 'changed_key' ? peer : owner);
+ },
+ signEvent: (template: UnsignedEvent) => {
+ signs++;
+ return mode === 'hold_sign'
+ ? new Promise<ReturnType<typeof sign>>((resolve) => {
+ release = () => resolve(sign(template));
+ })
+ : Promise.resolve(sign(template));
+ },
+ get nip44() {
+ capabilityReads++;
+ if (
+ watched &&
+ (mode === 'stop_capability_getter' ||
+ (mode === 'stop_capability_after_key' && capabilityReads === 2))
+ ) {
+ stopPrivateSeal(watched);
+ return undefined;
+ }
+ return mode === 'missing'
+ ? undefined
+ : {
+ get encrypt() {
+ const scheduler = browserExtensionScheduler(),
+ slot = scheduler && extensionSchedulerSnapshot(scheduler);
+ if (
+ mode === 'getter_reentry' &&
+ watched &&
+ slot &&
+ slot.state === 'active' &&
+ slot.pending === 'encrypt'
+ ) {
+ reentrantReads++;
+ getterStopped = true;
+ stopPrivateSeal(watched);
+ }
+ return (target: string, text: string) => {
+ encrypts++;
+ if (getterStopped) postStopEncrypts++;
+ if (mode === 'declined')
+ return Promise.reject(Error('private failure must not leak'));
+ if (mode === 'hold_encrypt')
+ return new Promise<string>((resolve) => {
+ release = () => resolve(encryptTo(target, text));
+ });
+ return Promise.resolve(encryptTo(target, text));
+ };
+ },
+ decrypt: (target: string, cipher: string) => {
+ const conversation = nip44.v2.utils.getConversationKey(
+ secret,
+ target
+ );
+ try {
+ return Promise.resolve(nip44.v2.decrypt(cipher, conversation));
+ } finally {
+ conversation.fill(0);
+ }
+ }
+ };
+ }
+ };
+ Object.defineProperty(window, 'nostr', {
+ configurable: true,
+ value: provider
+ });
+ const identity = createIdentitySession();
+ await connectIdentity(identity);
+ await probeIdentityMessaging(identity, 'reviewed_self_copy');
+ const food = finalizeEvent(
+ {
+ kind: 30402,
+ created_at: 1700000060,
+ content: 'Public carrots',
+ tags: [
+ ['d', 'carrots'],
+ ['title', 'Carrots'],
+ ['summary', 'Fresh carrots'],
+ ['published_at', '1700000000'],
+ ['location', 'Victoria'],
+ ['price', '3.5', 'CAD'],
+ ['radroots:price_unit', 'lb'],
+ ['status', 'active']
+ ]
+ },
+ peerSecret
+ );
+ const proof = verifyEnvelope(JSON.stringify(food));
+ if (!proof.ok) throw Error('invalid public fixture');
+ const context = captureEnquiryContext(proof.value);
+ if (!context) throw Error('invalid context');
+ const plan = captureEnquiryRumor(
+ identity,
+ context,
+ 'Private seal sentinel',
+ Math.floor(Date.now() / 1000)
+ );
+ if (!plan) throw Error('missing plan');
+ const opened = await openBrowserDatabase();
+ if (opened.state !== 'ready') throw Error('missing database');
+ const database = opened.owner,
+ repository = createPrivateSendReservationRepository(database, owner);
+ if (!repository) throw Error('missing repository');
+ const reservation = await reserveSendIdentity(
+ repository,
+ identity,
+ '12345678-1234-4234-8234-123456789abc',
+ plan,
+ 'reviewed_private_intent'
+ );
+ if (reservation.status !== 'reserved') throw Error('missing reservation');
+ const reserved = reservation.identity;
+ const original = reservedSendRumorWire(reserved);
+ return {
+ owner,
+ peer,
+ identity,
+ reserved,
+ operation: (
+ role: unknown = 'peer',
+ review: unknown = 'reviewed_private_seal'
+ ) => {
+ watched = capturePrivateSealOperation(identity, reserved, role, review);
+ return watched;
+ },
+ mode: (value: Mode) => {
+ mode = value;
+ capabilityReads = 0;
+ },
+ counts: () => ({ keys, encrypts, signs, reentrantReads, postStopEncrypts }),
+ identityState: () => identitySessionSnapshot(identity).state,
+ settle: () => {
+ release?.();
+ },
+ slot: () => {
+ const scheduler = browserExtensionScheduler();
+ return scheduler ? extensionSchedulerSnapshot(scheduler) : undefined;
+ },
+ disconnect: () => disconnectIdentity(identity),
+ async stored() {
+ const tx = browserDatabaseTransaction(
+ database,
+ ['private_sends'],
+ 'readonly'
+ ),
+ request = tx.objectStore('private_sends').getAll();
+ return await new Promise<string>((resolve, reject) => {
+ tx.addEventListener('complete', () =>
+ resolve(JSON.stringify(request.result))
+ );
+ tx.addEventListener('abort', () => reject(Error('inspection aborted')));
+ });
+ },
+ decrypt(wire: string, role: 'peer' | 'self') {
+ const seal = JSON.parse(wire) as { content: string };
+ const conversation = nip44.v2.utils.getConversationKey(
+ role === 'peer' ? peerSecret : secret,
+ owner
+ );
+ try {
+ return {
+ equal: nip44.v2.decrypt(seal.content, conversation) === original,
+ seal
+ };
+ } finally {
+ conversation.fill(0);
+ }
+ },
+ close() {
+ disconnectIdentity(identity);
+ closeBrowserDatabase(database);
+ secret.fill(0);
+ peerSecret.fill(0);
+ delete window.nostr;
+ }
+ };
+}
diff --git a/web/tests/e2e/seal-builder.spec.ts b/web/tests/e2e/seal-builder.spec.ts
@@ -0,0 +1,388 @@
+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 Seals from './harness/seal-builder.ts';
+declare global {
+ interface Window {
+ hcp075: typeof Seals;
+ hcp075Fixture: Awaited<ReturnType<typeof Seals.makeFixture>>;
+ hcp075Job: ReturnType<typeof Seals.buildPrivateSeal>;
+ hcp075Release: () => void;
+ hcp075Held: Promise<unknown>;
+ hcp075Operation: NonNullable<
+ ReturnType<typeof Seals.capturePrivateSealOperation>
+ >;
+ }
+}
+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/seal-builder.ts', import.meta.url)
+ ),
+ name: 'hcp075',
+ formats: ['iife']
+ }
+ }
+ });
+ const output = Array.isArray(result) ? result[0] : result;
+ if (!('output' in output)) throw Error('missing bundle');
+ const chunks = output.output.filter((x) => x.type === 'chunk');
+ expect(chunks).toHaveLength(1);
+ bundle = chunks[0].code;
+ console.log(
+ JSON.stringify({
+ fixture: 'HCP075_ACTUAL_SDK_CRYPTO_IDB_OWNER_LOCK',
+ bundleSha256: createHash('sha256').update(bundle).digest('hex'),
+ moduleIds: Object.keys(chunks[0].modules),
+ qualification:
+ 'Ephemeral controlled provider; not installed extension/relay/client 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.hcp075Fixture = await window.hcp075.makeFixture();
+ });
+}
+for (const role of ['peer', 'self'] as const)
+ test(`actual SDK ${role} ciphertext preserves original rumor; sender signs empty-tag13 only`, async ({
+ page
+ }) => {
+ await load(page);
+ const result = await page.evaluate(async (role) => {
+ const f = window.hcp075Fixture,
+ s = window.hcp075,
+ before = f.counts(),
+ operation = f.operation(role);
+ if (!operation) throw Error('missing operation');
+ const outcome = await s.buildPrivateSeal(operation);
+ if (outcome.status !== 'sealed') return { status: outcome.status };
+ const saved = s.privateSealSnapshot(outcome.seal);
+ if (!saved) throw Error('missing seal');
+ const decrypted = f.decrypt(saved.wire, role),
+ stored = await f.stored(),
+ after = f.counts(),
+ again = await s.buildPrivateSeal(operation);
+ f.close();
+ return {
+ status: outcome.status,
+ equal: decrypted.equal,
+ kind: (JSON.parse(saved.wire) as { kind: number }).kind,
+ tags: (JSON.parse(saved.wire) as { tags: string[][] }).tags,
+ owner: saved.owner,
+ target: saved.destination,
+ expected: role === 'self' ? f.owner : f.peer,
+ seven: Object.keys(JSON.parse(saved.wire) as Record<string, unknown>)
+ .length,
+ noPlaintext: !stored.includes('sentinel'),
+ randomizedBounds:
+ (JSON.parse(saved.wire) as { created_at: number }).created_at <=
+ Math.floor(Date.now() / 1000) &&
+ (JSON.parse(saved.wire) as { created_at: number }).created_at >=
+ Math.floor(Date.now() / 1000) - 3599,
+ signs: after.signs - before.signs,
+ encrypts: after.encrypts - before.encrypts,
+ keys: after.keys - before.keys,
+ again: again.status
+ };
+ }, role);
+ expect(result).toMatchObject({
+ status: 'sealed',
+ equal: true,
+ kind: 13,
+ tags: [],
+ seven: 7,
+ noPlaintext: true,
+ randomizedBounds: true,
+ signs: 1,
+ encrypts: 1,
+ keys: 3,
+ again: 'stopped'
+ });
+ expect(result.target).toBe(result.expected);
+ });
+for (const mode of [
+ 'wrong_cipher',
+ 'wrong_author',
+ 'wrong_tags',
+ 'wrong_time',
+ 'cached_bad_id'
+] as const)
+ test(`rejects ${mode} from provider without a seal capability`, async ({
+ page
+ }) => {
+ await load(page);
+ const result = await page.evaluate(async (mode) => {
+ const f = window.hcp075Fixture,
+ op = f.operation();
+ if (!op) throw Error('missing operation');
+ f.mode(mode);
+ const outcome = await window.hcp075.buildPrivateSeal(op);
+ f.close();
+ return outcome.status;
+ }, mode);
+ expect(result).toBe('mismatch');
+ });
+for (const mode of ['missing', 'declined', 'changed_key'] as const)
+ test(`${mode} pauses without extra signature or retry`, async ({ page }) => {
+ await load(page);
+ const result = await page.evaluate(async (mode) => {
+ const f = window.hcp075Fixture,
+ op = f.operation(),
+ before = f.counts();
+ if (!op) throw Error('missing operation');
+ f.mode(mode);
+ const result = await window.hcp075.buildPrivateSeal(op),
+ after = f.counts();
+ f.close();
+ return { status: result.status, signs: after.signs - before.signs };
+ }, mode);
+ expect(['unavailable', 'refused', 'stopped']).toContain(result.status);
+ expect(result.signs).toBe(0);
+ });
+test('detached reservation, wrong role or absent explicit review cannot acquire crypto authority', async ({
+ page
+}) => {
+ await load(page);
+ const result = await page.evaluate(() => {
+ const f = window.hcp075Fixture,
+ s = window.hcp075,
+ before = f.counts();
+ const invalid = [
+ f.operation('other'),
+ f.operation('peer', 'connect'),
+ s.capturePrivateSealOperation(
+ f.identity,
+ {} as typeof f.reserved,
+ 'peer',
+ 'reviewed_private_seal'
+ )
+ ];
+ const after = f.counts();
+ f.close();
+ return {
+ absent: invalid.every((x) => x === undefined),
+ same: JSON.stringify(before) === JSON.stringify(after)
+ };
+ });
+ expect(result).toEqual({ absent: true, same: true });
+});
+for (const phase of ['hold_encrypt', 'hold_sign'] as const)
+ test(`disconnect during ${phase} retains real slot until settlement and fences late result`, async ({
+ page
+ }) => {
+ await load(page);
+ await page.evaluate((phase) => {
+ const f = window.hcp075Fixture,
+ op = f.operation();
+ if (!op) throw Error('missing operation');
+ window.hcp075Operation = op;
+ f.mode(phase);
+ window.hcp075Job = window.hcp075.buildPrivateSeal(op);
+ }, phase);
+ await expect
+ .poll(() => page.evaluate(() => window.hcp075Fixture.slot()))
+ .toMatchObject({
+ state: 'active',
+ pending: phase === 'hold_encrypt' ? 'encrypt' : 'sign'
+ });
+ const pending = await page.evaluate(() => {
+ const f = window.hcp075Fixture;
+ f.disconnect();
+ window.hcp075.stopPrivateSeal(window.hcp075Operation);
+ return f.slot();
+ });
+ expect(pending).toMatchObject({ state: 'active' });
+ const result = await page.evaluate(async () => {
+ const f = window.hcp075Fixture,
+ before = f.counts();
+ f.settle();
+ const outcome = await window.hcp075Job,
+ after = f.counts(),
+ slot = f.slot();
+ f.close();
+ return {
+ status: outcome.status,
+ slot,
+ same: JSON.stringify(before) === JSON.stringify(after)
+ };
+ });
+ expect(result).toEqual({
+ status: 'stopped',
+ slot: { state: 'idle' },
+ same: true
+ });
+ });
+test('wait expiry prevents more calls but does not pretend to cancel pending extension approval', async ({
+ page
+}) => {
+ await load(page);
+ await page.evaluate(() => {
+ const f = window.hcp075Fixture,
+ op = f.operation();
+ if (!op) throw Error('missing operation');
+ f.mode('hold_encrypt');
+ window.hcp075Operation = op;
+ window.hcp075Job = window.hcp075.buildPrivateSeal(op);
+ });
+ await expect
+ .poll(() => page.evaluate(() => window.hcp075Fixture.slot()))
+ .toMatchObject({ pending: 'encrypt' });
+ const result = await page.evaluate(async () => {
+ const f = window.hcp075Fixture,
+ s = window.hcp075;
+ s.expirePrivateSealWait(window.hcp075Operation);
+ const pending = f.slot();
+ f.settle();
+ const outcome = await window.hcp075Job,
+ slot = f.slot();
+ f.close();
+ return { pending, status: outcome.status, slot };
+ });
+ expect(result.pending).toMatchObject({
+ state: 'active',
+ pending: 'encrypt',
+ phase: 'wait_expired'
+ });
+ expect(result.status).toBe('stopped');
+ expect(result.slot).toEqual({ state: 'idle' });
+});
+test('held origin owner lock fails busy before any extension call and never queues a retry', async ({
+ page
+}) => {
+ await load(page);
+ await page.evaluate(async () => {
+ let acquired: () => void = () => {};
+ const ready = new Promise<void>((resolve) => {
+ acquired = resolve;
+ });
+ window.hcp075Held = navigator.locks.request(
+ 'harvestcircle:owner:' + window.hcp075Fixture.owner,
+ async () => {
+ acquired();
+ await new Promise<void>((resolve) => {
+ window.hcp075Release = resolve;
+ });
+ }
+ );
+ await ready;
+ });
+ const result = await page.evaluate(async () => {
+ const f = window.hcp075Fixture,
+ op = f.operation(),
+ before = f.counts();
+ if (!op) throw Error('missing operation');
+ const outcome = await window.hcp075.buildPrivateSeal(op),
+ after = f.counts();
+ window.hcp075Release();
+ await window.hcp075Held;
+ const again = await window.hcp075.buildPrivateSeal(op);
+ f.close();
+ return {
+ status: outcome.status,
+ same: JSON.stringify(before) === JSON.stringify(after),
+ again: again.status
+ };
+ });
+ expect(result).toEqual({ status: 'busy', same: true, again: 'stopped' });
+});
+test('second peer/self operation cannot overlap the held scheduler/owner scope', async ({
+ page
+}) => {
+ await load(page);
+ await page.evaluate(() => {
+ const f = window.hcp075Fixture,
+ op = f.operation('self');
+ if (!op) throw Error('missing operation');
+ f.mode('hold_encrypt');
+ window.hcp075Operation = op;
+ window.hcp075Job = window.hcp075.buildPrivateSeal(op);
+ });
+ await expect
+ .poll(() => page.evaluate(() => window.hcp075Fixture.slot()))
+ .toMatchObject({ state: 'active', pending: 'encrypt' });
+ const result = await page.evaluate(async () => {
+ const f = window.hcp075Fixture,
+ s = window.hcp075,
+ second = f.operation('peer'),
+ before = f.counts();
+ if (!second) throw Error('missing second operation');
+ const blocked = await s.buildPrivateSeal(second),
+ after = f.counts();
+ s.stopPrivateSeal(window.hcp075Operation);
+ f.settle();
+ const original = await window.hcp075Job;
+ f.close();
+ return {
+ blocked: blocked.status,
+ same: JSON.stringify(before) === JSON.stringify(after),
+ original: original.status
+ };
+ });
+ expect(result).toEqual({ blocked: 'busy', same: true, original: 'stopped' });
+});
+test('provider method getter is captured before scheduler encryption admission, never re-read with private input', async ({
+ page
+}) => {
+ await load(page);
+ const result = await page.evaluate(async () => {
+ const f = window.hcp075Fixture,
+ op = f.operation();
+ if (!op) throw Error('missing operation');
+ f.mode('getter_reentry');
+ const outcome = await window.hcp075.buildPrivateSeal(op),
+ counts = f.counts();
+ f.close();
+ return {
+ status: outcome.status,
+ reentrant: counts.reentrantReads,
+ postStop: counts.postStopEncrypts
+ };
+ });
+ expect(result).toEqual({ status: 'sealed', reentrant: 0, postStop: 0 });
+});
+for (const mode of [
+ 'stop_capability_getter',
+ 'stop_capability_after_key'
+] as const)
+ test(`${mode} stops only the original operation and preserves the current shared identity`, async ({
+ page
+ }) => {
+ await load(page);
+ const result = await page.evaluate(async (mode) => {
+ const f = window.hcp075Fixture,
+ op = f.operation(),
+ before = f.counts();
+ if (!op) throw Error('missing operation');
+ f.mode(mode);
+ const outcome = await window.hcp075.buildPrivateSeal(op),
+ state = f.identityState(),
+ after = f.counts();
+ f.close();
+ return {
+ status: outcome.status,
+ state,
+ signs: after.signs - before.signs,
+ encrypts: after.encrypts - before.encrypts
+ };
+ }, mode);
+ expect(result).toEqual({
+ status: 'stopped',
+ state: 'messaging_capable',
+ signs: 0,
+ encrypts: 0
+ });
+ });
diff --git a/web/tests/unit/seal-builder.test.ts b/web/tests/unit/seal-builder.test.ts
@@ -0,0 +1,136 @@
+import { afterAll, expect, it } from 'vitest';
+import {
+ finalizeEvent,
+ generateSecretKey,
+ getPublicKey,
+ verifiedSymbol,
+ type UnsignedEvent
+} from 'applesauce-core/helpers';
+import {
+ sealCiphertextV2,
+ captureSealTemplate,
+ bindSealResponse
+} from '../../src/lib/nostr/seal-template.ts';
+import { isPublicEnvelopeKind } from '../../src/lib/nostr/public-kinds.ts';
+const key = generateSecretKey();
+const owner = getPublicKey(key);
+afterAll(() => key.fill(0));
+const cipher = btoa(String.fromCharCode(2) + 'x'.repeat(98));
+function fixture() {
+ const wire = captureSealTemplate(owner, cipher, 1700000000);
+ if (!wire) throw Error('expected source seal template');
+ return { wire, template: JSON.parse(wire) as UnsignedEvent };
+}
+it('captures only encrypted kind13 with exact sender/time and empty tags; public lane excludes it', () => {
+ const { template } = fixture();
+ expect(template).toEqual({
+ pubkey: owner,
+ kind: 13,
+ created_at: 1700000000,
+ tags: [],
+ content: cipher
+ });
+ expect(isPublicEnvelopeKind(13)).toBe(false);
+ expect(isPublicEnvelopeKind(14)).toBe(false);
+});
+it('requires bounded canonical v2 encoded payload and exact numeric/owner inputs', () => {
+ expect(sealCiphertextV2(cipher)).toBe(true);
+ for (const bad of [
+ null,
+ '',
+ 'plain text',
+ '#version',
+ cipher + '\n',
+ btoa(String.fromCharCode(1) + 'x'.repeat(98)),
+ 'A'.repeat(16385)
+ ])
+ expect(sealCiphertextV2(bad)).toBe(false);
+ for (const bad of [-0, -1, 1.5, Number.MAX_SAFE_INTEGER + 1, '100'])
+ expect(captureSealTemplate(owner, cipher, bad)).toBeUndefined();
+ expect(captureSealTemplate(owner.toUpperCase(), cipher, 1)).toBeUndefined();
+});
+it('accepts genuine signatures while reconstructing only seven allowed signed fields', () => {
+ const { wire, template } = fixture();
+ const signed = finalizeEvent(template, key);
+ const result = bindSealResponse(wire, {
+ ...signed,
+ plaintext: 'private sentinel',
+ toJSON: () => {
+ throw Error('must not execute');
+ }
+ });
+ expect(result).toBeDefined();
+ expect(
+ Object.keys(JSON.parse(result!) as Record<string, unknown>).sort()
+ ).toEqual(['content', 'created_at', 'id', 'kind', 'pubkey', 'sig', 'tags']);
+ expect(result).not.toContain('sentinel');
+});
+it('rejects valid signatures for substituted ciphertext, kind, tags, time or sender', () => {
+ const { wire, template } = fixture();
+ for (const changed of [
+ { ...template, content: btoa(String.fromCharCode(2) + 'y'.repeat(98)) },
+ { ...template, kind: 1059 },
+ { ...template, tags: [['p', owner]] },
+ { ...template, created_at: 1700000001 }
+ ])
+ expect(bindSealResponse(wire, finalizeEvent(changed, key))).toBeUndefined();
+ const other = generateSecretKey();
+ try {
+ expect(
+ bindSealResponse(wire, finalizeEvent(template, other))
+ ).toBeUndefined();
+ } finally {
+ other.fill(0);
+ }
+});
+it('freshly verifies hash and signature despite provider cache symbols', () => {
+ const { wire, template } = fixture();
+ const signed = finalizeEvent(template, key);
+ expect(
+ bindSealResponse(wire, {
+ ...signed,
+ id: '0'.repeat(64),
+ [verifiedSymbol]: true
+ })
+ ).toBeUndefined();
+ expect(
+ bindSealResponse(wire, {
+ ...signed,
+ sig: '0'.repeat(128),
+ [verifiedSymbol]: true
+ })
+ ).toBeUndefined();
+});
+it('own data fields only: getters/toJSON/iterators cannot supply accepted fields', () => {
+ const { wire, template } = fixture();
+ const signed = finalizeEvent(template, key);
+ let reads = 0;
+ const response = { ...signed };
+ Object.defineProperty(response, 'content', {
+ get() {
+ reads++;
+ return cipher;
+ }
+ });
+ expect(bindSealResponse(wire, response)).toBeUndefined();
+ expect(reads).toBe(0);
+ const tags: string[] = [];
+ Object.defineProperty(tags, Symbol.iterator, {
+ value: () => {
+ throw Error('must not enumerate');
+ }
+ });
+ expect(bindSealResponse(wire, { ...signed, tags })).toBeDefined();
+});
+it('malformed templates/objects and nonempty provider tags never become private seals', () => {
+ const { wire, template } = fixture();
+ for (const bad of [null, [], {}, '{', ' '.repeat(16385)])
+ expect(bindSealResponse(wire, bad)).toBeUndefined();
+ expect(bindSealResponse('{}', finalizeEvent(template, key))).toBeUndefined();
+ expect(
+ bindSealResponse(wire, {
+ ...finalizeEvent(template, key),
+ tags: [['client', 'leak']]
+ })
+ ).toBeUndefined();
+});