app

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

inbox-retention.ts (10092B)


      1 import { makeFixture as makeRecoveryFixture } from './resume-preparation.ts';
      2 import {
      3   createPrivateSession,
      4   closePrivateSession,
      5   privateSessionOwnership
      6 } from '../../../src/lib/runtime/private-session.ts';
      7 import { captureUnlockedSession } from '../../../src/lib/messaging/unlocked-session.ts';
      8 import {
      9   captureInboxSync,
     10   startInboxSync,
     11   stopInboxSync,
     12   inboxSyncSnapshot,
     13   type InboxSync
     14 } from '../../../src/lib/messaging/inbox-sync.ts';
     15 import {
     16   validateRelayPolicy,
     17   readRelayPolicy
     18 } from '../../../src/lib/config/relays.ts';
     19 import {
     20   captureReceivedCleanup,
     21   deleteReviewedReceivedCopies,
     22   receivedCleanupSnapshot,
     23   stopReceivedCleanup,
     24   type ReceivedCleanup
     25 } from '../../../src/lib/persistence/inbox-retention.ts';
     26 import {
     27   admitInboxEnvelope,
     28   retainInboxEnvelope
     29 } from '../../../src/lib/persistence/inbox-envelope-repository.ts';
     30 import {
     31   listPrivateReceivedRecords,
     32   commitPrivateRecord,
     33   createPrivateStorageRepository
     34 } from '../../../src/lib/persistence/private-storage.ts';
     35 import {
     36   decodePrivateRecord,
     37   privateRecordIdentity,
     38   privateRecordWire,
     39   privateRecordSnapshot
     40 } from '../../../src/lib/persistence/private-records.ts';
     41 import {
     42   openBrowserDatabase,
     43   closeBrowserDatabase
     44 } from '../../../src/lib/persistence/database.ts';
     45 import { finalizeEvent, getPublicKey } from 'applesauce-core/helpers';
     46 import { nip44 } from 'applesauce-core/helpers/encryption';
     47 export async function makeFixture() {
     48   const f = await makeRecoveryFixture();
     49   const session = await createPrivateSession(
     50     f.identity,
     51     'reviewed_private_session'
     52   );
     53   if (!session) throw Error('genuine session absent');
     54   const unlocked = captureUnlockedSession(session, 'reviewed_messages_unlock');
     55   if (!unlocked) throw Error('genuine unlock absent');
     56   const policy = validateRelayPolicy(
     57     JSON.stringify({
     58       ...readRelayPolicy(f.context.policy),
     59       messagingEnabled: true
     60     })
     61   );
     62   if (!policy) throw Error('policy absent');
     63   const initial = (await f.row())!;
     64   const originalOutbox = JSON.stringify(initial.record);
     65   const ownerSecret = new Uint8Array(32).fill(83),
     66     outerSecret = new Uint8Array(32).fill(86),
     67     otherSecret = new Uint8Array(32).fill(85),
     68     otherOwner = getPublicKey(otherSecret);
     69   const ids: string[] = [];
     70   let outer: string = '',
     71     foreignWire: string = '';
     72   const opened = await openBrowserDatabase();
     73   if (opened.state !== 'ready') throw Error('native database absent');
     74   const foreignRepo = createPrivateStorageRepository(opened.owner, otherOwner);
     75   if (!foreignRepo) throw Error('foreign namespace absent');
     76   try {
     77     const original = JSON.parse(initial.record.self.wire) as {
     78       pubkey: string;
     79       content: string;
     80     };
     81     const key = nip44.v2.utils.getConversationKey(ownerSecret, original.pubkey);
     82     let seal: string;
     83     try {
     84       seal = nip44.v2.decrypt(original.content, key);
     85     } finally {
     86       key.fill(0);
     87     }
     88     function wrap(target: string, n: number) {
     89       const k = nip44.v2.utils.getConversationKey(outerSecret, target);
     90       try {
     91         return finalizeEvent(
     92           {
     93             kind: 1059,
     94             created_at: 1700000000 + n,
     95             tags: [['p', target]],
     96             content: nip44.v2.encrypt(seal, k)
     97           },
     98           outerSecret
     99         );
    100       } finally {
    101         k.fill(0);
    102       }
    103     }
    104     for (let i = 0; i < 3; i++) {
    105       const event = wrap(f.owner, i);
    106       const wire = JSON.stringify(event),
    107         admitted = admitInboxEnvelope(
    108           wire,
    109           f.owner,
    110           'wss://archive.example.org',
    111           100 + i
    112         );
    113       if (
    114         !admitted ||
    115         (await retainInboxEnvelope(f.repository, session, admitted)).status !==
    116           'retained'
    117       )
    118         throw Error('real retention absent');
    119       ids.push(event.id);
    120       if (!i) outer = wire;
    121     }
    122     const event = wrap(otherOwner, 4),
    123       decoded = decodePrivateRecord(
    124         JSON.stringify({
    125           schema: 1,
    126           family: 'received_envelope',
    127           owner: otherOwner,
    128           id: event.id,
    129           revision: 0,
    130           outer: JSON.stringify(event),
    131           observedAtMilliseconds: 100,
    132           sources: ['wss://archive.example.org'],
    133           read: null
    134         }),
    135         otherOwner,
    136         event.id
    137       );
    138     if (!decoded.ok) throw Error('foreign structural record absent');
    139     if (!(await commitPrivateRecord(foreignRepo, decoded.value, null)).ok)
    140       throw Error('foreign native row absent');
    141     foreignWire = privateRecordWire(decoded.value, otherOwner, event.id)!;
    142   } finally {
    143     ownerSecret.fill(0);
    144     outerSecret.fill(0);
    145     otherSecret.fill(0);
    146   }
    147   let cleanup: ReceivedCleanup | undefined, sync: InboxSync | undefined;
    148   let restore = () => {};
    149   const baseline = f.counts();
    150   async function rows() {
    151     const result = await listPrivateReceivedRecords(f.repository);
    152     if (!result.ok) throw Error('native scan failed');
    153     return result.value.map((h) => ({
    154       id: privateRecordIdentity(h)!.id,
    155       wire: privateRecordWire(h, f.owner, privateRecordIdentity(h)!.id)!
    156     }));
    157   }
    158   return {
    159     ...f,
    160     outer,
    161     ids,
    162     async select(
    163       selected: unknown = ids.slice(0, 2),
    164       review: unknown = 'reviewed_received_cleanup_selection'
    165     ) {
    166       cleanup = await captureReceivedCleanup(
    167         f.repository,
    168         session,
    169         selected,
    170         review
    171       );
    172       return !!cleanup;
    173     },
    174     snapshot: () => cleanup && receivedCleanupSnapshot(cleanup),
    175     purge: (review: unknown = 'reviewed_delete_local_received_copies') =>
    176       cleanup
    177         ? deleteReviewedReceivedCopies(cleanup, review)
    178         : Promise.resolve({ status: 'invalid' }),
    179     copied: () =>
    180       deleteReviewedReceivedCopies(
    181         {} as ReceivedCleanup,
    182         'reviewed_delete_local_received_copies'
    183       ),
    184     rows,
    185     async preserved() {
    186       const rows = await listPrivateReceivedRecords(foreignRepo);
    187       return (
    188         JSON.stringify((await f.row())!.record) === originalOutbox &&
    189         rows.ok &&
    190         rows.value.length === 1 &&
    191         privateRecordWire(
    192           rows.value[0],
    193           otherOwner,
    194           privateRecordIdentity(rows.value[0])!.id
    195         ) === foreignWire
    196       );
    197     },
    198     delta: () => ({
    199       decrypts: f.counts().decrypts - baseline.decrypts,
    200       encrypts: f.counts().encrypts - baseline.encrypts,
    201       signs: f.counts().signs - baseline.signs
    202     }),
    203     logout() {
    204       closePrivateSession(session);
    205     },
    206     async revise() {
    207       const scan = await listPrivateReceivedRecords(f.repository);
    208       if (!scan.ok) throw Error('scan absent');
    209       const base = scan.value.find(
    210         (h) => privateRecordIdentity(h)?.id === ids[0]
    211       )!;
    212       const row = privateRecordSnapshot(base, f.owner, ids[0])!;
    213       if (row.family !== 'received_envelope')
    214         throw Error('received row absent');
    215       const next = decodePrivateRecord(
    216         JSON.stringify({
    217           ...row,
    218           revision: row.revision + 1,
    219           sources: [...row.sources, 'wss://other.example.org']
    220         }),
    221         f.owner,
    222         ids[0]
    223       );
    224       if (
    225         !next.ok ||
    226         !(await commitPrivateRecord(f.repository, next.value, base)).ok
    227       )
    228         throw Error('actual CAS revision failed');
    229     },
    230     fault(kind: 'abort' | 'readback' | 'logout_cursor' | 'stop_cursor') {
    231       const remove = Reflect.get<IDBObjectStore, 'delete'>(
    232           IDBObjectStore.prototype,
    233           'delete'
    234         ),
    235         cursor = Reflect.get<IDBIndex, 'openCursor'>(
    236           IDBIndex.prototype,
    237           'openCursor'
    238         );
    239       let written = false;
    240       IDBObjectStore.prototype.delete = function (
    241         ...args: Parameters<IDBObjectStore['delete']>
    242       ) {
    243         const request = remove.apply(this, args);
    244         if (this.name === 'received_envelopes') {
    245           written = true;
    246           if (kind === 'abort') this.transaction.abort();
    247         }
    248         return request;
    249       };
    250       IDBIndex.prototype.openCursor = function (
    251         ...args: Parameters<IDBIndex['openCursor']>
    252       ) {
    253         if (this.objectStore.name === 'received_envelopes') {
    254           if (
    255             kind === 'stop_cursor' &&
    256             this.objectStore.transaction.mode === 'readwrite' &&
    257             cleanup
    258           )
    259             stopReceivedCleanup(cleanup);
    260           if (
    261             kind === 'readback' &&
    262             written &&
    263             this.objectStore.transaction.mode === 'readonly'
    264           )
    265             throw Error('actual post-delete readback failure');
    266           if (
    267             kind === 'logout_cursor' &&
    268             this.objectStore.transaction.mode === 'readwrite'
    269           )
    270             closePrivateSession(session);
    271         }
    272         return cursor.apply(this, args);
    273       };
    274       restore = () => {
    275         IDBObjectStore.prototype.delete = remove;
    276         IDBIndex.prototype.openCursor = cursor;
    277       };
    278     },
    279     restore() {
    280       restore();
    281     },
    282     start() {
    283       const ownership = privateSessionOwnership(session)!;
    284       sync = captureInboxSync(
    285         f.repository,
    286         session,
    287         policy,
    288         f.context.own,
    289         unlocked,
    290         (c) => ({
    291           ...c,
    292           receive: 'qualified_exercised',
    293           archive: 'qualified_exercised',
    294           current: ownership.current
    295         }),
    296         'reviewed_foreground_inbox'
    297       );
    298       return !!sync && startInboxSync(sync, 'reviewed_foreground_inbox');
    299     },
    300     sync: () => sync && inboxSyncSnapshot(sync),
    301     storm(contentBytes = 16) {
    302       const secret = new Uint8Array(32).fill(87);
    303       try {
    304         return finalizeEvent(
    305           {
    306             kind: 1059,
    307             created_at: 1700000000,
    308             tags: [['p', f.owner]],
    309             content: 'x'.repeat(contentBytes)
    310           },
    311           secret
    312         );
    313       } finally {
    314         secret.fill(0);
    315       }
    316     },
    317     close() {
    318       restore();
    319       if (cleanup) stopReceivedCleanup(cleanup);
    320       if (sync) stopInboxSync(sync);
    321       closePrivateSession(session);
    322       closeBrowserDatabase(opened.owner);
    323       f.close();
    324     }
    325   };
    326 }