app

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

inbox-probe-retry.ts (23233B)


      1 import {
      2   makeRecoveryFixture,
      3   openRecoveryContext
      4 } from './inbox-probe-recovery.ts';
      5 import { RelayPool } from 'applesauce-relay';
      6 import { finalize } from 'rxjs';
      7 import {
      8   createPublicRuntimeContext,
      9   mountPublicRuntime,
     10   closePublicRuntime,
     11   createPublicView,
     12   beginPublicViewRun,
     13   disposePublicView
     14 } from '../../../src/lib/runtime/public-runtime.ts';
     15 import {
     16   resolveInboxPreference,
     17   settleInboxResolver,
     18   inboxResolutionSnapshot
     19 } from '../../../src/lib/messaging/resolve-inbox.ts';
     20 import {
     21   createInboxAccessController,
     22   closeInboxAccessController,
     23   inboxAccessControllerSnapshot,
     24   type InboxAccessController
     25 } from '../../../src/lib/messaging/inbox-access-controller.ts';
     26 import { privateSessionSnapshot } from '../../../src/lib/runtime/private-session.ts';
     27 import {
     28   openBrowserDatabase,
     29   closeBrowserDatabase,
     30   browserDatabaseTransaction
     31 } from '../../../src/lib/persistence/database.ts';
     32 import {
     33   reserveInboxProbeIdentity,
     34   inboxProbeSnapshot,
     35   type InboxProbeIdentity
     36 } from '../../../src/lib/nostr/inbox-access.ts';
     37 import {
     38   captureInboxProbeSealOperation,
     39   buildInboxProbeSeal
     40 } from '../../../src/lib/nostr/seal-builder.ts';
     41 import { buildInboxProbeGiftwrap } from '../../../src/lib/nostr/giftwrap-builder.ts';
     42 import {
     43   commitInboxProbe,
     44   adoptRecoveredInboxProbe,
     45   inboxProbeAcknowledgementSnapshot,
     46   inboxProbePublicationBinding,
     47   recoveredInboxProbePublicationBinding,
     48   commitInboxProbeArchiveAttempt,
     49   commitInboxProbeReadbackAttempt,
     50   type InboxProbeAcknowledgement
     51 } from '../../../src/lib/persistence/inbox-probes.ts';
     52 import {
     53   captureInboxProbeRecoveryReader,
     54   recoverInboxProbe,
     55   stopInboxProbeRecoveryReader,
     56   type InboxProbeRecoveryReader,
     57   type RecoveredInboxProbe
     58 } from '../../../src/lib/nostr/self-recovery-reader.ts';
     59 import {
     60   captureInboxProbePublicationAction,
     61   captureRecoveredInboxProbeRetryAction,
     62   captureInboxProbePublication,
     63   captureInboxProbeReadback,
     64   type InboxProbePublicationAction
     65 } from '../../../src/lib/nostr/private-publisher.ts';
     66 import {
     67   getPrivatePool,
     68   closePrivatePool,
     69   privatePoolProbeRetryIdle,
     70   publishInboxProbeArchiveAttempt,
     71   readInboxProbeAttempt,
     72   type PrivatePool,
     73   type InboxProbeArchiveAttemptResult,
     74   type InboxProbeReadbackAttemptResult
     75 } from '../../../src/lib/nostr/private-pool.ts';
     76 export * from './inbox-probe-recovery.ts';
     77 export {
     78   makeFixture as makeOrdinaryRecoveryFixture,
     79   resumeEncryptedPreparation,
     80   resumeRecoveredRumor
     81 } from './resume-preparation.ts';
     82 export {
     83   adoptRecoveredInboxProbe,
     84   captureRecoveredInboxProbeRetryAction,
     85   recoveredInboxProbePublicationBinding,
     86   inboxProbePublicationBinding,
     87   privatePoolProbeRetryIdle,
     88   commitInboxProbe,
     89   captureInboxProbePublicationAction,
     90   captureInboxProbePublication,
     91   captureInboxProbeReadback
     92 };
     93 export {
     94   authenticateInboxAccess,
     95   respondInboxAccessAuthentication,
     96   inboxAccessControllerSnapshot
     97 } from '../../../src/lib/messaging/inbox-access-controller.ts';
     98 export {
     99   closePrivateSession,
    100   subscribePrivateSessionClose,
    101   withIdlePrivateLocalStorage
    102 } from '../../../src/lib/runtime/private-session.ts';
    103 
    104 // Every actor and durable effect below is an actual source factory. The reused
    105 // host owns only ephemeral test crypto/native fixture access, never readiness.
    106 export async function makeRetryFixture() {
    107   const host = await makeRecoveryFixture(),
    108     publicContext = createPublicRuntimeContext(),
    109     runtime = mountPublicRuntime(publicContext, host.policy);
    110   if (!runtime) throw Error('actual shared public discovery');
    111   const shared = { context: publicContext, runtime };
    112   let actor: Awaited<ReturnType<typeof openRecoveryContext>> | undefined,
    113     access: InboxAccessController | undefined,
    114     replacementView: ReturnType<typeof createPublicView> | undefined,
    115     originalIdentity: InboxProbeIdentity | undefined,
    116     originalAck: InboxProbeAcknowledgement | undefined,
    117     originalAction: InboxProbePublicationAction | undefined,
    118     reader: InboxProbeRecoveryReader | undefined,
    119     proof: RecoveredInboxProbe | undefined,
    120     acknowledgement: InboxProbeAcknowledgement | undefined,
    121     action: InboxProbePublicationAction | undefined,
    122     command: string | undefined,
    123     pool: PrivatePool | undefined;
    124   const repository = host.repository;
    125   function currentActor() {
    126     if (!actor || !access) throw Error('actual current private actors missing');
    127     return { ...actor, access };
    128   }
    129   function acquire() {
    130     const a = currentActor();
    131     pool ??= getPrivatePool(
    132       a.session,
    133       host.policy,
    134       [
    135         'wss://inbox.example.org',
    136         'wss://peer.example.org',
    137         'wss://archive.example.org'
    138       ],
    139       access,
    140       'access'
    141     );
    142     if (!pool) throw Error('actual current private scope unavailable');
    143     return pool;
    144   }
    145   function stopCurrentController() {
    146     if (reader) stopInboxProbeRecoveryReader(reader);
    147     if (access) closeInboxAccessController(access);
    148     if (pool) closePrivatePool(pool);
    149     pool = undefined;
    150     if (replacementView) disposePublicView(replacementView);
    151     replacementView = undefined;
    152     reader = undefined;
    153     proof = undefined;
    154     acknowledgement = undefined;
    155     action = undefined;
    156   }
    157   return {
    158     host,
    159     repository,
    160     actors: currentActor,
    161     sharedPublicRuntime: () => runtime,
    162     originalIdentity: () => originalIdentity,
    163     originalAck: () => originalAck,
    164     proof: () => proof,
    165     acknowledgement: () => acknowledgement,
    166     action: () => action,
    167     command: () => command,
    168     pool: () => pool,
    169     async open() {
    170       actor = await openRecoveryContext(
    171         host.owner,
    172         host.policy,
    173         host.qualification,
    174         crypto.randomUUID(),
    175         shared
    176       );
    177       access = actor.access;
    178     },
    179     async prepareOriginal() {
    180       if (reader) stopInboxProbeRecoveryReader(reader);
    181       reader = undefined;
    182       proof = undefined;
    183       acknowledgement = undefined;
    184       action = undefined;
    185       const a = currentActor(),
    186         reserved = await reserveInboxProbeIdentity(
    187           repository,
    188           a.session,
    189           host.policy,
    190           a.access,
    191           host.qualification,
    192           'reviewed_inbox_probe_reservation'
    193         );
    194       if (!('identity' in reserved)) return reserved;
    195       originalIdentity = reserved.identity;
    196       const selected = inboxProbeSnapshot(originalIdentity);
    197       if (!selected) throw Error('actual original reserved identity');
    198       command = selected.id;
    199       const operation = captureInboxProbeSealOperation(
    200         a.session,
    201         originalIdentity,
    202         'reviewed_inbox_probe_seal'
    203       );
    204       if (!operation) throw Error('actual original seal admission');
    205       const sealed = await buildInboxProbeSeal(operation);
    206       if (!('seal' in sealed)) return sealed;
    207       const wrap = buildInboxProbeGiftwrap(
    208         sealed.seal,
    209         'reviewed_inbox_probe_wrap'
    210       );
    211       if (!wrap) throw Error('actual original wrap admission');
    212       const result = await commitInboxProbe(
    213         repository,
    214         a.session,
    215         wrap,
    216         'reviewed_inbox_probe_commit'
    217       );
    218       if ('acknowledgement' in result) originalAck = result.acknowledgement;
    219       originalAction = undefined;
    220       return result;
    221     },
    222     async recover() {
    223       const a = currentActor();
    224       if (!command) throw Error('actual original selection missing');
    225       reader ??= captureInboxProbeRecoveryReader(
    226         repository,
    227         a.identity,
    228         a.session,
    229         host.policy,
    230         a.access,
    231         host.qualification,
    232         command,
    233         'reviewed_inbox_probe_recovery'
    234       );
    235       if (!reader) return undefined;
    236       const result = await recoverInboxProbe(reader);
    237       if ('proof' in result) proof = result.proof;
    238       return result;
    239     },
    240     async adopt(review: unknown = 'reviewed_original_inbox_probe_retry') {
    241       const a = currentActor();
    242       if (!proof) throw Error('actual recovered proof missing');
    243       const result = await adoptRecoveredInboxProbe(
    244         repository,
    245         a.session,
    246         a.access,
    247         host.policy,
    248         host.qualification,
    249         proof,
    250         review
    251       );
    252       if ('acknowledgement' in result) acknowledgement = result.acknowledgement;
    253       return result;
    254     },
    255     async captureAction(
    256       review: unknown = 'reviewed_original_inbox_probe_retry'
    257     ) {
    258       const a = currentActor();
    259       if (!acknowledgement)
    260         throw Error('actual recovered acknowledgement missing');
    261       const selected = await captureRecoveredInboxProbeRetryAction(
    262         repository,
    263         a.session,
    264         host.policy,
    265         acknowledgement,
    266         review
    267       );
    268       if (selected) action = selected;
    269       return selected;
    270     },
    271     async originalPublish(
    272       origin = 'wss://inbox.example.org',
    273       signal = new AbortController().signal
    274     ) {
    275       const a = currentActor();
    276       if (!originalAck) throw Error('actual original acknowledgement missing');
    277       originalAction ??= captureInboxProbePublicationAction(
    278         repository,
    279         a.session,
    280         host.policy,
    281         originalAck,
    282         'reviewed_inbox_probe_network'
    283       );
    284       const permission =
    285         originalAction &&
    286         captureInboxProbePublication(
    287           repository,
    288           a.session,
    289           host.policy,
    290           originalAck,
    291           originalAction,
    292           origin,
    293           'reviewed_inbox_probe_publication'
    294         );
    295       return permission
    296         ? publishInboxProbeArchiveAttempt(acquire(), permission, signal)
    297         : undefined;
    298     },
    299     async originalRead(origin = 'wss://inbox.example.org') {
    300       const a = currentActor();
    301       if (!originalAck || !originalAction) return undefined;
    302       const permission = captureInboxProbeReadback(
    303         repository,
    304         a.session,
    305         host.policy,
    306         originalAck,
    307         originalAction,
    308         origin,
    309         'reviewed_inbox_probe_readback'
    310       );
    311       return permission
    312         ? readInboxProbeAttempt(
    313             acquire(),
    314             permission,
    315             new AbortController().signal
    316           )
    317         : undefined;
    318     },
    319     async publish(
    320       origin = 'wss://inbox.example.org',
    321       signal = new AbortController().signal
    322     ) {
    323       const a = currentActor();
    324       if (!acknowledgement || !action) return undefined;
    325       const permission = captureInboxProbePublication(
    326         repository,
    327         a.session,
    328         host.policy,
    329         acknowledgement,
    330         action,
    331         origin,
    332         'reviewed_inbox_probe_publication'
    333       );
    334       return permission
    335         ? publishInboxProbeArchiveAttempt(acquire(), permission, signal)
    336         : undefined;
    337     },
    338     async read(
    339       origin = 'wss://inbox.example.org',
    340       signal = new AbortController().signal
    341     ) {
    342       const a = currentActor();
    343       if (!acknowledgement || !action) return undefined;
    344       const permission = captureInboxProbeReadback(
    345         repository,
    346         a.session,
    347         host.policy,
    348         acknowledgement,
    349         action,
    350         origin,
    351         'reviewed_inbox_probe_readback'
    352       );
    353       return permission
    354         ? readInboxProbeAttempt(acquire(), permission, signal)
    355         : undefined;
    356     },
    357     append: (result: InboxProbeArchiveAttemptResult) =>
    358       commitInboxProbeArchiveAttempt(repository, result),
    359     appendRead: (result: InboxProbeReadbackAttemptResult) =>
    360       commitInboxProbeReadbackAttempt(repository, result),
    361     snapshot: () =>
    362       acknowledgement && inboxProbeAcknowledgementSnapshot(acknowledgement),
    363     originalBinding: () =>
    364       acknowledgement &&
    365       inboxProbePublicationBinding(
    366         repository,
    367         currentActor().session,
    368         acknowledgement,
    369         host.policy
    370       ),
    371     recoveredBinding: () =>
    372       acknowledgement &&
    373       recoveredInboxProbePublicationBinding(
    374         repository,
    375         currentActor().session,
    376         acknowledgement,
    377         host.policy
    378       ),
    379     idle: () => privatePoolProbeRetryIdle(currentActor().session, host.policy),
    380     installNetworkClock() {
    381       const original = performance.now.bind(performance);
    382       let now = original(),
    383         observations = 0;
    384       performance.now = () => {
    385         if (/at clock(?:\d+)? \(/.test(new Error().stack ?? '')) {
    386           observations++;
    387           return now;
    388         }
    389         return original();
    390       };
    391       return {
    392         advance: (value: number) => {
    393           now += value;
    394         },
    395         observations: () => observations,
    396         restore: () => {
    397           performance.now = original;
    398         }
    399       };
    400     },
    401     installAttemptTeardownFailure() {
    402       const original = Object.getOwnPropertyDescriptor(
    403           RelayPool.prototype,
    404           'relay'
    405         )!.value as RelayPool['relay'],
    406         restorations: (() => void)[] = [];
    407       let failing = true,
    408         faults = 0;
    409       RelayPool.prototype.relay = function (
    410         ...args: Parameters<RelayPool['relay']>
    411       ) {
    412         const relay = original.apply(this, args),
    413           event = relay.event.bind(relay);
    414         relay.event = (...args: Parameters<typeof relay.event>) =>
    415           event(...args).pipe(
    416             finalize(() => {
    417               if (failing) {
    418                 faults++;
    419                 throw Error('actual controlled SDK teardown failure');
    420               }
    421             })
    422           );
    423         restorations.push(() => {
    424           relay.event = event;
    425         });
    426         return relay;
    427       };
    428       return {
    429         faults: () => faults,
    430         restore: () => {
    431           failing = false;
    432           RelayPool.prototype.relay = original;
    433           for (const restore of restorations) restore();
    434         }
    435       };
    436     },
    437     installCommitFault(mode: 'aborted' | 'uncertain' | 'changed_successor') {
    438       const put = Object.getOwnPropertyDescriptor(
    439           IDBObjectStore.prototype,
    440           'put'
    441         )!.value as IDBObjectStore['put'],
    442         abort = Object.getOwnPropertyDescriptor(
    443           IDBTransaction.prototype,
    444           'abort'
    445         )!.value as IDBTransaction['abort'],
    446         transaction = Object.getOwnPropertyDescriptor(
    447           IDBDatabase.prototype,
    448           'transaction'
    449         )!.value as IDBDatabase['transaction'];
    450       let selected: IDBTransaction | undefined,
    451         putSuccess = 0,
    452         complete = 0,
    453         aborted = 0,
    454         abortRefused = 0,
    455         changed = 0;
    456       IDBDatabase.prototype.transaction = function (
    457         ...args: Parameters<IDBDatabase['transaction']>
    458       ) {
    459         // Queue a genuine competing write BEFORE the first final readonly
    460         // transaction. A later complete listener can run after its admission.
    461         if (
    462           mode === 'changed_successor' &&
    463           selected?.db === this &&
    464           !changed &&
    465           args[1] === 'readonly'
    466         ) {
    467           changed++;
    468           const next = transaction.call(this, ['private_sends'], 'readwrite'),
    469             store = next.objectStore('private_sends'),
    470             row = store.get([host.owner, command!]);
    471           row.addEventListener('success', () => {
    472             const current = row.result as {
    473                 owner: string;
    474                 id: string;
    475                 wire: string;
    476               },
    477               record = JSON.parse(current.wire) as { revision: number };
    478             record.revision++;
    479             put.call(store, { ...current, wire: JSON.stringify(record) });
    480           });
    481         }
    482         return transaction.apply(this, args);
    483       };
    484       IDBTransaction.prototype.abort = function (
    485         ...args: Parameters<IDBTransaction['abort']>
    486       ) {
    487         if (this === selected && mode !== 'aborted') {
    488           abortRefused++;
    489           throw Error('actual controlled abort refusal');
    490         }
    491         return abort.apply(this, args);
    492       };
    493       IDBObjectStore.prototype.put = function (
    494         ...args: Parameters<IDBObjectStore['put']>
    495       ) {
    496         const request = put.apply(this, args);
    497         if (!selected && this.name === 'private_sends') {
    498           selected = this.transaction;
    499           selected.addEventListener('complete', () => {
    500             complete++;
    501           });
    502           selected.addEventListener('abort', () => {
    503             aborted++;
    504           });
    505           request.addEventListener('success', () => {
    506             putSuccess++;
    507             if (mode === 'aborted') selected!.abort();
    508           });
    509           if (mode !== 'aborted')
    510             throw Error('actual controlled failure after native put admission');
    511         }
    512         return request;
    513       };
    514       return {
    515         counts: () => ({
    516           putSuccess,
    517           complete,
    518           aborted,
    519           abortRefused,
    520           changed
    521         }),
    522         restore: () => {
    523           IDBObjectStore.prototype.put = put;
    524           IDBTransaction.prototype.abort = abort;
    525           IDBDatabase.prototype.transaction = transaction;
    526         }
    527       };
    528     },
    529     async alternateController(foreignSession = false) {
    530       if (foreignSession) {
    531         const other = await openRecoveryContext(
    532           host.owner,
    533           host.policy,
    534           host.qualification,
    535           command!,
    536           shared
    537         );
    538         return {
    539           access: other.access,
    540           session: other.session,
    541           close: () => other.close()
    542         };
    543       }
    544       const view = createPublicView(runtime),
    545         run = beginPublicViewRun(view),
    546         resolver = resolveInboxPreference(view, run, host.owner);
    547       await settleInboxResolver(resolver);
    548       const other = createInboxAccessController(
    549         currentActor().session,
    550         host.policy,
    551         resolver
    552       );
    553       if (!other) throw Error('actual alternate controller');
    554       return {
    555         access: other,
    556         session: currentActor().session,
    557         close() {
    558           if (other !== access) closeInboxAccessController(other);
    559           disposePublicView(view);
    560         }
    561       };
    562     },
    563     async replacementWhilePending() {
    564       const a = currentActor(),
    565         view = createPublicView(runtime),
    566         run = beginPublicViewRun(view),
    567         resolver = resolveInboxPreference(view, run, host.owner);
    568       await settleInboxResolver(resolver);
    569       if (inboxResolutionSnapshot(resolver).status !== 'ready')
    570         throw Error('replacement must have actual ready discovery metadata');
    571       let other: InboxAccessController | undefined,
    572         recovery: InboxProbeRecoveryReader | undefined;
    573       try {
    574         other = createInboxAccessController(a.session, host.policy, resolver);
    575         if (!other)
    576           return {
    577             gate: 'actual_controller_factory' as const,
    578             privateCurrent: privateSessionSnapshot(a.session)?.current === true,
    579             originalController: inboxAccessControllerSnapshot(a.access)
    580           };
    581         recovery = captureInboxProbeRecoveryReader(
    582           repository,
    583           a.identity,
    584           a.session,
    585           host.policy,
    586           other,
    587           host.qualification,
    588           command!,
    589           'reviewed_inbox_probe_recovery'
    590         );
    591         if (!recovery)
    592           return {
    593             gate: 'actual_recovery_factory' as const,
    594             currentController: inboxAccessControllerSnapshot(other)
    595           };
    596         const recovered = await recoverInboxProbe(recovery);
    597         if (!('proof' in recovered))
    598           return {
    599             gate: 'actual_recovery_execution' as const,
    600             status: recovered.status,
    601             currentController: inboxAccessControllerSnapshot(other)
    602           };
    603         const adopted = await adoptRecoveredInboxProbe(
    604           repository,
    605           a.session,
    606           other,
    607           host.policy,
    608           host.qualification,
    609           recovered.proof,
    610           'reviewed_original_inbox_probe_retry'
    611         );
    612         if (!('acknowledgement' in adopted))
    613           return {
    614             gate: 'actual_adoption' as const,
    615             status: adopted.status,
    616             currentController: inboxAccessControllerSnapshot(other)
    617           };
    618         const binding = recoveredInboxProbePublicationBinding(
    619           repository,
    620           a.session,
    621           adopted.acknowledgement,
    622           host.policy
    623         );
    624         if (!binding?.current())
    625           throw Error(
    626             'fresh genuine recovered binding must be current before Retry'
    627           );
    628         const before = host.counts(),
    629           original = crypto.randomUUID.bind(crypto),
    630           closesBefore = Number(Reflect.get(window, 'ptCloseCalls') ?? 0);
    631         let uuids = 0;
    632         crypto.randomUUID = () => {
    633           uuids++;
    634           return original();
    635         };
    636         try {
    637           const selected = await captureRecoveredInboxProbeRetryAction(
    638             repository,
    639             a.session,
    640             host.policy,
    641             adopted.acknowledgement,
    642             'reviewed_original_inbox_probe_retry'
    643           );
    644           return {
    645             gate: 'actual_retry_admission' as const,
    646             genuineCurrentBinding: binding.current(),
    647             refused: !selected,
    648             uuids,
    649             before,
    650             after: host.counts(),
    651             closesBefore,
    652             closesAfter: Number(Reflect.get(window, 'ptCloseCalls') ?? 0),
    653             currentController: inboxAccessControllerSnapshot(other)
    654           };
    655         } finally {
    656           crypto.randomUUID = original;
    657         }
    658       } finally {
    659         if (recovery) stopInboxProbeRecoveryReader(recovery);
    660         if (other) closeInboxAccessController(other);
    661         disposePublicView(view);
    662       }
    663     },
    664     // Test-only physical deletion frees the existing native quota to test the
    665     // independent source meter bound. This is never product cleanup evidence.
    666     async removeFixtureRow() {
    667       const opened = await openBrowserDatabase();
    668       if (opened.state !== 'ready' || !command)
    669         throw Error('actual fixture deletion inputs');
    670       try {
    671         const tx = browserDatabaseTransaction(
    672           opened.owner,
    673           ['private_sends'],
    674           'readwrite'
    675         );
    676         tx.objectStore('private_sends').delete([host.owner, command]);
    677         await new Promise<void>((resolve, reject) => {
    678           tx.addEventListener('complete', () => resolve());
    679           tx.addEventListener('abort', () =>
    680             reject(Error('fixture delete abort'))
    681           );
    682         });
    683       } finally {
    684         closeBrowserDatabase(opened.owner);
    685       }
    686     },
    687     async replaceController() {
    688       const a = currentActor();
    689       stopCurrentController();
    690       replacementView = createPublicView(runtime);
    691       const run = beginPublicViewRun(replacementView),
    692         resolver = resolveInboxPreference(replacementView, run, host.owner);
    693       await settleInboxResolver(resolver);
    694       access = createInboxAccessController(a.session, host.policy, resolver);
    695       return access;
    696     },
    697     async freshSession() {
    698       stopCurrentController();
    699       actor?.close();
    700       actor = await openRecoveryContext(
    701         host.owner,
    702         host.policy,
    703         host.qualification,
    704         command ?? crypto.randomUUID(),
    705         shared
    706       );
    707       access = actor.access;
    708       return actor;
    709     },
    710     stop: stopCurrentController,
    711     close() {
    712       stopCurrentController();
    713       actor?.close();
    714       closePublicRuntime(publicContext);
    715       host.close();
    716     }
    717   };
    718 }