inbox-routing.test.ts (11567B)
1 import { describe, it, expect } from 'vitest'; 2 import { finalizeEvent } from 'applesauce-core/helpers'; 3 import { 4 validateRelayPolicy, 5 type RelayPolicy 6 } from '../../src/lib/config/relays.ts'; 7 import { 8 createPublicScheduler, 9 createPublicRun, 10 openInboxRequest, 11 closePublicScheduler 12 } from '../../src/lib/nostr/request-scope.ts'; 13 import { 14 createInboxResolver, 15 type InboxResolver 16 } from '../../src/lib/messaging/resolve-inbox.ts'; 17 import { inboxPreferenceSnapshot } from '../../src/lib/nostr/inbox-preferences.ts'; 18 import { inboxResolutionSnapshot } from '../../src/lib/messaging/resolve-inbox.ts'; 19 import { 20 createInboxRoutePlan, 21 inboxRoutePlanSnapshot, 22 recheckInboxRoutePlan 23 } from '../../src/lib/messaging/inbox-routing.ts'; 24 const discovery = 'wss://discovery.example.org', 25 peerOrigin = 'wss://peer.example.org', 26 archiveOrigin = 'wss://archive.example.org', 27 common = 'wss://common.example.org', 28 unapproved = 'wss://hint.example.org'; 29 function policy(targets = [peerOrigin, archiveOrigin, common]): RelayPolicy { 30 return validateRelayPolicy( 31 JSON.stringify({ 32 schemaVersion: 1, 33 public: [{ origin: discovery, read: true, write: false, nip50: false }], 34 inbox: targets.map((origin) => ({ origin, read: true, write: true })), 35 postingEnabled: false, 36 messagingEnabled: false, 37 operatorDenylist: [] 38 }) 39 )!; 40 } 41 function author(relays: string[]) { 42 const key = crypto.getRandomValues(new Uint8Array(32)); 43 try { 44 const tags = relays.map((origin) => ['relay', origin]); 45 const original = finalizeEvent( 46 { 47 kind: 10050, 48 created_at: 100, 49 tags: [...tags, ['unknown', 'preserve']], 50 content: '' 51 }, 52 key 53 ); 54 const removed = finalizeEvent( 55 { kind: 10050, created_at: 200, tags: tags.slice(1), content: '' }, 56 key 57 ); 58 const changed = finalizeEvent( 59 { 60 kind: 10050, 61 created_at: 201, 62 tags: [...tags, ['unknown', 'changed']], 63 content: '' 64 }, 65 key 66 ); 67 return { original, removed, changed }; 68 } finally { 69 key.fill(0); 70 } 71 } 72 function resolved( 73 event: ReturnType<typeof author>['original'], 74 complete = true, 75 now: () => number = () => 0 76 ) { 77 const scheduler = createPublicScheduler({ 78 now, 79 schedule: () => () => {} 80 }), 81 run = createPublicRun(scheduler, policy()); 82 let current = true; 83 const resolver = createInboxResolver( 84 run, 85 event.pubkey, 86 (next) => 87 openInboxRequest( 88 run, 89 event.pubkey, 90 (sink) => { 91 sink({ type: 'EVENT', from: discovery, id: 'fixture', event }); 92 if (complete) sink({ type: 'EOSE', from: discovery, id: 'fixture' }); 93 return () => {}; 94 }, 95 next 96 ), 97 () => current 98 ); 99 return { 100 resolver, 101 close: () => closePublicScheduler(scheduler), 102 stale() { 103 current = false; 104 } 105 }; 106 } 107 function fixture( 108 peerRelays = [peerOrigin, common], 109 selfRelays = [archiveOrigin] 110 ) { 111 const self = author(selfRelays), 112 peer = author(peerRelays), 113 own = resolved(self.original), 114 other = resolved(peer.original); 115 return { 116 self, 117 peer, 118 own, 119 other, 120 close() { 121 own.close(); 122 other.close(); 123 } 124 }; 125 } 126 describe('recipient and sender archive routing', () => { 127 it('selects recipient advertised allowed writes and computes sender archive independently', () => { 128 const f = fixture(); 129 try { 130 const plan = createInboxRoutePlan( 131 policy(), 132 f.self.original.pubkey, 133 f.peer.original.pubkey, 134 f.own.resolver, 135 f.other.resolver 136 )!; 137 const r = inboxRoutePlanSnapshot(plan)!; 138 expect(r.peer).toMatchObject({ 139 role: 'peer', 140 author: f.peer.original.pubkey, 141 targets: [peerOrigin, common], 142 knownBase: { id: f.peer.original.id } 143 }); 144 expect(r.archive).toMatchObject({ 145 role: 'self_archive', 146 author: f.self.original.pubkey, 147 targets: [archiveOrigin], 148 knownBase: { id: f.self.original.id } 149 }); 150 expect(Object.keys(plan)).toEqual([]); 151 expect(Object.isFrozen(plan)).toBe(true); 152 } finally { 153 f.close(); 154 } 155 }); 156 it('empty peer intersection never falls back to sender archive or public discovery', () => { 157 const f = fixture([unapproved]); 158 try { 159 expect( 160 createInboxRoutePlan( 161 policy(), 162 f.self.original.pubkey, 163 f.peer.original.pubkey, 164 f.own.resolver, 165 f.other.resolver 166 ) 167 ).toBeUndefined(); 168 } finally { 169 f.close(); 170 } 171 }); 172 it('empty sender archive never falls back to peer destinations', () => { 173 const f = fixture([peerOrigin], [unapproved]); 174 try { 175 expect( 176 createInboxRoutePlan( 177 policy(), 178 f.self.original.pubkey, 179 f.peer.original.pubkey, 180 f.own.resolver, 181 f.other.resolver 182 ) 183 ).toBeUndefined(); 184 } finally { 185 f.close(); 186 } 187 }); 188 it('keeps all advertised preference data while limiting selected routes to the fixed allowlist', () => { 189 const f = fixture([ 190 unapproved, 191 peerOrigin, 192 common, 193 archiveOrigin, 194 'wss://fifth.example.org' 195 ]); 196 try { 197 const before = inboxPreferenceSnapshot( 198 inboxResolutionSnapshot(f.other.resolver).head! 199 )!; 200 expect(before.relays).toHaveLength(5); 201 const plan = createInboxRoutePlan( 202 policy(), 203 f.self.original.pubkey, 204 f.peer.original.pubkey, 205 f.own.resolver, 206 f.other.resolver 207 )!; 208 expect(inboxRoutePlanSnapshot(plan)?.peer.targets).toEqual([ 209 peerOrigin, 210 archiveOrigin, 211 common 212 ]); 213 expect( 214 inboxPreferenceSnapshot(inboxResolutionSnapshot(f.other.resolver).head!) 215 ).toEqual(before); 216 } finally { 217 f.close(); 218 } 219 }); 220 it('rejects forged resolution/policy, invalid identities, swapped authors and self messaging', () => { 221 const f = fixture(); 222 try { 223 expect( 224 createInboxRoutePlan( 225 policy(), 226 f.self.original.pubkey, 227 f.peer.original.pubkey, 228 {} as InboxResolver, 229 f.other.resolver 230 ) 231 ).toBeUndefined(); 232 expect( 233 createInboxRoutePlan( 234 {} as RelayPolicy, 235 f.self.original.pubkey, 236 f.peer.original.pubkey, 237 f.own.resolver, 238 f.other.resolver 239 ) 240 ).toBeUndefined(); 241 expect( 242 createInboxRoutePlan( 243 policy(), 244 'f'.repeat(64), 245 f.peer.original.pubkey, 246 f.own.resolver, 247 f.other.resolver 248 ) 249 ).toBeUndefined(); 250 expect( 251 createInboxRoutePlan( 252 policy(), 253 f.peer.original.pubkey, 254 f.self.original.pubkey, 255 f.own.resolver, 256 f.other.resolver 257 ) 258 ).toBeUndefined(); 259 expect( 260 createInboxRoutePlan( 261 policy(), 262 f.self.original.pubkey, 263 f.self.original.pubkey, 264 f.own.resolver, 265 f.own.resolver 266 ) 267 ).toBeUndefined(); 268 expect( 269 inboxRoutePlanSnapshot( 270 {} as NonNullable<ReturnType<typeof createInboxRoutePlan>> 271 ) 272 ).toBeUndefined(); 273 } finally { 274 f.close(); 275 } 276 }); 277 it('partial, unsupported or stale preference evidence cannot produce routes', () => { 278 const f = fixture(), 279 partial = resolved(f.peer.original, false); 280 try { 281 expect( 282 createInboxRoutePlan( 283 policy(), 284 f.self.original.pubkey, 285 f.peer.original.pubkey, 286 f.own.resolver, 287 partial.resolver 288 ) 289 ).toBeUndefined(); 290 f.other.stale(); 291 expect( 292 createInboxRoutePlan( 293 policy(), 294 f.self.original.pubkey, 295 f.peer.original.pubkey, 296 f.own.resolver, 297 f.other.resolver 298 ) 299 ).toBeUndefined(); 300 } finally { 301 f.close(); 302 partial.close(); 303 } 304 const g = fixture([peerOrigin]), 305 bad = resolved(g.peer.removed); 306 try { 307 expect( 308 createInboxRoutePlan( 309 policy(), 310 g.self.original.pubkey, 311 g.peer.original.pubkey, 312 g.own.resolver, 313 bad.resolver 314 ) 315 ).toBeUndefined(); 316 } finally { 317 g.close(); 318 bad.close(); 319 } 320 }); 321 it('detached snapshots cannot retarget the opaque plan', () => { 322 const f = fixture(); 323 try { 324 const p = createInboxRoutePlan( 325 policy(), 326 f.self.original.pubkey, 327 f.peer.original.pubkey, 328 f.own.resolver, 329 f.other.resolver 330 )!; 331 const r = inboxRoutePlanSnapshot(p)!; 332 r.peer.targets.push(unapproved); 333 r.peer.sources.pop(); 334 expect(inboxRoutePlanSnapshot(p)?.peer.targets).toEqual([ 335 peerOrigin, 336 common 337 ]); 338 expect(inboxRoutePlanSnapshot(p)?.peer.sources).toHaveLength(1); 339 expect( 340 recheckInboxRoutePlan(p, policy(), f.own.resolver, f.other.resolver) 341 ).toBe('unchanged'); 342 } finally { 343 f.close(); 344 } 345 }); 346 it('removed approved destinations and changed known preference versions require explicit review', () => { 347 const f = fixture(), 348 removed = resolved(f.peer.removed), 349 version = resolved(f.peer.changed); 350 try { 351 const p = createInboxRoutePlan( 352 policy(), 353 f.self.original.pubkey, 354 f.peer.original.pubkey, 355 f.own.resolver, 356 f.other.resolver 357 )!; 358 expect( 359 recheckInboxRoutePlan( 360 p, 361 policy([archiveOrigin, common]), 362 f.own.resolver, 363 f.other.resolver 364 ) 365 ).toBe('review_required'); 366 expect( 367 recheckInboxRoutePlan(p, policy(), f.own.resolver, removed.resolver) 368 ).toBe('review_required'); 369 expect( 370 recheckInboxRoutePlan(p, policy(), f.own.resolver, version.resolver) 371 ).toBe('review_required'); 372 expect(inboxRoutePlanSnapshot(p)?.peer.targets).toEqual([ 373 peerOrigin, 374 common 375 ]); 376 f.other.stale(); 377 expect( 378 recheckInboxRoutePlan(p, policy(), f.own.resolver, f.other.resolver) 379 ).toBe('unavailable'); 380 } finally { 381 f.close(); 382 removed.close(); 383 version.close(); 384 } 385 }); 386 }); 387 388 it('peer clock reentry cannot admit a stale sender archive captured first', () => { 389 const f = fixture(); 390 let armed = false; 391 const peer = resolved(f.peer.original, true, () => { 392 if (armed) f.own.stale(); 393 return 0; 394 }); 395 try { 396 armed = true; 397 expect( 398 createInboxRoutePlan( 399 policy(), 400 f.self.original.pubkey, 401 f.peer.original.pubkey, 402 f.own.resolver, 403 peer.resolver 404 ) 405 ).toBeUndefined(); 406 } finally { 407 f.close(); 408 peer.close(); 409 } 410 }); 411 412 it('peer clock reentry cannot report unchanged after sender scheduler closes', () => { 413 const f = fixture(); 414 let armed = false; 415 const peer = resolved(f.peer.original, true, () => { 416 if (armed) f.own.close(); 417 return 0; 418 }); 419 try { 420 const p = createInboxRoutePlan( 421 policy(), 422 f.self.original.pubkey, 423 f.peer.original.pubkey, 424 f.own.resolver, 425 peer.resolver 426 )!; 427 expect(p).toBeDefined(); 428 armed = true; 429 expect( 430 recheckInboxRoutePlan(p, policy(), f.own.resolver, peer.resolver) 431 ).toBe('unavailable'); 432 expect(inboxRoutePlanSnapshot(p)?.archive.targets).toEqual([archiveOrigin]); 433 } finally { 434 f.close(); 435 peer.close(); 436 } 437 });