app

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

store-contract.test.ts (11424B)


      1 import { beforeEach, afterEach, describe, expect, it, vi } from 'vitest';
      2 import { readFileSync } from 'node:fs';
      3 import { finalizeEvent, verifiedSymbol } from 'applesauce-core/helpers';
      4 
      5 const corpus = JSON.parse(
      6   readFileSync(
      7     new URL(
      8       '../../../contracts/interop/food_availability/corpus.v1.json',
      9       import.meta.url
     10     ),
     11     'utf8'
     12   )
     13 ) as { vectors: { id: string; signed_wires: Record<string, string> }[] };
     14 const wires = (suffix: string) =>
     15   corpus.vectors.find((row) => row.id.endsWith(suffix))!.signed_wires;
     16 let store: typeof import('../../src/lib/nostr/public-store.ts');
     17 let envelope: typeof import('../../src/lib/nostr/verified-envelope.ts');
     18 beforeEach(async () => {
     19   vi.resetModules();
     20   store = await import('../../src/lib/nostr/public-store.ts');
     21   envelope = await import('../../src/lib/nostr/verified-envelope.ts');
     22 });
     23 afterEach(() => {
     24   vi.restoreAllMocks();
     25   vi.unstubAllGlobals();
     26 });
     27 function proof(raw: string) {
     28   const result = envelope.verifyEnvelope(raw);
     29   expect(result.ok).toBe(true);
     30   if (!result.ok) throw new Error('Expected qualified signed test event');
     31   return result.value;
     32 }
     33 function browserStore() {
     34   vi.stubGlobal('window', {});
     35   return store.getPublicStore()!;
     36 }
     37 // Ephemeral test-only signing material never becomes a fixture, production
     38 // provider, persisted input, output or user identity.
     39 function signed(kind: number, tags: string[][] = [], content = '') {
     40   const secret = crypto.getRandomValues(new Uint8Array(32));
     41   return JSON.stringify(
     42     finalizeEvent({ kind, tags, content, created_at: 1700000060 }, secret)
     43   );
     44 }
     45 describe('public store contract', () => {
     46   it('does no browser work during SSR and owns one anonymous browser lifetime', () => {
     47     vi.stubGlobal('window', undefined);
     48     expect(store.getPublicStore()).toBeUndefined();
     49     const owner = browserStore();
     50     expect(store.getPublicStore()).toBe(owner);
     51     expect(Object.keys(owner)).toEqual([]);
     52     expect(Object.isFrozen(owner)).toBe(true);
     53     store.closePublicStore(owner);
     54     expect(() => store.getPublicStore()).toThrow('public_store_closed');
     55   });
     56   it('has an explicit callable verifier and fixed evidence-preserving SDK options', async () => {
     57     const { EventStore } = await import('applesauce-core');
     58     // eslint-disable-next-line @typescript-eslint/unbound-method -- Explicit receiver supplied by original.call(this, event) below.
     59     const original = EventStore.prototype.add;
     60     const checks: boolean[] = [];
     61     vi.spyOn(EventStore.prototype, 'add').mockImplementation(function (
     62       this: InstanceType<typeof EventStore>,
     63       event
     64     ) {
     65       checks.push(
     66         typeof this.verifyEvent === 'function' &&
     67           this.keepOldVersions &&
     68           this.keepDeleted &&
     69           this.keepExpired
     70       );
     71       expect(this.verifyEvent!(event)).toBe(true);
     72       expect(this.verifyEvent!({ ...event, sig: '0'.repeat(128) })).toBe(false);
     73       return original.call(this, event);
     74     });
     75     const owner = browserStore();
     76     expect(store.insertPublicEnvelope(owner, proof(wires('_014').event))).toBe(
     77       'accepted'
     78     );
     79     expect(checks).toEqual([true]);
     80     expect('verifyEvent' in owner).toBe(false);
     81     // @ts-expect-error The production acquisition API accepts no store options.
     82     expect(store.getPublicStore({ verifyEvent: undefined })).toBe(owner);
     83     store.closePublicStore(owner);
     84   });
     85   it('rejects forged and mutated cached input before it can poison a verified winner', () => {
     86     const owner = browserStore();
     87     const old = proof(wires('_032').previous);
     88     expect(store.insertPublicEnvelope(owner, old)).toBe('accepted');
     89     const invalid = JSON.parse(wires('_032').current) as Record<
     90       string | symbol,
     91       unknown
     92     >;
     93     invalid.content = 'mutated';
     94     invalid[verifiedSymbol] = true;
     95     expect(
     96       store.insertPublicEnvelope(
     97         owner,
     98         invalid as unknown as ReturnType<typeof proof>
     99       )
    100     ).toBe('rejected');
    101     expect(
    102       store.insertPublicEnvelope(
    103         owner,
    104         Object.freeze({}) as ReturnType<typeof proof>
    105       )
    106     ).toBe('rejected');
    107     const event = envelope.verifiedEnvelopeSnapshot(old)!;
    108     expect(
    109       store
    110         .publicStoreVersions(owner, event.kind, event.pubkey, 'nantes-carrots')
    111         .map((token) => envelope.verifiedEnvelopeSnapshot(token))
    112     ).toEqual([event]);
    113     expect(envelope.verifyEnvelope(JSON.stringify(invalid)).ok).toBe(false);
    114     store.closePublicStore(owner);
    115   });
    116   it('preserves both valid versions before focused filtering and exposes detached proof lists', () => {
    117     const owner = browserStore();
    118     const newest = proof(wires('_032').current);
    119     const older = proof(wires('_032').previous);
    120     expect(store.insertPublicEnvelope(owner, newest)).toBe('accepted');
    121     expect(store.insertPublicEnvelope(owner, older)).toBe('accepted');
    122     const event = envelope.verifiedEnvelopeSnapshot(newest)!;
    123     const versions = store.publicStoreVersions(
    124       owner,
    125       event.kind,
    126       event.pubkey,
    127       'nantes-carrots'
    128     );
    129     expect(
    130       new Set(
    131         versions.map((token) => envelope.verifiedEnvelopeSnapshot(token)!.id)
    132       )
    133     ).toEqual(
    134       new Set([
    135         envelope.verifiedEnvelopeSnapshot(newest)!.id,
    136         envelope.verifiedEnvelopeSnapshot(older)!.id
    137       ])
    138     );
    139     (versions as unknown as unknown[]).pop();
    140     expect(
    141       store.publicStoreVersions(
    142         owner,
    143         event.kind,
    144         event.pubkey,
    145         'nantes-carrots'
    146       )
    147     ).toHaveLength(2);
    148     expect(
    149       envelope.verifiedEnvelopeSnapshot(
    150         store.publicStoreEnvelope(owner, event.id)!
    151       )
    152     ).toEqual(event);
    153     const detached = envelope.verifiedEnvelopeSnapshot(newest)!;
    154     detached.content = 'changed';
    155     expect(
    156       envelope.verifiedEnvelopeSnapshot(
    157         store.publicStoreEnvelope(owner, event.id)!
    158       )!.content
    159     ).toBe(event.content);
    160     store.closePublicStore(owner);
    161   });
    162   it('retains verified incompatible food without applying product admission', () => {
    163     const owner = browserStore();
    164     const incompatible = proof(wires('_020').event);
    165     expect(store.insertPublicEnvelope(owner, incompatible)).toBe('accepted');
    166     expect(
    167       envelope.verifiedEnvelopeSnapshot(
    168         store.publicStoreEnvelope(
    169           owner,
    170           envelope.verifiedEnvelopeSnapshot(incompatible)!.id
    171         )!
    172       )
    173     ).toEqual(envelope.verifiedEnvelopeSnapshot(incompatible));
    174     store.closePublicStore(owner);
    175   });
    176   it('retains deletion evidence without giving SDK deletion filtering lifecycle authority', () => {
    177     const owner = browserStore();
    178     const food = proof(wires('_014').event);
    179     const event = envelope.verifiedEnvelopeSnapshot(food)!;
    180     const deletion = proof(signed(5, [['e', event.id]]));
    181     expect(store.insertPublicEnvelope(owner, deletion)).toBe('accepted');
    182     expect(
    183       envelope.verifiedEnvelopeSnapshot(
    184         store.publicStoreEnvelope(
    185           owner,
    186           envelope.verifiedEnvelopeSnapshot(deletion)!.id
    187         )!
    188       )
    189     ).toEqual(envelope.verifiedEnvelopeSnapshot(deletion));
    190     expect(store.insertPublicEnvelope(owner, food)).toBe('accepted');
    191     expect(
    192       envelope.verifiedEnvelopeSnapshot(
    193         store.publicStoreEnvelope(owner, event.id)!
    194       )
    195     ).toEqual(event);
    196     store.closePublicStore(owner);
    197   });
    198   it.each([4, 13, 14, 1059, 22242])(
    199     'refuses authentic private or connection event kind %s',
    200     (kind) => {
    201       const owner = browserStore();
    202       const token = proof(signed(kind));
    203       expect(store.insertPublicEnvelope(owner, token)).toBe('not_public');
    204       expect(
    205         store.publicStoreEnvelope(
    206           owner,
    207           envelope.verifiedEnvelopeSnapshot(token)!.id
    208         )
    209       ).toBeUndefined();
    210       store.closePublicStore(owner);
    211     }
    212   );
    213   it('strips unprocessed decrypted metadata and SDK cache symbols from stored instances', async () => {
    214     const { EventStore } = await import('applesauce-core');
    215     // eslint-disable-next-line @typescript-eslint/unbound-method -- Explicit receiver supplied by original.call(this, event) below.
    216     const original = EventStore.prototype.add;
    217     const observed: unknown[] = [];
    218     vi.spyOn(EventStore.prototype, 'add').mockImplementation(function (
    219       this: InstanceType<typeof EventStore>,
    220       event
    221     ) {
    222       observed.push(Object.keys(event).sort());
    223       expect(Object.getOwnPropertySymbols(event)).toEqual([]);
    224       expect('decrypted' in event).toBe(false);
    225       return original.call(this, event);
    226     });
    227     const owner = browserStore();
    228     const raw = JSON.stringify({
    229       ...JSON.parse(wires('_014').event),
    230       decrypted: 'HC_TEST_ONLY_PRIVATE_METADATA'
    231     });
    232     expect(store.insertPublicEnvelope(owner, proof(raw))).toBe('accepted');
    233     expect(observed).toEqual([
    234       ['content', 'created_at', 'id', 'kind', 'pubkey', 'sig', 'tags']
    235     ]);
    236     const clean = envelope.verifiedEnvelopeSnapshot(
    237       store.publicStoreEnvelope(owner, (JSON.parse(raw) as { id: string }).id)!
    238     )!;
    239     expect('decrypted' in clean).toBe(false);
    240     expect(Object.keys(clean).sort()).toEqual([
    241       'content',
    242       'created_at',
    243       'id',
    244       'kind',
    245       'pubkey',
    246       'sig',
    247       'tags'
    248     ]);
    249     store.closePublicStore(owner);
    250   });
    251   it('deduplicates exact proof without importing duplicate symbols or mutable metadata', () => {
    252     const owner = browserStore();
    253     const first = proof(wires('_014').event);
    254     const second = proof(wires('_014').event);
    255     expect(store.insertPublicEnvelope(owner, first)).toBe('accepted');
    256     expect(store.insertPublicEnvelope(owner, second)).toBe('duplicate');
    257     expect(
    258       envelope.verifiedEnvelopeSnapshot(
    259         store.publicStoreEnvelope(
    260           owner,
    261           envelope.verifiedEnvelopeSnapshot(first)!.id
    262         )!
    263       )
    264     ).toEqual(envelope.verifiedEnvelopeSnapshot(first));
    265     store.closePublicStore(owner);
    266   });
    267   it('retains signed expired data as evidence before product display policy', () => {
    268     const owner = browserStore();
    269     const token = proof(
    270       signed(30402, [
    271         ['d', 'expired'],
    272         ['expiration', '1']
    273       ])
    274     );
    275     expect(store.insertPublicEnvelope(owner, token)).toBe('accepted');
    276     expect(
    277       envelope.verifiedEnvelopeSnapshot(
    278         store.publicStoreEnvelope(
    279           owner,
    280           envelope.verifiedEnvelopeSnapshot(token)!.id
    281         )!
    282       )
    283     ).toEqual(envelope.verifiedEnvelopeSnapshot(token));
    284     store.closePublicStore(owner);
    285   });
    286   it('rejects forged owners and terminally releases public proof on disposal', async () => {
    287     const { EventStore } = await import('applesauce-core');
    288     const disposal = vi.spyOn(EventStore.prototype, 'dispose');
    289     expect(() =>
    290       store.closePublicStore({} as Parameters<typeof store.closePublicStore>[0])
    291     ).toThrow('public_store_invalid');
    292     const owner = browserStore();
    293     const token = proof(wires('_014').event);
    294     store.insertPublicEnvelope(owner, token);
    295     store.closePublicStore(owner);
    296     store.closePublicStore(owner);
    297     expect(disposal).toHaveBeenCalledTimes(1);
    298     expect(
    299       store.publicStoreEnvelope(
    300         owner,
    301         envelope.verifiedEnvelopeSnapshot(token)!.id
    302       )
    303     ).toBeUndefined();
    304     expect(store.insertPublicEnvelope(owner, token)).toBe('closed');
    305     expect(store.publicStoreVersions(owner, 30402, '0'.repeat(64), '')).toEqual(
    306       []
    307     );
    308   });
    309 });