retry-listing.ts (17019B)
1 export const secondOrigin = 'wss://second.example.org'; 2 function retryPolicy(twoTargets = false, changed = false) { 3 const manifest = readRelayPolicy(fixturePolicy()); 4 const policy = validateRelayPolicy( 5 JSON.stringify({ 6 ...manifest, 7 public: twoTargets 8 ? [ 9 ...manifest.public, 10 { 11 origin: changed ? 'wss://changed.example.org' : secondOrigin, 12 read: true, 13 write: true, 14 nip50: false 15 } 16 ] 17 : manifest.public 18 }) 19 ); 20 if (!policy) throw Error('controlled policy invalid'); 21 return policy; 22 } 23 import { deliverListing } from '../../../src/lib/publishing/deliver-listing.ts'; 24 import { 25 getPublicPool, 26 closePublicPool 27 } from '../../../src/lib/nostr/public-pool.ts'; 28 import { 29 readRelayPolicy, 30 publicRelayTargets, 31 validateRelayPolicy 32 } from '../../../src/lib/config/relays.ts'; 33 import { 34 beginListingRetry, 35 listingRetryResult, 36 stopListingRetry, 37 type ListingRetry 38 } from '../../../src/lib/publishing/retry-listing.ts'; 39 import { 40 prepareListingResume, 41 resumeListing, 42 listingResumeSnapshot 43 } from '../../../src/lib/publishing/resume-listing.ts'; 44 import { makeFixture } from './approved-signing.ts'; 45 import { fixturePolicy, discovery, inbox } from './inbox-setup.ts'; 46 import { 47 createIdentitySession, 48 connectIdentity, 49 probeIdentityMessaging, 50 disconnectIdentity 51 } from '../../../src/lib/runtime/identity-session.ts'; 52 import { 53 createPublicScheduler, 54 createPublicRun, 55 openInboxRequest, 56 closePublicScheduler 57 } from '../../../src/lib/nostr/request-scope.ts'; 58 import { createInboxResolver } from '../../../src/lib/messaging/resolve-inbox.ts'; 59 import { 60 createInboxSetupView, 61 checkInboxSetupView, 62 unlockInboxSetupView, 63 closeInboxSetupView 64 } from '../../../src/lib/messaging/inbox-setup-view.ts'; 65 import { captureNewListingReadiness } from '../../../src/lib/publishing/new-listing-readiness.ts'; 66 import { 67 openBrowserDatabase, 68 closeBrowserDatabase 69 } from '../../../src/lib/persistence/database.ts'; 70 import { 71 createPublicPublicationRepository, 72 publicPublicationDraftRepository, 73 readPublicListingIntent 74 } from '../../../src/lib/persistence/public-publications.ts'; 75 import { 76 createPublicDraftController, 77 closePublicDraftController 78 } from '../../../src/lib/publishing/draft-controller.ts'; 79 import { 80 reviewNewListing, 81 reserveNewListing, 82 listingReviewSnapshot 83 } from '../../../src/lib/publishing/prepare-listing.ts'; 84 import { publicRecordSnapshot } from '../../../src/lib/persistence/records.ts'; 85 import { 86 beginListingSigning, 87 runListingSigning, 88 listingPublicationSnapshot 89 } from '../../../src/lib/publishing/sign-listing.ts'; 90 91 export async function createFixture(twoTargets = false) { 92 const trace: string[] = []; 93 const tracePut = Object.getOwnPropertyDescriptor( 94 IDBObjectStore.prototype, 95 'put' 96 ), 97 traceSend = Object.getOwnPropertyDescriptor(WebSocket.prototype, 'send'); 98 if (!tracePut) throw Error('native trace descriptors missing'); 99 const nativeTracePut = tracePut.value as IDBObjectStore['put'], 100 nativeTraceSend = Reflect.get<WebSocket, 'send'>( 101 WebSocket.prototype, 102 'send' 103 ); 104 Object.defineProperty(IDBObjectStore.prototype, 'put', { 105 ...tracePut, 106 value: function ( 107 this: IDBObjectStore, 108 ...args: Parameters<IDBObjectStore['put']> 109 ) { 110 const value: unknown = args[0]; 111 if ( 112 this.name === 'public_operations' && 113 typeof value === 'object' && 114 value && 115 'wire' in value && 116 typeof value.wire === 'string' 117 ) { 118 const revision = (JSON.parse(value.wire) as { revision: number }) 119 .revision; 120 this.transaction.addEventListener( 121 'complete', 122 () => trace.push('ack:' + revision), 123 { once: true } 124 ); 125 } 126 return nativeTracePut.apply(this, args); 127 } 128 }); 129 Object.defineProperty(WebSocket.prototype, 'send', { 130 configurable: true, 131 writable: true, 132 ...traceSend, 133 value: function (this: WebSocket, ...args: Parameters<WebSocket['send']>) { 134 if ( 135 typeof args[0] === 'string' && 136 (JSON.parse(args[0]) as unknown[])[0] === 'EVENT' 137 ) 138 trace.push('EVENT'); 139 return nativeTraceSend.apply(this, args); 140 } 141 }); 142 const signer = makeFixture(10050), 143 identity = createIdentitySession(), 144 policy = retryPolicy(twoTargets); 145 const preference = signer.sign({ 146 ...signer.template, 147 kind: 10050, 148 created_at: 100, 149 tags: [['relay', inbox]], 150 content: '' 151 }); 152 const prior = Object.getOwnPropertyDescriptor(window, 'nostr'); 153 let signs = 0, 154 keys = 0; 155 const observedOwner = signer.owner; 156 Object.defineProperty(window, 'nostr', { 157 configurable: true, 158 value: { 159 getPublicKey: () => { 160 keys++; 161 return Promise.resolve(observedOwner); 162 }, 163 signEvent: (input: Parameters<typeof signer.sign>[0]) => { 164 signs++; 165 return Promise.resolve(signer.sign(input)); 166 }, 167 nip44: { 168 encrypt: (_peer: string, text: string) => 169 Promise.resolve('fixture:' + text), 170 decrypt: (_peer: string, text: string) => Promise.resolve(text.slice(8)) 171 } 172 } 173 }); 174 await connectIdentity(identity); 175 await probeIdentityMessaging(identity, 'reviewed_self_copy'); 176 const scheduler = createPublicScheduler({ 177 now: () => 0, 178 schedule: () => () => {} 179 }); 180 const run = createPublicRun(scheduler, policy); 181 const resolver = createInboxResolver( 182 run, 183 signer.owner, 184 (next) => 185 openInboxRequest( 186 run, 187 signer.owner, 188 (sink) => { 189 sink({ 190 type: 'EVENT', 191 from: discovery, 192 id: 'fixture', 193 event: preference 194 }); 195 for (const origin of publicRelayTargets(policy, 'read')) 196 sink({ type: 'EOSE', from: origin, id: 'fixture' }); 197 return () => {}; 198 }, 199 next 200 ), 201 () => true 202 ); 203 // HC_TEST_ONLY_QUALIFICATION_PORT: original SDK owners, controlled exercised 204 // access observation; no real extension/operator/relay qualification. 205 const setup = createInboxSetupView({ 206 identity, 207 policy, 208 lookup: () => Promise.resolve(resolver), 209 observeAccess: (context) => ({ 210 ...context, 211 readTargets: context.readTargets.slice(), 212 archiveTargets: context.archiveTargets.slice(), 213 receive: 'qualified_exercised', 214 archive: 'qualified_exercised', 215 current: () => true 216 }) 217 }); 218 if (!setup) throw Error('original setup missing'); 219 await checkInboxSetupView(setup); 220 await unlockInboxSetupView(setup); 221 const ready = captureNewListingReadiness( 222 identity, 223 setup, 224 'reviewed_new_listing_inbox' 225 ); 226 if (!ready) throw Error('original readiness missing'); 227 const opened = await openBrowserDatabase(); 228 if (opened.state !== 'ready') throw Error(opened.reason); 229 const database = opened.owner, 230 repository = createPublicPublicationRepository(database, signer.owner); 231 const drafts = repository && publicPublicationDraftRepository(repository); 232 if (!repository || !drafts) throw Error('original repository missing'); 233 const originalRepository = repository; 234 const controller = await createPublicDraftController(drafts, { 235 title: 'Carrots', 236 description: 'Exact signed description', 237 location: 'Local farm', 238 amount: '2', 239 currency: 'USD', 240 unit: 'kg', 241 quantity: '', 242 contactType: '', 243 contactValue: '' 244 }); 245 if (!controller) throw Error('original controller missing'); 246 const command = crypto.randomUUID(); 247 const reviewed = await reviewNewListing( 248 repository, 249 controller, 250 ready, 251 command, 252 'reviewed_new_listing' 253 ); 254 if (reviewed.status !== 'review') throw Error(reviewed.reason); 255 const original = reviewed.review, 256 preview = listingReviewSnapshot(original); 257 if (!preview) throw Error('original preview missing'); 258 const reserved = await reserveNewListing( 259 original, 260 'publish_reviewed_listing' 261 ); 262 if (reserved.status !== 'saved') throw Error(reserved.status); 263 const signing = beginListingSigning(original, 'sign_reviewed_listing'); 264 if (!signing) throw Error('original signing missing'); 265 const originalSigning = signing; 266 async function stored() { 267 const read = await readPublicListingIntent(originalRepository, command); 268 const row = 269 read.status === 'found' && 270 publicRecordSnapshot(read.record, signer.owner, command); 271 if (!row || row.family !== 'public_operation') 272 throw Error('original stored command missing'); 273 return row; 274 } 275 function invoke() { 276 return runListingSigning(originalSigning, 'sign_reviewed_listing'); 277 } 278 const signed = await invoke(); 279 if (signed.status !== 'prepared') throw Error(signed.status); 280 const publication = signed.publication, 281 pool = getPublicPool(policy); 282 if (!pool) throw Error('original public pool missing'); 283 const cleanupPool = pool; 284 let control: ListingRetry | undefined; 285 let closed = false; 286 function close() { 287 if (closed) return; 288 closed = true; 289 if (control) stopListingRetry(control); 290 closePublicPool(cleanupPool); 291 if (controller) closePublicDraftController(controller); 292 closeBrowserDatabase(database); 293 closeInboxSetupView(setup); 294 disconnectIdentity(identity); 295 closePublicScheduler(scheduler); 296 signer.close(); 297 if (prior) Object.defineProperty(window, 'nostr', prior); 298 else Reflect.deleteProperty(window, 'nostr'); 299 if (tracePut) 300 Object.defineProperty(IDBObjectStore.prototype, 'put', tracePut); 301 else Reflect.deleteProperty(IDBObjectStore.prototype, 'put'); 302 if (traceSend) 303 Object.defineProperty(WebSocket.prototype, 'send', traceSend); 304 else Reflect.deleteProperty(WebSocket.prototype, 'send'); 305 } 306 return { 307 owner: signer.owner, 308 command, 309 policy, 310 async details() { 311 const row = await stored(); 312 return { 313 row, 314 signs, 315 keys, 316 trace: trace.slice(), 317 wire: listingPublicationSnapshot(publication)?.wire 318 }; 319 }, 320 start() { 321 control = beginListingRetry( 322 publication, 323 pool, 324 policy, 325 'retry_stored_listing' 326 ); 327 return !!control; 328 }, 329 async result() { 330 if (!control) throw Error('original retry missing'); 331 return await listingRetryResult(control); 332 }, 333 stop() { 334 if (control) stopListingRetry(control); 335 }, 336 copiedStop() { 337 if (control) stopListingRetry({ ...control }); 338 }, 339 async initial() { 340 return await deliverListing( 341 publication, 342 pool, 343 policy, 344 'publish_stored_listing' 345 ); 346 }, 347 close 348 }; 349 } 350 export async function openResumeFixture( 351 owner: string, 352 command: string, 353 twoTargets = false, 354 changed = false 355 ) { 356 const prior = Object.getOwnPropertyDescriptor(window, 'nostr'); 357 let observedOwner = owner, 358 signs = 0, 359 keys = 0, 360 heldKeys = 0, 361 completed = false; 362 let keyHold: Promise<string> | undefined, release: (() => void) | undefined; 363 Object.defineProperty(window, 'nostr', { 364 configurable: true, 365 value: { 366 getPublicKey() { 367 keys++; 368 if (keyHold) heldKeys++; 369 return keyHold ?? Promise.resolve(observedOwner); 370 }, 371 signEvent() { 372 signs++; 373 return Promise.reject( 374 Error( 375 'HC_TEST_ONLY resumed artifact must never request another signature' 376 ) 377 ); 378 }, 379 nip44: { 380 encrypt: (_peer: string, text: string) => 381 Promise.resolve('fixture:' + text), 382 decrypt: (_peer: string, text: string) => Promise.resolve(text.slice(8)) 383 } 384 } 385 }); 386 const identity = createIdentitySession(); 387 await connectIdentity(identity); 388 await probeIdentityMessaging(identity, 'reviewed_self_copy'); 389 const opened = await openBrowserDatabase(); 390 if (opened.state !== 'ready') throw Error(opened.reason); 391 const database = opened.owner, 392 repository = createPublicPublicationRepository(database, owner), 393 policy = retryPolicy(twoTargets, changed), 394 pool = getPublicPool(policy); 395 if (!repository || !pool) throw Error('actual reopened custody missing'); 396 const originalRepository = repository, 397 originalPool = pool; 398 let heldReadAcknowledgements = 0; 399 let releaseRead = () => {}; 400 let restoreReadListener = () => {}; 401 function holdNextNativeReadAcknowledgement() { 402 const prototype = IDBTransaction.prototype; 403 const descriptor = Object.getOwnPropertyDescriptor( 404 prototype, 405 'addEventListener' 406 ); 407 const nativeDescriptor = 408 descriptor ?? 409 Object.getOwnPropertyDescriptor( 410 EventTarget.prototype, 411 'addEventListener' 412 ); 413 if (!nativeDescriptor) 414 throw Error('native event registration descriptor missing'); 415 const native = nativeDescriptor.value as IDBTransaction['addEventListener']; 416 restoreReadListener = () => { 417 if (descriptor) 418 Object.defineProperty(prototype, 'addEventListener', descriptor); 419 else Reflect.deleteProperty(prototype, 'addEventListener'); 420 }; 421 prototype.addEventListener = function ( 422 type: string, 423 listener: EventListenerOrEventListenerObject, 424 options?: boolean | AddEventListenerOptions 425 ) { 426 if ( 427 type !== 'complete' || 428 !listener || 429 this.mode !== 'readonly' || 430 !this.objectStoreNames.contains('public_operations') 431 ) 432 return native.call(this, type, listener, options); 433 restoreReadListener(); 434 return native.call( 435 this, 436 type, 437 function (event: Event) { 438 const transaction = event.currentTarget; 439 if (!(transaction instanceof IDBTransaction)) 440 throw Error('native completion target missing'); 441 heldReadAcknowledgements++; 442 let released = false; 443 releaseRead = () => { 444 if (released) return; 445 released = true; 446 if (typeof listener === 'function') 447 listener.call(transaction, event); 448 else listener.handleEvent(event); 449 }; 450 }, 451 options 452 ); 453 }; 454 } 455 let control: ListingRetry | undefined; 456 async function read() { 457 const got = await readPublicListingIntent(originalRepository, command); 458 const row = 459 got.status === 'found' && 460 publicRecordSnapshot(got.record, owner, command); 461 if (!row || row.family !== 'public_operation') 462 throw Error('reopened original operation missing'); 463 return row; 464 } 465 return { 466 async start( 467 consent: unknown = 'resume_stored_listing', 468 holdAfterPrepare = false, 469 holdReadAfterPrepare = false 470 ) { 471 const prepared = await prepareListingResume( 472 originalRepository, 473 identity, 474 policy, 475 command, 476 'reviewed_stored_listing_resume' 477 ); 478 if (prepared.status !== 'ready') return prepared.status; 479 if (holdReadAfterPrepare) holdNextNativeReadAcknowledgement(); 480 if (holdAfterPrepare) 481 keyHold = new Promise<string>((resolve) => { 482 release = () => resolve(observedOwner); 483 }); 484 control = resumeListing(prepared.resume, originalPool, consent); 485 if (control) { 486 completed = false; 487 void listingRetryResult(control).then(() => { 488 completed = true; 489 }); 490 } 491 return control ? 'started' : 'invalid'; 492 }, 493 async preview() { 494 const p = await prepareListingResume( 495 originalRepository, 496 identity, 497 policy, 498 command, 499 'reviewed_stored_listing_resume' 500 ); 501 return p.status === 'ready' ? listingResumeSnapshot(p.resume) : p; 502 }, 503 async result() { 504 if (!control) throw Error('original resume missing'); 505 return await listingRetryResult(control); 506 }, 507 stop() { 508 if (control) stopListingRetry(control); 509 }, 510 copiedStop() { 511 if (control) stopListingRetry({ ...control }); 512 }, 513 holdKey() { 514 keyHold = new Promise<string>((resolve) => { 515 release = () => resolve(observedOwner); 516 }); 517 }, 518 releaseKey() { 519 release?.(); 520 keyHold = undefined; 521 }, 522 heldReadCount() { 523 return heldReadAcknowledgements; 524 }, 525 releaseRead() { 526 releaseRead(); 527 restoreReadListener(); 528 }, 529 changeKey() { 530 const other = makeFixture(10050); 531 observedOwner = other.owner; 532 other.close(); 533 }, 534 logout() { 535 disconnectIdentity(identity); 536 }, 537 async details() { 538 return { row: await read(), signs, keys, heldKeys, completed }; 539 }, 540 close() { 541 if (control) stopListingRetry(control); 542 release?.(); 543 releaseRead(); 544 restoreReadListener(); 545 closePublicPool(originalPool); 546 closeBrowserDatabase(database); 547 disconnectIdentity(identity); 548 if (prior) Object.defineProperty(window, 'nostr', prior); 549 else Reflect.deleteProperty(window, 'nostr'); 550 } 551 }; 552 }