deliver-listing.ts (14224B)
1 import { deliverListing } from '../../../src/lib/publishing/deliver-listing.ts'; 2 import { 3 getPublicPool, 4 closePublicPool 5 } from '../../../src/lib/nostr/public-pool.ts'; 6 import { 7 authorizeListingAttempt, 8 withListingDeliveryOwnership, 9 takeListingPublication 10 } from '../../../src/lib/nostr/listing-publisher.ts'; 11 import { 12 readRelayPolicy, 13 validateRelayPolicy 14 } from '../../../src/lib/config/relays.ts'; 15 import { verifyEnvelope } from '../../../src/lib/nostr/verified-envelope.ts'; 16 import { 17 getPublicStore, 18 insertPublicEnvelope, 19 publicStoreEnvelope 20 } from '../../../src/lib/nostr/public-store.ts'; 21 export { deliverListing, authorizeListingAttempt, takeListingPublication }; 22 import { makeFixture } from './approved-signing.ts'; 23 import { EventStore } from 'applesauce-core'; 24 import { getSeenRelays, type NostrEvent } from 'applesauce-core/helpers'; 25 import { fixturePolicy, discovery, inbox } from './inbox-setup.ts'; 26 import { 27 createIdentitySession, 28 connectIdentity, 29 probeIdentityMessaging, 30 disconnectIdentity 31 } from '../../../src/lib/runtime/identity-session.ts'; 32 import { 33 createPublicScheduler, 34 createPublicRun, 35 openInboxRequest, 36 closePublicScheduler 37 } from '../../../src/lib/nostr/request-scope.ts'; 38 import { createInboxResolver } from '../../../src/lib/messaging/resolve-inbox.ts'; 39 import { 40 createInboxSetupView, 41 checkInboxSetupView, 42 unlockInboxSetupView, 43 closeInboxSetupView 44 } from '../../../src/lib/messaging/inbox-setup-view.ts'; 45 import { captureNewListingReadiness } from '../../../src/lib/publishing/new-listing-readiness.ts'; 46 import { 47 openBrowserDatabase, 48 closeBrowserDatabase 49 } from '../../../src/lib/persistence/database.ts'; 50 import { 51 createPublicPublicationRepository, 52 publicPublicationDraftRepository, 53 readPublicListingIntent 54 } from '../../../src/lib/persistence/public-publications.ts'; 55 import { 56 createPublicDraftController, 57 closePublicDraftController 58 } from '../../../src/lib/publishing/draft-controller.ts'; 59 import { 60 reviewNewListing, 61 reserveNewListing, 62 listingReviewSnapshot 63 } from '../../../src/lib/publishing/prepare-listing.ts'; 64 import { publicRecordSnapshot } from '../../../src/lib/persistence/records.ts'; 65 import { 66 beginListingSigning, 67 runListingSigning, 68 listingPublicationSnapshot 69 } from '../../../src/lib/publishing/sign-listing.ts'; 70 71 export async function createFixture() { 72 const trace: string[] = []; 73 const tracePut = Object.getOwnPropertyDescriptor( 74 IDBObjectStore.prototype, 75 'put' 76 ), 77 traceSend = Object.getOwnPropertyDescriptor(WebSocket.prototype, 'send'); 78 if (!tracePut) throw Error('native trace descriptors missing'); 79 const nativeTracePut = tracePut.value as IDBObjectStore['put'], 80 nativeTraceSend = Reflect.get<WebSocket, 'send'>( 81 WebSocket.prototype, 82 'send' 83 ); 84 Object.defineProperty(IDBObjectStore.prototype, 'put', { 85 ...tracePut, 86 value: function ( 87 this: IDBObjectStore, 88 ...args: Parameters<IDBObjectStore['put']> 89 ) { 90 const value: unknown = args[0]; 91 if ( 92 this.name === 'public_operations' && 93 typeof value === 'object' && 94 value && 95 'wire' in value && 96 typeof value.wire === 'string' 97 ) { 98 const revision = (JSON.parse(value.wire) as { revision: number }) 99 .revision; 100 this.transaction.addEventListener( 101 'complete', 102 () => trace.push('ack:' + revision), 103 { once: true } 104 ); 105 } 106 return nativeTracePut.apply(this, args); 107 } 108 }); 109 Object.defineProperty(WebSocket.prototype, 'send', { 110 configurable: true, 111 writable: true, 112 ...traceSend, 113 value: function (this: WebSocket, ...args: Parameters<WebSocket['send']>) { 114 if ( 115 typeof args[0] === 'string' && 116 (JSON.parse(args[0]) as unknown[])[0] === 'EVENT' 117 ) 118 trace.push('EVENT'); 119 return nativeTraceSend.apply(this, args); 120 } 121 }); 122 const signer = makeFixture(10050), 123 identity = createIdentitySession(), 124 policy = fixturePolicy(); 125 const preference = signer.sign({ 126 ...signer.template, 127 kind: 10050, 128 created_at: 100, 129 tags: [['relay', inbox]], 130 content: '' 131 }); 132 const prior = Object.getOwnPropertyDescriptor(window, 'nostr'); 133 let signs = 0, 134 keys = 0, 135 observedOwner = signer.owner; 136 Object.defineProperty(window, 'nostr', { 137 configurable: true, 138 value: { 139 getPublicKey: () => { 140 keys++; 141 return Promise.resolve(observedOwner); 142 }, 143 signEvent: (input: Parameters<typeof signer.sign>[0]) => { 144 signs++; 145 return Promise.resolve(signer.sign(input)); 146 }, 147 nip44: { 148 encrypt: (_peer: string, text: string) => 149 Promise.resolve('fixture:' + text), 150 decrypt: (_peer: string, text: string) => Promise.resolve(text.slice(8)) 151 } 152 } 153 }); 154 await connectIdentity(identity); 155 await probeIdentityMessaging(identity, 'reviewed_self_copy'); 156 const scheduler = createPublicScheduler({ 157 now: () => 0, 158 schedule: () => () => {} 159 }); 160 const run = createPublicRun(scheduler, policy); 161 const resolver = createInboxResolver( 162 run, 163 signer.owner, 164 (next) => 165 openInboxRequest( 166 run, 167 signer.owner, 168 (sink) => { 169 sink({ 170 type: 'EVENT', 171 from: discovery, 172 id: 'fixture', 173 event: preference 174 }); 175 sink({ type: 'EOSE', from: discovery, id: 'fixture' }); 176 return () => {}; 177 }, 178 next 179 ), 180 () => true 181 ); 182 // HC_TEST_ONLY_QUALIFICATION_PORT: original SDK owners, controlled exercised 183 // access observation; no real extension/operator/relay qualification. 184 const setup = createInboxSetupView({ 185 identity, 186 policy, 187 lookup: () => Promise.resolve(resolver), 188 observeAccess: (context) => ({ 189 ...context, 190 readTargets: context.readTargets.slice(), 191 archiveTargets: context.archiveTargets.slice(), 192 receive: 'qualified_exercised', 193 archive: 'qualified_exercised', 194 current: () => true 195 }) 196 }); 197 if (!setup) throw Error('original setup missing'); 198 await checkInboxSetupView(setup); 199 await unlockInboxSetupView(setup); 200 const ready = captureNewListingReadiness( 201 identity, 202 setup, 203 'reviewed_new_listing_inbox' 204 ); 205 if (!ready) throw Error('original readiness missing'); 206 const opened = await openBrowserDatabase(); 207 if (opened.state !== 'ready') throw Error(opened.reason); 208 const database = opened.owner, 209 repository = createPublicPublicationRepository(database, signer.owner); 210 const drafts = repository && publicPublicationDraftRepository(repository); 211 if (!repository || !drafts) throw Error('original repository missing'); 212 const originalRepository = repository; 213 const controller = await createPublicDraftController(drafts, { 214 title: 'Carrots', 215 description: 'Exact signed description', 216 location: 'Local farm', 217 amount: '2', 218 currency: 'USD', 219 unit: 'kg', 220 quantity: '', 221 contactType: '', 222 contactValue: '' 223 }); 224 if (!controller) throw Error('original controller missing'); 225 const command = crypto.randomUUID(); 226 const reviewed = await reviewNewListing( 227 repository, 228 controller, 229 ready, 230 command, 231 'reviewed_new_listing' 232 ); 233 if (reviewed.status !== 'review') throw Error(reviewed.reason); 234 const original = reviewed.review, 235 preview = listingReviewSnapshot(original); 236 if (!preview) throw Error('original preview missing'); 237 const reserved = await reserveNewListing( 238 original, 239 'publish_reviewed_listing' 240 ); 241 if (reserved.status !== 'saved') throw Error(reserved.status); 242 const signing = beginListingSigning(original, 'sign_reviewed_listing'); 243 if (!signing) throw Error('original signing missing'); 244 const originalSigning = signing; 245 async function stored() { 246 const read = await readPublicListingIntent(originalRepository, command); 247 const row = 248 read.status === 'found' && 249 publicRecordSnapshot(read.record, signer.owner, command); 250 if (!row || row.family !== 'public_operation') 251 throw Error('original stored command missing'); 252 return row; 253 } 254 function invoke() { 255 return runListingSigning(originalSigning, 'sign_reviewed_listing'); 256 } 257 const signed = await invoke(); 258 if (signed.status !== 'prepared') throw Error(signed.status); 259 const publication = signed.publication, 260 pool = getPublicPool(policy); 261 if (!pool) throw Error('original public pool missing'); 262 return { 263 owner: signer.owner, 264 command, 265 publication, 266 pool, 267 policy, 268 async run(consent: unknown = 'publish_stored_listing') { 269 const a = deliverListing(publication, pool, policy, consent), 270 b = deliverListing(publication, pool, policy, consent); 271 const result = await a, 272 row = await stored(); 273 return { 274 result, 275 trace: trace.slice(), 276 same: a === b, 277 row, 278 signs, 279 keys, 280 owner: signer.owner, 281 expectedWire: listingPublicationSnapshot(publication)?.wire, 282 originalCapture: row.capture.wire === preview.templateWire 283 }; 284 }, 285 async read() { 286 return await stored(); 287 }, 288 copied() { 289 return deliverListing( 290 { ...listingPublicationSnapshot(publication) } as typeof publication, 291 pool, 292 policy, 293 'publish_stored_listing' 294 ); 295 }, 296 async foreignTarget() { 297 return await withListingDeliveryOwnership( 298 publication, 299 policy, 300 'publish_stored_listing', 301 async (lease) => 302 !!(await authorizeListingAttempt( 303 lease, 304 'wss://other.example.org', 305 'publish' 306 )) 307 ); 308 }, 309 retargeted() { 310 const manifest = readRelayPolicy(policy), 311 changed = validateRelayPolicy( 312 JSON.stringify({ 313 ...manifest, 314 public: [ 315 { 316 origin: 'wss://other.example.org', 317 read: true, 318 write: true, 319 nip50: false 320 } 321 ] 322 }) 323 ); 324 if (!changed) throw Error('changed fixture policy invalid'); 325 return deliverListing( 326 publication, 327 pool, 328 changed, 329 'publish_stored_listing' 330 ); 331 }, 332 async cacheArtifact() { 333 const row = await stored(); 334 const sdkStore = new EventStore(); 335 let seen: string[]; 336 try { 337 sdkStore.add(JSON.parse(row.artifact!.wire) as NostrEvent, discovery); 338 sdkStore.add( 339 JSON.parse(row.artifact!.wire) as NostrEvent, 340 'wss://other.example.org' 341 ); 342 const merged = sdkStore.getEvent(row.artifact!.eventId); 343 if (!merged) throw Error('actual SDK merge failed'); 344 seen = [...(getSeenRelays(merged) ?? [])].sort(); 345 if (seen.length !== 2) 346 throw Error('actual SDK seen metadata not merged'); 347 } finally { 348 sdkStore.dispose(); 349 } 350 const verified = verifyEnvelope(row.artifact!.wire), 351 store = getPublicStore(); 352 if ( 353 !verified.ok || 354 !store || 355 insertPublicEnvelope(store, verified.value) !== 'accepted' || 356 !publicStoreEnvelope(store, row.artifact!.eventId) 357 ) 358 throw Error('actual shared public cache admission failed'); 359 return { id: row.artifact!.eventId, seen }; 360 }, 361 async receiptFault(unknown: boolean) { 362 const put = Object.getOwnPropertyDescriptor( 363 IDBObjectStore.prototype, 364 'put' 365 ), 366 abort = Object.getOwnPropertyDescriptor( 367 IDBTransaction.prototype, 368 'abort' 369 ); 370 if (!put || !abort) throw Error('native descriptors missing'); 371 const nativePut = put.value as IDBObjectStore['put']; 372 let faultPuts = 0; 373 Object.defineProperty(IDBObjectStore.prototype, 'put', { 374 ...put, 375 value: function ( 376 this: IDBObjectStore, 377 ...args: Parameters<IDBObjectStore['put']> 378 ) { 379 const v: unknown = args[0]; 380 if ( 381 this.name === 'public_operations' && 382 typeof v === 'object' && 383 v && 384 'wire' in v && 385 typeof v.wire === 'string' && 386 (JSON.parse(v.wire) as { revision: number }).revision === 3 387 ) { 388 faultPuts++; 389 if (unknown) { 390 nativePut.apply(this, args); 391 throw Error( 392 'HC_TEST_ONLY real receipt put lost JS acknowledgement' 393 ); 394 } 395 this.transaction.abort(); 396 throw Error('HC_TEST_ONLY definite receipt abort'); 397 } 398 return nativePut.apply(this, args); 399 } 400 }); 401 if (unknown) 402 Object.defineProperty(IDBTransaction.prototype, 'abort', { 403 ...abort, 404 value() { 405 throw Error('HC_TEST_ONLY unavailable abort channel'); 406 } 407 }); 408 try { 409 const result = await deliverListing( 410 publication, 411 pool, 412 policy, 413 'publish_stored_listing' 414 ), 415 row = await stored(); 416 return { result, row, signs, faultPuts }; 417 } finally { 418 Object.defineProperty(IDBObjectStore.prototype, 'put', put); 419 Object.defineProperty(IDBTransaction.prototype, 'abort', abort); 420 } 421 }, 422 logout() { 423 disconnectIdentity(identity); 424 }, 425 stop() { 426 closeInboxSetupView(setup); 427 }, 428 changeKey() { 429 const other = makeFixture(10050); 430 observedOwner = other.owner; 431 other.close(); 432 }, 433 close() { 434 closePublicPool(pool); 435 closePublicDraftController(controller); 436 closeBrowserDatabase(database); 437 closeInboxSetupView(setup); 438 disconnectIdentity(identity); 439 closePublicScheduler(scheduler); 440 signer.close(); 441 if (prior) Object.defineProperty(window, 'nostr', prior); 442 else Reflect.deleteProperty(window, 'nostr'); 443 Object.defineProperty(IDBObjectStore.prototype, 'put', tracePut); 444 if (traceSend) 445 Object.defineProperty(WebSocket.prototype, 'send', traceSend); 446 else Reflect.deleteProperty(WebSocket.prototype, 'send'); 447 } 448 }; 449 }