inbox-probe-cleanup.ts (20730B)
1 import { makeRetryFixture } from './inbox-probe-retry.ts'; 2 import { 3 captureInboxProbeNonceReader, 4 captureRecoveredInboxProbeNonceReader, 5 readInboxProbeNonce, 6 readRecoveredInboxProbeNonce, 7 type InboxProbeNonceProof, 8 type RecoveredInboxProbeNonceProof 9 } from '../../../src/lib/nostr/self-recovery-reader.ts'; 10 import { 11 commitInboxProbeNonceVerification, 12 type InboxProbeNonceAcknowledgement 13 } from '../../../src/lib/persistence/inbox-probes.ts'; 14 import { 15 captureInboxProbeCleanup, 16 deleteReviewedInboxProbe, 17 stopInboxProbeCleanup, 18 inboxProbeRemovalAcknowledgementBinding, 19 type InboxProbeCleanup, 20 type InboxProbeRemovalAcknowledgement 21 } from '../../../src/lib/persistence/inbox-probe-cleanup.ts'; 22 import { captureInboxProbePublicationAction } from '../../../src/lib/nostr/private-publisher.ts'; 23 import type { 24 InboxProbeArchiveAttemptResult, 25 InboxProbeReadbackAttemptResult 26 } from '../../../src/lib/nostr/private-pool.ts'; 27 import type { PrivateAccessProbe } from '../../../src/lib/persistence/private-records.ts'; 28 import { generateSecretKey, finalizeEvent } from 'applesauce-core/helpers'; 29 import { nip44 } from 'applesauce-core/helpers/encryption'; 30 import { 31 decodePrivateRecord, 32 privateRecordSnapshot 33 } from '../../../src/lib/persistence/private-records.ts'; 34 import { privateRecordSettlement } from '../../../src/lib/persistence/local-inventory.ts'; 35 import { 36 openBrowserDatabase, 37 browserDatabaseTransaction, 38 closeBrowserDatabase 39 } from '../../../src/lib/persistence/database.ts'; 40 import { 41 captureInboxProbeSealOperation, 42 buildInboxProbeSeal 43 } from '../../../src/lib/nostr/seal-builder.ts'; 44 import { buildInboxProbeGiftwrap } from '../../../src/lib/nostr/giftwrap-builder.ts'; 45 import { commitInboxProbe } from '../../../src/lib/persistence/inbox-probes.ts'; 46 export * from './inbox-probe-nonce-facts.ts'; 47 export * from '../../../src/lib/persistence/inbox-probe-cleanup.ts'; 48 export { 49 removePrivateInboxProbe, 50 privateProbeRemovalEvidence 51 } from '../../../src/lib/persistence/private-storage.ts'; 52 export { 53 acquireInboxProbeCleanupLease, 54 releaseInboxProbeCleanupLease, 55 retireInboxProbeCleanupLease, 56 inboxProbePublicationSnapshot, 57 inboxProbeReadbackSnapshot 58 } from '../../../src/lib/nostr/private-publisher.ts'; 59 export { 60 publishInboxProbeArchiveAttempt, 61 readInboxProbeAttempt 62 } from '../../../src/lib/nostr/private-pool.ts'; 63 export { inboxProbeRumorWire } from '../../../src/lib/nostr/inbox-access.ts'; 64 export { inboxAccessConstructionBinding } from '../../../src/lib/messaging/inbox-access-controller.ts'; 65 export { 66 getPrivatePool, 67 closePrivatePool, 68 subscribePrivatePage, 69 subscribePrivateLive 70 } from '../../../src/lib/nostr/private-pool.ts'; 71 export { 72 beginInboxAuthentication, 73 closeInboxAuthentication 74 } from '../../../src/lib/nostr/inbox-auth.ts'; 75 76 export async function makeCleanupFixture() { 77 const base = await makeRetryFixture(); 78 let recovered = false, 79 nonce: InboxProbeNonceAcknowledgement | undefined, 80 proof: InboxProbeNonceProof | RecoveredInboxProbeNonceProof | undefined, 81 cleanup: InboxProbeCleanup | undefined, 82 removal: InboxProbeRemovalAcknowledgement | undefined, 83 observation: InboxProbeReadbackAttemptResult | undefined; 84 const observations: ( 85 InboxProbeArchiveAttemptResult | InboxProbeReadbackAttemptResult 86 )[] = [], 87 restores = new Set<() => void>(); 88 function retain(off: () => void) { 89 restores.add(off); 90 return () => { 91 off(); 92 restores.delete(off); 93 }; 94 } 95 const row = async () => { 96 const found = (await base.host.stored()).find( 97 (x) => x.id === base.command() 98 ); 99 if (!found) throw Error('actual selected row missing'); 100 return JSON.parse(found.wire) as PrivateAccessProbe; 101 }; 102 return { 103 ...base, 104 observations: () => observations.slice(), 105 nonce: () => nonce, 106 nonceProof: () => proof, 107 cleanup: () => cleanup, 108 removal: () => removal, 109 observation: () => observation, 110 async retryOriginalPreparation() { 111 const identity = base.originalIdentity(), 112 a = base.actors(); 113 if (!identity) throw Error('actual original identity'); 114 const operation = captureInboxProbeSealOperation( 115 a.session, 116 identity, 117 'reviewed_inbox_probe_seal' 118 ); 119 if (!operation) return { status: 'capture_refused' }; 120 const sealed = await buildInboxProbeSeal(operation); 121 if (!('seal' in sealed)) return sealed; 122 const wrapped = buildInboxProbeGiftwrap( 123 sealed.seal, 124 'reviewed_inbox_probe_wrap' 125 ); 126 return wrapped 127 ? commitInboxProbe( 128 base.repository, 129 a.session, 130 wrapped, 131 'reviewed_inbox_probe_commit' 132 ) 133 : { status: 'wrap_refused' }; 134 }, 135 async seedPreservedRecords() { 136 const selected = await row(), 137 owner = selected.owner, 138 peer = 139 'c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5', 140 secret = generateSecretKey(), 141 conversation = nip44.v2.utils.getConversationKey(secret, peer); 142 let peerArtifact: { eventId: string; wire: string }; 143 try { 144 const outer = finalizeEvent( 145 { 146 kind: 1059, 147 created_at: selected.createdAt, 148 tags: [['p', peer]], 149 content: nip44.v2.encrypt( 150 'storage-only preservation fixture', 151 conversation 152 ) 153 }, 154 secret 155 ); 156 peerArtifact = { eventId: outer.id, wire: JSON.stringify(outer) }; 157 } finally { 158 conversation.fill(0); 159 secret.fill(0); 160 } 161 const route = ( 162 role: 'peer' | 'self_archive', 163 author: string, 164 origin: string 165 ) => ({ 166 role, 167 author, 168 targets: [origin], 169 knownBase: { author, id: 'c'.repeat(64), createdAt: 100 }, 170 sources: [ 171 { 172 source: 'wss://discovery.example.org', 173 state: 'eose', 174 head: { id: 'c'.repeat(64), createdAt: 100 } 175 } 176 ] 177 }); 178 // Strict native metadata fixtures, not sender capabilities or exchange Q. 179 const ordinary = { 180 schema: 1, 181 family: 'private_send_operation', 182 owner, 183 id: crypto.randomUUID(), 184 revision: 1, 185 peer, 186 rumorHash: selected.rumorHash, 187 createdAt: selected.createdAt, 188 self: selected.self!, 189 peerArtifact, 190 deliveryPlan: { 191 state: 'prepared', 192 routes: { 193 peer: route('peer', peer, 'wss://peer.example.org'), 194 archive: route('self_archive', owner, 'wss://archive.example.org') 195 } 196 }, 197 receipts: [ 198 { 199 actionId: crypto.randomUUID(), 200 origin: 'wss://peer.example.org', 201 role: 'peer', 202 attempt: 1, 203 eventId: peerArtifact.eventId, 204 status: 'accepted', 205 observedAtMilliseconds: 1700000000000, 206 readbackWire: null 207 }, 208 { 209 actionId: crypto.randomUUID(), 210 origin: 'wss://archive.example.org', 211 role: 'self_archive', 212 attempt: 1, 213 eventId: selected.self!.eventId, 214 status: 'accepted', 215 observedAtMilliseconds: 1700000000000, 216 readbackWire: null 217 } 218 ] 219 }, 220 protectedProbe = { ...selected, id: crypto.randomUUID() }, 221 received = { 222 schema: 1, 223 family: 'received_envelope', 224 owner, 225 id: selected.self!.eventId, 226 revision: 0, 227 outer: selected.self!.wire, 228 observedAtMilliseconds: 1700000000000, 229 sources: ['wss://inbox.example.org'], 230 read: null 231 }; 232 const values = [ordinary, protectedProbe, received].map((value) => { 233 const wire = JSON.stringify(value), 234 decoded = decodePrivateRecord(wire, owner, value.id); 235 if (!decoded.ok) throw Error('strict preservation fixture rejected'); 236 const record = privateRecordSnapshot(decoded.value, owner, value.id)!; 237 if (value === ordinary && privateRecordSettlement(record) !== 'settled') 238 throw Error('actual settled metadata required'); 239 return { owner, id: value.id, wire }; 240 }); 241 const opened = await openBrowserDatabase(); 242 if (opened.state !== 'ready') throw Error('actual preservation database'); 243 const database = opened.owner; 244 try { 245 const tx = browserDatabaseTransaction( 246 database, 247 ['private_sends', 'received_envelopes'], 248 'readwrite' 249 ); 250 values.forEach((value, index) => 251 tx 252 .objectStore(index === 2 ? 'received_envelopes' : 'private_sends') 253 .put(value) 254 ); 255 await new Promise<void>((resolve, reject) => { 256 tx.addEventListener('complete', () => resolve()); 257 tx.addEventListener('abort', () => 258 reject(Error('preservation native seed abort')) 259 ); 260 }); 261 } finally { 262 closeBrowserDatabase(database); 263 } 264 return values; 265 }, 266 async receivedRows() { 267 const opened = await openBrowserDatabase(); 268 if (opened.state !== 'ready') throw Error('actual received database'); 269 try { 270 const tx = browserDatabaseTransaction( 271 opened.owner, 272 ['received_envelopes'], 273 'readonly' 274 ), 275 request = tx.objectStore('received_envelopes').getAll(); 276 return await new Promise<{ owner: string; id: string; wire: string }[]>( 277 (resolve, reject) => { 278 tx.addEventListener('complete', () => resolve(request.result)); 279 tx.addEventListener('abort', () => 280 reject(Error('received native observation abort')) 281 ); 282 } 283 ); 284 } finally { 285 closeBrowserDatabase(opened.owner); 286 } 287 }, 288 async qualify( 289 useRecovered = false, 290 options: { fresh?: boolean; skip?: string[]; readOrigin?: string } = {} 291 ) { 292 recovered = useRecovered; 293 observations.length = 0; 294 nonce = undefined; 295 proof = undefined; 296 cleanup = undefined; 297 removal = undefined; 298 if (recovered) { 299 if (options.fresh !== false) await base.freshSession(); 300 if ( 301 (await base.recover())?.status !== 'recovered' || 302 (await base.adopt()).status !== 'adopted' || 303 !(await base.captureAction()) 304 ) 305 throw Error('actual recovered cleanup setup'); 306 } 307 const selected = await row(); 308 for (const origin of selected.binding.archiveTargets) { 309 if (options.skip?.includes(origin)) continue; 310 const result = await (recovered 311 ? base.publish(origin) 312 : base.originalPublish(origin)); 313 if ( 314 !result || 315 result.status !== 'accepted' || 316 (await base.append(result)).status !== 'saved' 317 ) 318 throw Error('actual named archive source and native append'); 319 observations.push(result); 320 } 321 observation = await (recovered 322 ? base.read(options.readOrigin) 323 : base.originalRead(options.readOrigin)); 324 if ( 325 !observation || 326 observation.status !== 'readback' || 327 (await base.appendRead(observation)).status !== 'saved' 328 ) 329 throw Error('actual source readback and native append'); 330 observations.push(observation); 331 const a = base.actors(), 332 reader = ( 333 recovered 334 ? captureRecoveredInboxProbeNonceReader 335 : captureInboxProbeNonceReader 336 )( 337 base.repository, 338 a.identity, 339 a.session, 340 base.host.policy, 341 observation, 342 'reviewed_inbox_probe_nonce_decryption' 343 ); 344 if (!reader) throw Error('actual nonce reader'); 345 const verified = recovered 346 ? await readRecoveredInboxProbeNonce( 347 reader as Parameters<typeof readRecoveredInboxProbeNonce>[0] 348 ) 349 : await readInboxProbeNonce( 350 reader as Parameters<typeof readInboxProbeNonce>[0] 351 ); 352 if (!('proof' in verified)) 353 throw Error('actual nonce verification ' + verified.status); 354 proof = verified.proof; 355 const saved = await commitInboxProbeNonceVerification( 356 base.repository, 357 a.session, 358 base.host.policy, 359 proof 360 ); 361 if (!saved.acknowledgement) 362 throw Error('actual nonce native fact ' + saved.status); 363 nonce = saved.acknowledgement; 364 return saved; 365 }, 366 async select( 367 review: unknown = 'reviewed_inbox_probe_cleanup_selection', 368 input: unknown = observations 369 ) { 370 cleanup = await captureInboxProbeCleanup( 371 base.repository, 372 base.actors().session, 373 base.host.policy, 374 nonce!, 375 input, 376 review 377 ); 378 return cleanup; 379 }, 380 async remove( 381 review: unknown = 'reviewed_delete_local_inbox_probe', 382 selected = cleanup 383 ) { 384 const result = await deleteReviewedInboxProbe(selected!, review); 385 if (result.acknowledgement) removal = result.acknowledgement; 386 return result; 387 }, 388 stopCleanup() { 389 if (cleanup) stopInboxProbeCleanup(cleanup); 390 }, 391 removalBinding: () => 392 removal && 393 inboxProbeRemovalAcknowledgementBinding( 394 removal, 395 base.repository, 396 base.actors().session, 397 base.host.policy 398 ), 399 async withHeld<T>(kind: 'lock' | 'SDK', work: () => Promise<T>) { 400 let release = () => {}, 401 enter = () => {}; 402 const entered = new Promise<void>((resolve) => { 403 enter = resolve; 404 }), 405 wait = new Promise<void>((resolve) => { 406 release = resolve; 407 }), 408 holder = async () => { 409 enter(); 410 await wait; 411 }, 412 held = 413 kind === 'lock' 414 ? navigator.locks.request( 415 'harvestcircle:owner:' + base.host.owner, 416 holder 417 ) 418 : ( 419 await import('../../../src/lib/runtime/private-session.ts') 420 ).withIdlePrivateLocalStorage(base.actors().session, holder); 421 await entered; 422 try { 423 return await work(); 424 } finally { 425 release(); 426 await held; 427 } 428 }, 429 async capacity() { 430 const session = base.actors().session, 431 originals = new Map<string, string>(); 432 for (let index = 0; index < 100; index++) { 433 if (index) { 434 if ( 435 !(await base.replaceController()) || 436 (await base.prepareOriginal()).status !== 'prepared' 437 ) 438 throw Error('actual protected capacity preparation ' + index); 439 } 440 if ( 441 !captureInboxProbePublicationAction( 442 base.repository, 443 session, 444 base.host.policy, 445 base.originalAck()!, 446 'reviewed_inbox_probe_network' 447 ) 448 ) 449 throw Error('actual protected command slot ' + index); 450 const selected = (await base.host.stored()).find( 451 (x) => x.id === base.command() 452 )!; 453 originals.set(selected.id, selected.wire); 454 } 455 const retained = await base.host.stored(); 456 if (retained.length !== 100 || base.actors().session !== session) 457 throw Error('actual same-session full capacity'); 458 await base.replaceController(); 459 const denied = await base.prepareOriginal(); 460 return { session, originals, denied }; 461 }, 462 // Actual native request/complete/abort instrumentation; no success labels. 463 nativeFault( 464 mode: 465 | 'abort' 466 | 'uncertain' 467 | 'complete_loss' 468 | 'read_before' 469 | 'read_after' 470 | 'read_loss' 471 | 'delete_loss' 472 | 'wire_race' 473 | 'initial_read_abort' 474 | 'native_pre_delete_loss', 475 callback = () => {} 476 ) { 477 const remove = Object.getOwnPropertyDescriptor( 478 IDBObjectStore.prototype, 479 'delete' 480 )!.value as IDBObjectStore['delete'], 481 abort = Object.getOwnPropertyDescriptor( 482 IDBTransaction.prototype, 483 'abort' 484 )!.value as IDBTransaction['abort'], 485 cursor = Object.getOwnPropertyDescriptor( 486 IDBIndex.prototype, 487 'openCursor' 488 )!.value as IDBIndex['openCursor'], 489 transaction = Object.getOwnPropertyDescriptor( 490 IDBDatabase.prototype, 491 'transaction' 492 )!.value as IDBDatabase['transaction']; 493 let selected: IDBTransaction | undefined, 494 readonly = 0, 495 deletes = 0, 496 completes = 0, 497 aborts = 0, 498 refused = 0, 499 races = 0; 500 IDBDatabase.prototype.transaction = function ( 501 ...args: Parameters<IDBDatabase['transaction']> 502 ) { 503 if ( 504 mode === 'wire_race' && 505 !races && 506 args[1] === 'readwrite' && 507 Array.from(args[0] as string[]).includes('private_sends') 508 ) { 509 races++; 510 const other = transaction.call(this, ['private_sends'], 'readwrite'), 511 store = other.objectStore('private_sends'), 512 get = store.get([base.host.owner, base.command()!]); 513 get.addEventListener('success', () => { 514 const item = get.result as { 515 owner: string; 516 id: string; 517 wire: string; 518 }, 519 record = JSON.parse(item.wire) as { revision: number }; 520 record.revision++; 521 store.put({ ...item, wire: JSON.stringify(record) }); 522 }); 523 } 524 return transaction.apply(this, args); 525 }; 526 IDBIndex.prototype.openCursor = function ( 527 ...args: Parameters<IDBIndex['openCursor']> 528 ) { 529 const request = cursor.apply(this, args), 530 tx = this.objectStore.transaction; 531 if ( 532 this.objectStore.name === 'private_sends' && 533 tx.mode === 'readonly' 534 ) { 535 readonly++; 536 const hit = readonly; 537 if (mode === 'read_before' && hit === 2) tx.abort(); 538 if (mode === 'read_after' && hit === 2) 539 request.addEventListener('success', () => { 540 if (!request.result) tx.abort(); 541 }); 542 if (mode === 'read_loss' && hit === 1) 543 request.addEventListener('success', () => { 544 if (!request.result) callback(); 545 }); 546 if (mode === 'initial_read_abort' && hit === 1) tx.abort(); 547 } 548 if ( 549 this.objectStore.name === 'private_sends' && 550 tx.mode === 'readwrite' && 551 mode === 'native_pre_delete_loss' 552 ) 553 request.addEventListener('success', () => { 554 if (!request.result) callback(); 555 }); 556 return request; 557 }; 558 IDBTransaction.prototype.abort = function ( 559 ...args: Parameters<IDBTransaction['abort']> 560 ) { 561 if (this === selected && mode === 'uncertain') { 562 refused++; 563 throw Error('controlled actual abort refusal'); 564 } 565 return abort.apply(this, args); 566 }; 567 IDBObjectStore.prototype.delete = function ( 568 ...args: Parameters<IDBObjectStore['delete']> 569 ) { 570 const request = remove.apply(this, args); 571 if (this.name === 'private_sends' && !selected) { 572 deletes++; 573 selected = this.transaction; 574 selected.addEventListener('complete', () => { 575 completes++; 576 if (mode === 'complete_loss') callback(); 577 }); 578 selected.addEventListener('abort', () => { 579 aborts++; 580 }); 581 request.addEventListener('success', () => { 582 if (mode === 'abort') selected!.abort(); 583 if (mode === 'delete_loss') callback(); 584 }); 585 if (mode === 'uncertain') 586 throw Error('controlled throw after actual delete admission'); 587 } 588 return request; 589 }; 590 return { 591 counts: () => ({ 592 readonly, 593 deletes, 594 completes, 595 aborts, 596 refused, 597 races 598 }), 599 restore: retain(() => { 600 IDBObjectStore.prototype.delete = remove; 601 IDBTransaction.prototype.abort = abort; 602 IDBIndex.prototype.openCursor = cursor; 603 IDBDatabase.prototype.transaction = transaction; 604 }) 605 }; 606 }, 607 close() { 608 for (const off of restores) off(); 609 restores.clear(); 610 if (cleanup) stopInboxProbeCleanup(cleanup); 611 base.close(); 612 } 613 }; 614 }