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