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 });