app

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

deletions.test.ts (13011B)


      1 import { afterAll, describe, expect, it } from 'vitest';
      2 import { finalizeEvent } from 'applesauce-core/helpers';
      3 import {
      4   verifyEnvelope,
      5   type VerifiedEnvelope
      6 } from '../../src/lib/nostr/verified-envelope.ts';
      7 import {
      8   admitDeletionRequest,
      9   deletionRequestEnvelope,
     10   deletionRequestSnapshot,
     11   type DeletionRequest
     12 } from '../../src/lib/nostr/deletion-adapter.ts';
     13 import {
     14   evaluateDeletion,
     15   evaluatePublicHeadDeletion
     16 } from '../../src/lib/catalog/deletions.ts';
     17 import {
     18   createPublicHeadCandidate,
     19   selectPublicHead,
     20   publicHeadSnapshot
     21 } from '../../src/lib/catalog/heads.ts';
     22 
     23 const keys: Uint8Array[] = [];
     24 afterAll(() => {
     25   for (const key of keys) key.fill(0);
     26 });
     27 function author() {
     28   const key = crypto.getRandomValues(new Uint8Array(32));
     29   keys.push(key);
     30   return (time: number, tags: string[][], kind = 30402, content = '') => {
     31     const event = finalizeEvent({ kind, created_at: time, tags, content }, key);
     32     const result = verifyEnvelope(JSON.stringify(event));
     33     if (!result.ok) throw new Error('Invalid signed test event');
     34     return { event, proof: result.value };
     35   };
     36 }
     37 function admitted(proof: VerifiedEnvelope) {
     38   const result = admitDeletionRequest(proof);
     39   if (!result.ok) throw new Error(result.code);
     40   return result.value;
     41 }
     42 function fixture() {
     43   const a = author(),
     44     b = author(),
     45     target = a(100, [['d', 'stock']]);
     46   const address = `30402:${target.event.pubkey}:stock`;
     47   const request = (time: number, tags = [['a', address]]) =>
     48     admitted(a(time, tags, 5).proof);
     49   return { a, b, target, address, request };
     50 }
     51 describe('verified owned NIP09 deletion evidence', () => {
     52   it('retains the genuine original verified envelope for retained tombstone evidence', () => {
     53     const f = fixture();
     54     const original = f.a(100, [['a', f.address]], 5, 'withdrawal evidence');
     55     const request = admitted(original.proof);
     56     expect(deletionRequestEnvelope(request)).toBe(original.proof);
     57     expect(deletionRequestEnvelope({} as DeletionRequest)).toBeUndefined();
     58   });
     59   it('retains admitted deletion before the target is evaluated', () => {
     60     const f = fixture(),
     61       deletion = f.request(100);
     62     expect(evaluateDeletion(f.target.proof, [deletion])).toMatchObject({
     63       outcome: 'suppressed',
     64       reason: 'deletion_address_reference',
     65       addressReference: { inclusiveCutoff: 100 }
     66     });
     67   });
     68   it('rejects matching references by the wrong author', () => {
     69     const f = fixture();
     70     const wrong = admitted(
     71       f.b(
     72         101,
     73         [
     74           ['e', f.target.event.id],
     75           ['a', f.address]
     76         ],
     77         5
     78       ).proof
     79     );
     80     expect(evaluateDeletion(f.target.proof, [wrong])).toMatchObject({
     81       outcome: 'visible',
     82       reason: 'deletion_request_author_mismatch',
     83       eventReference: null,
     84       addressReference: null
     85     });
     86   });
     87   it('uses inclusive address cutoff and allows a genuinely later revision', () => {
     88     const f = fixture(),
     89       request = f.request(100);
     90     expect(evaluateDeletion(f.target.proof, [request]).outcome).toBe(
     91       'suppressed'
     92     );
     93     expect(
     94       evaluateDeletion(f.a(101, [['d', 'stock']]).proof, [request])
     95     ).toMatchObject({
     96       outcome: 'visible',
     97       reason: 'deletion_address_cutoff_precedes_target',
     98       addressReference: { inclusiveCutoff: 100 }
     99     });
    100     expect(
    101       evaluateDeletion(f.a(99, [['d', 'stock']]).proof, [request]).outcome
    102     ).toBe('suppressed');
    103   });
    104   it('applies an exact e reference regardless of request timestamp or k mismatch', () => {
    105     const f = fixture(),
    106       request = f.request(0, [
    107         ['e', f.target.event.id],
    108         ['k', '1']
    109       ]);
    110     expect(evaluateDeletion(f.target.proof, [request])).toMatchObject({
    111       outcome: 'suppressed',
    112       reason: 'deletion_event_id_reference',
    113       addressReference: null
    114     });
    115   });
    116   it('cannot resurrect an older head after withdrawal or repeated old arrival', () => {
    117     const f = fixture();
    118     const old = createPublicHeadCandidate(f.a(99, [['d', 'stock']]).proof)!;
    119     const head = createPublicHeadCandidate(f.target.proof)!;
    120     const tombstones = [f.request(100)];
    121     const selected = selectPublicHead(head, old);
    122     expect(selected.decision).toBe('older');
    123     expect(publicHeadSnapshot(selected.head).id).toBe(f.target.event.id);
    124     expect(evaluatePublicHeadDeletion(selected.head, tombstones).outcome).toBe(
    125       'suppressed'
    126     );
    127     expect(evaluatePublicHeadDeletion(selected.head, tombstones).outcome).toBe(
    128       'suppressed'
    129     );
    130   });
    131   it('never treats kind5 itself as retractable evidence', () => {
    132     const f = fixture(),
    133       target = f.a(100, [['e', f.target.event.id]], 5);
    134     expect(
    135       evaluateDeletion(target.proof, [f.request(101, [['e', target.event.id]])])
    136     ).toEqual({
    137       outcome: 'visible',
    138       reason: 'deletion_request_immune',
    139       eventReference: null,
    140       addressReference: null
    141     });
    142   });
    143   it('distinguishes unrelated requests from wrong authors', () => {
    144     const f = fixture();
    145     expect(
    146       evaluateDeletion(f.target.proof, [
    147         f.request(101, [['e', 'f'.repeat(64)]])
    148       ]).reason
    149     ).toBe('deletion_no_authorized_reference');
    150   });
    151   it('chooses lowest exact request ID and greatest cutoff/lower-ID address evidence independent of order and repeats', () => {
    152     const f = fixture(),
    153       exactA = f.request(0, [['e', f.target.event.id]]),
    154       exactB = f.request(200, [['e', f.target.event.id]]);
    155     const addressA = f.request(120),
    156       addressB = f.request(120, [
    157         ['a', f.address],
    158         ['x', 'different']
    159       ]),
    160       stale = f.request(110);
    161     const rows = [exactA, addressA, exactB, addressB, stale];
    162     const expected = evaluateDeletion(f.target.proof, rows);
    163     expect(
    164       evaluateDeletion(f.target.proof, [...rows].reverse().concat(rows))
    165     ).toEqual(expected);
    166     expect(expected).toMatchObject({
    167       reason: 'deletion_event_id_and_address_reference',
    168       eventReference: {
    169         requestId: [exactA, exactB]
    170           .map((v) => deletionRequestSnapshot(v)!.id)
    171           .sort()[0]
    172       },
    173       addressReference: {
    174         inclusiveCutoff: 120,
    175         requestId: [addressA, addressB]
    176           .map((v) => deletionRequestSnapshot(v)!.id)
    177           .sort()[0]
    178       }
    179     });
    180   });
    181   it('retains stale authorized address evidence in preference to wrong-author reason', () => {
    182     const f = fixture(),
    183       wrong = admitted(f.b(200, [['e', f.target.event.id]], 5).proof);
    184     expect(
    185       evaluateDeletion(f.target.proof, [wrong, f.request(99)]).reason
    186     ).toBe('deletion_address_cutoff_precedes_target');
    187   });
    188   it('uses first d exactly, with no address for missing or malformed first d', () => {
    189     const f = fixture(),
    190       empty = f.request(100, [['a', `30402:${f.target.event.pubkey}:`]]);
    191     for (const tags of [[], [['d']], [['d'], ['d', 'stock']]])
    192       expect(
    193         evaluateDeletion(f.a(100, tags).proof, [empty, f.request(100)]).outcome
    194       ).toBe('visible');
    195     expect(evaluateDeletion(f.a(100, [['d', '']]).proof, [empty]).outcome).toBe(
    196       'suppressed'
    197     );
    198     expect(
    199       evaluateDeletion(
    200         f.a(100, [
    201           ['d', 'stock'],
    202           ['d', 'other']
    203         ]).proof,
    204         [f.request(100)]
    205       ).outcome
    206     ).toBe('suppressed');
    207   });
    208   it('preserves opaque identifier bytes and does not normalize titles, whitespace, Unicode or colon', () => {
    209     const f = fixture();
    210     for (const id of ['a:b', ' stock ', 'é', 'e\u0301', '\ufeffstock']) {
    211       const target = f.a(100, [['d', id]]);
    212       const request = f.request(100, [
    213         ['a', `30402:${target.event.pubkey}:${id}`]
    214       ]);
    215       expect(evaluateDeletion(target.proof, [request]).outcome).toBe(
    216         'suppressed'
    217       );
    218       expect(evaluateDeletion(f.target.proof, [request]).outcome).toBe(
    219         'visible'
    220       );
    221     }
    222   });
    223   it('accepts generic replaceable coordinate kinds with empty identifiers', () => {
    224     const f = fixture();
    225     for (const kind of [0, 3, 10000, 19999]) {
    226       const target = f.a(100, [['d', 'ignored']], kind);
    227       const request = f.request(100, [
    228         ['a', `${kind}:${target.event.pubkey}:`]
    229       ]);
    230       expect(evaluateDeletion(target.proof, [request]).outcome).toBe(
    231         'suppressed'
    232       );
    233     }
    234   });
    235   it('canonicalizes mixed-case e/a and plus/leading-zero coordinate kinds while retaining first raw provenance', () => {
    236     const f = fixture();
    237     const tags = [
    238       ['e', f.target.event.id.toUpperCase(), 'relay'],
    239       ['e', f.target.event.id],
    240       ['a', `+030402:${f.target.event.pubkey.toUpperCase()}:stock`, 'extra'],
    241       ['a', f.address],
    242       ['x', 'unknown']
    243     ];
    244     const request = f.request(100, tags),
    245       view = deletionRequestSnapshot(request)!;
    246     expect(view.rawTags).toEqual(tags);
    247     expect(view.eventTargets).toEqual([
    248       { tagIndex: 0, eventId: f.target.event.id, rawTag: tags[0] }
    249     ]);
    250     expect(view.addressTargets).toEqual([
    251       { tagIndex: 2, coordinate: f.address, rawTag: tags[2] }
    252     ]);
    253     expect(evaluateDeletion(f.target.proof, [request]).reason).toBe(
    254       'deletion_event_id_and_address_reference'
    255     );
    256   });
    257   it('keeps k advisory and returns ordered shape/invalid/duplicate/conflict diagnostics', () => {
    258     const f = fixture(),
    259       request = f.request(100, [
    260         ['k'],
    261         ['a', f.address],
    262         ['k', '+30402'],
    263         ['k', '30402'],
    264         ['k', '30402', 'duplicate'],
    265         ['k', '31923'],
    266         ['k', '65536']
    267       ]);
    268     const view = deletionRequestSnapshot(request)!;
    269     expect(view.kindAdvisories.map((v) => v.kind)).toEqual([30402, 31923]);
    270     expect(view.diagnostics.map((v) => [v.tagIndex, v.code])).toEqual([
    271       [0, 'deletion_kind_advisory_shape_ignored'],
    272       [2, 'deletion_kind_advisory_invalid_ignored'],
    273       [4, 'deletion_kind_advisory_duplicate_ignored'],
    274       [5, 'deletion_kind_advisory_conflict_ignored'],
    275       [6, 'deletion_kind_advisory_invalid_ignored']
    276     ]);
    277     expect(evaluateDeletion(f.target.proof, [request]).outcome).toBe(
    278       'suppressed'
    279     );
    280     expect(
    281       deletionRequestSnapshot(
    282         f.request(100, [
    283           ['a', f.address],
    284           ['e', f.target.event.id],
    285           ['k', '31923']
    286         ])
    287       )!.diagnostics
    288     ).toEqual([]);
    289   });
    290   it('rejects any malformed e/a in source order rather than partially admitting a request', () => {
    291     const f = fixture();
    292     for (const [tags, code] of [
    293       [[['a', f.address], ['e'], ['a', 'bad']], 'deletion_event_target_shape'],
    294       [
    295         [
    296           ['e', f.target.event.id],
    297           ['a', 'bad'],
    298           ['e', 'bad']
    299         ],
    300         'deletion_address_target_invalid'
    301       ],
    302       [[['e', 'bad']], 'deletion_event_target_invalid'],
    303       [[['a']], 'deletion_address_target_shape'],
    304       [[['x', 'unknown'], ['k']], 'deletion_target_missing']
    305     ] as [string[][], string][])
    306       expect(admitDeletionRequest(f.a(100, tags, 5).proof)).toMatchObject({
    307         ok: false,
    308         code
    309       });
    310   });
    311   it('rejects unsupported/invalid address kinds, nonempty replaceable identifiers, bad curve keys and whitespace', () => {
    312     const f = fixture();
    313     for (const value of [
    314       `1:${f.target.event.pubkey}:`,
    315       `0:${f.target.event.pubkey}:x`,
    316       '30402:' + '0'.repeat(64) + ':stock',
    317       ` 30402:${f.target.event.pubkey}:stock`,
    318       `30402:${f.target.event.pubkey}:stock` +
    319         'x'.repeat(4097 - f.address.length)
    320     ]) {
    321       const tags = [['a', value]];
    322       const wire = JSON.stringify(
    323         finalizeEvent({ kind: 5, created_at: 100, tags, content: '' }, keys[0])
    324       );
    325       const proof = verifyEnvelope(wire);
    326       if (!proof.ok) {
    327         expect(value.length).toBeGreaterThanOrEqual(4096);
    328         continue;
    329       }
    330       expect(admitDeletionRequest(proof.value).ok).toBe(false);
    331     }
    332   });
    333   it('requires genuine proofs and admitted ownership rather than SDK flags or forged tokens', () => {
    334     const f = fixture();
    335     expect(admitDeletionRequest({} as VerifiedEnvelope)).toEqual({
    336       ok: false,
    337       code: 'deletion_proof_invalid'
    338     });
    339     expect(admitDeletionRequest(f.target.proof)).toEqual({
    340       ok: false,
    341       code: 'unsupported_kind'
    342     });
    343     expect(deletionRequestSnapshot({} as DeletionRequest)).toBeUndefined();
    344     expect(
    345       evaluateDeletion(f.target.proof, [{} as DeletionRequest]).outcome
    346     ).toBe('visible');
    347     expect(() => evaluateDeletion({} as VerifiedEnvelope, [])).toThrow(
    348       'deletion_target_proof_invalid'
    349     );
    350   });
    351   it('protects retained tombstone metadata and raw tags from caller mutation', () => {
    352     const f = fixture(),
    353       request = f.request(100),
    354       view = deletionRequestSnapshot(request)!;
    355     (view.rawTags as string[][])[0][1] = 'bad';
    356     (view.addressTargets as unknown as { coordinate: string }[])[0].coordinate =
    357       'bad';
    358     expect(deletionRequestSnapshot(request)!.rawTags[0][1]).toBe(f.address);
    359     expect(evaluateDeletion(f.target.proof, [request]).outcome).toBe(
    360       'suppressed'
    361     );
    362   });
    363 });