app

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

inbox-probe-cleanup.ts (20730B)


      1 import { makeRetryFixture } from './inbox-probe-retry.ts';
      2 import {
      3   captureInboxProbeNonceReader,
      4   captureRecoveredInboxProbeNonceReader,
      5   readInboxProbeNonce,
      6   readRecoveredInboxProbeNonce,
      7   type InboxProbeNonceProof,
      8   type RecoveredInboxProbeNonceProof
      9 } from '../../../src/lib/nostr/self-recovery-reader.ts';
     10 import {
     11   commitInboxProbeNonceVerification,
     12   type InboxProbeNonceAcknowledgement
     13 } from '../../../src/lib/persistence/inbox-probes.ts';
     14 import {
     15   captureInboxProbeCleanup,
     16   deleteReviewedInboxProbe,
     17   stopInboxProbeCleanup,
     18   inboxProbeRemovalAcknowledgementBinding,
     19   type InboxProbeCleanup,
     20   type InboxProbeRemovalAcknowledgement
     21 } from '../../../src/lib/persistence/inbox-probe-cleanup.ts';
     22 import { captureInboxProbePublicationAction } from '../../../src/lib/nostr/private-publisher.ts';
     23 import type {
     24   InboxProbeArchiveAttemptResult,
     25   InboxProbeReadbackAttemptResult
     26 } from '../../../src/lib/nostr/private-pool.ts';
     27 import type { PrivateAccessProbe } from '../../../src/lib/persistence/private-records.ts';
     28 import { generateSecretKey, finalizeEvent } from 'applesauce-core/helpers';
     29 import { nip44 } from 'applesauce-core/helpers/encryption';
     30 import {
     31   decodePrivateRecord,
     32   privateRecordSnapshot
     33 } from '../../../src/lib/persistence/private-records.ts';
     34 import { privateRecordSettlement } from '../../../src/lib/persistence/local-inventory.ts';
     35 import {
     36   openBrowserDatabase,
     37   browserDatabaseTransaction,
     38   closeBrowserDatabase
     39 } from '../../../src/lib/persistence/database.ts';
     40 import {
     41   captureInboxProbeSealOperation,
     42   buildInboxProbeSeal
     43 } from '../../../src/lib/nostr/seal-builder.ts';
     44 import { buildInboxProbeGiftwrap } from '../../../src/lib/nostr/giftwrap-builder.ts';
     45 import { commitInboxProbe } from '../../../src/lib/persistence/inbox-probes.ts';
     46 export * from './inbox-probe-nonce-facts.ts';
     47 export * from '../../../src/lib/persistence/inbox-probe-cleanup.ts';
     48 export {
     49   removePrivateInboxProbe,
     50   privateProbeRemovalEvidence
     51 } from '../../../src/lib/persistence/private-storage.ts';
     52 export {
     53   acquireInboxProbeCleanupLease,
     54   releaseInboxProbeCleanupLease,
     55   retireInboxProbeCleanupLease,
     56   inboxProbePublicationSnapshot,
     57   inboxProbeReadbackSnapshot
     58 } from '../../../src/lib/nostr/private-publisher.ts';
     59 export {
     60   publishInboxProbeArchiveAttempt,
     61   readInboxProbeAttempt
     62 } from '../../../src/lib/nostr/private-pool.ts';
     63 export { inboxProbeRumorWire } from '../../../src/lib/nostr/inbox-access.ts';
     64 export { inboxAccessConstructionBinding } from '../../../src/lib/messaging/inbox-access-controller.ts';
     65 export {
     66   getPrivatePool,
     67   closePrivatePool,
     68   subscribePrivatePage,
     69   subscribePrivateLive
     70 } from '../../../src/lib/nostr/private-pool.ts';
     71 export {
     72   beginInboxAuthentication,
     73   closeInboxAuthentication
     74 } from '../../../src/lib/nostr/inbox-auth.ts';
     75 
     76 export async function makeCleanupFixture() {
     77   const base = await makeRetryFixture();
     78   let recovered = false,
     79     nonce: InboxProbeNonceAcknowledgement | undefined,
     80     proof: InboxProbeNonceProof | RecoveredInboxProbeNonceProof | undefined,
     81     cleanup: InboxProbeCleanup | undefined,
     82     removal: InboxProbeRemovalAcknowledgement | undefined,
     83     observation: InboxProbeReadbackAttemptResult | undefined;
     84   const observations: (
     85       InboxProbeArchiveAttemptResult | InboxProbeReadbackAttemptResult
     86     )[] = [],
     87     restores = new Set<() => void>();
     88   function retain(off: () => void) {
     89     restores.add(off);
     90     return () => {
     91       off();
     92       restores.delete(off);
     93     };
     94   }
     95   const row = async () => {
     96     const found = (await base.host.stored()).find(
     97       (x) => x.id === base.command()
     98     );
     99     if (!found) throw Error('actual selected row missing');
    100     return JSON.parse(found.wire) as PrivateAccessProbe;
    101   };
    102   return {
    103     ...base,
    104     observations: () => observations.slice(),
    105     nonce: () => nonce,
    106     nonceProof: () => proof,
    107     cleanup: () => cleanup,
    108     removal: () => removal,
    109     observation: () => observation,
    110     async retryOriginalPreparation() {
    111       const identity = base.originalIdentity(),
    112         a = base.actors();
    113       if (!identity) throw Error('actual original identity');
    114       const operation = captureInboxProbeSealOperation(
    115         a.session,
    116         identity,
    117         'reviewed_inbox_probe_seal'
    118       );
    119       if (!operation) return { status: 'capture_refused' };
    120       const sealed = await buildInboxProbeSeal(operation);
    121       if (!('seal' in sealed)) return sealed;
    122       const wrapped = buildInboxProbeGiftwrap(
    123         sealed.seal,
    124         'reviewed_inbox_probe_wrap'
    125       );
    126       return wrapped
    127         ? commitInboxProbe(
    128             base.repository,
    129             a.session,
    130             wrapped,
    131             'reviewed_inbox_probe_commit'
    132           )
    133         : { status: 'wrap_refused' };
    134     },
    135     async seedPreservedRecords() {
    136       const selected = await row(),
    137         owner = selected.owner,
    138         peer =
    139           'c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5',
    140         secret = generateSecretKey(),
    141         conversation = nip44.v2.utils.getConversationKey(secret, peer);
    142       let peerArtifact: { eventId: string; wire: string };
    143       try {
    144         const outer = finalizeEvent(
    145           {
    146             kind: 1059,
    147             created_at: selected.createdAt,
    148             tags: [['p', peer]],
    149             content: nip44.v2.encrypt(
    150               'storage-only preservation fixture',
    151               conversation
    152             )
    153           },
    154           secret
    155         );
    156         peerArtifact = { eventId: outer.id, wire: JSON.stringify(outer) };
    157       } finally {
    158         conversation.fill(0);
    159         secret.fill(0);
    160       }
    161       const route = (
    162         role: 'peer' | 'self_archive',
    163         author: string,
    164         origin: string
    165       ) => ({
    166         role,
    167         author,
    168         targets: [origin],
    169         knownBase: { author, id: 'c'.repeat(64), createdAt: 100 },
    170         sources: [
    171           {
    172             source: 'wss://discovery.example.org',
    173             state: 'eose',
    174             head: { id: 'c'.repeat(64), createdAt: 100 }
    175           }
    176         ]
    177       });
    178       // Strict native metadata fixtures, not sender capabilities or exchange Q.
    179       const ordinary = {
    180           schema: 1,
    181           family: 'private_send_operation',
    182           owner,
    183           id: crypto.randomUUID(),
    184           revision: 1,
    185           peer,
    186           rumorHash: selected.rumorHash,
    187           createdAt: selected.createdAt,
    188           self: selected.self!,
    189           peerArtifact,
    190           deliveryPlan: {
    191             state: 'prepared',
    192             routes: {
    193               peer: route('peer', peer, 'wss://peer.example.org'),
    194               archive: route('self_archive', owner, 'wss://archive.example.org')
    195             }
    196           },
    197           receipts: [
    198             {
    199               actionId: crypto.randomUUID(),
    200               origin: 'wss://peer.example.org',
    201               role: 'peer',
    202               attempt: 1,
    203               eventId: peerArtifact.eventId,
    204               status: 'accepted',
    205               observedAtMilliseconds: 1700000000000,
    206               readbackWire: null
    207             },
    208             {
    209               actionId: crypto.randomUUID(),
    210               origin: 'wss://archive.example.org',
    211               role: 'self_archive',
    212               attempt: 1,
    213               eventId: selected.self!.eventId,
    214               status: 'accepted',
    215               observedAtMilliseconds: 1700000000000,
    216               readbackWire: null
    217             }
    218           ]
    219         },
    220         protectedProbe = { ...selected, id: crypto.randomUUID() },
    221         received = {
    222           schema: 1,
    223           family: 'received_envelope',
    224           owner,
    225           id: selected.self!.eventId,
    226           revision: 0,
    227           outer: selected.self!.wire,
    228           observedAtMilliseconds: 1700000000000,
    229           sources: ['wss://inbox.example.org'],
    230           read: null
    231         };
    232       const values = [ordinary, protectedProbe, received].map((value) => {
    233         const wire = JSON.stringify(value),
    234           decoded = decodePrivateRecord(wire, owner, value.id);
    235         if (!decoded.ok) throw Error('strict preservation fixture rejected');
    236         const record = privateRecordSnapshot(decoded.value, owner, value.id)!;
    237         if (value === ordinary && privateRecordSettlement(record) !== 'settled')
    238           throw Error('actual settled metadata required');
    239         return { owner, id: value.id, wire };
    240       });
    241       const opened = await openBrowserDatabase();
    242       if (opened.state !== 'ready') throw Error('actual preservation database');
    243       const database = opened.owner;
    244       try {
    245         const tx = browserDatabaseTransaction(
    246           database,
    247           ['private_sends', 'received_envelopes'],
    248           'readwrite'
    249         );
    250         values.forEach((value, index) =>
    251           tx
    252             .objectStore(index === 2 ? 'received_envelopes' : 'private_sends')
    253             .put(value)
    254         );
    255         await new Promise<void>((resolve, reject) => {
    256           tx.addEventListener('complete', () => resolve());
    257           tx.addEventListener('abort', () =>
    258             reject(Error('preservation native seed abort'))
    259           );
    260         });
    261       } finally {
    262         closeBrowserDatabase(database);
    263       }
    264       return values;
    265     },
    266     async receivedRows() {
    267       const opened = await openBrowserDatabase();
    268       if (opened.state !== 'ready') throw Error('actual received database');
    269       try {
    270         const tx = browserDatabaseTransaction(
    271             opened.owner,
    272             ['received_envelopes'],
    273             'readonly'
    274           ),
    275           request = tx.objectStore('received_envelopes').getAll();
    276         return await new Promise<{ owner: string; id: string; wire: string }[]>(
    277           (resolve, reject) => {
    278             tx.addEventListener('complete', () => resolve(request.result));
    279             tx.addEventListener('abort', () =>
    280               reject(Error('received native observation abort'))
    281             );
    282           }
    283         );
    284       } finally {
    285         closeBrowserDatabase(opened.owner);
    286       }
    287     },
    288     async qualify(
    289       useRecovered = false,
    290       options: { fresh?: boolean; skip?: string[]; readOrigin?: string } = {}
    291     ) {
    292       recovered = useRecovered;
    293       observations.length = 0;
    294       nonce = undefined;
    295       proof = undefined;
    296       cleanup = undefined;
    297       removal = undefined;
    298       if (recovered) {
    299         if (options.fresh !== false) await base.freshSession();
    300         if (
    301           (await base.recover())?.status !== 'recovered' ||
    302           (await base.adopt()).status !== 'adopted' ||
    303           !(await base.captureAction())
    304         )
    305           throw Error('actual recovered cleanup setup');
    306       }
    307       const selected = await row();
    308       for (const origin of selected.binding.archiveTargets) {
    309         if (options.skip?.includes(origin)) continue;
    310         const result = await (recovered
    311           ? base.publish(origin)
    312           : base.originalPublish(origin));
    313         if (
    314           !result ||
    315           result.status !== 'accepted' ||
    316           (await base.append(result)).status !== 'saved'
    317         )
    318           throw Error('actual named archive source and native append');
    319         observations.push(result);
    320       }
    321       observation = await (recovered
    322         ? base.read(options.readOrigin)
    323         : base.originalRead(options.readOrigin));
    324       if (
    325         !observation ||
    326         observation.status !== 'readback' ||
    327         (await base.appendRead(observation)).status !== 'saved'
    328       )
    329         throw Error('actual source readback and native append');
    330       observations.push(observation);
    331       const a = base.actors(),
    332         reader = (
    333           recovered
    334             ? captureRecoveredInboxProbeNonceReader
    335             : captureInboxProbeNonceReader
    336         )(
    337           base.repository,
    338           a.identity,
    339           a.session,
    340           base.host.policy,
    341           observation,
    342           'reviewed_inbox_probe_nonce_decryption'
    343         );
    344       if (!reader) throw Error('actual nonce reader');
    345       const verified = recovered
    346         ? await readRecoveredInboxProbeNonce(
    347             reader as Parameters<typeof readRecoveredInboxProbeNonce>[0]
    348           )
    349         : await readInboxProbeNonce(
    350             reader as Parameters<typeof readInboxProbeNonce>[0]
    351           );
    352       if (!('proof' in verified))
    353         throw Error('actual nonce verification ' + verified.status);
    354       proof = verified.proof;
    355       const saved = await commitInboxProbeNonceVerification(
    356         base.repository,
    357         a.session,
    358         base.host.policy,
    359         proof
    360       );
    361       if (!saved.acknowledgement)
    362         throw Error('actual nonce native fact ' + saved.status);
    363       nonce = saved.acknowledgement;
    364       return saved;
    365     },
    366     async select(
    367       review: unknown = 'reviewed_inbox_probe_cleanup_selection',
    368       input: unknown = observations
    369     ) {
    370       cleanup = await captureInboxProbeCleanup(
    371         base.repository,
    372         base.actors().session,
    373         base.host.policy,
    374         nonce!,
    375         input,
    376         review
    377       );
    378       return cleanup;
    379     },
    380     async remove(
    381       review: unknown = 'reviewed_delete_local_inbox_probe',
    382       selected = cleanup
    383     ) {
    384       const result = await deleteReviewedInboxProbe(selected!, review);
    385       if (result.acknowledgement) removal = result.acknowledgement;
    386       return result;
    387     },
    388     stopCleanup() {
    389       if (cleanup) stopInboxProbeCleanup(cleanup);
    390     },
    391     removalBinding: () =>
    392       removal &&
    393       inboxProbeRemovalAcknowledgementBinding(
    394         removal,
    395         base.repository,
    396         base.actors().session,
    397         base.host.policy
    398       ),
    399     async withHeld<T>(kind: 'lock' | 'SDK', work: () => Promise<T>) {
    400       let release = () => {},
    401         enter = () => {};
    402       const entered = new Promise<void>((resolve) => {
    403           enter = resolve;
    404         }),
    405         wait = new Promise<void>((resolve) => {
    406           release = resolve;
    407         }),
    408         holder = async () => {
    409           enter();
    410           await wait;
    411         },
    412         held =
    413           kind === 'lock'
    414             ? navigator.locks.request(
    415                 'harvestcircle:owner:' + base.host.owner,
    416                 holder
    417               )
    418             : (
    419                 await import('../../../src/lib/runtime/private-session.ts')
    420               ).withIdlePrivateLocalStorage(base.actors().session, holder);
    421       await entered;
    422       try {
    423         return await work();
    424       } finally {
    425         release();
    426         await held;
    427       }
    428     },
    429     async capacity() {
    430       const session = base.actors().session,
    431         originals = new Map<string, string>();
    432       for (let index = 0; index < 100; index++) {
    433         if (index) {
    434           if (
    435             !(await base.replaceController()) ||
    436             (await base.prepareOriginal()).status !== 'prepared'
    437           )
    438             throw Error('actual protected capacity preparation ' + index);
    439         }
    440         if (
    441           !captureInboxProbePublicationAction(
    442             base.repository,
    443             session,
    444             base.host.policy,
    445             base.originalAck()!,
    446             'reviewed_inbox_probe_network'
    447           )
    448         )
    449           throw Error('actual protected command slot ' + index);
    450         const selected = (await base.host.stored()).find(
    451           (x) => x.id === base.command()
    452         )!;
    453         originals.set(selected.id, selected.wire);
    454       }
    455       const retained = await base.host.stored();
    456       if (retained.length !== 100 || base.actors().session !== session)
    457         throw Error('actual same-session full capacity');
    458       await base.replaceController();
    459       const denied = await base.prepareOriginal();
    460       return { session, originals, denied };
    461     },
    462     // Actual native request/complete/abort instrumentation; no success labels.
    463     nativeFault(
    464       mode:
    465         | 'abort'
    466         | 'uncertain'
    467         | 'complete_loss'
    468         | 'read_before'
    469         | 'read_after'
    470         | 'read_loss'
    471         | 'delete_loss'
    472         | 'wire_race'
    473         | 'initial_read_abort'
    474         | 'native_pre_delete_loss',
    475       callback = () => {}
    476     ) {
    477       const remove = Object.getOwnPropertyDescriptor(
    478           IDBObjectStore.prototype,
    479           'delete'
    480         )!.value as IDBObjectStore['delete'],
    481         abort = Object.getOwnPropertyDescriptor(
    482           IDBTransaction.prototype,
    483           'abort'
    484         )!.value as IDBTransaction['abort'],
    485         cursor = Object.getOwnPropertyDescriptor(
    486           IDBIndex.prototype,
    487           'openCursor'
    488         )!.value as IDBIndex['openCursor'],
    489         transaction = Object.getOwnPropertyDescriptor(
    490           IDBDatabase.prototype,
    491           'transaction'
    492         )!.value as IDBDatabase['transaction'];
    493       let selected: IDBTransaction | undefined,
    494         readonly = 0,
    495         deletes = 0,
    496         completes = 0,
    497         aborts = 0,
    498         refused = 0,
    499         races = 0;
    500       IDBDatabase.prototype.transaction = function (
    501         ...args: Parameters<IDBDatabase['transaction']>
    502       ) {
    503         if (
    504           mode === 'wire_race' &&
    505           !races &&
    506           args[1] === 'readwrite' &&
    507           Array.from(args[0] as string[]).includes('private_sends')
    508         ) {
    509           races++;
    510           const other = transaction.call(this, ['private_sends'], 'readwrite'),
    511             store = other.objectStore('private_sends'),
    512             get = store.get([base.host.owner, base.command()!]);
    513           get.addEventListener('success', () => {
    514             const item = get.result as {
    515                 owner: string;
    516                 id: string;
    517                 wire: string;
    518               },
    519               record = JSON.parse(item.wire) as { revision: number };
    520             record.revision++;
    521             store.put({ ...item, wire: JSON.stringify(record) });
    522           });
    523         }
    524         return transaction.apply(this, args);
    525       };
    526       IDBIndex.prototype.openCursor = function (
    527         ...args: Parameters<IDBIndex['openCursor']>
    528       ) {
    529         const request = cursor.apply(this, args),
    530           tx = this.objectStore.transaction;
    531         if (
    532           this.objectStore.name === 'private_sends' &&
    533           tx.mode === 'readonly'
    534         ) {
    535           readonly++;
    536           const hit = readonly;
    537           if (mode === 'read_before' && hit === 2) tx.abort();
    538           if (mode === 'read_after' && hit === 2)
    539             request.addEventListener('success', () => {
    540               if (!request.result) tx.abort();
    541             });
    542           if (mode === 'read_loss' && hit === 1)
    543             request.addEventListener('success', () => {
    544               if (!request.result) callback();
    545             });
    546           if (mode === 'initial_read_abort' && hit === 1) tx.abort();
    547         }
    548         if (
    549           this.objectStore.name === 'private_sends' &&
    550           tx.mode === 'readwrite' &&
    551           mode === 'native_pre_delete_loss'
    552         )
    553           request.addEventListener('success', () => {
    554             if (!request.result) callback();
    555           });
    556         return request;
    557       };
    558       IDBTransaction.prototype.abort = function (
    559         ...args: Parameters<IDBTransaction['abort']>
    560       ) {
    561         if (this === selected && mode === 'uncertain') {
    562           refused++;
    563           throw Error('controlled actual abort refusal');
    564         }
    565         return abort.apply(this, args);
    566       };
    567       IDBObjectStore.prototype.delete = function (
    568         ...args: Parameters<IDBObjectStore['delete']>
    569       ) {
    570         const request = remove.apply(this, args);
    571         if (this.name === 'private_sends' && !selected) {
    572           deletes++;
    573           selected = this.transaction;
    574           selected.addEventListener('complete', () => {
    575             completes++;
    576             if (mode === 'complete_loss') callback();
    577           });
    578           selected.addEventListener('abort', () => {
    579             aborts++;
    580           });
    581           request.addEventListener('success', () => {
    582             if (mode === 'abort') selected!.abort();
    583             if (mode === 'delete_loss') callback();
    584           });
    585           if (mode === 'uncertain')
    586             throw Error('controlled throw after actual delete admission');
    587         }
    588         return request;
    589       };
    590       return {
    591         counts: () => ({
    592           readonly,
    593           deletes,
    594           completes,
    595           aborts,
    596           refused,
    597           races
    598         }),
    599         restore: retain(() => {
    600           IDBObjectStore.prototype.delete = remove;
    601           IDBTransaction.prototype.abort = abort;
    602           IDBIndex.prototype.openCursor = cursor;
    603           IDBDatabase.prototype.transaction = transaction;
    604         })
    605       };
    606     },
    607     close() {
    608       for (const off of restores) off();
    609       restores.clear();
    610       if (cleanup) stopInboxProbeCleanup(cleanup);
    611       base.close();
    612     }
    613   };
    614 }