app

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

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 }