app

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

received-envelopes.ts (4539B)


      1 import { makeFixture as makeRecoveryFixture } from './resume-preparation.ts';
      2 import {
      3   createPrivateSession,
      4   closePrivateSession
      5 } from '../../../src/lib/runtime/private-session.ts';
      6 import {
      7   admitInboxEnvelope,
      8   retainInboxEnvelope
      9 } from '../../../src/lib/persistence/inbox-envelope-repository.ts';
     10 import {
     11   loadPrivateRecord,
     12   commitPrivateRecord
     13 } from '../../../src/lib/persistence/private-storage.ts';
     14 import {
     15   privateRecordSnapshot,
     16   decodePrivateRecord
     17 } from '../../../src/lib/persistence/private-records.ts';
     18 import {
     19   captureReceivedUnwrap,
     20   unwrapReceivedEnvelope,
     21   stopReceivedUnwrap,
     22   receivedNestedEnvelopeSnapshot,
     23   type ReceivedUnwrap,
     24   type ReceivedNestedEnvelope
     25 } from '../../../src/lib/nostr/unwrap-admission.ts';
     26 export async function makeFixture() {
     27   const f = await makeRecoveryFixture(),
     28     privateSession = await createPrivateSession(
     29       f.identity,
     30       'reviewed_private_session'
     31     );
     32   if (!privateSession) throw Error('missing genuine private session');
     33   const self = (await f.row())!.record.self,
     34     admitted = admitInboxEnvelope(
     35       self.wire,
     36       f.owner,
     37       'wss://archive.example.org',
     38       100
     39     );
     40   if (!admitted) throw Error('missing admitted real outer');
     41   const saved = await retainInboxEnvelope(
     42     f.repository,
     43     privateSession,
     44     admitted
     45   );
     46   if (saved.status !== 'retained' && saved.status !== 'duplicate')
     47     throw Error('no actual retained outer');
     48   let reader: ReceivedUnwrap | undefined,
     49     proof: ReceivedNestedEnvelope | undefined;
     50   let releaseKey: (() => void) | undefined;
     51   let restoreKey = () => {};
     52   return {
     53     ...f,
     54     outerId: self.eventId,
     55     capture(review: unknown = 'reviewed_inbox_unlock') {
     56       reader = captureReceivedUnwrap(
     57         f.repository,
     58         f.identity,
     59         self.eventId,
     60         review
     61       );
     62       return !!reader;
     63     },
     64     async run() {
     65       if (!reader) return { status: 'invalid' as const };
     66       const result = await unwrapReceivedEnvelope(reader);
     67       if (result.status === 'authenticated') proof = result.envelope;
     68       return {
     69         status: result.status,
     70         snapshot: proof && receivedNestedEnvelopeSnapshot(proof)
     71       };
     72     },
     73     stop() {
     74       if (reader) stopReceivedUnwrap(reader);
     75     },
     76     snapshot() {
     77       return proof && receivedNestedEnvelopeSnapshot(proof);
     78     },
     79     forged() {
     80       return receivedNestedEnvelopeSnapshot({} as ReceivedNestedEnvelope);
     81     },
     82     holdFinalKey() {
     83       const provider = window.nostr as
     84         { getPublicKey: () => Promise<string> } | undefined;
     85       if (!provider) throw Error('missing actual fixture provider');
     86       const original = provider.getPublicKey;
     87       let calls = 0;
     88       provider.getPublicKey = async () => {
     89         const owner = await original.call(provider);
     90         calls++;
     91         return calls === 3
     92           ? new Promise<string>((resolve) => {
     93               releaseKey = () => resolve(owner);
     94             })
     95           : owner;
     96       };
     97       restoreKey = () => {
     98         provider.getPublicKey = original;
     99       };
    100     },
    101     pendingFinalKey: () => !!releaseKey,
    102     settleFinalKey() {
    103       const release = releaseKey;
    104       releaseKey = undefined;
    105       release?.();
    106     },
    107     countsValue: () => f.counts(),
    108     async stored() {
    109       const row = await loadPrivateRecord(
    110         f.repository,
    111         'received_envelopes',
    112         self.eventId
    113       );
    114       return row.ok
    115         ? privateRecordSnapshot(row.value, f.owner, self.eventId)
    116         : undefined;
    117     },
    118     async changeObservedSource() {
    119       const old = await loadPrivateRecord(
    120         f.repository,
    121         'received_envelopes',
    122         self.eventId
    123       );
    124       if (!old.ok) throw Error('missing actual received row');
    125       const record = privateRecordSnapshot(old.value, f.owner, self.eventId);
    126       if (!record || record.family !== 'received_envelope')
    127         throw Error('wrong received row');
    128       const next = decodePrivateRecord(
    129         JSON.stringify({
    130           ...record,
    131           revision: record.revision + 1,
    132           sources: [...record.sources, 'wss://peer-inbox.example.org']
    133         }),
    134         f.owner,
    135         self.eventId
    136       );
    137       if (!next.ok) throw Error('invalid controlled metadata successor');
    138       return commitPrivateRecord(f.repository, next.value, old.value);
    139     },
    140     close() {
    141       releaseKey?.();
    142       releaseKey = undefined;
    143       restoreKey();
    144       if (reader) stopReceivedUnwrap(reader);
    145       closePrivateSession(privateSession);
    146       f.close();
    147     }
    148   };
    149 }