inbox-retention.ts (10092B)
1 import { makeFixture as makeRecoveryFixture } from './resume-preparation.ts'; 2 import { 3 createPrivateSession, 4 closePrivateSession, 5 privateSessionOwnership 6 } from '../../../src/lib/runtime/private-session.ts'; 7 import { captureUnlockedSession } from '../../../src/lib/messaging/unlocked-session.ts'; 8 import { 9 captureInboxSync, 10 startInboxSync, 11 stopInboxSync, 12 inboxSyncSnapshot, 13 type InboxSync 14 } from '../../../src/lib/messaging/inbox-sync.ts'; 15 import { 16 validateRelayPolicy, 17 readRelayPolicy 18 } from '../../../src/lib/config/relays.ts'; 19 import { 20 captureReceivedCleanup, 21 deleteReviewedReceivedCopies, 22 receivedCleanupSnapshot, 23 stopReceivedCleanup, 24 type ReceivedCleanup 25 } from '../../../src/lib/persistence/inbox-retention.ts'; 26 import { 27 admitInboxEnvelope, 28 retainInboxEnvelope 29 } from '../../../src/lib/persistence/inbox-envelope-repository.ts'; 30 import { 31 listPrivateReceivedRecords, 32 commitPrivateRecord, 33 createPrivateStorageRepository 34 } from '../../../src/lib/persistence/private-storage.ts'; 35 import { 36 decodePrivateRecord, 37 privateRecordIdentity, 38 privateRecordWire, 39 privateRecordSnapshot 40 } from '../../../src/lib/persistence/private-records.ts'; 41 import { 42 openBrowserDatabase, 43 closeBrowserDatabase 44 } from '../../../src/lib/persistence/database.ts'; 45 import { finalizeEvent, getPublicKey } from 'applesauce-core/helpers'; 46 import { nip44 } from 'applesauce-core/helpers/encryption'; 47 export async function makeFixture() { 48 const f = await makeRecoveryFixture(); 49 const session = await createPrivateSession( 50 f.identity, 51 'reviewed_private_session' 52 ); 53 if (!session) throw Error('genuine session absent'); 54 const unlocked = captureUnlockedSession(session, 'reviewed_messages_unlock'); 55 if (!unlocked) throw Error('genuine unlock absent'); 56 const policy = validateRelayPolicy( 57 JSON.stringify({ 58 ...readRelayPolicy(f.context.policy), 59 messagingEnabled: true 60 }) 61 ); 62 if (!policy) throw Error('policy absent'); 63 const initial = (await f.row())!; 64 const originalOutbox = JSON.stringify(initial.record); 65 const ownerSecret = new Uint8Array(32).fill(83), 66 outerSecret = new Uint8Array(32).fill(86), 67 otherSecret = new Uint8Array(32).fill(85), 68 otherOwner = getPublicKey(otherSecret); 69 const ids: string[] = []; 70 let outer: string = '', 71 foreignWire: string = ''; 72 const opened = await openBrowserDatabase(); 73 if (opened.state !== 'ready') throw Error('native database absent'); 74 const foreignRepo = createPrivateStorageRepository(opened.owner, otherOwner); 75 if (!foreignRepo) throw Error('foreign namespace absent'); 76 try { 77 const original = JSON.parse(initial.record.self.wire) as { 78 pubkey: string; 79 content: string; 80 }; 81 const key = nip44.v2.utils.getConversationKey(ownerSecret, original.pubkey); 82 let seal: string; 83 try { 84 seal = nip44.v2.decrypt(original.content, key); 85 } finally { 86 key.fill(0); 87 } 88 function wrap(target: string, n: number) { 89 const k = nip44.v2.utils.getConversationKey(outerSecret, target); 90 try { 91 return finalizeEvent( 92 { 93 kind: 1059, 94 created_at: 1700000000 + n, 95 tags: [['p', target]], 96 content: nip44.v2.encrypt(seal, k) 97 }, 98 outerSecret 99 ); 100 } finally { 101 k.fill(0); 102 } 103 } 104 for (let i = 0; i < 3; i++) { 105 const event = wrap(f.owner, i); 106 const wire = JSON.stringify(event), 107 admitted = admitInboxEnvelope( 108 wire, 109 f.owner, 110 'wss://archive.example.org', 111 100 + i 112 ); 113 if ( 114 !admitted || 115 (await retainInboxEnvelope(f.repository, session, admitted)).status !== 116 'retained' 117 ) 118 throw Error('real retention absent'); 119 ids.push(event.id); 120 if (!i) outer = wire; 121 } 122 const event = wrap(otherOwner, 4), 123 decoded = decodePrivateRecord( 124 JSON.stringify({ 125 schema: 1, 126 family: 'received_envelope', 127 owner: otherOwner, 128 id: event.id, 129 revision: 0, 130 outer: JSON.stringify(event), 131 observedAtMilliseconds: 100, 132 sources: ['wss://archive.example.org'], 133 read: null 134 }), 135 otherOwner, 136 event.id 137 ); 138 if (!decoded.ok) throw Error('foreign structural record absent'); 139 if (!(await commitPrivateRecord(foreignRepo, decoded.value, null)).ok) 140 throw Error('foreign native row absent'); 141 foreignWire = privateRecordWire(decoded.value, otherOwner, event.id)!; 142 } finally { 143 ownerSecret.fill(0); 144 outerSecret.fill(0); 145 otherSecret.fill(0); 146 } 147 let cleanup: ReceivedCleanup | undefined, sync: InboxSync | undefined; 148 let restore = () => {}; 149 const baseline = f.counts(); 150 async function rows() { 151 const result = await listPrivateReceivedRecords(f.repository); 152 if (!result.ok) throw Error('native scan failed'); 153 return result.value.map((h) => ({ 154 id: privateRecordIdentity(h)!.id, 155 wire: privateRecordWire(h, f.owner, privateRecordIdentity(h)!.id)! 156 })); 157 } 158 return { 159 ...f, 160 outer, 161 ids, 162 async select( 163 selected: unknown = ids.slice(0, 2), 164 review: unknown = 'reviewed_received_cleanup_selection' 165 ) { 166 cleanup = await captureReceivedCleanup( 167 f.repository, 168 session, 169 selected, 170 review 171 ); 172 return !!cleanup; 173 }, 174 snapshot: () => cleanup && receivedCleanupSnapshot(cleanup), 175 purge: (review: unknown = 'reviewed_delete_local_received_copies') => 176 cleanup 177 ? deleteReviewedReceivedCopies(cleanup, review) 178 : Promise.resolve({ status: 'invalid' }), 179 copied: () => 180 deleteReviewedReceivedCopies( 181 {} as ReceivedCleanup, 182 'reviewed_delete_local_received_copies' 183 ), 184 rows, 185 async preserved() { 186 const rows = await listPrivateReceivedRecords(foreignRepo); 187 return ( 188 JSON.stringify((await f.row())!.record) === originalOutbox && 189 rows.ok && 190 rows.value.length === 1 && 191 privateRecordWire( 192 rows.value[0], 193 otherOwner, 194 privateRecordIdentity(rows.value[0])!.id 195 ) === foreignWire 196 ); 197 }, 198 delta: () => ({ 199 decrypts: f.counts().decrypts - baseline.decrypts, 200 encrypts: f.counts().encrypts - baseline.encrypts, 201 signs: f.counts().signs - baseline.signs 202 }), 203 logout() { 204 closePrivateSession(session); 205 }, 206 async revise() { 207 const scan = await listPrivateReceivedRecords(f.repository); 208 if (!scan.ok) throw Error('scan absent'); 209 const base = scan.value.find( 210 (h) => privateRecordIdentity(h)?.id === ids[0] 211 )!; 212 const row = privateRecordSnapshot(base, f.owner, ids[0])!; 213 if (row.family !== 'received_envelope') 214 throw Error('received row absent'); 215 const next = decodePrivateRecord( 216 JSON.stringify({ 217 ...row, 218 revision: row.revision + 1, 219 sources: [...row.sources, 'wss://other.example.org'] 220 }), 221 f.owner, 222 ids[0] 223 ); 224 if ( 225 !next.ok || 226 !(await commitPrivateRecord(f.repository, next.value, base)).ok 227 ) 228 throw Error('actual CAS revision failed'); 229 }, 230 fault(kind: 'abort' | 'readback' | 'logout_cursor' | 'stop_cursor') { 231 const remove = Reflect.get<IDBObjectStore, 'delete'>( 232 IDBObjectStore.prototype, 233 'delete' 234 ), 235 cursor = Reflect.get<IDBIndex, 'openCursor'>( 236 IDBIndex.prototype, 237 'openCursor' 238 ); 239 let written = false; 240 IDBObjectStore.prototype.delete = function ( 241 ...args: Parameters<IDBObjectStore['delete']> 242 ) { 243 const request = remove.apply(this, args); 244 if (this.name === 'received_envelopes') { 245 written = true; 246 if (kind === 'abort') this.transaction.abort(); 247 } 248 return request; 249 }; 250 IDBIndex.prototype.openCursor = function ( 251 ...args: Parameters<IDBIndex['openCursor']> 252 ) { 253 if (this.objectStore.name === 'received_envelopes') { 254 if ( 255 kind === 'stop_cursor' && 256 this.objectStore.transaction.mode === 'readwrite' && 257 cleanup 258 ) 259 stopReceivedCleanup(cleanup); 260 if ( 261 kind === 'readback' && 262 written && 263 this.objectStore.transaction.mode === 'readonly' 264 ) 265 throw Error('actual post-delete readback failure'); 266 if ( 267 kind === 'logout_cursor' && 268 this.objectStore.transaction.mode === 'readwrite' 269 ) 270 closePrivateSession(session); 271 } 272 return cursor.apply(this, args); 273 }; 274 restore = () => { 275 IDBObjectStore.prototype.delete = remove; 276 IDBIndex.prototype.openCursor = cursor; 277 }; 278 }, 279 restore() { 280 restore(); 281 }, 282 start() { 283 const ownership = privateSessionOwnership(session)!; 284 sync = captureInboxSync( 285 f.repository, 286 session, 287 policy, 288 f.context.own, 289 unlocked, 290 (c) => ({ 291 ...c, 292 receive: 'qualified_exercised', 293 archive: 'qualified_exercised', 294 current: ownership.current 295 }), 296 'reviewed_foreground_inbox' 297 ); 298 return !!sync && startInboxSync(sync, 'reviewed_foreground_inbox'); 299 }, 300 sync: () => sync && inboxSyncSnapshot(sync), 301 storm(contentBytes = 16) { 302 const secret = new Uint8Array(32).fill(87); 303 try { 304 return finalizeEvent( 305 { 306 kind: 1059, 307 created_at: 1700000000, 308 tags: [['p', f.owner]], 309 content: 'x'.repeat(contentBytes) 310 }, 311 secret 312 ); 313 } finally { 314 secret.fill(0); 315 } 316 }, 317 close() { 318 restore(); 319 if (cleanup) stopReceivedCleanup(cleanup); 320 if (sync) stopInboxSync(sync); 321 closePrivateSession(session); 322 closeBrowserDatabase(opened.owner); 323 f.close(); 324 } 325 }; 326 }