app

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

store-retention.test.ts (10684B)


      1 import { beforeEach, afterEach, describe, it, expect, vi } from 'vitest';
      2 import { readFileSync } from 'node:fs';
      3 import { finalizeEvent } from 'applesauce-core/helpers';
      4 
      5 let store: typeof import('../../src/lib/nostr/public-store.ts');
      6 let envelope: typeof import('../../src/lib/nostr/verified-envelope.ts');
      7 let heads: typeof import('../../src/lib/catalog/heads.ts');
      8 let deletions: typeof import('../../src/lib/catalog/deletions.ts');
      9 beforeEach(async () => {
     10   vi.resetModules();
     11   store = await import('../../src/lib/nostr/public-store.ts');
     12   envelope = await import('../../src/lib/nostr/verified-envelope.ts');
     13   heads = await import('../../src/lib/catalog/heads.ts');
     14   deletions = await import('../../src/lib/catalog/deletions.ts');
     15   vi.stubGlobal('window', {});
     16 });
     17 afterEach(() => {
     18   vi.restoreAllMocks();
     19   vi.unstubAllGlobals();
     20 });
     21 const corpus = JSON.parse(
     22   readFileSync(
     23     new URL(
     24       '../../../contracts/interop/food_availability/corpus.v1.json',
     25       import.meta.url
     26     ),
     27     'utf8'
     28   )
     29 ) as { vectors: { id: string; signed_wires: Record<string, string> }[] };
     30 const base = JSON.parse(
     31   corpus.vectors.find((v) => v.id.endsWith('_032'))!.signed_wires.previous
     32 ) as { tags: string[][]; content: string; created_at: number };
     33 function wire(
     34   time: number,
     35   tags = base.tags,
     36   content = base.content,
     37   kind = 30402,
     38   key?: Uint8Array
     39 ) {
     40   const secret = key ?? crypto.getRandomValues(new Uint8Array(32));
     41   try {
     42     return JSON.stringify(
     43       finalizeEvent({ kind, created_at: time, tags, content }, secret)
     44     );
     45   } finally {
     46     if (!key) secret.fill(0);
     47   }
     48 }
     49 function proof(raw: string) {
     50   const p = envelope.verifyEnvelope(raw);
     51   if (!p.ok) throw Error('store retention fixture');
     52   return p.value;
     53 }
     54 describe('actual SDK public working-set ownership', () => {
     55   it('indexes retained generic newer heads and same-author deletion without SDK erasure', () => {
     56     const owner = store.getPublicStore()!,
     57       key = crypto.getRandomValues(new Uint8Array(32));
     58     try {
     59       const old = proof(
     60           wire(base.created_at, base.tags, base.content, 30402, key)
     61         ),
     62         next = proof(
     63           wire(
     64             base.created_at + 1,
     65             base.tags.map((t) =>
     66               t[0] === 'status' ? ['status', 'unknown'] : [...t]
     67             ),
     68             base.content,
     69             30402,
     70             key
     71           )
     72         );
     73       const nextId = envelope.verifiedEnvelopeSnapshot(next)!.id;
     74       const request = proof(
     75         wire(base.created_at - 1, [['e', nextId]], '', 5, key)
     76       );
     77       for (const p of [old, request, next])
     78         expect(store.insertPublicEnvelope(owner, p)).toBe('accepted');
     79       const h = heads.createPublicHeadCandidate(old)!;
     80       const known = store.publicStoreKnownEvidence(owner, h);
     81       expect(heads.publicHeadSnapshot(known.head).id).toBe(nextId);
     82       expect(
     83         deletions.evaluatePublicHeadDeletion(known.head, known.requests).outcome
     84       ).toBe('suppressed');
     85       expect(store.publicStoreEnvelope(owner, nextId)).toBeDefined();
     86       expect(store.publicStoreRetention(owner).events).toBe(3);
     87     } finally {
     88       key.fill(0);
     89       store.closePublicStore(owner);
     90     }
     91   });
     92   it('rejects signed private kinds without changing public retention or exposing their envelope', () => {
     93     const owner = store.getPublicStore()!;
     94     try {
     95       const p = proof(
     96         wire(base.created_at, [], 'opaque private test envelope', 1059)
     97       );
     98       expect(store.insertPublicEnvelope(owner, p)).toBe('not_public');
     99       expect(store.publicStoreRetention(owner)).toMatchObject({
    100         payloadBytes: 0,
    101         events: 0,
    102         stopped: false
    103       });
    104       expect(
    105         store.publicStoreEnvelope(
    106           owner,
    107           envelope.verifiedEnvelopeSnapshot(p)!.id
    108         )
    109       ).toBeUndefined();
    110     } finally {
    111       store.closePublicStore(owner);
    112     }
    113   });
    114 });
    115 
    116 for (const evidenceKind of ['newer', 'deletion'] as const)
    117   it(`normal shared runtime close settles unconsumed ${evidenceKind} evidence before SDK disposal`, async () => {
    118     const runtime = await import('../../src/lib/runtime/public-runtime.ts'),
    119       resolver = await import('../../src/lib/catalog/resolve-head.ts');
    120     const context = runtime.createPublicRuntimeContext(),
    121       mounted = runtime.mountPublicRuntime(context)!,
    122       view = runtime.createPublicView(mounted),
    123       run = runtime.beginPublicViewRun(view);
    124     const key = crypto.getRandomValues(new Uint8Array(32));
    125     try {
    126       const old = proof(
    127           wire(base.created_at, base.tags, base.content, 30402, key)
    128         ),
    129         h = heads.createPublicHeadCandidate(old)!,
    130         model = resolver.createPublicViewHeadResolver(view, run, {
    131           nowSeconds: () => base.created_at + 10
    132         });
    133       resolver.resolveHeads(model, [h]);
    134       expect(
    135         resolver.headResolutionSnapshot(model)[0].state.food
    136       ).toBeDefined();
    137       const next = proof(
    138         wire(
    139           base.created_at + 1,
    140           base.tags.map((t) =>
    141             t[0] === 'status' ? ['status', 'unknown'] : [...t]
    142           ),
    143           base.content,
    144           30402,
    145           key
    146         )
    147       );
    148       const admitted =
    149         evidenceKind === 'newer'
    150           ? next
    151           : proof(
    152               wire(
    153                 base.created_at - 1,
    154                 [['e', envelope.verifiedEnvelopeSnapshot(old)!.id]],
    155                 '',
    156                 5,
    157                 key
    158               )
    159             );
    160       expect(
    161         store.insertPublicEnvelope(store.getPublicStore()!, admitted)
    162       ).toBe('accepted');
    163       runtime.closePublicRuntime(context);
    164       const row = resolver.headResolutionSnapshot(model)[0];
    165       expect(row.lastKnown).toBe(true);
    166       expect(row.state.food).toBeUndefined();
    167       if (evidenceKind === 'newer')
    168         expect(row.state.head.id).toBe(
    169           envelope.verifiedEnvelopeSnapshot(next)!.id
    170         );
    171       else expect(row.deletion.outcome).toBe('suppressed');
    172     } finally {
    173       key.fill(0);
    174       runtime.closePublicRuntime(context);
    175     }
    176   });
    177 it('a settlement clock reentry cannot overwrite a newer view run', async () => {
    178   const runtime = await import('../../src/lib/runtime/public-runtime.ts'),
    179     resolver = await import('../../src/lib/catalog/resolve-head.ts');
    180   const context = runtime.createPublicRuntimeContext(),
    181     mounted = runtime.mountPublicRuntime(context)!,
    182     view = runtime.createPublicView(mounted),
    183     run = runtime.beginPublicViewRun(view);
    184   const key = crypto.getRandomValues(new Uint8Array(32));
    185   let armed = false,
    186     nested: ReturnType<typeof runtime.beginPublicViewRun> | undefined;
    187   try {
    188     const old = proof(
    189         wire(base.created_at, base.tags, base.content, 30402, key)
    190       ),
    191       next = proof(
    192         wire(base.created_at + 1, base.tags, base.content, 30402, key)
    193       ),
    194       model = resolver.createPublicViewHeadResolver(view, run, {
    195         nowSeconds: () => {
    196           if (armed) {
    197             armed = false;
    198             nested = runtime.beginPublicViewRun(view);
    199           }
    200           return base.created_at + 10;
    201         }
    202       });
    203     resolver.resolveHeads(model, [heads.createPublicHeadCandidate(old)!]);
    204     store.insertPublicEnvelope(store.getPublicStore()!, next);
    205     armed = true;
    206     expect(() => runtime.beginPublicViewRun(view)).toThrow(
    207       'public_view_run_superseded'
    208     );
    209     expect(nested).toBeDefined();
    210     expect(runtime.publicViewRunCurrent(view, nested!)).toBe(true);
    211     expect(resolver.headResolutionSnapshot(model)[0].state.head.id).toBe(
    212       envelope.verifiedEnvelopeSnapshot(next)!.id
    213     );
    214   } finally {
    215     key.fill(0);
    216     runtime.closePublicRuntime(context);
    217   }
    218 });
    219 it('terminal public invalidation retries failed view settlement independently', async () => {
    220   const runtime = await import('../../src/lib/runtime/public-runtime.ts');
    221   const context = runtime.createPublicRuntimeContext(),
    222     mounted = runtime.mountPublicRuntime(context)!,
    223     a = runtime.createPublicView(mounted),
    224     b = runtime.createPublicView(mounted);
    225   const arun = runtime.beginPublicViewRun(a),
    226     brun = runtime.beginPublicViewRun(b);
    227   let acalls = 0,
    228     bcalls = 0;
    229   runtime.settlePublicViewProjection(a, () => {
    230     acalls++;
    231     if (acalls === 1) throw Error('one settlement failure');
    232   });
    233   runtime.settlePublicViewProjection(b, () => {
    234     bcalls++;
    235   });
    236   try {
    237     store.closePublicStore(store.getPublicStore()!);
    238     expect(() => runtime.publicViewProjectionAvailable(a)).toThrow(
    239       'public_projection_close_failed'
    240     );
    241     expect(acalls).toBe(1);
    242     expect(bcalls).toBe(1);
    243     expect(runtime.publicViewProjectionAvailable(a)).toBe(false);
    244     expect(acalls).toBe(2);
    245     expect(bcalls).toBe(1);
    246     expect(runtime.publicViewRunCurrent(a, arun)).toBe(false);
    247     expect(runtime.publicViewRunCurrent(b, brun)).toBe(false);
    248   } finally {
    249     runtime.closePublicRuntime(context);
    250   }
    251 });
    252 it('nested close during settlement cannot discard newly admitted shared evidence beneath returned rows', async () => {
    253   const runtime = await import('../../src/lib/runtime/public-runtime.ts'),
    254     resolver = await import('../../src/lib/catalog/resolve-head.ts');
    255   const context = runtime.createPublicRuntimeContext(),
    256     mounted = runtime.mountPublicRuntime(context)!,
    257     view = runtime.createPublicView(mounted),
    258     run = runtime.beginPublicViewRun(view),
    259     key = crypto.getRandomValues(new Uint8Array(32));
    260   let armed = false;
    261   try {
    262     const old = proof(
    263         wire(base.created_at, base.tags, base.content, 30402, key)
    264       ),
    265       next = proof(
    266         wire(base.created_at + 1, base.tags, base.content, 30402, key)
    267       ),
    268       unknown = proof(
    269         wire(
    270           base.created_at + 2,
    271           base.tags.map((t) =>
    272             t[0] === 'status' ? ['status', 'unknown'] : [...t]
    273           ),
    274           base.content,
    275           30402,
    276           key
    277         )
    278       );
    279     const model = resolver.createPublicViewHeadResolver(view, run, {
    280       nowSeconds: () => {
    281         if (armed) {
    282           armed = false;
    283           expect(
    284             store.insertPublicEnvelope(store.getPublicStore()!, unknown)
    285           ).toBe('accepted');
    286           runtime.closePublicRuntime(context);
    287         }
    288         return base.created_at + 10;
    289       }
    290     });
    291     resolver.resolveHeads(model, [heads.createPublicHeadCandidate(old)!]);
    292     store.insertPublicEnvelope(store.getPublicStore()!, next);
    293     armed = true;
    294     runtime.closePublicRuntime(context);
    295     expect(resolver.headResolutionSnapshot(model)).toEqual([]);
    296     expect(runtime.publicViewProjectionAvailable(view)).toBe(false);
    297   } finally {
    298     key.fill(0);
    299     runtime.closePublicRuntime(context);
    300   }
    301 });