app

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

commit 554afb6602c34c4335f9209e89488f0d8f4f0b14
parent b77e50537ccbc01fbd35e73cdab6cd3d8c0c3cf4
Author: triesap <tyson@radroots.org>
Date:   Tue,  6 Oct 2026 09:15:35 +0000

web: Own HarvestCircle verified public event storage

- Keep supported SDK verification and evidence-preserving options enabled
- Retain sanitized public proof before product lifecycle filtering
- Isolate private events and dispose the anonymous store terminally
- Qualify direct SDK admission and public store contract boundaries

Diffstat:
Aweb/src/lib/nostr/public-store.ts | 150+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/tests/provenance/source-boundaries.test.mjs | 53+++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/tests/unit/store-contract.test.ts | 309+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/tools/source-boundaries.mjs | 34++++++++++++++++++++++++++++++++++
4 files changed, 546 insertions(+), 0 deletions(-)

diff --git a/web/src/lib/nostr/public-store.ts b/web/src/lib/nostr/public-store.ts @@ -0,0 +1,150 @@ +import { EventStore, type EventStoreOptions } from 'applesauce-core'; +import { + verifyEnvelope, + verifiedEnvelopeSnapshot, + type VerifiedEnvelope +} from './verified-envelope.ts'; +import type { NostrEvent } from 'applesauce-core/helpers'; + +declare const ownedStore: unique symbol; +export type PublicStore = Readonly<{ readonly [ownedStore]: true }>; +interface Owner { + readonly closed: () => boolean; + readonly insert: ( + token: VerifiedEnvelope + ) => 'accepted' | 'duplicate' | 'not_public' | 'rejected' | 'closed'; + readonly envelope: (id: string) => VerifiedEnvelope | undefined; + readonly versions: ( + kind: number, + pubkey: string, + identifier: string + ) => readonly VerifiedEnvelope[]; + readonly close: () => void; +} +const owners = new WeakMap<PublicStore, Owner>(); +let lifetime: PublicStore | undefined; +const disposedOwner: Owner = { + closed: () => true, + insert: () => 'closed', + envelope: () => undefined, + versions: () => [], + close: () => undefined +}; + +function signedFields(event: NostrEvent): NostrEvent { + return { + id: event.id, + pubkey: event.pubkey, + kind: event.kind, + created_at: event.created_at, + tags: event.tags.map((tag) => [...tag]), + content: event.content, + sig: event.sig + }; +} +// Only fresh signed fields cross SDK verification: verified/cache/decrypt/relay +// symbols and unprocessed extra metadata are never verification or cache proof. +function verifyStoredEvent(event: NostrEvent): boolean { + return verifyEnvelope(JSON.stringify(signedFields(event))).ok; +} +const options: Readonly<EventStoreOptions> & { + readonly verifyEvent: typeof verifyStoredEvent; +} = { + keepOldVersions: true, + keepDeleted: true, + keepExpired: true, + verifyEvent: verifyStoredEvent +}; + +// Import/SSR is inert. The private SDK instance and mutable verifier setter are +// never exposed; acquisition accepts no caller options or private session state. +export function getPublicStore(): PublicStore | undefined { + if (typeof window === 'undefined') return undefined; + if (lifetime) { + if (ownerOf(lifetime).closed()) throw new Error('public_store_closed'); + return lifetime; + } + const sdk = new EventStore(options); + const proofs = new Map<string, VerifiedEnvelope>(); + let closed = false; + const owner: Owner = { + closed: () => closed, + insert(token) { + if (closed) return 'closed'; + const snapshot = verifiedEnvelopeSnapshot(token); + if (!snapshot) return 'rejected'; + // This application's approved public inventory. Private wrappers, inner + // plaintext and connection AUTH belong to separate owners, never here. + if (![0, 5, 10050, 30402].includes(snapshot.kind)) return 'not_public'; + const event = signedFields(snapshot); + const sanitized = verifyEnvelope(JSON.stringify(event)); + if (!sanitized.ok) return 'rejected'; + if (proofs.has(event.id)) return 'duplicate'; + // Pinned core6.2.0 handles deletion and some replacement paths before + // verifyEvent. Outer genuine proof/fresh verification precedes every SDK + // branch. Kind5 stays exact evidence without activating DeleteManager. + // keepOldVersions/keepExpired preserve verified incompatible/old heads; + // SDK filtered queries are never product lifecycle authority. HCP033-037 + // own head/deletion/display-expiry/working-set disposal policy. + if (event.kind !== 5 && sdk.add(event) === null) return 'rejected'; + proofs.set(event.id, sanitized.value); + return 'accepted'; + }, + envelope(id) { + return closed ? undefined : proofs.get(id); + }, + versions(kind, pubkey, identifier) { + if (closed) return []; + return ( + sdk.getReplaceableHistory(kind, pubkey, identifier) ?? [] + ).flatMap((event) => { + const proof = proofs.get(event.id); + return proof ? [proof] : []; + }); + }, + close() { + if (closed) return; + closed = true; + proofs.clear(); + try { + sdk.dispose(); + } finally { + // Remove the owner's closures retaining the SDK and its signed data. + // Terminal disposal is not a JavaScript secure-memory-erasure claim. + owners.set(token, disposedOwner); + } + } + }; + const token = Object.freeze({}) as PublicStore; + owners.set(token, owner); + lifetime = token; + return token; +} +function ownerOf(token: PublicStore): Owner { + const owner = owners.get(token); + if (!owner) throw new Error('public_store_invalid'); + return owner; +} +export function insertPublicEnvelope( + owner: PublicStore, + token: VerifiedEnvelope +): ReturnType<Owner['insert']> { + return ownerOf(owner).insert(token); +} +export function publicStoreEnvelope( + owner: PublicStore, + id: string +): VerifiedEnvelope | undefined { + return ownerOf(owner).envelope(id); +} +export function publicStoreVersions( + owner: PublicStore, + kind: number, + pubkey: string, + identifier: string +): readonly VerifiedEnvelope[] { + return ownerOf(owner).versions(kind, pubkey, identifier); +} +export function closePublicStore(owner: PublicStore): void { + ownerOf(owner).close(); +} diff --git a/web/tests/provenance/source-boundaries.test.mjs b/web/tests/provenance/source-boundaries.test.mjs @@ -1855,6 +1855,59 @@ for (const [name, specifier] of [ ); } +test('HCP030 admits a direct add on an immutable actual EventStore instance', async () => { + await fixture(async ({ directory, put, execute }) => { + await confineSvelte(directory); + const { cp } = await import('node:fs/promises'); + await cp( + await realpath(path.join(root, 'node_modules/applesauce-core')), + path.join(directory, 'node_modules/applesauce-core'), + { recursive: true } + ); + await put( + 'src/lib/nostr/store.ts', + "import { EventStore } from 'applesauce-core'; const sdk = new EventStore({keepOldVersions:true}); export function admit(event:unknown){return sdk.add(event);}" + ); + await put( + 'src/routes/+page.ts', + "export { admit } from '../lib/nostr/store';" + ); + const result = execute(); + assert.equal(result.status, 0, result.stderr); + }); +}); +for (const source of [ + 'export function admit(sdk:{add:(value:unknown)=>unknown},event:unknown){return sdk.add(event);}', + 'class EventStore { add(value:unknown){return value;} } const sdk = new EventStore(); export function admit(event:unknown){return sdk.add(event);}', + "import { EventStore } from 'applesauce-core'; const sdk = new EventStore(); const add=sdk.add; export function admit(event:unknown){return add(event);}", + "import { EventStore } from 'applesauce-core'; const sdk = new EventStore(); export function admit(event:unknown){return sdk['add'](event);}", + "import { EventStore } from 'applesauce-core'; let sdk = new EventStore(); export function admit(event:unknown){return sdk.add(event);}", + "import { EventStore } from 'applesauce-core'; const sdk = new EventStore(); sdk=opaque; export function admit(event:unknown){return sdk.add(event);}", + "import { EventStore } from 'applesauce-core'; EventStore=opaque; const sdk = new EventStore(); export function admit(event:unknown){return sdk.add(event);}", + "import { EventStore } from 'applesauce-core'; const sdk = new EventStore(); export function admit(){return sdk.add();}", + "import { EventStore } from 'applesauce-core'; const sdk = new EventStore(); export function admit(event:unknown){return sdk.add(event,event);}", + "import { EventStore } from 'applesauce-core'; const Constructor=EventStore; const sdk = new Constructor(); export function admit(event:unknown){return sdk.add(event);}", + "import { EventStore } from 'applesauce-core'; const sdk = new EventStore(); sdk.add=opaque; export function admit(event:unknown){return sdk.add(event);}", + "import { EventStore } from 'applesauce-core'; const sdk = new EventStore(); export function admit(event:unknown){return sdk.add.call(sdk,event);}" +]) + test(`HCP030 rejects unqualified or escaped EventStore mutation: ${source}`, async () => { + await fixture(async ({ directory, put, execute }) => { + await confineSvelte(directory); + const { cp } = await import('node:fs/promises'); + await cp( + await realpath(path.join(root, 'node_modules/applesauce-core')), + path.join(directory, 'node_modules/applesauce-core'), + { recursive: true } + ); + await put('src/lib/nostr/store.ts', source); + await put( + 'src/routes/+page.ts', + "export { admit } from '../lib/nostr/store';" + ); + reject(execute(), /mutation|owned|prototype/); + }); + }); + test('HCP029 admits direct read-only descriptor inspection of unknown data', async () => { await fixture(async ({ put, execute }) => { await put( diff --git a/web/tests/unit/store-contract.test.ts b/web/tests/unit/store-contract.test.ts @@ -0,0 +1,309 @@ +import { beforeEach, afterEach, describe, expect, it, vi } from 'vitest'; +import { readFileSync } from 'node:fs'; +import { finalizeEvent, verifiedSymbol } from 'applesauce-core/helpers'; + +const corpus = JSON.parse( + readFileSync( + new URL( + '../../../contracts/interop/food_availability/corpus.v1.json', + import.meta.url + ), + 'utf8' + ) +) as { vectors: { id: string; signed_wires: Record<string, string> }[] }; +const wires = (suffix: string) => + corpus.vectors.find((row) => row.id.endsWith(suffix))!.signed_wires; +let store: typeof import('../../src/lib/nostr/public-store.ts'); +let envelope: typeof import('../../src/lib/nostr/verified-envelope.ts'); +beforeEach(async () => { + vi.resetModules(); + store = await import('../../src/lib/nostr/public-store.ts'); + envelope = await import('../../src/lib/nostr/verified-envelope.ts'); +}); +afterEach(() => { + vi.restoreAllMocks(); + vi.unstubAllGlobals(); +}); +function proof(raw: string) { + const result = envelope.verifyEnvelope(raw); + expect(result.ok).toBe(true); + if (!result.ok) throw new Error('Expected qualified signed test event'); + return result.value; +} +function browserStore() { + vi.stubGlobal('window', {}); + return store.getPublicStore()!; +} +// Ephemeral test-only signing material never becomes a fixture, production +// provider, persisted input, output or user identity. +function signed(kind: number, tags: string[][] = [], content = '') { + const secret = crypto.getRandomValues(new Uint8Array(32)); + return JSON.stringify( + finalizeEvent({ kind, tags, content, created_at: 1700000060 }, secret) + ); +} +describe('public store contract', () => { + it('does no browser work during SSR and owns one anonymous browser lifetime', () => { + vi.stubGlobal('window', undefined); + expect(store.getPublicStore()).toBeUndefined(); + const owner = browserStore(); + expect(store.getPublicStore()).toBe(owner); + expect(Object.keys(owner)).toEqual([]); + expect(Object.isFrozen(owner)).toBe(true); + store.closePublicStore(owner); + expect(() => store.getPublicStore()).toThrow('public_store_closed'); + }); + it('has an explicit callable verifier and fixed evidence-preserving SDK options', async () => { + const { EventStore } = await import('applesauce-core'); + // eslint-disable-next-line @typescript-eslint/unbound-method -- Explicit receiver supplied by original.call(this, event) below. + const original = EventStore.prototype.add; + const checks: boolean[] = []; + vi.spyOn(EventStore.prototype, 'add').mockImplementation(function ( + this: InstanceType<typeof EventStore>, + event + ) { + checks.push( + typeof this.verifyEvent === 'function' && + this.keepOldVersions && + this.keepDeleted && + this.keepExpired + ); + expect(this.verifyEvent!(event)).toBe(true); + expect(this.verifyEvent!({ ...event, sig: '0'.repeat(128) })).toBe(false); + return original.call(this, event); + }); + const owner = browserStore(); + expect(store.insertPublicEnvelope(owner, proof(wires('_014').event))).toBe( + 'accepted' + ); + expect(checks).toEqual([true]); + expect('verifyEvent' in owner).toBe(false); + // @ts-expect-error The production acquisition API accepts no store options. + expect(store.getPublicStore({ verifyEvent: undefined })).toBe(owner); + store.closePublicStore(owner); + }); + it('rejects forged and mutated cached input before it can poison a verified winner', () => { + const owner = browserStore(); + const old = proof(wires('_032').previous); + expect(store.insertPublicEnvelope(owner, old)).toBe('accepted'); + const invalid = JSON.parse(wires('_032').current) as Record< + string | symbol, + unknown + >; + invalid.content = 'mutated'; + invalid[verifiedSymbol] = true; + expect( + store.insertPublicEnvelope( + owner, + invalid as unknown as ReturnType<typeof proof> + ) + ).toBe('rejected'); + expect( + store.insertPublicEnvelope( + owner, + Object.freeze({}) as ReturnType<typeof proof> + ) + ).toBe('rejected'); + const event = envelope.verifiedEnvelopeSnapshot(old)!; + expect( + store + .publicStoreVersions(owner, event.kind, event.pubkey, 'nantes-carrots') + .map((token) => envelope.verifiedEnvelopeSnapshot(token)) + ).toEqual([event]); + expect(envelope.verifyEnvelope(JSON.stringify(invalid)).ok).toBe(false); + store.closePublicStore(owner); + }); + it('preserves both valid versions before focused filtering and exposes detached proof lists', () => { + const owner = browserStore(); + const newest = proof(wires('_032').current); + const older = proof(wires('_032').previous); + expect(store.insertPublicEnvelope(owner, newest)).toBe('accepted'); + expect(store.insertPublicEnvelope(owner, older)).toBe('accepted'); + const event = envelope.verifiedEnvelopeSnapshot(newest)!; + const versions = store.publicStoreVersions( + owner, + event.kind, + event.pubkey, + 'nantes-carrots' + ); + expect( + new Set( + versions.map((token) => envelope.verifiedEnvelopeSnapshot(token)!.id) + ) + ).toEqual( + new Set([ + envelope.verifiedEnvelopeSnapshot(newest)!.id, + envelope.verifiedEnvelopeSnapshot(older)!.id + ]) + ); + (versions as unknown as unknown[]).pop(); + expect( + store.publicStoreVersions( + owner, + event.kind, + event.pubkey, + 'nantes-carrots' + ) + ).toHaveLength(2); + expect( + envelope.verifiedEnvelopeSnapshot( + store.publicStoreEnvelope(owner, event.id)! + ) + ).toEqual(event); + const detached = envelope.verifiedEnvelopeSnapshot(newest)!; + detached.content = 'changed'; + expect( + envelope.verifiedEnvelopeSnapshot( + store.publicStoreEnvelope(owner, event.id)! + )!.content + ).toBe(event.content); + store.closePublicStore(owner); + }); + it('retains verified incompatible food without applying product admission', () => { + const owner = browserStore(); + const incompatible = proof(wires('_020').event); + expect(store.insertPublicEnvelope(owner, incompatible)).toBe('accepted'); + expect( + envelope.verifiedEnvelopeSnapshot( + store.publicStoreEnvelope( + owner, + envelope.verifiedEnvelopeSnapshot(incompatible)!.id + )! + ) + ).toEqual(envelope.verifiedEnvelopeSnapshot(incompatible)); + store.closePublicStore(owner); + }); + it('retains deletion evidence without giving SDK deletion filtering lifecycle authority', () => { + const owner = browserStore(); + const food = proof(wires('_014').event); + const event = envelope.verifiedEnvelopeSnapshot(food)!; + const deletion = proof(signed(5, [['e', event.id]])); + expect(store.insertPublicEnvelope(owner, deletion)).toBe('accepted'); + expect( + envelope.verifiedEnvelopeSnapshot( + store.publicStoreEnvelope( + owner, + envelope.verifiedEnvelopeSnapshot(deletion)!.id + )! + ) + ).toEqual(envelope.verifiedEnvelopeSnapshot(deletion)); + expect(store.insertPublicEnvelope(owner, food)).toBe('accepted'); + expect( + envelope.verifiedEnvelopeSnapshot( + store.publicStoreEnvelope(owner, event.id)! + ) + ).toEqual(event); + store.closePublicStore(owner); + }); + it.each([4, 13, 14, 1059, 22242])( + 'refuses authentic private or connection event kind %s', + (kind) => { + const owner = browserStore(); + const token = proof(signed(kind)); + expect(store.insertPublicEnvelope(owner, token)).toBe('not_public'); + expect( + store.publicStoreEnvelope( + owner, + envelope.verifiedEnvelopeSnapshot(token)!.id + ) + ).toBeUndefined(); + store.closePublicStore(owner); + } + ); + it('strips unprocessed decrypted metadata and SDK cache symbols from stored instances', async () => { + const { EventStore } = await import('applesauce-core'); + // eslint-disable-next-line @typescript-eslint/unbound-method -- Explicit receiver supplied by original.call(this, event) below. + const original = EventStore.prototype.add; + const observed: unknown[] = []; + vi.spyOn(EventStore.prototype, 'add').mockImplementation(function ( + this: InstanceType<typeof EventStore>, + event + ) { + observed.push(Object.keys(event).sort()); + expect(Object.getOwnPropertySymbols(event)).toEqual([]); + expect('decrypted' in event).toBe(false); + return original.call(this, event); + }); + const owner = browserStore(); + const raw = JSON.stringify({ + ...JSON.parse(wires('_014').event), + decrypted: 'HC_TEST_ONLY_PRIVATE_METADATA' + }); + expect(store.insertPublicEnvelope(owner, proof(raw))).toBe('accepted'); + expect(observed).toEqual([ + ['content', 'created_at', 'id', 'kind', 'pubkey', 'sig', 'tags'] + ]); + const clean = envelope.verifiedEnvelopeSnapshot( + store.publicStoreEnvelope(owner, (JSON.parse(raw) as { id: string }).id)! + )!; + expect('decrypted' in clean).toBe(false); + expect(Object.keys(clean).sort()).toEqual([ + 'content', + 'created_at', + 'id', + 'kind', + 'pubkey', + 'sig', + 'tags' + ]); + store.closePublicStore(owner); + }); + it('deduplicates exact proof without importing duplicate symbols or mutable metadata', () => { + const owner = browserStore(); + const first = proof(wires('_014').event); + const second = proof(wires('_014').event); + expect(store.insertPublicEnvelope(owner, first)).toBe('accepted'); + expect(store.insertPublicEnvelope(owner, second)).toBe('duplicate'); + expect( + envelope.verifiedEnvelopeSnapshot( + store.publicStoreEnvelope( + owner, + envelope.verifiedEnvelopeSnapshot(first)!.id + )! + ) + ).toEqual(envelope.verifiedEnvelopeSnapshot(first)); + store.closePublicStore(owner); + }); + it('retains signed expired data as evidence before product display policy', () => { + const owner = browserStore(); + const token = proof( + signed(30402, [ + ['d', 'expired'], + ['expiration', '1'] + ]) + ); + expect(store.insertPublicEnvelope(owner, token)).toBe('accepted'); + expect( + envelope.verifiedEnvelopeSnapshot( + store.publicStoreEnvelope( + owner, + envelope.verifiedEnvelopeSnapshot(token)!.id + )! + ) + ).toEqual(envelope.verifiedEnvelopeSnapshot(token)); + store.closePublicStore(owner); + }); + it('rejects forged owners and terminally releases public proof on disposal', async () => { + const { EventStore } = await import('applesauce-core'); + const disposal = vi.spyOn(EventStore.prototype, 'dispose'); + expect(() => + store.closePublicStore({} as Parameters<typeof store.closePublicStore>[0]) + ).toThrow('public_store_invalid'); + const owner = browserStore(); + const token = proof(wires('_014').event); + store.insertPublicEnvelope(owner, token); + store.closePublicStore(owner); + store.closePublicStore(owner); + expect(disposal).toHaveBeenCalledTimes(1); + expect( + store.publicStoreEnvelope( + owner, + envelope.verifiedEnvelopeSnapshot(token)!.id + ) + ).toBeUndefined(); + expect(store.insertPublicEnvelope(owner, token)).toBe('closed'); + expect(store.publicStoreVersions(owner, 30402, '0'.repeat(64), '')).toEqual( + [] + ); + }); +}); diff --git a/web/tools/source-boundaries.mjs b/web/tools/source-boundaries.mjs @@ -343,6 +343,39 @@ function mutationAdmission(ast, report, identity = () => null) { return null; return { node: decl.initializer, seen: new Set([...seen, decl]) }; } + // The pinned EventStore is a model receiver, not a DOM collection. Admit + // only its direct one-argument add on an immutable actual imported instance; + // aliases, shadowed imports, rebound receivers and escaped methods stay red. + function eventStoreAdd(node) { + if ( + !ts.isPropertyAccessExpression(node) || + node.name.text !== 'add' || + !ts.isCallExpression(node.parent) || + node.parent.expression !== node || + node.parent.arguments.length !== 1 || + ts.isSpreadElement(node.parent.arguments[0]) + ) + return false; + const receiver = immutable(node.expression); + const initializer = receiver && unwrap(receiver.node); + if ( + !initializer || + !ts.isNewExpression(initializer) || + !ts.isIdentifier(initializer.expression) + ) + return false; + const importedClass = declaration(initializer.expression); + return ( + !!importedClass && + ts.isImportSpecifier(importedClass) && + !importedClass.isTypeOnly && + !importedClass.parent.parent.isTypeOnly && + (importedClass.propertyName ?? importedClass.name).text === + 'EventStore' && + importedClass.parent.parent.parent.moduleSpecifier.text === + 'applesauce-core' + ); + } // Reject writes and namespace escapes independently from successful sink // resolution, so losing a binding's trust can never hide its capability. function capabilityBinding(node) { @@ -854,6 +887,7 @@ function mutationAdmission(ast, report, identity = () => null) { if ( methods.has(name) && !primitiveMethod(node) && + !eventStoreAdd(node) && !locationMethod && !( animationMethods.has(name) &&