resume-preparation.ts (12452B)
1 import { 2 finalizeEvent, 3 getPublicKey, 4 type UnsignedEvent 5 } from 'applesauce-core/helpers'; 6 import { nip44 } from 'applesauce-core/helpers/encryption'; 7 import { verifyEnvelope } from '../../../src/lib/nostr/verified-envelope.ts'; 8 import { 9 createIdentitySession, 10 connectIdentity, 11 probeIdentityMessaging, 12 disconnectIdentity 13 } from '../../../src/lib/runtime/identity-session.ts'; 14 import { 15 openBrowserDatabase, 16 closeBrowserDatabase, 17 browserDatabaseTransaction 18 } from '../../../src/lib/persistence/database.ts'; 19 import { 20 createPrivateStorageRepository, 21 loadPrivateRecord 22 } from '../../../src/lib/persistence/private-storage.ts'; 23 import { 24 privateRecordSnapshot, 25 privateRecordWire, 26 decodePrivateRecord 27 } from '../../../src/lib/persistence/private-records.ts'; 28 import { createPrivateSendReservationRepository } from '../../../src/lib/persistence/private-send-reservations.ts'; 29 import { captureEnquiryContext } from '../../../src/lib/messaging/enquiry-context.ts'; 30 import { 31 captureEnquiryRumor, 32 stopRumorPlan, 33 rumorPlanSnapshot 34 } from '../../../src/lib/messaging/rumor-plan.ts'; 35 import { 36 reserveSendIdentity, 37 reservedSendSnapshot 38 } from '../../../src/lib/messaging/send-identity.ts'; 39 import { 40 captureSelfRecoveryPreparation, 41 prepareSelfRecovery, 42 stopSelfRecoveryPreparation 43 } from '../../../src/lib/messaging/prepare-send.ts'; 44 import { 45 browserExtensionScheduler, 46 extensionSchedulerSnapshot 47 } from '../../../src/lib/nostr/extension-scheduler.ts'; 48 import { validateRelayPolicy } from '../../../src/lib/config/relays.ts'; 49 import { 50 createPublicScheduler, 51 createPublicRun, 52 openInboxRequest, 53 closePublicScheduler 54 } from '../../../src/lib/nostr/request-scope.ts'; 55 import { createInboxResolver } from '../../../src/lib/messaging/resolve-inbox.ts'; 56 import { createInboxRoutePlan } from '../../../src/lib/messaging/inbox-routing.ts'; 57 import { 58 captureResumePreparation, 59 resumeEncryptedPreparation, 60 resumePreparationSnapshot, 61 resumeRecoveredRumor, 62 stopResumePreparation 63 } from '../../../src/lib/messaging/resume-preparation.ts'; 64 export { 65 captureResumePreparation, 66 resumeEncryptedPreparation, 67 resumePreparationSnapshot, 68 resumeRecoveredRumor, 69 stopResumePreparation, 70 rumorPlanSnapshot 71 }; 72 // Public disposable fixture keys, never installed operator credentials. Stable 73 // only so an actual page reload can unlock the same actual stored ciphertext. 74 const command = '12345678-1234-4234-8234-123456789abc', 75 marker = 'HCP083_PRIVATE_RECOVERY_MEMORY_ONLY_SENTINEL'; 76 type Mode = 77 | 'normal' 78 | 'changed_key' 79 | 'hold_decrypt' 80 | 'declined_decrypt' 81 | 'wrong_plaintext'; 82 export async function makeFixture(initialise = true) { 83 const secret = new Uint8Array(32).fill(83), 84 peerSecret = new Uint8Array(32).fill(84), 85 owner = getPublicKey(secret), 86 peer = getPublicKey(peerSecret); 87 let mode: Mode = 'normal', 88 keys = 0, 89 encrypts = 0, 90 decrypts = 0, 91 signs = 0, 92 release: (() => void) | undefined; 93 function encrypt(target: string, text: string) { 94 const conversation = nip44.v2.utils.getConversationKey(secret, target); 95 try { 96 return nip44.v2.encrypt(text, conversation); 97 } finally { 98 conversation.fill(0); 99 } 100 } 101 function decrypt(target: string, wire: string) { 102 const conversation = nip44.v2.utils.getConversationKey(secret, target); 103 try { 104 return nip44.v2.decrypt(wire, conversation); 105 } finally { 106 conversation.fill(0); 107 } 108 } 109 Object.defineProperty(window, 'nostr', { 110 configurable: true, 111 value: { 112 getPublicKey: () => { 113 keys++; 114 return Promise.resolve(mode === 'changed_key' ? peer : owner); 115 }, 116 signEvent: (template: UnsignedEvent) => { 117 signs++; 118 return Promise.resolve(finalizeEvent(template, secret)); 119 }, 120 nip44: { 121 encrypt: (target: string, text: string) => { 122 encrypts++; 123 return Promise.resolve(encrypt(target, text)); 124 }, 125 decrypt: (target: string, wire: string) => { 126 decrypts++; 127 if (mode === 'declined_decrypt') 128 return Promise.reject(Error('controlled decryption refusal')); 129 const work = () => 130 mode === 'wrong_plaintext' ? '{}' : decrypt(target, wire); 131 return mode === 'hold_decrypt' 132 ? new Promise<string>((resolve) => { 133 release = () => resolve(work()); 134 }) 135 : Promise.resolve(work()); 136 } 137 } 138 } 139 }); 140 const identity = createIdentitySession(); 141 await connectIdentity(identity); 142 await probeIdentityMessaging(identity, 'reviewed_self_copy'); 143 const opened = await openBrowserDatabase(); 144 if (opened.state !== 'ready') throw Error('fixture storage unavailable'); 145 const database = opened.owner, 146 repository = createPrivateStorageRepository(database, owner); 147 if (!repository) throw Error('fixture namespace unavailable'); 148 if (initialise) { 149 const listing = finalizeEvent( 150 { 151 kind: 30402, 152 created_at: 1700000060, 153 content: 'Public carrots', 154 tags: [ 155 ['d', 'carrots'], 156 ['title', 'Carrots'], 157 ['summary', 'Fresh carrots'], 158 ['published_at', '1700000000'], 159 ['location', 'Victoria'], 160 ['price', '3.5', 'CAD'], 161 ['radroots:price_unit', 'lb'], 162 ['status', 'active'] 163 ] 164 }, 165 peerSecret 166 ); 167 const verified = verifyEnvelope(JSON.stringify(listing)), 168 context = verified.ok && captureEnquiryContext(verified.value), 169 observed = Date.now(); 170 const plan = 171 context && 172 captureEnquiryRumor( 173 identity, 174 context, 175 marker, 176 Math.floor(observed / 1000) 177 ); 178 const reservations = createPrivateSendReservationRepository( 179 database, 180 owner 181 ); 182 if (!plan || !reservations) 183 throw Error('fixture original intent unavailable'); 184 const realNow = Date.now; 185 Date.now = () => observed; 186 let reserved: Awaited<ReturnType<typeof reserveSendIdentity>>; 187 try { 188 reserved = await reserveSendIdentity( 189 reservations, 190 identity, 191 command, 192 plan, 193 'reviewed_private_intent' 194 ); 195 } finally { 196 Date.now = realNow; 197 } 198 if (!('identity' in reserved) || !reservedSendSnapshot(reserved.identity)) 199 throw Error('fixture original command unavailable'); 200 const preparation = captureSelfRecoveryPreparation( 201 repository, 202 identity, 203 reserved.identity, 204 'reviewed_self_recovery' 205 ); 206 if ( 207 !preparation || 208 !['saved', 'existing'].includes( 209 (await prepareSelfRecovery(preparation, 'reviewed_self_recovery')) 210 .status 211 ) 212 ) 213 throw Error('fixture actual self save unavailable'); 214 stopSelfRecoveryPreparation(preparation); 215 stopRumorPlan(plan); 216 } 217 const discovery = 'wss://discovery.example.org', 218 archive = 'wss://archive.example.org', 219 destination = 'wss://peer.example.org'; 220 const policy = validateRelayPolicy( 221 JSON.stringify({ 222 schemaVersion: 1, 223 public: [{ origin: discovery, read: true, write: false, nip50: false }], 224 inbox: [archive, destination].map((origin) => ({ 225 origin, 226 read: true, 227 write: true 228 })), 229 postingEnabled: false, 230 messagingEnabled: false, 231 operatorDenylist: [] 232 }) 233 ); 234 if (!policy) throw Error('fixture policy unavailable'); 235 const schedulers: ReturnType<typeof createPublicScheduler>[] = [], 236 tokens: ReturnType<typeof captureResumePreparation>[] = []; 237 let current = true; 238 function resolve(asPeer: boolean) { 239 const event = finalizeEvent( 240 { 241 kind: 10050, 242 created_at: 100, 243 tags: [['relay', asPeer ? destination : archive]], 244 content: '' 245 }, 246 asPeer ? peerSecret : secret 247 ); 248 const scheduler = createPublicScheduler({ 249 now: () => 0, 250 schedule: () => () => {} 251 }); 252 schedulers.push(scheduler); 253 const run = createPublicRun(scheduler, policy!); 254 return createInboxResolver( 255 run, 256 event.pubkey, 257 (next) => 258 openInboxRequest( 259 run, 260 event.pubkey, 261 (sink) => { 262 sink({ type: 'EVENT', from: discovery, id: 'fixture', event }); 263 sink({ type: 'EOSE', from: discovery, id: 'fixture' }); 264 return () => {}; 265 }, 266 next 267 ), 268 () => current 269 ); 270 } 271 const own = resolve(false), 272 other = resolve(true), 273 plan = createInboxRoutePlan(policy, owner, peer, own, other); 274 if (!plan) throw Error('fixture genuine routing unavailable'); 275 async function row() { 276 const loaded = await loadPrivateRecord( 277 repository!, 278 'private_sends', 279 command 280 ); 281 if (!loaded.ok) return undefined; 282 const record = privateRecordSnapshot(loaded.value, owner, command), 283 wire = privateRecordWire(loaded.value, owner, command); 284 return record?.family === 'private_send_operation' && wire 285 ? { record, wire } 286 : undefined; 287 } 288 async function raw() { 289 const tx = browserDatabaseTransaction( 290 database, 291 ['private_sends'], 292 'readonly' 293 ), 294 request = tx.objectStore('private_sends').getAll(); 295 return new Promise<string>((resolve, reject) => { 296 tx.addEventListener('complete', () => 297 resolve(JSON.stringify(request.result)) 298 ); 299 tx.addEventListener('abort', () => reject(Error('fixture read aborted'))); 300 }); 301 } 302 async function write(kind: 'erase' | 'revision' | 'corrupt') { 303 const original = kind === 'revision' ? await row() : undefined; 304 const wire = 305 original && 306 JSON.stringify({ 307 ...original.record, 308 revision: original.record.revision + 1 309 }); 310 if ( 311 kind === 'revision' && 312 (!wire || !decodePrivateRecord(wire, owner, command).ok) 313 ) 314 throw Error('fixture successor unavailable'); 315 const tx = browserDatabaseTransaction( 316 database, 317 ['private_sends'], 318 'readwrite' 319 ), 320 store = tx.objectStore('private_sends'); 321 if (kind === 'erase') store.delete([owner, command]); 322 else 323 store.put({ 324 owner, 325 id: command, 326 wire: kind === 'corrupt' ? '{"schema":999}' : wire 327 }); 328 await new Promise<void>((resolve, reject) => { 329 tx.addEventListener('complete', () => resolve()); 330 tx.addEventListener('abort', () => 331 reject(Error('fixture write aborted')) 332 ); 333 }); 334 } 335 return { 336 owner, 337 peer, 338 command, 339 marker, 340 identity, 341 repository, 342 context: { plan, policy, own, other }, 343 row, 344 raw, 345 write, 346 capture() { 347 const token = captureResumePreparation( 348 repository, 349 identity, 350 command, 351 'reviewed_private_resume' 352 ); 353 if (!token) throw Error('fixture resume unavailable'); 354 tokens.push(token); 355 return token; 356 }, 357 counts: () => ({ keys, encrypts, decrypts, signs }), 358 mode: (next: Mode) => { 359 mode = next; 360 }, 361 settle: () => release?.(), 362 pending: () => { 363 const scheduler = browserExtensionScheduler(), 364 slot = scheduler && extensionSchedulerSnapshot(scheduler); 365 return slot?.state === 'active' && slot.pending === 'decrypt'; 366 }, 367 disconnect: () => disconnectIdentity(identity), 368 decryptPeer(wire: string) { 369 const outer = JSON.parse(wire) as { pubkey: string; content: string }; 370 const conversation = nip44.v2.utils.getConversationKey( 371 peerSecret, 372 outer.pubkey 373 ); 374 let seal: { pubkey: string; content: string }; 375 try { 376 seal = JSON.parse( 377 nip44.v2.decrypt(outer.content, conversation) 378 ) as typeof seal; 379 } finally { 380 conversation.fill(0); 381 } 382 const inner = nip44.v2.utils.getConversationKey(peerSecret, seal.pubkey); 383 try { 384 return JSON.parse(nip44.v2.decrypt(seal.content, inner)) as { 385 id: string; 386 created_at: number; 387 content: string; 388 }; 389 } finally { 390 inner.fill(0); 391 } 392 }, 393 close() { 394 current = false; 395 for (const token of tokens) if (token) stopResumePreparation(token); 396 for (const scheduler of schedulers) closePublicScheduler(scheduler); 397 disconnectIdentity(identity); 398 closeBrowserDatabase(database); 399 secret.fill(0); 400 peerSecret.fill(0); 401 delete window.nostr; 402 } 403 }; 404 }