app

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

retry-send.ts (9408B)


      1 import {
      2   privateRecordSnapshot,
      3   type PrivateRecordHandle
      4 } from '../persistence/private-records.ts';
      5 import {
      6   loadPrivateRecord,
      7   type PrivateStorageRepository
      8 } from '../persistence/private-storage.ts';
      9 import {
     10   pairedDeliveryAcknowledgementSnapshot,
     11   pairedDeliveryRecordMatches,
     12   pairedDeliveryTargetAccepted,
     13   verifyPairedDeliveryAcknowledgement,
     14   commitPairedDeliveryReceipt,
     15   type PairedDeliveryAcknowledgement
     16 } from '../persistence/private-sends.ts';
     17 import {
     18   privateSessionOwnership,
     19   type PrivateSession
     20 } from '../runtime/private-session.ts';
     21 import {
     22   capturePrivatePublicationAction,
     23   capturePrivatePublication
     24 } from '../nostr/private-publisher.ts';
     25 import {
     26   publishPrivateGiftWrapAttempt,
     27   type PrivatePool
     28 } from '../nostr/private-pool.ts';
     29 import { PRIVATE_PUBLICATION_BUDGETS } from '../config/budgets.ts';
     30 import type { PairedDeliveryContext } from './prepare-send.ts';
     31 import { reconcilePrivateSendAttempt } from '../persistence/private-send-settlements.ts';
     32 // Codec readback metadata alone is not a qualified authenticated remote query.
     33 // Only named acceptance suppresses retry here; separate readback remains visible.
     34 export function privateRetryTargets(
     35   handle: PrivateRecordHandle,
     36   owner: unknown,
     37   id: unknown
     38 ) {
     39   const row = privateRecordSnapshot(handle, owner, id);
     40   if (
     41     !row ||
     42     row.family !== 'private_send_operation' ||
     43     !row.peerArtifact ||
     44     !row.deliveryPlan
     45   )
     46     return undefined;
     47   const pair = row.peerArtifact;
     48   return [
     49     row.deliveryPlan.routes.peer,
     50     row.deliveryPlan.routes.archive
     51   ].flatMap((route) => {
     52     const eventId = route.role === 'peer' ? pair.eventId : row.self.eventId;
     53     return route.targets
     54       .filter(
     55         (origin) =>
     56           !(row.receipts ?? []).some(
     57             (f) =>
     58               f.role === route.role &&
     59               f.origin === origin &&
     60               f.eventId === eventId &&
     61               f.status === 'accepted'
     62           )
     63       )
     64       .map((origin) => ({ role: route.role, origin, eventId }));
     65   });
     66 }
     67 declare const retryBrand: unique symbol;
     68 export type PrivateRetry = Readonly<{ [retryBrand]: true }>;
     69 type Result = Readonly<{
     70   status: 'completed' | 'needs_action' | 'stopped' | 'invalid' | 'busy';
     71 }>;
     72 type Controller = {
     73   run(review: unknown): Promise<Result>;
     74   stop(): void;
     75   snapshot(): Readonly<{
     76     owner: string;
     77     command: string;
     78     state: Result['status'] | 'ready';
     79     attempts: number;
     80   }>;
     81 };
     82 const retries = new WeakMap<PrivateRetry, Controller>();
     83 // Capture is explicit, memory-only and opens no socket. Genuine custody and
     84 // actual whole-wire readback are rechecked before every externally visible step.
     85 export function capturePrivateRetry(
     86   repository: PrivateStorageRepository,
     87   session: PrivateSession,
     88   receipt: PairedDeliveryAcknowledgement,
     89   context: PairedDeliveryContext,
     90   pool: PrivatePool,
     91   review: unknown
     92 ): PrivateRetry | undefined {
     93   if (typeof window === 'undefined' || review !== 'reviewed_private_retry')
     94     return undefined;
     95   const ownership = privateSessionOwnership(session),
     96     row = pairedDeliveryAcknowledgementSnapshot(receipt);
     97   if (!ownership?.current() || !row || row.owner !== ownership.owner)
     98     return undefined;
     99   const action = capturePrivatePublicationAction(
    100     repository,
    101     session,
    102     receipt,
    103     context,
    104     review
    105   );
    106   if (!action) return undefined;
    107   const abort = new AbortController();
    108   let consumed = false,
    109     busy = false,
    110     attempts = 0,
    111     state: Result['status'] | 'ready' = 'ready';
    112   const token = Object.freeze({}) as PrivateRetry;
    113   function finish(status: Result['status']): Result {
    114     state = status;
    115     return { status };
    116   }
    117   retries.set(token, {
    118     stop() {
    119       abort.abort();
    120       state = 'stopped';
    121     },
    122     snapshot() {
    123       return { owner: row.owner, command: row.id, state, attempts };
    124     },
    125     async run(reviewed) {
    126       if (reviewed !== 'reviewed_private_retry') return { status: 'invalid' };
    127       if (abort.signal.aborted || !ownership.current())
    128         return finish('stopped');
    129       if (busy) return { status: 'busy' };
    130       if (consumed) return { status: 'invalid' };
    131       consumed = true;
    132       busy = true;
    133       try {
    134         if (!(await verifyPairedDeliveryAcknowledgement(repository, receipt)))
    135           return finish('needs_action');
    136         const loaded = await loadPrivateRecord(
    137           repository,
    138           'private_sends',
    139           row.id
    140         );
    141         if (abort.signal.aborted || !ownership.current())
    142           return finish('stopped');
    143         if (
    144           !loaded.ok ||
    145           !pairedDeliveryRecordMatches(receipt, loaded.value) ||
    146           !(await verifyPairedDeliveryAcknowledgement(repository, receipt))
    147         )
    148           return finish('needs_action');
    149         if (abort.signal.aborted || !ownership.current())
    150           return finish('stopped');
    151         const targets =
    152           loaded.ok && privateRetryTargets(loaded.value, row.owner, row.id);
    153         if (!targets) return finish('needs_action');
    154         for (const target of targets) {
    155           let accepted = false;
    156           for (
    157             let index = 0;
    158             index < PRIVATE_PUBLICATION_BUDGETS.attemptsPerTargetAction;
    159             index++
    160           ) {
    161             if (abort.signal.aborted || !ownership.current())
    162               return finish('stopped');
    163             if (
    164               pairedDeliveryTargetAccepted(
    165                 receipt,
    166                 target.role,
    167                 target.origin,
    168                 target.eventId
    169               )
    170             ) {
    171               if (
    172                 !(await verifyPairedDeliveryAcknowledgement(
    173                   repository,
    174                   receipt
    175                 ))
    176               )
    177                 return finish('needs_action');
    178               if (abort.signal.aborted || !ownership.current())
    179                 return finish('stopped');
    180               accepted = true;
    181               break;
    182             }
    183             const permission = capturePrivatePublication(
    184               repository,
    185               session,
    186               receipt,
    187               context,
    188               target.role,
    189               target.origin,
    190               'reviewed_private_delivery',
    191               action
    192             );
    193             if (!permission) return finish('needs_action');
    194             const result = await publishPrivateGiftWrapAttempt(
    195               pool,
    196               permission,
    197               abort.signal
    198             );
    199             if (abort.signal.aborted || !ownership.current()) {
    200               if (result.actionId) attempts++;
    201               await reconcilePrivateSendAttempt(result);
    202               return finish('stopped');
    203             }
    204             if (
    205               !result.actionId &&
    206               pairedDeliveryTargetAccepted(
    207                 receipt,
    208                 target.role,
    209                 target.origin,
    210                 target.eventId
    211               ) &&
    212               (await verifyPairedDeliveryAcknowledgement(repository, receipt))
    213             ) {
    214               if (abort.signal.aborted || !ownership.current())
    215                 return finish('stopped');
    216               accepted = true;
    217               break;
    218             }
    219             if (
    220               !result.actionId ||
    221               !result.attempt ||
    222               result.role !== target.role ||
    223               result.origin !== target.origin ||
    224               result.eventId !== target.eventId
    225             )
    226               return finish('needs_action');
    227             attempts++;
    228             const observedAtMilliseconds = Date.now();
    229             if (
    230               !Number.isSafeInteger(observedAtMilliseconds) ||
    231               observedAtMilliseconds < 0
    232             )
    233               return finish('needs_action');
    234             const saved = await commitPairedDeliveryReceipt(
    235               repository,
    236               receipt,
    237               JSON.stringify({
    238                 actionId: result.actionId,
    239                 role: target.role,
    240                 origin: target.origin,
    241                 eventId: target.eventId,
    242                 attempt: result.attempt,
    243                 status: result.status,
    244                 observedAtMilliseconds,
    245                 readbackWire: null
    246               })
    247             );
    248             if (abort.signal.aborted || !ownership.current()) {
    249               await reconcilePrivateSendAttempt(result);
    250               return finish('stopped');
    251             }
    252             if (!('record' in saved)) return finish('needs_action');
    253             if (result.status === 'accepted') {
    254               accepted = true;
    255               break;
    256             }
    257             if (result.status === 'refused' || result.status === 'stopped')
    258               return finish('needs_action');
    259           }
    260           if (!accepted) return finish('needs_action');
    261         }
    262         return finish('completed');
    263       } catch {
    264         return finish(
    265           abort.signal.aborted || !ownership.current()
    266             ? 'stopped'
    267             : 'needs_action'
    268         );
    269       } finally {
    270         busy = false;
    271       }
    272     }
    273   });
    274   return token;
    275 }
    276 export function runPrivateRetry(
    277   token: PrivateRetry,
    278   review: unknown
    279 ): Promise<Result> {
    280   return (
    281     retries.get(token)?.run(review) ?? Promise.resolve({ status: 'invalid' })
    282   );
    283 }
    284 export function stopPrivateRetry(token: PrivateRetry): void {
    285   retries.get(token)?.stop();
    286 }
    287 export function privateRetrySnapshot(token: PrivateRetry) {
    288   return retries.get(token)?.snapshot();
    289 }