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