app

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

resolve-head.test.ts (18451B)


      1 import { afterAll, describe, expect, it } from 'vitest';
      2 import { readFileSync } from 'node:fs';
      3 import { finalizeEvent } from 'applesauce-core/helpers';
      4 import { validateRelayPolicy } from '../../src/lib/config/relays.ts';
      5 import { PUBLIC_INGRESS_BUDGETS } from '../../src/lib/config/budgets.ts';
      6 import { verifyEnvelope } from '../../src/lib/nostr/verified-envelope.ts';
      7 import type { PublicPoolMessage } from '../../src/lib/nostr/exports.ts';
      8 import {
      9   createPublicScheduler,
     10   createPublicRun,
     11   openPublicRequest,
     12   publicRunSnapshot,
     13   closePublicScheduler,
     14   type RequestClock
     15 } from '../../src/lib/nostr/request-scope.ts';
     16 import {
     17   createPublicHeadCandidate,
     18   publicHeadEnvelope,
     19   publicHeadSnapshot,
     20   publicHeadKey
     21 } from '../../src/lib/catalog/heads.ts';
     22 import { headResolutionQueries } from '../../src/lib/nostr/product-queries.ts';
     23 import {
     24   createHeadResolver,
     25   resolveHeads,
     26   resolveKnownHeads,
     27   headResolutionSnapshot,
     28   closeHeadResolver,
     29   type HeadSubscriber
     30 } from '../../src/lib/catalog/resolve-head.ts';
     31 import {
     32   createPublicRetention,
     33   retainPublicEnvelope,
     34   publicRetentionEnvelope,
     35   publicRetentionKnown
     36 } from '../../src/lib/catalog/retention.ts';
     37 
     38 const corpus = JSON.parse(
     39   readFileSync(
     40     new URL(
     41       '../../../contracts/interop/food_availability/corpus.v1.json',
     42       import.meta.url
     43     ),
     44     'utf8'
     45   )
     46 ) as { vectors: { id: string; signed_wires: Record<string, string> }[] };
     47 const base = JSON.parse(
     48   corpus.vectors.find((v) => v.id.endsWith('_032'))!.signed_wires.previous
     49 ) as { tags: string[][]; content: string; created_at: number };
     50 const keys: Uint8Array[] = [];
     51 const cleanup: (() => void)[] = [];
     52 afterAll(() => {
     53   for (const stop of cleanup) stop();
     54   for (const key of keys) key.fill(0);
     55 });
     56 function fixture() {
     57   const key = crypto.getRandomValues(new Uint8Array(32));
     58   keys.push(key);
     59   const event = (
     60     time = base.created_at,
     61     tags = base.tags,
     62     content = base.content,
     63     kind = 30402
     64   ) => finalizeEvent({ kind, created_at: time, tags, content }, key);
     65   const proof = (value: ReturnType<typeof event>) => {
     66     const p = verifyEnvelope(JSON.stringify(value));
     67     if (!p.ok) throw Error('fixture proof');
     68     return p.value;
     69   };
     70   const head = (value = event()) => {
     71     const h = createPublicHeadCandidate(proof(value));
     72     if (!h) throw Error('fixture head');
     73     return h;
     74   };
     75   const origin = 'wss://one.example.org';
     76   const policy = validateRelayPolicy(
     77     JSON.stringify({
     78       schemaVersion: 1,
     79       public: [{ origin, read: true, write: false, nip50: false }],
     80       inbox: [],
     81       postingEnabled: false,
     82       messagingEnabled: false,
     83       operatorDenylist: []
     84     })
     85   )!;
     86   let now = 0;
     87   const timers = new Map<() => void, { at: number; callback: () => void }>();
     88   const clock: RequestClock = {
     89     now: () => now,
     90     schedule(callback, delay) {
     91       const cancel = () => {
     92         timers.delete(cancel);
     93       };
     94       timers.set(cancel, { at: now + delay, callback });
     95       return cancel;
     96     }
     97   };
     98   const scheduler = createPublicScheduler(clock),
     99     run = createPublicRun(scheduler, policy);
    100   cleanup.push(() => closePublicScheduler(scheduler));
    101   const channels: {
    102     kind: string;
    103     filters: unknown;
    104     emit: (message: PublicPoolMessage) => void;
    105     stopped: () => boolean;
    106   }[] = [];
    107   const subscribe: HeadSubscriber = (kind, filters, onVerified) =>
    108     openPublicRequest(
    109       run,
    110       kind,
    111       (next) => {
    112         let stopped = false;
    113         channels.push({ kind, filters, emit: next, stopped: () => stopped });
    114         return () => {
    115           stopped = true;
    116         };
    117       },
    118       onVerified
    119     );
    120   const resolver = createHeadResolver(run, subscribe, {
    121     nowSeconds: () => base.created_at + 10
    122   });
    123   const emit = (i: number, value: ReturnType<typeof event>) =>
    124     channels[i].emit({
    125       type: 'EVENT',
    126       id: 'fixture',
    127       from: origin,
    128       event: value
    129     });
    130   const eose = (i: number) =>
    131     channels[i].emit({ type: 'EOSE', id: 'fixture', from: origin });
    132   const initial = head();
    133   return {
    134     event,
    135     head,
    136     initial,
    137     run,
    138     resolver,
    139     channels,
    140     emit,
    141     eose,
    142     proof,
    143     origin,
    144     timers,
    145     advance: (value: number) => {
    146       now = value;
    147       for (const t of [...timers.values()]) if (t.at <= now) t.callback();
    148     }
    149   };
    150 }
    151 describe('bounded exact-coordinate head resolution', () => {
    152   it('materializes already retained heads after the run ends without opening a new request', () => {
    153     const f = fixture(),
    154       retention = createPublicRetention();
    155     retainPublicEnvelope(retention, publicHeadEnvelope(f.initial));
    156     let opened = 0;
    157     const known = createHeadResolver(
    158       f.run,
    159       () => {
    160         opened++;
    161         throw Error('inactive request');
    162       },
    163       { nowSeconds: () => base.created_at + 10 },
    164       {
    165         retain: (heads) => {
    166           if (
    167             heads.some(
    168               (h) =>
    169                 !publicRetentionEnvelope(retention, publicHeadSnapshot(h).id)
    170             )
    171           )
    172             throw Error('cache_missing');
    173           return true;
    174         },
    175         read: (h) => publicRetentionKnown(retention, h),
    176         available: () => true
    177       }
    178     );
    179     f.advance(15000);
    180     resolveKnownHeads(known, [f.initial]);
    181     expect(headResolutionSnapshot(known)[0]).toMatchObject({
    182       lastKnown: true,
    183       coverage: 'partial',
    184       definitiveAbsence: false
    185     });
    186     expect(headResolutionSnapshot(known)[0].state.food).toBeDefined();
    187     const target = publicHeadSnapshot(f.initial).id;
    188     const deletion = f.proof(f.event(base.created_at, [['e', target]], '', 5));
    189     retainPublicEnvelope(retention, deletion);
    190     expect(headResolutionSnapshot(known)[0].deletion.outcome).toBe(
    191       'suppressed'
    192     );
    193     expect(headResolutionSnapshot(known)[0].state.food).toBeUndefined();
    194     expect(opened).toBe(0);
    195   });
    196   it('denies unretained proof in an inactive projection before changing its known rows', () => {
    197     const f = fixture(),
    198       retention = createPublicRetention();
    199     retainPublicEnvelope(retention, publicHeadEnvelope(f.initial));
    200     const known = createHeadResolver(
    201       f.run,
    202       () => {
    203         throw Error('inactive request');
    204       },
    205       { nowSeconds: () => base.created_at + 10 },
    206       {
    207         retain: (heads) => {
    208           if (
    209             heads.some(
    210               (h) =>
    211                 !publicRetentionEnvelope(retention, publicHeadSnapshot(h).id)
    212             )
    213           )
    214             throw Error('cache_missing');
    215           return true;
    216         },
    217         read: (h) => publicRetentionKnown(retention, h),
    218         available: () => true
    219       }
    220     );
    221     expect(() => resolveKnownHeads(known, [f.initial])).toThrow(
    222       'head_resolver_still_active'
    223     );
    224     f.advance(15000);
    225     resolveKnownHeads(known, [f.initial]);
    226     const other = f.head(
    227       f.event(
    228         base.created_at,
    229         base.tags.map((t) => (t[0] === 'd' ? ['d', 'uncached'] : [...t]))
    230       )
    231     );
    232     expect(() => resolveKnownHeads(known, [other])).toThrow('cache_missing');
    233     expect(headResolutionSnapshot(known)).toHaveLength(1);
    234   });
    235   it('batches unique exact coordinates and author deletion lookups without keyword constraints', () => {
    236     const f = fixture(),
    237       other = f.head(
    238         f.event(
    239           base.created_at,
    240           base.tags.map((t) => (t[0] === 'd' ? ['d', 'other'] : [...t]))
    241         )
    242       );
    243     const queries = headResolutionQueries([f.initial, other, f.initial]);
    244     expect(queries.head).toHaveLength(2);
    245     expect(queries.deletion).toHaveLength(1);
    246     expect(queries.head[0]).toEqual({
    247       kinds: [30402],
    248       authors: [f.event().pubkey],
    249       '#d': [base.tags.find((t) => t[0] === 'd')![1]],
    250       limit: 200
    251     });
    252     for (const filter of [...queries.head, ...queries.deletion]) {
    253       expect(filter).not.toHaveProperty('search');
    254       expect(filter).not.toHaveProperty('q');
    255       expect(filter).not.toHaveProperty('since');
    256     }
    257     expect(queries.deletion[0]).toMatchObject({ kinds: [5], limit: 200 });
    258   });
    259   it('empty generic coordinates omit d filters so missing first d is discoverable', () => {
    260     const f = fixture();
    261     const h = f.head(
    262       f.event(
    263         base.created_at,
    264         base.tags.filter((t) => t[0] !== 'd')
    265       )
    266     );
    267     expect(headResolutionQueries([h]).head[0]).not.toHaveProperty('#d');
    268   });
    269   it('renamed and sold revisions supersede the original keyword match before projection', () => {
    270     const f = fixture();
    271     resolveHeads(f.resolver, [f.initial]);
    272     const tags = base.tags.map((t) =>
    273       t[0] === 'title'
    274         ? ['title', 'Renamed celery']
    275         : t[0] === 'status'
    276           ? ['status', 'sold']
    277           : [...t]
    278     );
    279     const newer = f.event(base.created_at + 1, tags);
    280     f.emit(0, newer);
    281     f.eose(0);
    282     f.eose(1);
    283     const row = headResolutionSnapshot(f.resolver)[0];
    284     expect(row.state.head.id).toBe(newer.id);
    285     expect(row.state.food?.title).toBe('Renamed celery');
    286     expect(row.state.food?.status).toBe('sold');
    287     expect(row.coverage).toBe('bounded-eose');
    288     expect(row.lastKnown).toBe(false);
    289     expect(row.definitiveAbsence).toBe(false);
    290   });
    291   it('newer incompatible heads prevent an older focused fallback', () => {
    292     const f = fixture();
    293     resolveHeads(f.resolver, [f.initial]);
    294     const newer = f.event(
    295       base.created_at + 1,
    296       base.tags.map((t) => (t[0] === 'status' ? ['status', 'unknown'] : [...t]))
    297     );
    298     f.emit(0, newer);
    299     f.emit(0, f.event());
    300     const row = headResolutionSnapshot(f.resolver)[0];
    301     expect(row.state.head.id).toBe(newer.id);
    302     expect(row.state.display).toBe('unsupported');
    303     expect(row.state.food).toBeUndefined();
    304   });
    305   it('incomplete or unavailable lookup retains honest last-known source outcomes', () => {
    306     const f = fixture();
    307     resolveHeads(f.resolver, [f.initial]);
    308     f.eose(0);
    309     let row = headResolutionSnapshot(f.resolver)[0];
    310     expect(row.lastKnown).toBe(true);
    311     expect(row.deletionSources?.result.sources[0].state).toBe('pending');
    312     f.channels[1].emit({
    313       type: 'CLOSED',
    314       id: 'fixture',
    315       from: f.origin,
    316       reason: 'untrusted relay text'
    317     });
    318     row = headResolutionSnapshot(f.resolver)[0];
    319     expect(row.coverage).toBe('partial');
    320     expect(row.lastKnown).toBe(true);
    321     expect(row.state.head.id).toBe(
    322       headResolutionSnapshot(f.resolver)[0].state.head.id
    323     );
    324     expect(JSON.stringify(row)).not.toContain('untrusted relay text');
    325   });
    326   it('coalesces repeated coordinates and updates retained winners without extra requests', () => {
    327     const f = fixture();
    328     resolveHeads(f.resolver, [f.initial, f.initial]);
    329     resolveHeads(f.resolver, [f.initial]);
    330     expect(f.channels).toHaveLength(2);
    331     expect(publicRunSnapshot(f.run).activeRequests).toBe(2);
    332     const newer = f.head(f.event(base.created_at + 1));
    333     resolveHeads(f.resolver, [newer]);
    334     expect(f.channels).toHaveLength(2);
    335     expect(headResolutionSnapshot(f.resolver)[0].key).toBe(
    336       publicHeadKey(newer)
    337     );
    338   });
    339   it('same-author deletion of a newly discovered ID suppresses that winner and retains its evidence', () => {
    340     const f = fixture();
    341     resolveHeads(f.resolver, [f.initial]);
    342     const newer = f.event(base.created_at + 1);
    343     f.emit(0, newer);
    344     f.emit(1, f.event(base.created_at - 1, [['e', newer.id]], '', 5));
    345     f.eose(0);
    346     f.eose(1);
    347     const row = headResolutionSnapshot(f.resolver)[0];
    348     expect(row.state.head.id).toBe(newer.id);
    349     expect(row.deletion.outcome).toBe('suppressed');
    350     expect(row.state.food).toBeUndefined();
    351     expect(row.deletionProofs).toHaveLength(1);
    352     expect(verifyEnvelope(JSON.stringify(newer)).ok).toBe(true);
    353     expect(publicRunSnapshot(f.run).ingress.deliveries).toBe(2);
    354   });
    355   it('rejects out-of-coordinate responses locally and marks malformed deletion coverage partial', () => {
    356     const f = fixture();
    357     resolveHeads(f.resolver, [f.initial]);
    358     f.emit(
    359       0,
    360       f.event(
    361         base.created_at + 1,
    362         base.tags.map((t) => (t[0] === 'd' ? ['d', 'wrong'] : [...t]))
    363       )
    364     );
    365     f.emit(1, f.event(base.created_at, [['e', 'bad']], '', 5));
    366     f.eose(0);
    367     f.eose(1);
    368     const row = headResolutionSnapshot(f.resolver)[0];
    369     expect(row.coverage).toBe('partial');
    370     expect(row.state.head.id).toBe(f.event().id);
    371     expect(publicRunSnapshot(f.run).ingress.deliveries).toBe(2);
    372   });
    373   it('auxiliary deliveries exhaust the same run budget and stop both queries', () => {
    374     const f = fixture();
    375     resolveHeads(f.resolver, [f.initial]);
    376     const value = f.event();
    377     for (let n = 0; n < PUBLIC_INGRESS_BUDGETS.deliveries; n++)
    378       f.emit(n % 2, value);
    379     expect(publicRunSnapshot(f.run).ingress.deliveries).toBe(2000);
    380     expect(f.channels.every((c) => c.stopped())).toBe(true);
    381     expect(headResolutionSnapshot(f.resolver)[0].lastKnown).toBe(true);
    382   });
    383   it('deadline and explicit teardown stop effects while retaining last-known evidence', () => {
    384     const f = fixture();
    385     resolveHeads(f.resolver, [f.initial]);
    386     f.advance(10000);
    387     expect(f.channels.every((c) => c.stopped())).toBe(true);
    388     expect(f.timers.size).toBe(0);
    389     expect(headResolutionSnapshot(f.resolver)[0].headSources?.state).toBe(
    390       'deadline'
    391     );
    392     closeHeadResolver(f.resolver);
    393     expect(headResolutionSnapshot(f.resolver)[0].lastKnown).toBe(true);
    394     expect(() => resolveHeads(f.resolver, [f.initial])).toThrow();
    395   });
    396   it('a second scope admission failure closes the first without cancelling unrelated work', () => {
    397     const f = fixture();
    398     for (let n = 0; n < 5; n++)
    399       openPublicRequest(
    400         f.run,
    401         'profile',
    402         () => () => {},
    403         () => {}
    404       );
    405     resolveHeads(f.resolver, [f.initial]);
    406     expect(f.channels).toHaveLength(1);
    407     expect(f.channels[0].stopped()).toBe(true);
    408     expect(publicRunSnapshot(f.run).activeRequests).toBe(5);
    409     expect(headResolutionSnapshot(f.resolver)[0].coverage).toBe('partial');
    410   });
    411   it('detached result metadata cannot alter winner, deletion evidence or later coverage', () => {
    412     const f = fixture();
    413     resolveHeads(f.resolver, [f.initial]);
    414     const row = headResolutionSnapshot(f.resolver)[0];
    415     (row.state.head as unknown as { id: string }).id = 'forged';
    416     const source = row.headSources!.result.sources[0];
    417     (source as unknown as { state: string }).state = 'eose';
    418     expect(headResolutionSnapshot(f.resolver)[0].state.head.id).toBe(
    419       f.event().id
    420     );
    421     expect(
    422       headResolutionSnapshot(f.resolver)[0].headSources?.result.sources[0].state
    423     ).toBe('pending');
    424   });
    425   it('late callbacks after resolver teardown cannot replace retained evidence', () => {
    426     const f = fixture();
    427     resolveHeads(f.resolver, [f.initial]);
    428     closeHeadResolver(f.resolver);
    429     f.emit(0, f.event(base.created_at + 1));
    430     expect(headResolutionSnapshot(f.resolver)[0].state.head.id).toBe(
    431       f.event().id
    432     );
    433     expect(publicRunSnapshot(f.run).ingress.deliveries).toBe(0);
    434   });
    435   it('first d identity prevents a matching secondary d from advancing another coordinate', () => {
    436     const f = fixture();
    437     resolveHeads(f.resolver, [f.initial]);
    438     f.emit(0, f.event(base.created_at + 1, [['d', 'other'], ...base.tags]));
    439     expect(headResolutionSnapshot(f.resolver)[0].state.head.id).toBe(
    440       f.event().id
    441     );
    442     expect(headResolutionSnapshot(f.resolver)[0].coverage).toBe('partial');
    443   });
    444   it('publishes the accepted final head delivery before the shared budget stops the run', () => {
    445     const f = fixture();
    446     resolveHeads(f.resolver, [f.initial]);
    447     const value = f.event();
    448     for (let n = 0; n < 1999; n++) f.emit(0, value);
    449     const newer = f.event(base.created_at + 1);
    450     f.emit(0, newer);
    451     expect(publicRunSnapshot(f.run).ingress.deliveries).toBe(2000);
    452     expect(headResolutionSnapshot(f.resolver)[0].state.head.id).toBe(newer.id);
    453     expect(headResolutionSnapshot(f.resolver)[0].lastKnown).toBe(true);
    454   });
    455   it('retains the accepted final tombstone delivery before the shared budget stops the run', () => {
    456     const f = fixture();
    457     resolveHeads(f.resolver, [f.initial]);
    458     const value = f.event();
    459     for (let n = 0; n < 1999; n++) f.emit(0, value);
    460     f.emit(1, f.event(base.created_at - 1, [['e', value.id]], '', 5));
    461     expect(publicRunSnapshot(f.run).ingress.deliveries).toBe(2000);
    462     const row = headResolutionSnapshot(f.resolver)[0];
    463     expect(row.deletion.outcome).toBe('suppressed');
    464     expect(row.state.food).toBeUndefined();
    465     expect(row.lastKnown).toBe(true);
    466   });
    467   it('a tombstone already retained by an earlier batch suppresses a subsequently resolved coordinate without relay redelivery', () => {
    468     const f = fixture();
    469     resolveHeads(f.resolver, [f.initial]);
    470     const next = f.head(
    471       f.event(
    472         base.created_at + 1,
    473         base.tags.map((t) => (t[0] === 'd' ? ['d', 'next'] : [...t]))
    474       )
    475     );
    476     const author = f.event().pubkey;
    477     f.emit(
    478       1,
    479       f.event(base.created_at + 2, [['a', `30402:${author}:next`]], '', 5)
    480     );
    481     f.eose(0);
    482     f.eose(1);
    483     resolveHeads(f.resolver, [next]);
    484     f.eose(2);
    485     f.eose(3);
    486     const row = headResolutionSnapshot(f.resolver).find(
    487       (r) => r.key === publicHeadKey(next)
    488     )!;
    489     expect(row.deletion.outcome).toBe('suppressed');
    490     expect(row.state.food).toBeUndefined();
    491     expect(row.coverage).toBe('bounded-eose');
    492   });
    493   it('deletion learned in a later batch also suppresses an earlier retained coordinate', () => {
    494     const f = fixture();
    495     resolveHeads(f.resolver, [f.initial]);
    496     f.eose(0);
    497     f.eose(1);
    498     const next = f.head(
    499       f.event(
    500         base.created_at + 1,
    501         base.tags.map((t) => (t[0] === 'd' ? ['d', 'next'] : [...t]))
    502       )
    503     );
    504     resolveHeads(f.resolver, [next]);
    505     f.emit(3, f.event(base.created_at - 1, [['e', f.event().id]], '', 5));
    506     f.eose(2);
    507     f.eose(3);
    508     const row = headResolutionSnapshot(f.resolver).find(
    509       (r) => r.key === publicHeadKey(f.initial)
    510     )!;
    511     expect(row.deletion.outcome).toBe('suppressed');
    512     expect(row.state.food).toBeUndefined();
    513     expect(row.deletionProofs).toHaveLength(1);
    514   });
    515   it('refuses oversized batches before effects', () => {
    516     const f = fixture();
    517     expect(() =>
    518       resolveHeads(
    519         f.resolver,
    520         Array.from({ length: 2001 }, () => f.initial)
    521       )
    522     ).toThrow();
    523     expect(f.channels).toHaveLength(0);
    524   });
    525 });