history-pagination.ts (15180B)
1 import { 2 captureOlderInbox, 3 loadOlderInbox, 4 olderInboxSnapshot, 5 stopOlderInbox, 6 type OlderInbox 7 } from '../../../src/lib/messaging/history-pagination.ts'; 8 import { 9 admitInboxEnvelope, 10 retainInboxEnvelope 11 } from '../../../src/lib/persistence/inbox-envelope-repository.ts'; 12 import { 13 createPublicScheduler, 14 createPublicRun, 15 openInboxRequest, 16 closePublicScheduler 17 } from '../../../src/lib/nostr/request-scope.ts'; 18 import { createInboxResolver } from '../../../src/lib/messaging/resolve-inbox.ts'; 19 import { outerHistoryPlan } from '../../../src/lib/messaging/history-cursor.ts'; 20 import { finalizeEvent } from 'applesauce-core/helpers'; 21 import { 22 browserDatabaseTransaction, 23 openBrowserDatabase, 24 closeBrowserDatabase 25 } from '../../../src/lib/persistence/database.ts'; 26 import { decodePrivateRecord } from '../../../src/lib/persistence/private-records.ts'; 27 import { nip44 } from 'applesauce-core/helpers/encryption'; 28 import { 29 captureUnlockedSession, 30 closeUnlockedSession 31 } from '../../../src/lib/messaging/unlocked-session.ts'; 32 import { identitySessionSnapshot } from '../../../src/lib/runtime/identity-session.ts'; 33 import { 34 browserExtensionScheduler, 35 extensionSchedulerSnapshot 36 } from '../../../src/lib/nostr/extension-scheduler.ts'; 37 import { makeFixture as makeRecoveryFixture } from './resume-preparation.ts'; 38 import { 39 validateRelayPolicy, 40 readRelayPolicy 41 } from '../../../src/lib/config/relays.ts'; 42 import { 43 createPrivateSession, 44 closePrivateSession, 45 privateSessionOwnership 46 } from '../../../src/lib/runtime/private-session.ts'; 47 import { 48 captureInboxSync, 49 startInboxSync, 50 stopInboxSync, 51 inboxSyncSnapshot, 52 type InboxSync 53 } from '../../../src/lib/messaging/inbox-sync.ts'; 54 import { 55 loadPrivateRecord, 56 inspectPrivateStorage 57 } from '../../../src/lib/persistence/private-storage.ts'; 58 import { privateRecordSnapshot } from '../../../src/lib/persistence/private-records.ts'; 59 import { 60 getPublicStore, 61 publicStoreEnvelope 62 } from '../../../src/lib/nostr/public-store.ts'; 63 export async function makeFixture( 64 previousOuterCheck?: number, 65 artifactAgeSeconds = 0, 66 newStorage = true 67 ) { 68 outerHistoryPlan(Math.floor(Date.now() / 1000), previousOuterCheck); 69 const originalClock = Date.now; 70 const f = await (async () => { 71 try { 72 if (artifactAgeSeconds) 73 Date.now = () => originalClock() - artifactAgeSeconds * 1000; 74 // Actual SDK creates/signs/persists the original send while this isolated 75 // fixture clock is old. Never edit a signed timestamp or regenerate it at delivery. 76 return await makeRecoveryFixture(newStorage); 77 } finally { 78 Date.now = originalClock; 79 } 80 })(); 81 const policy = validateRelayPolicy( 82 JSON.stringify({ 83 ...readRelayPolicy(f.context.policy), 84 messagingEnabled: true 85 }) 86 ); 87 if (!policy) throw Error('fixture policy unavailable'); 88 const session = await createPrivateSession( 89 f.identity, 90 'reviewed_private_session' 91 ); 92 if (!session) throw Error('missing genuine session'); 93 const capturedSession = session; 94 const capture = privateSessionOwnership(session)!; 95 const unlocked = captureUnlockedSession(session, 'reviewed_messages_unlock'); 96 if (!unlocked) throw Error('missing genuine unlock'); 97 const scheduler = createPublicScheduler({ 98 now: () => 0, 99 schedule: () => () => {} 100 }); 101 const fixtureSecret = new Uint8Array(32).fill(83); 102 let ownEvent: ReturnType<typeof finalizeEvent>; 103 try { 104 ownEvent = finalizeEvent( 105 { 106 kind: 10050, 107 created_at: 101, 108 tags: [ 109 ['relay', 'wss://archive.example.org'], 110 ['relay', 'wss://peer.example.org'] 111 ], 112 content: '' 113 }, 114 fixtureSecret 115 ); 116 } finally { 117 fixtureSecret.fill(0); 118 } 119 const publicRun = createPublicRun(scheduler, policy); 120 const own = createInboxResolver( 121 publicRun, 122 f.owner, 123 (next) => 124 openInboxRequest( 125 publicRun, 126 f.owner, 127 (sink) => { 128 sink({ 129 type: 'EVENT', 130 from: 'wss://discovery.example.org', 131 id: 'fixture', 132 event: ownEvent 133 }); 134 sink({ 135 type: 'EOSE', 136 from: 'wss://discovery.example.org', 137 id: 'fixture' 138 }); 139 return () => {}; 140 }, 141 next 142 ), 143 () => capture.current() 144 ); 145 const publicStore = getPublicStore()!; 146 const self = (await f.row())!.record.self; 147 let ingress: InboxSync | undefined; 148 async function retireOriginalSync() { 149 for (;;) { 150 let incomplete = false; 151 try { 152 if (ingress) stopInboxSync(ingress); 153 } catch (error) { 154 if ( 155 !(error instanceof Error) || 156 error.message !== 'private_inbox_cleanup_required' 157 ) 158 throw error; 159 incomplete = true; 160 } 161 const sessionClean = closePrivateSession(capturedSession); 162 if (!incomplete && sessionClean) { 163 if (ingress && inboxSyncSnapshot(ingress)?.cleanupRequired) 164 throw Error('actual original sync cleanup remains incomplete'); 165 return; 166 } 167 // Retry exact original disposal after its actual SDK close observers; 168 // this wait starts no retrieval, permission or replacement session. 169 await new Promise<void>((resolve) => setTimeout(resolve, 0)); 170 } 171 } 172 173 let older: OlderInbox | undefined; 174 let capacityWires: string[] = [], 175 capacityWrites = 0; 176 let authorized = true; 177 let restoreFault = () => {}; 178 let releaseKey: (() => void) | undefined; 179 let restoreKey = () => {}; 180 return { 181 ...f, 182 outer: self.wire, 183 outerId: self.eventId, 184 oldSignedOuter(createdAt: number) { 185 const ownerSecret = new Uint8Array(32).fill(83), 186 randomSecret = new Uint8Array(32).fill(86); 187 let oldKey: Uint8Array | undefined, nextKey: Uint8Array | undefined; 188 try { 189 const old = JSON.parse(self.wire) as { 190 pubkey: string; 191 content: string; 192 }; 193 oldKey = nip44.v2.utils.getConversationKey(ownerSecret, old.pubkey); 194 const seal = nip44.v2.decrypt(old.content, oldKey); 195 nextKey = nip44.v2.utils.getConversationKey(randomSecret, f.owner); 196 return JSON.stringify( 197 finalizeEvent( 198 { 199 kind: 1059, 200 created_at: createdAt, 201 tags: [['p', f.owner]], 202 content: nip44.v2.encrypt(seal, nextKey) 203 }, 204 randomSecret 205 ) 206 ); 207 } finally { 208 ownerSecret.fill(0); 209 randomSecret.fill(0); 210 oldKey?.fill(0); 211 nextKey?.fill(0); 212 } 213 }, 214 capture( 215 access = true, 216 review: unknown = 'reviewed_foreground_inbox', 217 outerCheck = previousOuterCheck 218 ) { 219 const candidate = captureInboxSync( 220 f.repository, 221 session, 222 policy, 223 own, 224 unlocked, 225 access 226 ? (context) => ({ 227 ...context, 228 receive: 'qualified_exercised', 229 archive: 'qualified_exercised', 230 current: () => authorized && capture.current() 231 }) 232 : undefined, 233 review, 234 outerCheck 235 ); 236 if (candidate) ingress = candidate; 237 return !!candidate; 238 }, 239 start(review: unknown = 'reviewed_foreground_inbox') { 240 if (!ingress) return false; 241 return startInboxSync(ingress, review); 242 }, 243 stop: retireOriginalSync, 244 snapshot: () => ingress && inboxSyncSnapshot(ingress), 245 captureOlder(review: unknown = 'reviewed_load_older') { 246 if (!ingress) return false; 247 const candidate = captureOlderInbox(ingress, review); 248 if (candidate) older = candidate; 249 return !!candidate; 250 }, 251 loadOlder(review: unknown = 'reviewed_load_older') { 252 return older ? loadOlderInbox(older, review) : Promise.resolve(false); 253 }, 254 oldStopAfterSuccessor() { 255 if (!older || !ingress) throw Error('original history controller absent'); 256 const old = older; 257 stopOlderInbox(old); 258 const successor = captureOlderInbox(ingress, 'reviewed_load_older'); 259 if (!successor) throw Error('genuine successor absent'); 260 older = successor; 261 stopOlderInbox(old); 262 const third = captureOlderInbox(ingress, 'reviewed_load_older'); 263 if (third) stopOlderInbox(third); 264 return { 265 successor: !!successor, 266 third: !!third, 267 current: olderInboxSnapshot(successor) 268 }; 269 }, 270 copiedOlderStart() { 271 return older 272 ? loadOlderInbox(Object.freeze({ ...older }), 'reviewed_load_older') 273 : Promise.resolve(false); 274 }, 275 olderSnapshot: () => older && olderInboxSnapshot(older), 276 stopOlder() { 277 if (older) stopOlderInbox(older); 278 }, 279 // Source-only bulk strict ciphertext, not new inner-message/delivery proof. 280 async seedCapacity(source = 'wss://archive.example.org') { 281 const records = Array.from({ length: 2000 }, (_, index) => { 282 const outer = 283 index === 0 284 ? self.wire 285 : this.oldSignedOuter(Math.floor(Date.now() / 1000) - index), 286 event = JSON.parse(outer) as { id: string }; 287 const wire = JSON.stringify({ 288 schema: 1, 289 family: 'received_envelope', 290 owner: f.owner, 291 id: event.id, 292 revision: 0, 293 outer, 294 observedAtMilliseconds: Date.now(), 295 sources: [source], 296 read: null 297 }); 298 if (!decodePrivateRecord(wire, f.owner, event.id).ok) 299 throw Error('strict capacity outer rejected'); 300 return { owner: f.owner, id: event.id, wire }; 301 }); 302 capacityWires = records.map( 303 (row) => (JSON.parse(row.wire) as { outer: string }).outer 304 ); 305 if (new Set(records.map((row) => row.id)).size !== 2000) 306 throw Error('capacity fixture IDs collide'); 307 const opened = await openBrowserDatabase(); 308 if (opened.state !== 'ready') 309 throw Error('owned capacity connection unavailable'); 310 try { 311 const tx = browserDatabaseTransaction( 312 opened.owner, 313 ['received_envelopes'], 314 'readwrite' 315 ); 316 for (const row of records) 317 tx.objectStore('received_envelopes').put(row); 318 await new Promise<void>((resolve, reject) => { 319 tx.addEventListener('complete', () => resolve()); 320 tx.addEventListener('abort', () => 321 reject(Error('capacity seed aborted')) 322 ); 323 }); 324 } finally { 325 closeBrowserDatabase(opened.owner); 326 } 327 const checked = await inspectPrivateStorage( 328 f.repository, 329 'received_envelopes' 330 ); 331 if (!checked.ok || checked.value.count !== 2000) 332 throw Error('actual committed capacity absent'); 333 return checked.value; 334 }, 335 capacityOuterWires: () => capacityWires.slice(0, 500), 336 capacityWriteCount: () => capacityWrites, 337 observeCapacityWrites() { 338 const nativePut = Reflect.get<IDBObjectStore, 'put'>( 339 IDBObjectStore.prototype, 340 'put' 341 ), 342 priorRestore = restoreFault; 343 IDBObjectStore.prototype.put = function (...args) { 344 const request = Reflect.apply(nativePut, this, args); 345 if (this.name === 'received_envelopes') capacityWrites++; 346 return request; 347 }; 348 restoreFault = () => { 349 IDBObjectStore.prototype.put = nativePut; 350 priorRestore(); 351 }; 352 }, 353 async seed(wire: string, origin = 'wss://archive.example.org') { 354 const envelope = admitInboxEnvelope(wire, f.owner, origin, Date.now()); 355 if (!envelope) throw Error('invalid genuinefixture envelope'); 356 const result = await retainInboxEnvelope(f.repository, session, envelope); 357 if (result.status !== 'retained' && result.status !== 'duplicate') 358 throw Error('genuinefixture retention failed'); 359 }, 360 async stored(id = self.eventId) { 361 const row = await loadPrivateRecord( 362 f.repository, 363 'received_envelopes', 364 id 365 ); 366 return row.ok ? privateRecordSnapshot(row.value, f.owner, id) : undefined; 367 }, 368 publicContains: (id = self.eventId) => 369 !!publicStoreEnvelope(publicStore, id), 370 countsValue: () => f.counts(), 371 closeUnlock() { 372 closeUnlockedSession(unlocked); 373 }, 374 navigateAway: retireOriginalSync, 375 changeKey() { 376 f.mode('changed_key'); 377 }, 378 holdNextKey() { 379 const provider = window.nostr as 380 { getPublicKey: () => Promise<string> } | undefined; 381 if (!provider) throw Error('missing genuine fixture provider'); 382 const original = provider.getPublicKey; 383 provider.getPublicKey = async () => { 384 const owner = await original.call(provider); 385 return await new Promise<string>((resolve) => { 386 releaseKey = () => resolve(owner); 387 }); 388 }; 389 restoreKey = () => { 390 provider.getPublicKey = original; 391 }; 392 }, 393 pendingKey: () => !!releaseKey, 394 keyJobOccupied() { 395 const scheduler = browserExtensionScheduler(); 396 const slot = scheduler && extensionSchedulerSnapshot(scheduler); 397 return slot?.state === 'active' && slot.pending === 'key'; 398 }, 399 identityState: () => identitySessionSnapshot(f.identity).state, 400 settleKey() { 401 const release = releaseKey; 402 releaseKey = undefined; 403 restoreKey(); 404 release?.(); 405 }, 406 revokeAccess() { 407 authorized = false; 408 }, 409 logout() { 410 closePrivateSession(session); 411 }, 412 logoutIdentity() { 413 f.disconnect(); 414 closePrivateSession(session); 415 }, 416 restoreFault() { 417 restoreFault(); 418 }, 419 faultRetention(kind: 'abort' | 'readback') { 420 const put = Reflect.get<IDBObjectStore, 'put'>( 421 IDBObjectStore.prototype, 422 'put' 423 ); 424 const cursor = Reflect.get<IDBIndex, 'openCursor'>( 425 IDBIndex.prototype, 426 'openCursor' 427 ); 428 let written = false; 429 IDBObjectStore.prototype.put = function ( 430 ...args: Parameters<IDBObjectStore['put']> 431 ) { 432 const request = put.apply(this, args); 433 if (this.name === 'received_envelopes') { 434 written = true; 435 if (kind === 'abort') this.transaction.abort(); 436 } 437 return request; 438 }; 439 IDBIndex.prototype.openCursor = function ( 440 ...args: Parameters<IDBIndex['openCursor']> 441 ) { 442 if ( 443 kind === 'readback' && 444 written && 445 this.objectStore.name === 'received_envelopes' && 446 this.objectStore.transaction.mode === 'readonly' 447 ) 448 throw Error('actual post-put inbox readback failure'); 449 return cursor.apply(this, args); 450 }; 451 restoreFault = () => { 452 IDBObjectStore.prototype.put = put; 453 IDBIndex.prototype.openCursor = cursor; 454 }; 455 }, 456 async close() { 457 const release = releaseKey; 458 releaseKey = undefined; 459 restoreKey(); 460 release?.(); 461 restoreFault(); 462 if (older) stopOlderInbox(older); 463 closePublicScheduler(scheduler); 464 await retireOriginalSync(); 465 closePrivateSession(session); 466 f.close(); 467 } 468 }; 469 }