giftwrap-builder.ts (11347B)
1 import { 2 buildPrivateGiftwrap, 3 privateGiftwrapSnapshot 4 } from '../../../src/lib/nostr/giftwrap-builder.ts'; 5 export { buildPrivateGiftwrap, privateGiftwrapSnapshot }; 6 import { 7 finalizeEvent, 8 generateSecretKey, 9 getPublicKey, 10 verifiedSymbol, 11 type UnsignedEvent 12 } from 'applesauce-core/helpers'; 13 import { nip44 } from 'applesauce-core/helpers/encryption'; 14 import { verifyEnvelope } from '../../../src/lib/nostr/verified-envelope.ts'; 15 import { captureEnquiryContext } from '../../../src/lib/messaging/enquiry-context.ts'; 16 import { captureEnquiryRumor } from '../../../src/lib/messaging/rumor-plan.ts'; 17 import { 18 openBrowserDatabase, 19 closeBrowserDatabase, 20 browserDatabaseTransaction 21 } from '../../../src/lib/persistence/database.ts'; 22 import { createPrivateSendReservationRepository } from '../../../src/lib/persistence/private-send-reservations.ts'; 23 import { 24 reserveSendIdentity, 25 reservedSendRumorWire 26 } from '../../../src/lib/messaging/send-identity.ts'; 27 import { 28 createIdentitySession, 29 connectIdentity, 30 probeIdentityMessaging, 31 identitySessionSnapshot, 32 disconnectIdentity 33 } from '../../../src/lib/runtime/identity-session.ts'; 34 import { 35 capturePrivateSealOperation, 36 buildPrivateSeal, 37 stopPrivateSeal, 38 expirePrivateSealWait, 39 privateSealSnapshot 40 } from '../../../src/lib/nostr/seal-builder.ts'; 41 import { 42 browserExtensionScheduler, 43 extensionSchedulerSnapshot 44 } from '../../../src/lib/nostr/extension-scheduler.ts'; 45 export { 46 capturePrivateSealOperation, 47 buildPrivateSeal, 48 stopPrivateSeal, 49 expirePrivateSealWait, 50 privateSealSnapshot 51 }; 52 export type Mode = 53 | 'normal' 54 | 'wrong_cipher' 55 | 'wrong_author' 56 | 'wrong_tags' 57 | 'wrong_time' 58 | 'cached_bad_id' 59 | 'missing' 60 | 'declined' 61 | 'changed_key' 62 | 'hold_encrypt' 63 | 'hold_sign' 64 | 'wrong_plaintext' 65 | 'declined_decrypt' 66 | 'hold_decrypt' 67 | 'getter_reentry' 68 | 'stop_capability_getter' 69 | 'stop_capability_after_key'; 70 // Ephemeral source-only provider: actual stock SDK encryption/signature and real 71 // Chromium IDB/WebLocks. No installed extension/relay/client qualification. 72 export async function makeFixture( 73 inputText: unknown = 'Private seal sentinel' 74 ) { 75 const secret = generateSecretKey(), 76 peerSecret = generateSecretKey(), 77 owner = getPublicKey(secret), 78 peer = getPublicKey(peerSecret); 79 let mode: Mode = 'normal', 80 keys = 0, 81 encrypts = 0, 82 signs = 0, 83 decrypts = 0, 84 capabilityReads = 0, 85 reentrantReads = 0, 86 postStopEncrypts = 0, 87 getterStopped = false, 88 watched: ReturnType<typeof capturePrivateSealOperation>, 89 release: (() => void) | undefined; 90 function encryptTo(target: string, text: string) { 91 const conversation = nip44.v2.utils.getConversationKey(secret, target); 92 try { 93 return nip44.v2.encrypt(text, conversation); 94 } finally { 95 conversation.fill(0); 96 } 97 } 98 function sign(template: UnsignedEvent) { 99 const input = 100 mode === 'wrong_cipher' 101 ? { ...template, content: encryptTo(peer, 'different immutable rumor') } 102 : mode === 'wrong_tags' 103 ? { ...template, tags: [['client', 'leak']] } 104 : mode === 'wrong_time' 105 ? { ...template, created_at: template.created_at + 1 } 106 : template; 107 const signed = finalizeEvent( 108 input, 109 mode === 'wrong_author' ? peerSecret : secret 110 ); 111 return mode === 'cached_bad_id' 112 ? { ...signed, id: '0'.repeat(64), [verifiedSymbol]: true } 113 : { 114 ...signed, 115 plaintext: 'never retained sentinel', 116 toJSON: () => { 117 throw Error('unexpected provider conversion'); 118 } 119 }; 120 } 121 const provider = { 122 getPublicKey: () => { 123 keys++; 124 return Promise.resolve(mode === 'changed_key' ? peer : owner); 125 }, 126 signEvent: (template: UnsignedEvent) => { 127 signs++; 128 return mode === 'hold_sign' 129 ? new Promise<ReturnType<typeof sign>>((resolve) => { 130 release = () => resolve(sign(template)); 131 }) 132 : Promise.resolve(sign(template)); 133 }, 134 get nip44() { 135 capabilityReads++; 136 if ( 137 watched && 138 (mode === 'stop_capability_getter' || 139 (mode === 'stop_capability_after_key' && capabilityReads === 2)) 140 ) { 141 stopPrivateSeal(watched); 142 return undefined; 143 } 144 return mode === 'missing' 145 ? undefined 146 : { 147 get encrypt() { 148 const scheduler = browserExtensionScheduler(), 149 slot = scheduler && extensionSchedulerSnapshot(scheduler); 150 if ( 151 mode === 'getter_reentry' && 152 watched && 153 slot && 154 slot.state === 'active' && 155 slot.pending === 'encrypt' 156 ) { 157 reentrantReads++; 158 getterStopped = true; 159 stopPrivateSeal(watched); 160 } 161 return (target: string, text: string) => { 162 encrypts++; 163 if (getterStopped) postStopEncrypts++; 164 if (mode === 'declined') 165 return Promise.reject(Error('private failure must not leak')); 166 if (mode === 'hold_encrypt') 167 return new Promise<string>((resolve) => { 168 release = () => resolve(encryptTo(target, text)); 169 }); 170 return Promise.resolve( 171 encryptTo( 172 target, 173 mode === 'wrong_plaintext' ? 'substitute rumor' : text 174 ) 175 ); 176 }; 177 }, 178 decrypt: (target: string, cipher: string) => { 179 decrypts++; 180 if (mode === 'declined_decrypt') 181 return Promise.reject(Error('decrypt refused')); 182 const decryptNow = () => { 183 const conversation = nip44.v2.utils.getConversationKey( 184 secret, 185 target 186 ); 187 try { 188 return nip44.v2.decrypt(cipher, conversation); 189 } finally { 190 conversation.fill(0); 191 } 192 }; 193 if (mode === 'hold_decrypt') 194 return new Promise<string>((resolve) => { 195 release = () => resolve(decryptNow()); 196 }); 197 return Promise.resolve(decryptNow()); 198 } 199 }; 200 } 201 }; 202 Object.defineProperty(window, 'nostr', { 203 configurable: true, 204 value: provider 205 }); 206 const identity = createIdentitySession(); 207 await connectIdentity(identity); 208 await probeIdentityMessaging(identity, 'reviewed_self_copy'); 209 const food = finalizeEvent( 210 { 211 kind: 30402, 212 created_at: 1700000060, 213 content: 'Public carrots', 214 tags: [ 215 ['d', 'carrots'], 216 ['title', 'Carrots'], 217 ['summary', 'Fresh carrots'], 218 ['published_at', '1700000000'], 219 ['location', 'Victoria'], 220 ['price', '3.5', 'CAD'], 221 ['radroots:price_unit', 'lb'], 222 ['status', 'active'] 223 ] 224 }, 225 peerSecret 226 ); 227 const proof = verifyEnvelope(JSON.stringify(food)); 228 if (!proof.ok) throw Error('invalid public fixture'); 229 const context = captureEnquiryContext(proof.value); 230 if (!context) throw Error('invalid context'); 231 const reservationTime = Date.now(); 232 const plan = captureEnquiryRumor( 233 identity, 234 context, 235 inputText, 236 Math.floor(reservationTime / 1000) 237 ); 238 if (!plan) throw Error('missing plan'); 239 const opened = await openBrowserDatabase(); 240 if (opened.state !== 'ready') throw Error('missing database'); 241 const database = opened.owner, 242 repository = createPrivateSendReservationRepository(database, owner); 243 if (!repository) throw Error('missing repository'); 244 // Controlled fixture second across actual asynchronous IDB/WebLock setup. 245 // Production admission still requires its real current observed second. 246 const liveNow = Date.now; 247 let reservation: Awaited<ReturnType<typeof reserveSendIdentity>>; 248 Date.now = () => reservationTime; 249 try { 250 reservation = await reserveSendIdentity( 251 repository, 252 identity, 253 '12345678-1234-4234-8234-123456789abc', 254 plan, 255 'reviewed_private_intent' 256 ); 257 } finally { 258 Date.now = liveNow; 259 } 260 if (reservation.status !== 'reserved') 261 throw Error('missing reservation: ' + reservation.status); 262 const reserved = reservation.identity; 263 const original = reservedSendRumorWire(reserved); 264 return { 265 owner, 266 peer, 267 identity, 268 reserved, 269 textPlan: (text: unknown) => 270 captureEnquiryRumor( 271 identity, 272 context, 273 text, 274 Math.floor(Date.now() / 1000) 275 ), 276 async reserveAgain() { 277 const result = await reserveSendIdentity( 278 repository, 279 identity, 280 '12345678-1234-4234-8234-123456789abc', 281 plan, 282 'reviewed_private_intent' 283 ); 284 if (result.status !== 'existing' && result.status !== 'reserved') 285 throw Error('missing second reservation'); 286 return result.identity; 287 }, 288 operation: ( 289 role: unknown = 'peer', 290 review: unknown = 'reviewed_private_seal' 291 ) => { 292 watched = capturePrivateSealOperation(identity, reserved, role, review); 293 return watched; 294 }, 295 mode: (value: Mode) => { 296 mode = value; 297 capabilityReads = 0; 298 }, 299 counts: () => ({ 300 keys, 301 encrypts, 302 decrypts, 303 signs, 304 reentrantReads, 305 postStopEncrypts 306 }), 307 identityState: () => identitySessionSnapshot(identity).state, 308 settle: () => { 309 release?.(); 310 }, 311 slot: () => { 312 const scheduler = browserExtensionScheduler(); 313 return scheduler ? extensionSchedulerSnapshot(scheduler) : undefined; 314 }, 315 disconnect: () => disconnectIdentity(identity), 316 async stored() { 317 const tx = browserDatabaseTransaction( 318 database, 319 ['private_sends'], 320 'readonly' 321 ), 322 request = tx.objectStore('private_sends').getAll(); 323 return await new Promise<string>((resolve, reject) => { 324 tx.addEventListener('complete', () => 325 resolve(JSON.stringify(request.result)) 326 ); 327 tx.addEventListener('abort', () => reject(Error('inspection aborted'))); 328 }); 329 }, 330 decryptWrap(wire: string, role: 'peer' | 'self') { 331 const wrap = JSON.parse(wire) as { pubkey: string; content: string }; 332 const conversation = nip44.v2.utils.getConversationKey( 333 role === 'peer' ? peerSecret : secret, 334 wrap.pubkey 335 ); 336 try { 337 return nip44.v2.decrypt(wrap.content, conversation); 338 } finally { 339 conversation.fill(0); 340 } 341 }, 342 decrypt(wire: string, role: 'peer' | 'self') { 343 const seal = JSON.parse(wire) as { content: string }; 344 const conversation = nip44.v2.utils.getConversationKey( 345 role === 'peer' ? peerSecret : secret, 346 owner 347 ); 348 try { 349 return { 350 equal: nip44.v2.decrypt(seal.content, conversation) === original, 351 seal 352 }; 353 } finally { 354 conversation.fill(0); 355 } 356 }, 357 close() { 358 disconnectIdentity(identity); 359 closeBrowserDatabase(database); 360 secret.fill(0); 361 peerSecret.fill(0); 362 delete window.nostr; 363 } 364 }; 365 }