app

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

self-recovery.ts (6687B)


      1 import { makeFixture as makeCryptoFixture } from './giftwrap-builder.ts';
      2 import {
      3   openBrowserDatabase,
      4   closeBrowserDatabase,
      5   browserDatabaseTransaction
      6 } from '../../../src/lib/persistence/database.ts';
      7 import { createPrivateStorageRepository } from '../../../src/lib/persistence/private-storage.ts';
      8 import { reservedSendSnapshot } from '../../../src/lib/messaging/send-identity.ts';
      9 import {
     10   captureEnvelopePreparation,
     11   prepareEnvelopeRole,
     12   preparedEnvelopeProof,
     13   closeEnvelopePreparation
     14 } from '../../../src/lib/messaging/envelope-preparation.ts';
     15 import {
     16   commitSelfRecovery,
     17   selfRecoveryAcknowledgementSnapshot
     18 } from '../../../src/lib/persistence/private-sends.ts';
     19 import {
     20   captureSelfRecoveryPreparation,
     21   prepareSelfRecovery,
     22   selfRecoveryPreparationSnapshot,
     23   preparedSelfRecovery,
     24   selfRecoveryPeerPreparation,
     25   stopSelfRecoveryPreparation
     26 } from '../../../src/lib/messaging/prepare-send.ts';
     27 export {
     28   commitSelfRecovery,
     29   selfRecoveryAcknowledgementSnapshot,
     30   captureSelfRecoveryPreparation,
     31   prepareSelfRecovery,
     32   selfRecoveryPreparationSnapshot,
     33   preparedSelfRecovery,
     34   selfRecoveryPeerPreparation,
     35   stopSelfRecoveryPreparation
     36 };
     37 // Source-only genuine stock SDK plus actual Chromium IDB/Web Locks. Neither
     38 // this disposable provider nor these synthetic faults qualify an operator.
     39 export async function makeFixture() {
     40   const marker = 'HCP081_PRIVATE_TEXT_MEMORY_ONLY_SENTINEL';
     41   const cryptoFixture = await makeCryptoFixture(marker);
     42   const opened = await openBrowserDatabase();
     43   if (opened.state !== 'ready') throw Error('self storage unavailable');
     44   const database = opened.owner,
     45     repository = createPrivateStorageRepository(database, cryptoFixture.owner),
     46     foreignRepository = createPrivateStorageRepository(
     47       database,
     48       cryptoFixture.peer
     49     );
     50   if (!repository || !foreignRepository)
     51     throw Error('self storage namespace missing');
     52   const preparation = captureSelfRecoveryPreparation(
     53     repository,
     54     cryptoFixture.identity,
     55     cryptoFixture.reserved,
     56     'reviewed_self_recovery'
     57   );
     58   if (!preparation) throw Error('self preparation missing');
     59   let restore = () => {},
     60     releaseLock: (() => void) | undefined;
     61   const pairs = new Set<ReturnType<typeof captureEnvelopePreparation>>();
     62   async function proof(role: 'self' | 'peer') {
     63     const pair = captureEnvelopePreparation(
     64       cryptoFixture.identity,
     65       cryptoFixture.reserved,
     66       'reviewed_envelope_pair'
     67     );
     68     if (!pair) throw Error('crypto pair missing');
     69     pairs.add(pair);
     70     if (
     71       (await prepareEnvelopeRole(pair, 'self', 'reviewed_pair_role')).status !==
     72         'prepared' ||
     73       (role === 'peer' &&
     74         (await prepareEnvelopeRole(pair, 'peer', 'reviewed_pair_role'))
     75           .status !== 'complete')
     76     )
     77       throw Error('role proof missing');
     78     const proof = preparedEnvelopeProof(pair, role);
     79     if (!proof) throw Error('peer proof missing');
     80     return proof;
     81   }
     82   // The queued write and transaction are real. In unknown mode the fixture
     83   // loses its acknowledgement after the actual put, then makes abort fail;
     84   // actual completion/readback determine whether the original ciphertext exists.
     85   function fault(mode: 'abort' | 'unknown') {
     86     restore();
     87     const put = Reflect.get<IDBObjectStore, 'put'>(
     88         IDBObjectStore.prototype,
     89         'put'
     90       ),
     91       abort = Reflect.get<IDBTransaction, 'abort'>(
     92         IDBTransaction.prototype,
     93         'abort'
     94       );
     95     let hits = 0;
     96     const affected = new WeakSet<IDBTransaction>();
     97     IDBObjectStore.prototype.put = function (
     98       value: unknown,
     99       key?: IDBValidKey
    100     ) {
    101       const request =
    102         key === undefined ? put.call(this, value) : put.call(this, value, key);
    103       if (this.name === 'private_sends' && hits === 0) {
    104         hits++;
    105         if (mode === 'abort') abort.call(this.transaction);
    106         else {
    107           affected.add(this.transaction);
    108           throw Error('controlled lost acknowledgement');
    109         }
    110       }
    111       return request;
    112     };
    113     IDBTransaction.prototype.abort = function () {
    114       if (affected.has(this)) throw Error('controlled abort unavailable');
    115       return abort.call(this);
    116     };
    117     restore = () => {
    118       IDBObjectStore.prototype.put = put;
    119       IDBTransaction.prototype.abort = abort;
    120     };
    121     return () => hits;
    122   }
    123   async function holdOwner() {
    124     let entered: (() => void) | undefined;
    125     const ready = new Promise<void>((resolve) => {
    126       entered = resolve;
    127     });
    128     const held = navigator.locks.request(
    129       'harvestcircle:owner:' + cryptoFixture.owner,
    130       async () => {
    131         entered?.();
    132         await new Promise<void>((resolve) => {
    133           releaseLock = resolve;
    134         });
    135       }
    136     );
    137     await ready;
    138     return () => {
    139       releaseLock?.();
    140       return held;
    141     };
    142   }
    143   async function publicDraftRows() {
    144     const tx = browserDatabaseTransaction(
    145         database,
    146         ['public_drafts'],
    147         'readonly'
    148       ),
    149       request = tx.objectStore('public_drafts').getAll();
    150     return new Promise<string>((resolve, reject) => {
    151       tx.addEventListener('complete', () =>
    152         resolve(JSON.stringify(request.result))
    153       );
    154       tx.addEventListener('abort', () => reject(Error('inspection aborted')));
    155     });
    156   }
    157   async function corruptReservation() {
    158     const record = reservedSendSnapshot(cryptoFixture.reserved);
    159     if (!record) throw Error('missing original reservation');
    160     const tx = browserDatabaseTransaction(
    161       database,
    162       ['private_sends'],
    163       'readwrite'
    164     );
    165     tx.objectStore('private_sends').put({
    166       owner: record.owner,
    167       id: record.id,
    168       wire: '{"schema":999}'
    169     });
    170     await new Promise<void>((resolve, reject) => {
    171       tx.addEventListener('complete', () => resolve());
    172       tx.addEventListener('abort', () =>
    173         reject(Error('fixture write aborted'))
    174       );
    175     });
    176   }
    177   return {
    178     ...cryptoFixture,
    179     marker,
    180     database,
    181     repository,
    182     foreignRepository,
    183     preparation,
    184     fault,
    185     peerProof: () => proof('peer'),
    186     selfProof: () => proof('self'),
    187     holdOwner,
    188     publicDraftRows,
    189     corruptReservation,
    190     closePeerPreparation: closeEnvelopePreparation,
    191     pendingEncryption: () => {
    192       const slot = cryptoFixture.slot();
    193       return slot?.state === 'active' && slot.pending === 'encrypt';
    194     },
    195     closeStorage: () => closeBrowserDatabase(database),
    196     close() {
    197       restore();
    198       releaseLock?.();
    199       stopSelfRecoveryPreparation(preparation);
    200       for (const pair of pairs) if (pair) closeEnvelopePreparation(pair);
    201       closeBrowserDatabase(database);
    202       cryptoFixture.close();
    203     }
    204   };
    205 }