app

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

retention.test.ts (12310B)


      1 import { afterAll, describe, expect, it } from 'vitest';
      2 import { finalizeEvent } from 'applesauce-core/helpers';
      3 import { verifyEnvelope } from '../../src/lib/nostr/verified-envelope.ts';
      4 import {
      5   createPublicHeadCandidate,
      6   publicHeadSnapshot
      7 } from '../../src/lib/catalog/heads.ts';
      8 import { evaluatePublicHeadDeletion } from '../../src/lib/catalog/deletions.ts';
      9 import {
     10   createPublicRetention,
     11   retainPublicEnvelope,
     12   publicRetentionSnapshot,
     13   publicRetentionEnvelope,
     14   publicRetentionKnown,
     15   closePublicRetention
     16 } from '../../src/lib/catalog/retention.ts';
     17 
     18 const keys: Uint8Array[] = [];
     19 afterAll(() => {
     20   for (const key of keys) key.fill(0);
     21 });
     22 function fixture() {
     23   const key = crypto.getRandomValues(new Uint8Array(32));
     24   keys.push(key);
     25   const proof = (
     26     time: number,
     27     tags: string[][] = [['d', 'item']],
     28     content = '',
     29     kind = 30402
     30   ) => {
     31     const raw = JSON.stringify(
     32       finalizeEvent({ kind, created_at: time, tags, content }, key)
     33     );
     34     const p = verifyEnvelope(raw);
     35     if (!p.ok) throw Error('signed retention fixture');
     36     return {
     37       proof: p.value,
     38       raw,
     39       event: JSON.parse(raw) as { id: string; pubkey: string }
     40     };
     41   };
     42   const head = (p: ReturnType<typeof proof>) => {
     43     const h = createPublicHeadCandidate(p.proof);
     44     if (!h) throw Error('head fixture');
     45     return h;
     46   };
     47   return { proof, head, owner: createPublicRetention() };
     48 }
     49 describe('coherent public working-set retention', () => {
     50   it('counts actual UTF8 serialized event payload once per verified ID and exposes detached metrics', () => {
     51     const f = fixture(),
     52       p = f.proof(100, [['d', '菜']], 'multiline\n菜');
     53     expect(retainPublicEnvelope(f.owner, p.proof)).toBe('accepted');
     54     const bytes = new TextEncoder().encode(p.raw).length;
     55     expect(publicRetentionSnapshot(f.owner)).toMatchObject({
     56       payloadBytes: bytes,
     57       events: 1,
     58       stopped: false,
     59       closed: false
     60     });
     61     expect(retainPublicEnvelope(f.owner, p.proof)).toBe('duplicate');
     62     const row = publicRetentionSnapshot(f.owner);
     63     (row as unknown as { payloadBytes: number }).payloadBytes = 0;
     64     expect(publicRetentionSnapshot(f.owner).payloadBytes).toBe(bytes);
     65     expect(publicRetentionEnvelope(f.owner, p.event.id)).toBe(p.proof);
     66   });
     67   it('retains the generic newest incompatible coordinate winner ahead of focused selection', () => {
     68     const f = fixture(),
     69       old = f.proof(100),
     70       next = f.proof(101, [
     71         ['d', 'item'],
     72         ['status', 'unknown']
     73       ]);
     74     retainPublicEnvelope(f.owner, old.proof);
     75     retainPublicEnvelope(f.owner, next.proof);
     76     const known = publicRetentionKnown(f.owner, f.head(old));
     77     expect(publicHeadSnapshot(known.head).id).toBe(next.event.id);
     78     expect(publicRetentionEnvelope(f.owner, old.event.id)).toBe(old.proof);
     79   });
     80   it('retains authorized tombstones before their target and across later lookups without redelivery', () => {
     81     const f = fixture(),
     82       target = f.proof(100),
     83       request = f.proof(1, [['e', target.event.id]], '', 5);
     84     retainPublicEnvelope(f.owner, request.proof);
     85     retainPublicEnvelope(f.owner, target.proof);
     86     const known = publicRetentionKnown(f.owner, f.head(target));
     87     expect(known.requests).toHaveLength(1);
     88     expect(evaluatePublicHeadDeletion(known.head, known.requests).outcome).toBe(
     89       'suppressed'
     90     );
     91     expect(retainPublicEnvelope(f.owner, target.proof)).toBe('duplicate');
     92     expect(
     93       evaluatePublicHeadDeletion(
     94         known.head,
     95         publicRetentionKnown(f.owner, f.head(target)).requests
     96       ).outcome
     97     ).toBe('suppressed');
     98   });
     99   it('retains greatest inclusive address cutoff and canonical exact-ID authority without imposing k or time on e', () => {
    100     const f = fixture(),
    101       target = f.proof(100),
    102       coordinate = `30402:${target.event.pubkey}:item`;
    103     const old = f.proof(99, [['a', coordinate]], '', 5),
    104       current = f.proof(
    105         100,
    106         [
    107           ['a', coordinate],
    108           ['k', '30402']
    109         ],
    110         '',
    111         5
    112       ),
    113       exact = f.proof(1, [['e', target.event.id]], '', 5);
    114     for (const p of [target, old, current, exact])
    115       retainPublicEnvelope(f.owner, p.proof);
    116     const known = publicRetentionKnown(f.owner, f.head(target));
    117     const decision = evaluatePublicHeadDeletion(known.head, known.requests);
    118     expect(decision.outcome).toBe('suppressed');
    119     expect(decision.addressReference?.inclusiveCutoff).toBe(100);
    120     expect(decision.eventReference?.requestId).toBe(exact.event.id);
    121   });
    122   it('a missing first d cannot acquire address deletion authority from generic empty head identity', () => {
    123     const f = fixture(),
    124       target = f.proof(100, []),
    125       request = f.proof(100, [['a', `30402:${target.event.pubkey}:`]], '', 5);
    126     retainPublicEnvelope(f.owner, target.proof);
    127     retainPublicEnvelope(f.owner, request.proof);
    128     const known = publicRetentionKnown(f.owner, f.head(target));
    129     expect(evaluatePublicHeadDeletion(known.head, known.requests).outcome).toBe(
    130       'visible'
    131     );
    132   });
    133   it('denies forged and non-public proofs before installation or public accounting', () => {
    134     const f = fixture();
    135     let installs = 0;
    136     const install = () => {
    137       installs++;
    138       return true;
    139     };
    140     expect(
    141       retainPublicEnvelope(
    142         f.owner,
    143         {} as ReturnType<typeof f.proof>['proof'],
    144         install
    145       )
    146     ).toBe('rejected');
    147     expect(
    148       retainPublicEnvelope(
    149         f.owner,
    150         f.proof(100, [], 'opaque test envelope', 1059).proof,
    151         install
    152       )
    153     ).toBe('not_public');
    154     expect(installs).toBe(0);
    155     expect(publicRetentionSnapshot(f.owner)).toMatchObject({
    156       events: 0,
    157       payloadBytes: 0,
    158       stopped: false
    159     });
    160   });
    161   it('accepts the inclusive real32MiB boundary, then stops before installation and retains all lifecycle evidence', () => {
    162     const f = fixture(),
    163       target = f.proof(100),
    164       request = f.proof(1, [['e', target.event.id]], '', 5);
    165     for (const p of [target, request]) retainPublicEnvelope(f.owner, p.proof);
    166     const cap = 33554432;
    167     let time = 1000;
    168     for (;;) {
    169       const empty = f.proof(time, [['d', `bulk-${time}`]]),
    170         overhead = new TextEncoder().encode(empty.raw).length,
    171         remaining = cap - publicRetentionSnapshot(f.owner).payloadBytes;
    172       const length = Math.min(131000, remaining - overhead);
    173       expect(length).toBeGreaterThanOrEqual(0);
    174       const p = f.proof(time, [['d', `bulk-${time}`]], 'a'.repeat(length));
    175       expect(retainPublicEnvelope(f.owner, p.proof)).toBe('accepted');
    176       time++;
    177       if (publicRetentionSnapshot(f.owner).payloadBytes === cap) break;
    178     }
    179     expect(publicRetentionSnapshot(f.owner)).toMatchObject({
    180       payloadBytes: cap,
    181       stopped: false
    182     });
    183     expect(retainPublicEnvelope(f.owner, target.proof)).toBe('duplicate');
    184     let installs = 0;
    185     const tooMany = f.proof(time);
    186     expect(
    187       retainPublicEnvelope(f.owner, tooMany.proof, () => {
    188         installs++;
    189         return true;
    190       })
    191     ).toBe('limit');
    192     expect(installs).toBe(0);
    193     expect(publicRetentionSnapshot(f.owner)).toMatchObject({
    194       payloadBytes: cap,
    195       stopped: true,
    196       reason: 'payload_limit'
    197     });
    198     expect(retainPublicEnvelope(f.owner, target.proof)).toBe('limit');
    199     const known = publicRetentionKnown(f.owner, f.head(target));
    200     expect(evaluatePublicHeadDeletion(known.head, known.requests).outcome).toBe(
    201       'suppressed'
    202     );
    203     expect(publicRetentionEnvelope(f.owner, request.event.id)).toBe(
    204       request.proof
    205     );
    206   }, 30000);
    207   it('reserves coherent evidence before installer reentry and stops on installation failure', () => {
    208     const f = fixture(),
    209       old = f.proof(100),
    210       newer = f.proof(101);
    211     expect(
    212       retainPublicEnvelope(f.owner, old.proof, () => {
    213         expect(publicRetentionEnvelope(f.owner, old.event.id)).toBe(old.proof);
    214         expect(retainPublicEnvelope(f.owner, newer.proof)).toBe('accepted');
    215         return true;
    216       })
    217     ).toBe('accepted');
    218     expect(
    219       publicHeadSnapshot(publicRetentionKnown(f.owner, f.head(old)).head).id
    220     ).toBe(newer.event.id);
    221     const failed = f.proof(102);
    222     expect(retainPublicEnvelope(f.owner, failed.proof, () => false)).toBe(
    223       'rejected'
    224     );
    225     expect(publicRetentionSnapshot(f.owner)).toMatchObject({
    226       stopped: true,
    227       reason: 'installation_unavailable'
    228     });
    229     expect(retainPublicEnvelope(f.owner, old.proof)).toBe('limit');
    230   });
    231   it('terminal disposal cannot reset public admission or touch a separately owned private envelope', () => {
    232     const f = fixture(),
    233       publicValue = f.proof(100),
    234       privateValue = f.proof(100, [], 'opaque private test payload', 1059);
    235     retainPublicEnvelope(f.owner, publicValue.proof);
    236     const original = privateValue.raw;
    237     closePublicRetention(f.owner);
    238     expect(publicRetentionSnapshot(f.owner)).toMatchObject({
    239       closed: true,
    240       events: 0,
    241       payloadBytes: 0
    242     });
    243     expect(retainPublicEnvelope(f.owner, publicValue.proof)).toBe('closed');
    244     expect(
    245       publicRetentionEnvelope(f.owner, publicValue.event.id)
    246     ).toBeUndefined();
    247     expect(privateValue.raw).toBe(original);
    248     expect(verifyEnvelope(privateValue.raw).ok).toBe(true);
    249   });
    250 });
    251 
    252 import { validateRelayPolicy } from '../../src/lib/config/relays.ts';
    253 import {
    254   createPublicScheduler,
    255   createPublicRun,
    256   openPublicRequest,
    257   closePublicScheduler
    258 } from '../../src/lib/nostr/request-scope.ts';
    259 import {
    260   createHeadResolver,
    261   resolveHeads,
    262   headResolutionSnapshot
    263 } from '../../src/lib/catalog/resolve-head.ts';
    264 function resolverFixture() {
    265   const f = fixture();
    266   const policy = validateRelayPolicy(
    267     JSON.stringify({
    268       schemaVersion: 1,
    269       public: [
    270         {
    271           origin: 'wss://one.example.org',
    272           read: true,
    273           write: false,
    274           nip50: false
    275         }
    276       ],
    277       inbox: [],
    278       postingEnabled: false,
    279       messagingEnabled: false,
    280       operatorDenylist: []
    281     })
    282   )!;
    283   const scheduler = createPublicScheduler({
    284       now: () => 0,
    285       schedule: () => () => {}
    286     }),
    287     run = createPublicRun(scheduler, policy);
    288   return { ...f, scheduler, run };
    289 }
    290 it('retries failed projection cleanup without repeating a successful request stop', () => {
    291   const f = resolverFixture();
    292   let available = true,
    293     headStops = 0,
    294     deletionStops = 0;
    295   const resolver = createHeadResolver(
    296     f.run,
    297     (kind, filters, next) =>
    298       openPublicRequest(
    299         f.run,
    300         kind,
    301         () => () => {
    302           if (kind === 'head') {
    303             headStops++;
    304             if (headStops === 1) throw Error('one cleanup failure');
    305           } else deletionStops++;
    306         },
    307         next
    308       ),
    309     { nowSeconds: () => 200 },
    310     {
    311       retain: () => true,
    312       read: (head) => ({ head, requests: [] }),
    313       available: () => available
    314     }
    315   );
    316   try {
    317     resolveHeads(resolver, [f.head(f.proof(100))]);
    318     available = false;
    319     expect(() => headResolutionSnapshot(resolver)).toThrow(
    320       'head_resolver_close_failed'
    321     );
    322     expect(headStops).toBe(1);
    323     expect(deletionStops).toBe(1);
    324     expect(headResolutionSnapshot(resolver)).toEqual([]);
    325     expect(headStops).toBe(2);
    326     expect(deletionStops).toBe(1);
    327   } finally {
    328     closePublicScheduler(f.scheduler);
    329   }
    330 });
    331 it('a snapshot clock cannot publish rows after reentrant retention invalidation', () => {
    332   const f = resolverFixture();
    333   let available = true,
    334     armed = false;
    335   const old = f.proof(100),
    336     newer = f.proof(101);
    337   retainPublicEnvelope(f.owner, old.proof);
    338   const resolver = createHeadResolver(
    339     f.run,
    340     (kind, filters, next) =>
    341       openPublicRequest(f.run, kind, () => () => {}, next),
    342     {
    343       nowSeconds: () => {
    344         if (armed) available = false;
    345         return 200;
    346       }
    347     },
    348     {
    349       retain: () => true,
    350       read: (head) => publicRetentionKnown(f.owner, head),
    351       available: () => available
    352     }
    353   );
    354   try {
    355     resolveHeads(resolver, [f.head(old)]);
    356     retainPublicEnvelope(f.owner, newer.proof);
    357     armed = true;
    358     expect(headResolutionSnapshot(resolver)).toEqual([]);
    359     expect(headResolutionSnapshot(resolver)).toEqual([]);
    360   } finally {
    361     closePublicScheduler(f.scheduler);
    362   }
    363 });