app

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

inbox-probe-nonce-facts.ts (10332B)


      1 import { makeRetryFixture } from './inbox-probe-retry.ts';
      2 import {
      3   captureInboxProbeNonceReader,
      4   captureRecoveredInboxProbeNonceReader,
      5   readInboxProbeNonce,
      6   readRecoveredInboxProbeNonce,
      7   stopInboxProbeNonceReader,
      8   stopRecoveredInboxProbeNonceReader,
      9   expireInboxProbeNonceReaderWait,
     10   expireRecoveredInboxProbeNonceReaderWait,
     11   type InboxProbeNonceReader,
     12   type RecoveredInboxProbeNonceReader,
     13   type InboxProbeNonceProof,
     14   type RecoveredInboxProbeNonceProof
     15 } from '../../../src/lib/nostr/self-recovery-reader.ts';
     16 import { inboxProbeNonceVerificationEvidence } from '../../../src/lib/nostr/self-recovery-reader.ts';
     17 import { inboxProbeReadbackAttemptEvidence } from '../../../src/lib/nostr/private-pool.ts';
     18 import {
     19   decodePrivateRecord,
     20   privateRecordWire,
     21   type PrivateAccessProbeReceipt
     22 } from '../../../src/lib/persistence/private-records.ts';
     23 import {
     24   commitInboxProbeNonceVerification,
     25   inboxProbeNonceAcknowledgementBinding,
     26   type InboxProbeNonceAcknowledgement
     27 } from '../../../src/lib/persistence/inbox-probes.ts';
     28 import { closePrivateSession } from '../../../src/lib/runtime/private-session.ts';
     29 import type { InboxProbeReadbackAttemptResult } from '../../../src/lib/nostr/private-pool.ts';
     30 export * from './inbox-probe-retry.ts';
     31 export * from '../../../src/lib/nostr/self-recovery-reader.ts';
     32 export * from '../../../src/lib/persistence/inbox-probes.ts';
     33 export { createPrivateStorageRepository } from '../../../src/lib/persistence/private-storage.ts';
     34 export { privateRecordSettlement } from '../../../src/lib/persistence/local-inventory.ts';
     35 export { inboxProbeReadbackAttemptEvidence } from '../../../src/lib/nostr/private-pool.ts';
     36 export { capturePrivateOutboxCleanup } from '../../../src/lib/persistence/private-outbox-cleanup.ts';
     37 export {
     38   createIdentitySession,
     39   connectIdentity,
     40   probeIdentityMessaging,
     41   disconnectIdentity
     42 } from '../../../src/lib/runtime/identity-session.ts';
     43 export { createPrivateSession } from '../../../src/lib/runtime/private-session.ts';
     44 export {
     45   openBrowserDatabase,
     46   closeBrowserDatabase,
     47   browserDatabaseTransaction
     48 } from '../../../src/lib/persistence/database.ts';
     49 
     50 export async function makeNonceFactsFixture() {
     51   const base = await makeRetryFixture();
     52   let recovered = false,
     53     observation: InboxProbeReadbackAttemptResult | undefined,
     54     reader: InboxProbeNonceReader | RecoveredInboxProbeNonceReader | undefined,
     55     proof: InboxProbeNonceProof | RecoveredInboxProbeNonceProof | undefined,
     56     acknowledgement: InboxProbeNonceAcknowledgement | undefined;
     57   const restores = new Set<() => void>();
     58   function retain(off: () => void) {
     59     restores.add(off);
     60     return () => {
     61       off();
     62       restores.delete(off);
     63     };
     64   }
     65   function capture(review: unknown = 'reviewed_inbox_probe_nonce_decryption') {
     66     if (!observation) return undefined;
     67     const a = base.actors();
     68     return (
     69       recovered
     70         ? captureRecoveredInboxProbeNonceReader
     71         : captureInboxProbeNonceReader
     72     )(
     73       base.repository,
     74       a.identity,
     75       a.session,
     76       base.host.policy,
     77       observation,
     78       review
     79     );
     80   }
     81   function stop(expired = false) {
     82     if (!reader) return;
     83     if (recovered) {
     84       if (expired)
     85         expireRecoveredInboxProbeNonceReaderWait(
     86           reader as RecoveredInboxProbeNonceReader
     87         );
     88       else
     89         stopRecoveredInboxProbeNonceReader(
     90           reader as RecoveredInboxProbeNonceReader
     91         );
     92     } else if (expired)
     93       expireInboxProbeNonceReaderWait(reader as InboxProbeNonceReader);
     94     else stopInboxProbeNonceReader(reader as InboxProbeNonceReader);
     95   }
     96   function lose(kind: 'reader' | 'expiry' | 'controller' | 'head' | 'session') {
     97     if (kind === 'reader' || kind === 'expiry') stop(kind === 'expiry');
     98     else if (kind === 'head') base.actors().churnHead();
     99     else if (kind === 'session') closePrivateSession(base.actors().session);
    100     else base.stop();
    101   }
    102   return {
    103     ...base,
    104     observation: () => observation,
    105     nonceReader: () => reader,
    106     nonceProof: () => proof,
    107     nonceAcknowledgement: () => acknowledgement,
    108     captureNonce: capture,
    109     lose,
    110     async prepareRead(useRecovered: boolean, apply = true) {
    111       stop();
    112       reader = undefined;
    113       proof = undefined;
    114       acknowledgement = undefined;
    115       recovered = useRecovered;
    116       if (recovered) {
    117         await base.freshSession();
    118         if (
    119           (await base.recover())?.status !== 'recovered' ||
    120           (await base.adopt()).status !== 'adopted' ||
    121           !(await base.captureAction())
    122         )
    123           throw Error('actual recovered original Retry setup');
    124       }
    125       const pub = recovered
    126         ? await base.publish()
    127         : await base.originalPublish();
    128       if (
    129         pub?.status !== 'accepted' ||
    130         (await base.append(pub)).status !== 'saved'
    131       )
    132         throw Error('actual original archive effect and native append');
    133       observation = recovered ? await base.read() : await base.originalRead();
    134       if (observation?.status !== 'readback')
    135         throw Error('actual original B2 readback');
    136       if (apply && (await base.appendRead(observation)).status !== 'saved')
    137         throw Error('actual original B2 native append');
    138       return observation;
    139     },
    140     applyRead: () => observation && base.appendRead(observation),
    141     async nonce(selected = (reader ??= capture())) {
    142       if (!selected) return { status: 'invalid' as const };
    143       reader ??= selected;
    144       const result = recovered
    145         ? await readRecoveredInboxProbeNonce(
    146             selected as RecoveredInboxProbeNonceReader
    147           )
    148         : await readInboxProbeNonce(selected as InboxProbeNonceReader);
    149       if ('proof' in result) proof = result.proof;
    150       return result;
    151     },
    152     async appendNonce() {
    153       if (!proof) throw Error('actual nonce proof required');
    154       const result = await commitInboxProbeNonceVerification(
    155         base.repository,
    156         base.actors().session,
    157         base.host.policy,
    158         proof
    159       );
    160       if (result.acknowledgement) acknowledgement = result.acknowledgement;
    161       return result;
    162     },
    163     nonceBinding: () =>
    164       acknowledgement &&
    165       inboxProbeNonceAcknowledgementBinding(
    166         base.repository,
    167         base.actors().session,
    168         acknowledgement,
    169         base.host.policy
    170       ),
    171     async storedRow() {
    172       const row = (await base.host.stored()).find(
    173         (x) => x.id === base.command()
    174       );
    175       if (!row) throw Error('actual selected native row missing');
    176       return row;
    177     },
    178     async handwrittenNonceSuccessor() {
    179       if (!proof || !observation)
    180         throw Error('actual genuine nonce and read evidence required');
    181       const evidence = inboxProbeNonceVerificationEvidence(
    182           proof,
    183           base.repository,
    184           base.actors().session,
    185           base.host.policy
    186         ),
    187         effect = inboxProbeReadbackAttemptEvidence(observation),
    188         row = (await base.host.stored()).find((x) => x.id === base.command());
    189       if (!evidence || !effect || !row)
    190         throw Error('actual current fixture source associations');
    191       const record = JSON.parse(row.wire) as {
    192           revision: number;
    193           receipts: PrivateAccessProbeReceipt[];
    194         },
    195         fact = JSON.parse(effect.receiptWire) as PrivateAccessProbeReceipt,
    196         candidate = decodePrivateRecord(
    197           JSON.stringify({
    198             ...record,
    199             revision: record.revision + 1,
    200             receipts: [
    201               ...record.receipts,
    202               {
    203                 ...fact,
    204                 status: 'nonce_verified',
    205                 observedAtMilliseconds: evidence.verifiedAtMilliseconds
    206               }
    207             ]
    208           }),
    209           row.owner,
    210           row.id
    211         );
    212       if (!candidate.ok)
    213         throw Error('actual strict codec handwritten successor');
    214       const wire = privateRecordWire(candidate.value, row.owner, row.id);
    215       if (!wire) throw Error('actual strict canonical successor wire');
    216       return { ...row, wire };
    217     },
    218     nativeReadonlyHook(
    219       hit: number,
    220       kind: 'before_abort' | 'after_abort' | 'callback',
    221       callback = () => {}
    222     ) {
    223       const original = Object.getOwnPropertyDescriptor(
    224         IDBIndex.prototype,
    225         'openCursor'
    226       )!.value as IDBIndex['openCursor'];
    227       let hits = 0,
    228         faults = 0;
    229       IDBIndex.prototype.openCursor = function (
    230         ...args: Parameters<IDBIndex['openCursor']>
    231       ) {
    232         const request = original.apply(this, args);
    233         if (
    234           this.objectStore.name === 'private_sends' &&
    235           this.objectStore.transaction.mode === 'readonly' &&
    236           ++hits === hit
    237         ) {
    238           faults++;
    239           const tx = this.objectStore.transaction;
    240           if (kind === 'before_abort') tx.abort();
    241           else if (kind === 'after_abort')
    242             request.addEventListener('success', () => {
    243               if (!request.result) tx.abort();
    244             });
    245           else callback();
    246         }
    247         return request;
    248       };
    249       return {
    250         faults: () => faults,
    251         restore: retain(() => {
    252           IDBIndex.prototype.openCursor = original;
    253         })
    254       };
    255     },
    256     nativeWriteHook(callback: () => void) {
    257       const original = Object.getOwnPropertyDescriptor(
    258         IDBObjectStore.prototype,
    259         'put'
    260       )!.value as IDBObjectStore['put'];
    261       let hits = 0;
    262       IDBObjectStore.prototype.put = function (
    263         ...args: Parameters<IDBObjectStore['put']>
    264       ) {
    265         const request = original.apply(this, args);
    266         if (this.name === 'private_sends' && !hits++)
    267           request.addEventListener('success', callback, { once: true });
    268         return request;
    269       };
    270       return {
    271         hits: () => hits,
    272         restore: retain(() => {
    273           IDBObjectStore.prototype.put = original;
    274         })
    275       };
    276     },
    277     clockHook(callback: () => void) {
    278       const original = Date.now;
    279       let hits = 0;
    280       Date.now = () => {
    281         if (!hits++) callback();
    282         return original();
    283       };
    284       return {
    285         hits: () => hits,
    286         restore: retain(() => {
    287           Date.now = original;
    288         })
    289       };
    290     },
    291     close() {
    292       for (const off of restores) off();
    293       restores.clear();
    294       stop();
    295       base.close();
    296     }
    297   };
    298 }