inbox-probe-exclusion.ts (16897B)
1 import { makeQualificationFixture } from './inbox-access-qualification.ts'; 2 import type { openRecoveryContext } from './inbox-probe-recovery.ts'; 3 import { 4 admitInboxEnvelope, 5 inboxEnvelopeSnapshot, 6 retainInboxEnvelope 7 } from '../../../src/lib/persistence/inbox-envelope-repository.ts'; 8 import type { PrivateAccessProbe } from '../../../src/lib/persistence/private-records.ts'; 9 import { observeQualifiedInboxAccess } from '../../../src/lib/messaging/inbox-access-qualification.ts'; 10 import { 11 captureInboxIngress, 12 startInboxIngress, 13 stopInboxIngress, 14 inboxIngressSnapshot, 15 type InboxIngress 16 } from '../../../src/lib/nostr/inbox-ingress.ts'; 17 import { 18 captureInboxSync, 19 startInboxSync, 20 stopInboxSync, 21 inboxSyncSnapshot, 22 type InboxSync 23 } from '../../../src/lib/messaging/inbox-sync.ts'; 24 import { 25 captureOlderInbox, 26 loadOlderInbox, 27 olderInboxSnapshot, 28 stopOlderInbox, 29 type OlderInbox 30 } from '../../../src/lib/messaging/history-pagination.ts'; 31 import { 32 captureUnlockedSession, 33 type UnlockedSession 34 } from '../../../src/lib/messaging/unlocked-session.ts'; 35 import { 36 captureDecryptionQueue, 37 runDecryptionBatch, 38 stopDecryptionQueue, 39 decryptionQueueSnapshot, 40 decryptionQueueConversations, 41 type DecryptionQueue 42 } from '../../../src/lib/messaging/decryption-queue.ts'; 43 import { 44 createPublicView, 45 beginPublicViewRun, 46 disposePublicView 47 } from '../../../src/lib/runtime/public-runtime.ts'; 48 import { 49 resolveInboxPreference, 50 settleInboxResolver 51 } from '../../../src/lib/messaging/resolve-inbox.ts'; 52 import { 53 openBrowserDatabase, 54 browserDatabaseTransaction, 55 closeBrowserDatabase 56 } from '../../../src/lib/persistence/database.ts'; 57 import { inboxProbeRumorWire } from '../../../src/lib/nostr/inbox-access.ts'; 58 import { recoveredInboxProbeRumorWire } from '../../../src/lib/nostr/self-recovery-reader.ts'; 59 import { 60 generateSecretKey, 61 getPublicKey, 62 getEventHash, 63 finalizeEvent 64 } from 'applesauce-core/helpers'; 65 import { nip44 } from 'applesauce-core/helpers/encryption'; 66 export { 67 observeInboxProbeDelivery, 68 consumeInboxProbeDelivery 69 } from '../../../src/lib/persistence/inbox-probes.ts'; 70 export * from './inbox-access-qualification.ts'; 71 export { admitInboxEnvelope, retainInboxEnvelope }; 72 export { openBrowserDatabase, closeBrowserDatabase }; 73 // Observe real native transactions and mutation calls without changing results. 74 export function watchExclusionNative() { 75 const transaction = Object.getOwnPropertyDescriptor( 76 IDBDatabase.prototype, 77 'transaction' 78 )!.value as IDBDatabase['transaction'], 79 put = Object.getOwnPropertyDescriptor(IDBObjectStore.prototype, 'put')! 80 .value as IDBObjectStore['put'], 81 remove = Object.getOwnPropertyDescriptor( 82 IDBObjectStore.prototype, 83 'delete' 84 )!.value as IDBObjectStore['delete']; 85 let readonly = 0, 86 readwrite = 0, 87 puts = 0, 88 deletes = 0; 89 IDBDatabase.prototype.transaction = function ( 90 ...args: Parameters<IDBDatabase['transaction']> 91 ) { 92 if (args[1] === 'readwrite') readwrite++; 93 else readonly++; 94 return transaction.apply(this, args); 95 }; 96 IDBObjectStore.prototype.put = function ( 97 ...args: Parameters<IDBObjectStore['put']> 98 ) { 99 puts++; 100 return put.apply(this, args); 101 }; 102 IDBObjectStore.prototype.delete = function ( 103 ...args: Parameters<IDBObjectStore['delete']> 104 ) { 105 deletes++; 106 return remove.apply(this, args); 107 }; 108 return { 109 counts: () => ({ readonly, readwrite, puts, deletes }), 110 restore() { 111 IDBDatabase.prototype.transaction = transaction; 112 IDBObjectStore.prototype.put = put; 113 IDBObjectStore.prototype.delete = remove; 114 } 115 }; 116 } 117 // Delay delivery of the FIRST actual native complete notification. The real 118 // cursor, result and trusted completion event still run; no success is fabricated. 119 export function holdExclusionNativeCompletion() { 120 const transaction = Object.getOwnPropertyDescriptor( 121 IDBDatabase.prototype, 122 'transaction' 123 )!.value as IDBDatabase['transaction']; 124 let selected = false, 125 waiting = false, 126 released = false; 127 const deliveries: (() => void)[] = []; 128 IDBDatabase.prototype.transaction = function ( 129 ...args: Parameters<IDBDatabase['transaction']> 130 ) { 131 const tx = transaction.apply(this, args); 132 if ( 133 !selected && 134 tx.mode === 'readonly' && 135 tx.objectStoreNames.contains('private_sends') 136 ) { 137 selected = true; 138 const add = tx.addEventListener.bind(tx); 139 Object.defineProperty(tx, 'addEventListener', { 140 configurable: true, 141 value( 142 type: string, 143 listener: EventListenerOrEventListenerObject | null, 144 options?: boolean | AddEventListenerOptions 145 ) { 146 if (!listener) return; 147 if (type !== 'complete') return add(type, listener, options); 148 add( 149 type, 150 (event) => { 151 const deliver = () => { 152 if (typeof listener === 'function') listener.call(tx, event); 153 else listener.handleEvent(event); 154 }; 155 if (released) deliver(); 156 else { 157 waiting = true; 158 deliveries.push(deliver); 159 } 160 }, 161 options 162 ); 163 } 164 }); 165 } 166 return tx; 167 }; 168 return { 169 waiting: () => waiting, 170 release() { 171 released = true; 172 waiting = false; 173 IDBDatabase.prototype.transaction = transaction; 174 for (const deliver of deliveries.splice(0)) deliver(); 175 } 176 }; 177 } 178 // Real child documents use the surviving extension host while all product 179 // actors and their private provenance belong to the child's fresh module realm. 180 export async function retainInRecoveryContext( 181 context: Awaited<ReturnType<typeof openRecoveryContext>>, 182 wire: string 183 ) { 184 const envelope = admitInboxEnvelope( 185 wire, 186 context.owner, 187 'wss://inbox.example.org', 188 Date.now() 189 ); 190 return envelope 191 ? (await retainInboxEnvelope(context.repository, context.session, envelope)) 192 .status 193 : 'invalid'; 194 } 195 export async function decryptInRecoveryContext( 196 context: Awaited<ReturnType<typeof openRecoveryContext>> 197 ) { 198 const unlocked = captureUnlockedSession( 199 context.session, 200 'reviewed_messages_unlock' 201 ); 202 if (!unlocked) throw Error('actual child explicit unlock'); 203 const queue = captureDecryptionQueue( 204 context.repository, 205 context.session, 206 context.identity, 207 unlocked, 208 'reviewed_inbox_unlock' 209 ); 210 if (!queue) throw Error('actual child decryption queue'); 211 try { 212 const result = await runDecryptionBatch( 213 queue, 214 'reviewed_decrypt_batch', 215 [] 216 ); 217 return { 218 result, 219 snapshot: decryptionQueueSnapshot(queue), 220 rooms: decryptionQueueConversations(queue).length 221 }; 222 } finally { 223 stopDecryptionQueue(queue); 224 } 225 } 226 export async function makeExclusionFixture() { 227 const base = await makeQualificationFixture(); 228 const views: ReturnType<typeof createPublicView>[] = []; 229 let finite: InboxIngress | undefined, 230 sync: InboxSync | undefined, 231 older: OlderInbox | undefined, 232 unlocked: UnlockedSession | undefined, 233 queue: DecryptionQueue | undefined; 234 async function selfWire() { 235 const row = (await base.host.stored()).find( 236 (value) => value.id === base.command() 237 ); 238 if (!row) throw Error('actual source-admitted original probe row'); 239 const record = JSON.parse(row.wire) as PrivateAccessProbe; 240 if (!record.self) throw Error('actual original self ciphertext'); 241 return record.self.wire; 242 } 243 return { 244 ...base, 245 selfWire, 246 async seedReceived(count = 1999) { 247 if (!Number.isSafeInteger(count) || count < 0 || count > 2000) 248 throw Error('bounded native quota fixture'); 249 const probe = JSON.parse(await selfWire()) as { created_at: number }; 250 const secret = generateSecretKey(), 251 key = nip44.v2.utils.getConversationKey(secret, base.host.owner); 252 const rows: { owner: string; id: string; wire: string }[] = []; 253 try { 254 const content = nip44.v2.encrypt( 255 'bounded native outer-only quota fixture', 256 key 257 ); 258 for (let n = 0; n < count; n++) { 259 const event = finalizeEvent( 260 { 261 kind: 1059, 262 created_at: probe.created_at + n + 1, 263 tags: [['p', base.host.owner]], 264 content 265 }, 266 secret 267 ); 268 const envelope = admitInboxEnvelope( 269 JSON.stringify(event), 270 base.host.owner, 271 'wss://inbox.example.org', 272 Date.now() 273 ); 274 const record = envelope && inboxEnvelopeSnapshot(envelope); 275 if (!record) 276 throw Error('actual stock signed outer fixture admission'); 277 rows.push({ 278 owner: base.host.owner, 279 id: event.id, 280 wire: JSON.stringify(record) 281 }); 282 } 283 } finally { 284 key.fill(0); 285 secret.fill(0); 286 } 287 const opened = await openBrowserDatabase(); 288 if (opened.state !== 'ready') 289 throw Error('actual received quota database'); 290 try { 291 const tx = browserDatabaseTransaction( 292 opened.owner, 293 ['received_envelopes'], 294 'readwrite' 295 ); 296 for (const row of rows) tx.objectStore('received_envelopes').put(row); 297 await new Promise<void>((resolve, reject) => { 298 tx.addEventListener('complete', () => resolve()); 299 tx.addEventListener('abort', () => 300 reject(Error('actual received quota seed abort')) 301 ); 302 }); 303 } finally { 304 closeBrowserDatabase(opened.owner); 305 } 306 return probe.created_at + 1; 307 }, 308 async deleteReceived(id: string) { 309 const opened = await openBrowserDatabase(); 310 if (opened.state !== 'ready') 311 throw Error('actual received fixture deletion'); 312 try { 313 const tx = browserDatabaseTransaction( 314 opened.owner, 315 ['received_envelopes'], 316 'readwrite' 317 ); 318 tx.objectStore('received_envelopes').delete([base.host.owner, id]); 319 await new Promise<void>((resolve, reject) => { 320 tx.addEventListener('complete', () => resolve()); 321 tx.addEventListener('abort', () => 322 reject(Error('actual received fixture delete abort')) 323 ); 324 }); 325 } finally { 326 closeBrowserDatabase(opened.owner); 327 } 328 }, 329 async rowWire() { 330 const row = (await base.host.stored()).find( 331 (value) => value.id === base.command() 332 ); 333 if (!row) throw Error('actual source journal row'); 334 return row.wire; 335 }, 336 async replaceRow( 337 wire: string, 338 id = base.command()!, 339 owner = base.host.owner 340 ) { 341 const opened = await openBrowserDatabase(); 342 if (opened.state !== 'ready') 343 throw Error('actual fixture native database'); 344 try { 345 const tx = browserDatabaseTransaction( 346 opened.owner, 347 ['private_sends'], 348 'readwrite' 349 ); 350 tx.objectStore('private_sends').put({ owner, id, wire }); 351 await new Promise<void>((resolve, reject) => { 352 tx.addEventListener('complete', () => resolve()); 353 tx.addEventListener('abort', () => 354 reject(Error('actual fixture native write abort')) 355 ); 356 }); 357 } finally { 358 closeBrowserDatabase(opened.owner); 359 } 360 }, 361 ordinaryWire(recovered: boolean, time?: number) { 362 const a = base.actors(), 363 original = base.originalIdentity(), 364 proof = base.proof(); 365 const rumorWire = 366 recovered && proof 367 ? recoveredInboxProbeRumorWire( 368 proof, 369 base.repository, 370 a.session, 371 a.access, 372 base.host.policy, 373 base.host.qualification 374 ) 375 : original && inboxProbeRumorWire(original, a.session); 376 if (!rumorWire) throw Error('actual original diagnostic rumor source'); 377 const diagnostic = JSON.parse(rumorWire) as { 378 content: string; 379 created_at: number; 380 }; 381 const peer = generateSecretKey(), 382 outer = generateSecretKey(); 383 function encrypt(secret: Uint8Array, plain: string) { 384 const key = nip44.v2.utils.getConversationKey(secret, base.host.owner); 385 try { 386 return nip44.v2.encrypt(plain, key); 387 } finally { 388 key.fill(0); 389 } 390 } 391 try { 392 const template = { 393 pubkey: getPublicKey(peer), 394 kind: 14, 395 created_at: diagnostic.created_at, 396 tags: [['p', base.host.owner]], 397 content: diagnostic.content 398 }; 399 const rumor = { id: getEventHash(template), ...template }; 400 const seal = finalizeEvent( 401 { 402 kind: 13, 403 created_at: diagnostic.created_at, 404 tags: [], 405 content: encrypt(peer, JSON.stringify(rumor)) 406 }, 407 peer 408 ); 409 return JSON.stringify( 410 finalizeEvent( 411 { 412 kind: 1059, 413 created_at: time ?? diagnostic.created_at, 414 tags: [['p', base.host.owner]], 415 content: encrypt(outer, JSON.stringify(seal)) 416 }, 417 outer 418 ) 419 ); 420 } finally { 421 peer.fill(0); 422 outer.fill(0); 423 } 424 }, 425 async startReceive(lane: 'finite' | 'sync') { 426 const qualification = base.qualification(); 427 if (!qualification) 428 throw Error('actual genuine access qualification missing'); 429 const a = base.actors(), 430 view = createPublicView(base.sharedPublicRuntime()); 431 views.push(view); 432 const own = resolveInboxPreference( 433 view, 434 beginPublicViewRun(view), 435 base.host.owner 436 ); 437 await settleInboxResolver(own); 438 const observe = observeQualifiedInboxAccess(qualification); 439 if (lane === 'finite') { 440 finite = captureInboxIngress( 441 base.repository, 442 a.session, 443 base.host.policy, 444 own, 445 observe, 446 'reviewed_private_inbox_receive' 447 ); 448 return ( 449 !!finite && 450 startInboxIngress(finite, 'reviewed_private_inbox_receive') 451 ); 452 } 453 unlocked = captureUnlockedSession(a.session, 'reviewed_messages_unlock'); 454 if (!unlocked) throw Error('actual owner unlocked scope'); 455 sync = captureInboxSync( 456 base.repository, 457 a.session, 458 base.host.policy, 459 own, 460 unlocked, 461 observe, 462 'reviewed_foreground_inbox' 463 ); 464 return !!sync && startInboxSync(sync, 'reviewed_foreground_inbox'); 465 }, 466 receiveSnapshot: () => 467 finite ? inboxIngressSnapshot(finite) : sync && inboxSyncSnapshot(sync), 468 async older() { 469 if (!sync) throw Error('actual foreground sync'); 470 older ??= captureOlderInbox(sync, 'reviewed_load_older'); 471 return !!older && loadOlderInbox(older, 'reviewed_load_older'); 472 }, 473 olderSnapshot: () => older && olderInboxSnapshot(older), 474 stopReceive() { 475 if (older) stopOlderInbox(older); 476 if (finite) stopInboxIngress(finite); 477 if (sync) stopInboxSync(sync); 478 }, 479 async decryptStored() { 480 const a = base.actors(); 481 unlocked ??= captureUnlockedSession( 482 a.session, 483 'reviewed_messages_unlock' 484 ); 485 if (!unlocked) throw Error('actual explicit unlock'); 486 queue ??= captureDecryptionQueue( 487 base.repository, 488 a.session, 489 a.identity, 490 unlocked, 491 'reviewed_inbox_unlock' 492 ); 493 if (!queue) throw Error('actual explicit decryption queue'); 494 const before = base.host.counts(); 495 const result = await runDecryptionBatch( 496 queue, 497 'reviewed_decrypt_batch', 498 [] 499 ); 500 return { 501 result, 502 snapshot: decryptionQueueSnapshot(queue), 503 rooms: decryptionQueueConversations(queue).length, 504 before, 505 after: base.host.counts() 506 }; 507 }, 508 async retain(raw?: string, cancellation?: AbortSignal) { 509 const a = base.actors(); 510 const envelope = admitInboxEnvelope( 511 raw ?? (await selfWire()), 512 base.host.owner, 513 'wss://inbox.example.org', 514 Date.now() 515 ); 516 return envelope 517 ? ( 518 await retainInboxEnvelope( 519 base.repository, 520 a.session, 521 envelope, 522 cancellation 523 ) 524 ).status 525 : 'invalid'; 526 }, 527 close() { 528 if (queue) stopDecryptionQueue(queue); 529 if (older) stopOlderInbox(older); 530 if (finite) stopInboxIngress(finite); 531 if (sync) stopInboxSync(sync); 532 for (const view of views) disposePublicView(view); 533 base.close(); 534 } 535 }; 536 }