app

Local-first trade for farms and co-ops
git clone https://radroots.dev/git/app.git
Log | Files | Refs | README | LICENSE

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 }