app

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

private-receipts.ts (6569B)


      1 import { makeFixture as makeDeliveryFixture } from './private-publisher.ts';
      2 import { preparedPairedDelivery } from '../../../src/lib/messaging/prepare-send.ts';
      3 import {
      4   commitPairedDeliveryReceipt,
      5   verifyPairedDeliveryAcknowledgement,
      6   type PairedDeliveryAcknowledgement
      7 } from '../../../src/lib/persistence/private-sends.ts';
      8 import {
      9   loadPrivateRecord,
     10   createPrivateStorageRepository
     11 } from '../../../src/lib/persistence/private-storage.ts';
     12 import {
     13   privateRecordSnapshot,
     14   privateRecordWire
     15 } from '../../../src/lib/persistence/private-records.ts';
     16 import {
     17   preparePrivateReceiptTransition,
     18   commitPrivateReceiptTransition
     19 } from '../../../src/lib/persistence/private-receipts.ts';
     20 import { privateSendStatus } from '../../../src/lib/messaging/send-status.ts';
     21 import { reservedSendSnapshot } from '../../../src/lib/messaging/send-identity.ts';
     22 import {
     23   openBrowserDatabase,
     24   closeBrowserDatabase
     25 } from '../../../src/lib/persistence/database.ts';
     26 export { commitPairedDeliveryReceipt };
     27 const action = '12345678-1234-4234-8234-123456789abd';
     28 export async function readExisting(owner: string, id: string) {
     29   const opened = await openBrowserDatabase();
     30   if (opened.state !== 'ready') throw Error('storage unavailable');
     31   try {
     32     const repository = createPrivateStorageRepository(opened.owner, owner);
     33     if (!repository) throw Error('namespace unavailable');
     34     const loaded = await loadPrivateRecord(repository, 'private_sends', id);
     35     if (!loaded.ok) throw Error('record unavailable');
     36     return {
     37       row: privateRecordSnapshot(loaded.value, owner, id),
     38       status: privateSendStatus(loaded.value, owner, id)
     39     };
     40   } finally {
     41     closeBrowserDatabase(opened.owner);
     42   }
     43 }
     44 export async function makeFixture() {
     45   const f = await makeDeliveryFixture();
     46   let restore = () => {},
     47     faults = 0;
     48   const command = reservedSendSnapshot(f.reserved);
     49   if (!command) throw Error('missing actual command');
     50   const id = command.id;
     51   async function handle() {
     52     const loaded = await loadPrivateRecord(f.repository, 'private_sends', id);
     53     if (!loaded.ok) throw Error('missing private record: ' + loaded.reason);
     54     return loaded.value;
     55   }
     56   async function state() {
     57     const h = await handle();
     58     return {
     59       row: privateRecordSnapshot(h, f.owner, id),
     60       wire: privateRecordWire(h, f.owner, id),
     61       status: privateSendStatus(h, f.owner, id)
     62     };
     63   }
     64   async function fact(
     65     role: 'peer' | 'self_archive',
     66     status: string,
     67     time = 100,
     68     readbackWire: string | null = null
     69   ) {
     70     const row = await f.storedPair();
     71     if (!row?.peerArtifact) throw Error('missing actual pair');
     72     return {
     73       actionId: action,
     74       role,
     75       origin: role === 'peer' ? f.peerOrigin : f.archiveOrigin,
     76       attempt: 1,
     77       eventId: role === 'peer' ? row.peerArtifact.eventId : row.self.eventId,
     78       status,
     79       observedAtMilliseconds: time,
     80       readbackWire
     81     };
     82   }
     83   async function observe(
     84     role: 'peer' | 'self_archive',
     85     status: string,
     86     time = 100,
     87     readbackWire: string | null = null
     88   ) {
     89     const receipt = preparedPairedDelivery(f.preparation);
     90     if (!receipt) throw Error('missing genuine pair acknowledgment');
     91     const wire = JSON.stringify(await fact(role, status, time, readbackWire));
     92     return commitPairedDeliveryReceipt(f.repository, receipt, wire);
     93   }
     94   async function race() {
     95     const base = await handle(),
     96       a = preparePrivateReceiptTransition(
     97         base,
     98         f.owner,
     99         id,
    100         JSON.stringify(await fact('peer', 'accepted'))
    101       ),
    102       b = preparePrivateReceiptTransition(
    103         base,
    104         f.owner,
    105         id,
    106         JSON.stringify(await fact('self_archive', 'accepted'))
    107       );
    108     if (!a.ok || !b.ok) throw Error('missing receipt transitions');
    109     return Promise.all([
    110       commitPrivateReceiptTransition(f.repository, a.value),
    111       commitPrivateReceiptTransition(f.repository, b.value)
    112     ]);
    113   }
    114   async function genuineRace() {
    115     const peer = await fact('peer', 'accepted'),
    116       archive = await fact('self_archive', 'accepted');
    117     const receipt = preparedPairedDelivery(f.preparation);
    118     if (!receipt) throw Error('missing genuine paired receipt');
    119     const results = await Promise.all([
    120       commitPairedDeliveryReceipt(f.repository, receipt, JSON.stringify(peer)),
    121       commitPairedDeliveryReceipt(
    122         f.repository,
    123         receipt,
    124         JSON.stringify(archive)
    125       )
    126     ]);
    127     const observed = await state();
    128     const winner =
    129       observed.row?.family === 'private_send_operation'
    130         ? observed.row.receipts?.[0].role
    131         : undefined;
    132     if (!winner) throw Error('missing winning receipt');
    133     return {
    134       results,
    135       observed,
    136       verified: await verified(),
    137       remaining: await f.deliver(winner === 'peer' ? 'self_archive' : 'peer')
    138     };
    139   }
    140   function failAfterPut(mode: 'abort' | 'readback') {
    141     const put = Reflect.get<IDBObjectStore, 'put'>(
    142         IDBObjectStore.prototype,
    143         'put'
    144       ),
    145       cursor = Reflect.get<IDBIndex, 'openCursor'>(
    146         IDBIndex.prototype,
    147         'openCursor'
    148       );
    149     IDBObjectStore.prototype.put = function (
    150       ...args: Parameters<IDBObjectStore['put']>
    151     ) {
    152       const request = put.apply(this, args);
    153       if (this.name === 'private_sends') {
    154         faults++;
    155         if (mode === 'abort') this.transaction.abort();
    156         else
    157           IDBIndex.prototype.openCursor = function (
    158             ...args: Parameters<IDBIndex['openCursor']>
    159           ) {
    160             if (this.objectStore.name === 'private_sends')
    161               throw Error('controlled actual receipt readback failure');
    162             return cursor.apply(this, args);
    163           };
    164       }
    165       return request;
    166     };
    167     restore = () => {
    168       IDBObjectStore.prototype.put = put;
    169       IDBIndex.prototype.openCursor = cursor;
    170     };
    171   }
    172   async function forged() {
    173     return commitPairedDeliveryReceipt(
    174       f.repository,
    175       {} as PairedDeliveryAcknowledgement,
    176       JSON.stringify(await fact('peer', 'accepted'))
    177     );
    178   }
    179   async function verified() {
    180     const receipt = preparedPairedDelivery(f.preparation);
    181     return receipt
    182       ? verifyPairedDeliveryAcknowledgement(f.repository, receipt)
    183       : false;
    184   }
    185   return {
    186     ...f,
    187     id,
    188     handle,
    189     state,
    190     fact,
    191     observe,
    192     race,
    193     genuineRace,
    194     failAfterPut,
    195     forged,
    196     verified,
    197     faults: () => faults,
    198     clearFault() {
    199       restore();
    200       restore = () => {};
    201     },
    202     close() {
    203       restore();
    204       f.close();
    205     }
    206   };
    207 }