public-hides.ts (14853B)
1 // HC_TEST_ONLY_RELAY: actual owner/IndexedDB/public SDK over loopback, no live Q. 2 import { mount, unmount } from 'svelte'; 3 import Panel from './public-hides-panel.svelte'; 4 import { makeFixture } from './approved-signing.ts'; 5 import { createFixture as publicationFixture } from './listing-operation-view.ts'; 6 import { 7 openSellingView, 8 sellingViewSnapshot, 9 closeSellingView 10 } from '../../../src/lib/publishing/selling-view.ts'; 11 import { fixturePolicy } from './inbox-setup.ts'; 12 import { 13 validateRelayPolicy, 14 readRelayPolicy 15 } from '../../../src/lib/config/relays.ts'; 16 import { 17 createIdentityViewContext, 18 mountIdentityView, 19 connectIdentityView, 20 closeIdentityView 21 } from '../../../src/lib/runtime/view-context.ts'; 22 import { 23 createPublicRuntimeContext, 24 mountPublicRuntime, 25 bindPublicRuntimeHides, 26 createPublicView, 27 closePublicRuntime 28 } from '../../../src/lib/runtime/public-runtime.ts'; 29 import { 30 createLocalPublicHides, 31 mountLocalPublicHides, 32 refreshLocalPublicHides, 33 localPublicHidesSnapshot, 34 hideLocalPublicPublisher, 35 undoLocalPublicPublisher, 36 closeLocalPublicHides, 37 LOCAL_PUBLIC_HIDES_CONTEXT 38 } from '../../../src/lib/persistence/local-public-hides.ts'; 39 import { 40 createProductView, 41 productViewSnapshot, 42 productViewPublisherProof, 43 closeProductView, 44 type ProductView 45 } from '../../../src/lib/catalog/product-view.ts'; 46 import { 47 createSearchView, 48 startSearchView, 49 searchViewSnapshot, 50 closeSearchView, 51 type SearchView 52 } from '../../../src/lib/catalog/search-view.ts'; 53 import { buildFoodTemplate } from '../../../src/lib/contracts/food-availability-v1/write.ts'; 54 import { encodeProductReference } from '../../../src/lib/nostr/references.ts'; 55 import { 56 verifyEnvelope, 57 type VerifiedEnvelope 58 } from '../../../src/lib/nostr/verified-envelope.ts'; 59 import { 60 openBrowserDatabase, 61 closeBrowserDatabase, 62 browserDatabaseTransaction 63 } from '../../../src/lib/persistence/database.ts'; 64 65 export async function createFixture(denied = false, retained = false) { 66 const signer = makeFixture(), 67 second = makeFixture(); 68 const prior = Object.getOwnPropertyDescriptor(window, 'nostr'); 69 const original = retained ? await publicationFixture() : undefined; 70 if (original && (await original.signed()) !== 'prepared') 71 throw Error('original native signed operation missing'); 72 const retainedRow = await original?.row(); 73 const owner = original?.owner ?? signer.owner; 74 Object.defineProperty(window, 'nostr', { 75 configurable: true, 76 value: { getPublicKey: () => Promise.resolve(owner) } 77 }); 78 const context = createIdentityViewContext(); 79 mountIdentityView(context); 80 await connectIdentityView(context); 81 const hides = createLocalPublicHides(context); 82 await mountLocalPublicHides(hides); 83 const publicContext = createPublicRuntimeContext(); 84 const manifest = readRelayPolicy(fixturePolicy()); 85 const policy = validateRelayPolicy( 86 JSON.stringify({ 87 ...manifest, 88 operatorDenylist: denied ? [signer.owner] : [] 89 }) 90 ); 91 if (!policy) throw Error('fixture policy missing'); 92 const runtime = mountPublicRuntime(publicContext, policy); 93 if (!runtime) throw Error('original public runtime missing'); 94 bindPublicRuntimeHides(runtime, hides); 95 const now = Math.floor(Date.now() / 1000); 96 const built = buildFoodTemplate({ 97 identifier: 'visible-carrots', 98 title: 'Visible carrots', 99 description: 'Public plain text only', 100 location: 'Farm', 101 amount: '3', 102 currency: 'CAD', 103 unit: 'each', 104 created_at: now, 105 published_at: now, 106 status: 'active' 107 }); 108 if (!built.ok) throw Error('fixture food invalid'); 109 const event = retainedRow?.artifact 110 ? (JSON.parse(retainedRow.artifact.wire) as ReturnType<typeof signer.sign>) 111 : signer.sign({ 112 kind: 30402, 113 created_at: now, 114 tags: built.wire_parts.tags.map((tag) => [...tag]), 115 content: built.wire_parts.content 116 }); 117 const reference = encodeProductReference({ 118 kind: 30402, 119 pubkey: event.pubkey, 120 identifier: event.tags.find((tag) => tag[0] === 'd')?.[1] ?? '' 121 }); 122 if (!reference) throw Error('fixture reference missing'); 123 const proof = verifyEnvelope(JSON.stringify(event)); 124 if (!proof.ok) throw Error('actual verified publisher missing'); 125 const opened = await openBrowserDatabase(); 126 if (opened.state !== 'ready') throw Error(opened.reason); 127 const database = opened.owner; 128 const listeners = new Map<symbol, () => void>(); 129 let product: ProductView | undefined, search: SearchView | undefined; 130 let panel: ReturnType<typeof mount> | undefined, 131 target: HTMLElement | undefined; 132 const notify = () => { 133 for (const listener of listeners.values()) listener(); 134 }; 135 const fixture = { 136 events: [event], 137 view: () => product, 138 publicSnapshot: () => product && productViewSnapshot(product), 139 searchSnapshot: () => search && searchViewSnapshot(search), 140 hidesSnapshot: () => localPublicHidesSnapshot(hides), 141 subscribe(listener: () => void) { 142 const id = Symbol(); 143 listeners.set(id, listener); 144 return () => { 145 listeners.delete(id); 146 }; 147 }, 148 read() { 149 if (product) closeProductView(product); 150 product = createProductView( 151 createPublicView(runtime), 152 reference, 153 { nowSeconds: () => Math.floor(Date.now() / 1000) }, 154 notify 155 ); 156 notify(); 157 }, 158 search() { 159 if (search) closeSearchView(search); 160 search = createSearchView( 161 createPublicView(runtime), 162 { nowSeconds: () => Math.floor(Date.now() / 1000) }, 163 notify 164 ); 165 startSearchView(search, 'carrots'); 166 }, 167 async render() { 168 if (!product) fixture.read(); 169 if (panel) await unmount(panel); 170 target?.remove(); 171 target = document.createElement('div'); 172 target.id = 'hcp122-panel'; 173 document.body.append(target); 174 panel = mount(Panel, { 175 target, 176 props: { fixture }, 177 context: new Map([[LOCAL_PUBLIC_HIDES_CONTEXT, hides]]) 178 }); 179 }, 180 hide() { 181 return hideLocalPublicPublisher( 182 hides, 183 product 184 ? (productViewPublisherProof(product) ?? proof.value) 185 : proof.value, 186 'reviewed_local_public_hide' 187 ); 188 }, 189 fake() { 190 return hideLocalPublicPublisher( 191 hides, 192 { pubkey: event.pubkey } as unknown as VerifiedEnvelope, 193 'reviewed_local_public_hide' 194 ); 195 }, 196 refresh() { 197 return refreshLocalPublicHides(hides); 198 }, 199 async concurrentPreference(hidden: boolean) { 200 const other = createLocalPublicHides(context); 201 await mountLocalPublicHides(other); 202 try { 203 const otherEvent = second.sign({ 204 kind: event.kind, 205 created_at: event.created_at, 206 tags: event.tags.map((tag) => [...tag]), 207 content: event.content 208 }); 209 const otherProof = verifyEnvelope(JSON.stringify(otherEvent)); 210 if (!otherProof.ok) throw Error('other genuine publisher missing'); 211 const unrelated = await hideLocalPublicPublisher( 212 other, 213 otherProof.value, 214 'reviewed_local_public_hide' 215 ); 216 if (unrelated.status !== 'saved') throw Error('other hide missing'); 217 const changed = hidden 218 ? await hideLocalPublicPublisher( 219 other, 220 proof.value, 221 'reviewed_local_public_hide' 222 ) 223 : await undoLocalPublicPublisher( 224 other, 225 event.pubkey, 226 'reviewed_local_public_undo' 227 ); 228 if (changed.status !== 'saved') 229 throw Error('concurrent preference missing'); 230 return { 231 snapshot: localPublicHidesSnapshot(other), 232 rows: await fixture.rows() 233 }; 234 } finally { 235 closeLocalPublicHides(other); 236 } 237 }, 238 undo() { 239 return undoLocalPublicPublisher( 240 hides, 241 event.pubkey, 242 'reviewed_local_public_undo' 243 ); 244 }, 245 async rows() { 246 const tx = browserDatabaseTransaction( 247 database, 248 ['local_preferences'], 249 'readonly' 250 ); 251 return new Promise<unknown[]>((resolve, reject) => { 252 const request = tx 253 .objectStore('local_preferences') 254 .index('by_owner') 255 .getAll(owner); 256 tx.addEventListener('complete', () => 257 resolve(request.result as unknown[]) 258 ); 259 tx.addEventListener('abort', () => 260 reject(Error('native read aborted')) 261 ); 262 }); 263 }, 264 async corrupt() { 265 const tx = browserDatabaseTransaction( 266 database, 267 ['local_preferences'], 268 'readwrite' 269 ); 270 tx.objectStore('local_preferences').put({ 271 owner: signer.owner, 272 id: 'public_hides', 273 wire: 'corrupt local metadata' 274 }); 275 await new Promise<void>((resolve, reject) => { 276 tx.addEventListener('complete', () => resolve()); 277 tx.addEventListener('abort', () => 278 reject(Error('native write aborted')) 279 ); 280 }); 281 }, 282 nativeRecord() { 283 return original?.row(); 284 }, 285 async sellingSnapshot() { 286 const view = await openSellingView(context, runtime); 287 if (!view) throw Error('original owner selling view missing'); 288 try { 289 const snapshot = sellingViewSnapshot(view); 290 return ( 291 snapshot && { 292 ...snapshot, 293 attention: snapshot.attention.map((row) => ({ 294 ...row, 295 operations: row.operations.map(() => 'original_operation_view') 296 })) 297 } 298 ); 299 } finally { 300 closeSellingView(view); 301 } 302 }, 303 async abortWrite() { 304 const native = Reflect.get<IDBDatabase, 'transaction'>( 305 IDBDatabase.prototype, 306 'transaction' 307 ); 308 let injected = false; 309 IDBDatabase.prototype.transaction = function ( 310 ...args: Parameters<typeof native> 311 ) { 312 const tx = native.apply(this, args); 313 if ( 314 !injected && 315 this.name === 'harvestcircle_browser' && 316 args[1] === 'readwrite' 317 ) { 318 injected = true; 319 tx.abort(); 320 } 321 return tx; 322 }; 323 try { 324 return await fixture.hide(); 325 } finally { 326 IDBDatabase.prototype.transaction = native; 327 } 328 }, 329 async conflictWrite() { 330 const native = Reflect.get<IDBDatabase, 'transaction'>( 331 IDBDatabase.prototype, 332 'transaction' 333 ); 334 let injected = false; 335 IDBDatabase.prototype.transaction = function ( 336 ...args: Parameters<typeof native> 337 ) { 338 if ( 339 !injected && 340 this.name === 'harvestcircle_browser' && 341 args[1] === 'readwrite' 342 ) { 343 injected = true; 344 const concurrent = native.call( 345 this, 346 ['local_preferences'], 347 'readwrite' 348 ); 349 concurrent.objectStore('local_preferences').put({ 350 owner: signer.owner, 351 id: 'public_hides', 352 wire: JSON.stringify({ 353 schema: 1, 354 family: 'public_hides', 355 owner: signer.owner, 356 id: 'public_hides', 357 revision: 1, 358 publishers: [second.owner] 359 }) 360 }); 361 } 362 return native.apply(this, args); 363 }; 364 try { 365 return await fixture.hide(); 366 } finally { 367 IDBDatabase.prototype.transaction = native; 368 } 369 }, 370 async failReadback() { 371 const native = Reflect.get<IDBDatabase, 'transaction'>( 372 IDBDatabase.prototype, 373 'transaction' 374 ); 375 let reads = 0; 376 IDBDatabase.prototype.transaction = function ( 377 ...args: Parameters<typeof native> 378 ) { 379 if ( 380 this.name === 'harvestcircle_browser' && 381 args[1] === 'readonly' && 382 ++reads === 2 383 ) 384 throw new DOMException( 385 'controlled readback failure', 386 'SecurityError' 387 ); 388 return native.apply(this, args); 389 }; 390 try { 391 return await fixture.hide(); 392 } finally { 393 IDBDatabase.prototype.transaction = native; 394 } 395 }, 396 async denyStorage() { 397 const native = Reflect.get<IDBFactory, 'open'>( 398 IDBFactory.prototype, 399 'open' 400 ); 401 IDBFactory.prototype.open = () => { 402 throw new DOMException('controlled denied open', 'SecurityError'); 403 }; 404 try { 405 await refreshLocalPublicHides(hides); 406 return localPublicHidesSnapshot(hides); 407 } finally { 408 IDBFactory.prototype.open = native; 409 } 410 }, 411 async switchOwner() { 412 Object.defineProperty(window, 'nostr', { 413 configurable: true, 414 value: { getPublicKey: () => Promise.resolve(second.owner) } 415 }); 416 await connectIdentityView(context); 417 }, 418 async reconnect() { 419 // Delay only the lock callback to exercise a real account-generation 420 // transition during an admitted local action, before any IDB mutation. 421 const native = navigator.locks.request.bind(navigator.locks); 422 const descriptor = Object.getOwnPropertyDescriptor( 423 navigator.locks, 424 'request' 425 ); 426 let release: (() => void) | undefined; 427 const gate = new Promise<void>((resolve) => { 428 release = resolve; 429 }); 430 const wrapper = ( 431 name: string, 432 options: LockOptions, 433 callback: LockGrantedCallback<unknown> 434 ) => 435 native(name, options, async (lock) => { 436 await gate; 437 return callback(lock); 438 }); 439 Object.defineProperty(navigator.locks, 'request', { 440 configurable: true, 441 value: wrapper 442 }); 443 try { 444 const pending = undoLocalPublicPublisher( 445 hides, 446 event.pubkey, 447 'reviewed_local_public_undo' 448 ); 449 await connectIdentityView(context); 450 release?.(); 451 const result = await pending; 452 await refreshLocalPublicHides(hides); 453 return result; 454 } finally { 455 release?.(); 456 if (descriptor) 457 Object.defineProperty(navigator.locks, 'request', descriptor); 458 else Reflect.deleteProperty(navigator.locks, 'request'); 459 } 460 }, 461 async close() { 462 if (panel) await unmount(panel); 463 target?.remove(); 464 if (product) closeProductView(product); 465 if (search) closeSearchView(search); 466 closeLocalPublicHides(hides); 467 closeIdentityView(context); 468 closePublicRuntime(publicContext); 469 closeBrowserDatabase(database); 470 signer.close(); 471 second.close(); 472 original?.close(); 473 if (prior) Object.defineProperty(window, 'nostr', prior); 474 else Reflect.deleteProperty(window, 'nostr'); 475 } 476 }; 477 return fixture; 478 }