app

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

paired-delivery.ts (7365B)


      1 import { makeFixture as makeSelfFixture } from './self-recovery.ts';
      2 import type { finalizeEvent, EventTemplate } from 'applesauce-core/helpers';
      3 import { validateRelayPolicy } from '../../../src/lib/config/relays.ts';
      4 import {
      5   createPublicScheduler,
      6   createPublicRun,
      7   openInboxRequest,
      8   closePublicScheduler
      9 } from '../../../src/lib/nostr/request-scope.ts';
     10 import { createInboxResolver } from '../../../src/lib/messaging/resolve-inbox.ts';
     11 import {
     12   createInboxRoutePlan,
     13   inboxRoutePlanSnapshot
     14 } from '../../../src/lib/messaging/inbox-routing.ts';
     15 import { verifiedOutboundSnapshot } from '../../../src/lib/nostr/verify-outbound-envelope.ts';
     16 export { verifiedOutboundSnapshot, inboxRoutePlanSnapshot };
     17 import {
     18   prepareSelfRecovery,
     19   preparedSelfRecovery,
     20   selfRecoveryPeerPreparation,
     21   preparePairedDelivery,
     22   preparedPairedDelivery
     23 } from '../../../src/lib/messaging/prepare-send.ts';
     24 import {
     25   commitPairedDelivery,
     26   pairedDeliveryAcknowledgementSnapshot,
     27   selfRecoveryAcknowledgementSnapshot
     28 } from '../../../src/lib/persistence/private-sends.ts';
     29 import {
     30   decodePrivateRecord,
     31   privateRecordSnapshot
     32 } from '../../../src/lib/persistence/private-records.ts';
     33 import { loadPrivateRecord } from '../../../src/lib/persistence/private-storage.ts';
     34 import { browserDatabaseTransaction } from '../../../src/lib/persistence/database.ts';
     35 import { createPrivateSendReservationRepository } from '../../../src/lib/persistence/private-send-reservations.ts';
     36 import {
     37   reserveSendIdentity,
     38   reservedSendSnapshot
     39 } from '../../../src/lib/messaging/send-identity.ts';
     40 export {
     41   prepareSelfRecovery,
     42   preparedSelfRecovery,
     43   selfRecoveryPeerPreparation,
     44   preparePairedDelivery,
     45   preparedPairedDelivery,
     46   commitPairedDelivery,
     47   pairedDeliveryAcknowledgementSnapshot,
     48   selfRecoveryAcknowledgementSnapshot,
     49   decodePrivateRecord
     50 };
     51 const discovery = 'wss://discovery.example.org',
     52   peerOrigin = 'wss://peer.example.org',
     53   archiveOrigin = 'wss://archive.example.org';
     54 // Disposable existing source fixture provider signs actual public10050 facts;
     55 // local discovery observations qualify route semantics only, never relay Q.
     56 export async function makeFixture(
     57   options: Readonly<{
     58     messaging?: boolean;
     59     peerRead?: boolean;
     60     sharedOrigin?: boolean;
     61   }> = {}
     62 ) {
     63   const f = await makeSelfFixture(),
     64     policy = validateRelayPolicy(
     65       JSON.stringify({
     66         schemaVersion: 1,
     67         public: [{ origin: discovery, read: true, write: false, nip50: false }],
     68         inbox: (options.sharedOrigin
     69           ? [peerOrigin]
     70           : [peerOrigin, archiveOrigin]
     71         ).map((origin) => ({
     72           origin,
     73           read: origin === peerOrigin ? options.peerRead !== false : true,
     74           write: true
     75         })),
     76         postingEnabled: false,
     77         messagingEnabled: options.messaging === true,
     78         operatorDenylist: []
     79       })
     80     );
     81   if (!policy || !window.nostr) throw Error('missing fixture policy/provider');
     82   const provider = window.nostr as Readonly<{
     83     signEvent(
     84       template: EventTemplate
     85     ): Promise<ReturnType<typeof finalizeEvent>>;
     86   }>;
     87   const schedulers: ReturnType<typeof createPublicScheduler>[] = [];
     88   let current = true;
     89   async function preference(peer: boolean) {
     90     f.mode(peer ? 'wrong_author' : 'normal');
     91     const signed = await provider.signEvent({
     92       kind: 10050,
     93       created_at: 100,
     94       tags: [
     95         ['relay', peer || options.sharedOrigin ? peerOrigin : archiveOrigin]
     96       ],
     97       content: ''
     98     });
     99     f.mode('normal');
    100     return {
    101       id: signed.id,
    102       pubkey: signed.pubkey,
    103       sig: signed.sig,
    104       kind: signed.kind,
    105       created_at: signed.created_at,
    106       tags: signed.tags,
    107       content: signed.content
    108     };
    109   }
    110   const ownEvent = await preference(false),
    111     peerEvent = await preference(true);
    112   function resolve(event: typeof ownEvent) {
    113     const scheduler = createPublicScheduler({
    114       now: () => 0,
    115       schedule: () => () => {}
    116     });
    117     schedulers.push(scheduler);
    118     const run = createPublicRun(scheduler, policy!);
    119     return createInboxResolver(
    120       run,
    121       event.pubkey,
    122       (next) =>
    123         openInboxRequest(
    124           run,
    125           event.pubkey,
    126           (sink) => {
    127             sink({ type: 'EVENT', from: discovery, id: 'fixture', event });
    128             sink({ type: 'EOSE', from: discovery, id: 'fixture' });
    129             return () => {};
    130           },
    131           next
    132         ),
    133       () => current
    134     );
    135   }
    136   const own = resolve(ownEvent),
    137     other = resolve(peerEvent),
    138     plan = createInboxRoutePlan(policy, f.owner, f.peer, own, other);
    139   if (!plan) {
    140     f.close();
    141     throw Error('missing genuine route plan');
    142   }
    143   async function distinctIntent() {
    144     const repository = createPrivateSendReservationRepository(
    145       f.database,
    146       f.owner
    147     );
    148     const observed = Date.now(),
    149       realNow = Date.now;
    150     Date.now = () => observed;
    151     try {
    152       const rumor = f.textPlan(f.marker);
    153       if (!repository || !rumor) throw Error('missing distinct intent fixture');
    154       const result = await reserveSendIdentity(
    155         repository,
    156         f.identity,
    157         '22345678-1234-4234-8234-123456789abc',
    158         rumor,
    159         'reviewed_private_intent'
    160       );
    161       return {
    162         status: result.status,
    163         identity: 'identity' in result ? result.identity : undefined,
    164         id:
    165           'identity' in result
    166             ? reservedSendSnapshot(result.identity)?.id
    167             : undefined
    168       };
    169     } finally {
    170       Date.now = realNow;
    171     }
    172   }
    173   async function changePairRevision() {
    174     const identity = reservedSendSnapshot(f.reserved);
    175     if (!identity) throw Error('missing original fixture command');
    176     const loaded = await loadPrivateRecord(
    177       f.repository,
    178       'private_sends',
    179       identity.id
    180     );
    181     const row =
    182       loaded.ok && privateRecordSnapshot(loaded.value, f.owner, identity.id);
    183     if (!row || row.family !== 'private_send_operation' || !row.deliveryPlan)
    184       throw Error('missing original pair');
    185     const wire = JSON.stringify({ ...row, revision: row.revision + 1 });
    186     if (!decodePrivateRecord(wire, f.owner, identity.id).ok)
    187       throw Error('invalid competing fixture row');
    188     const tx = browserDatabaseTransaction(
    189       f.database,
    190       ['private_sends'],
    191       'readwrite'
    192     );
    193     tx.objectStore('private_sends').put({
    194       owner: f.owner,
    195       id: identity.id,
    196       wire
    197     });
    198     await new Promise<void>((resolve, reject) => {
    199       tx.addEventListener('complete', () => resolve());
    200       tx.addEventListener('abort', () =>
    201         reject(Error('competing fixture write aborted'))
    202       );
    203     });
    204   }
    205   async function storedPair() {
    206     const identity = reservedSendSnapshot(f.reserved);
    207     if (!identity) return undefined;
    208     const loaded = await loadPrivateRecord(
    209       f.repository,
    210       'private_sends',
    211       identity.id
    212     );
    213     const row =
    214       loaded.ok && privateRecordSnapshot(loaded.value, f.owner, identity.id);
    215     return row && row.family === 'private_send_operation' ? row : undefined;
    216   }
    217   return {
    218     ...f,
    219     context: { policy, own, other, plan },
    220     distinctIntent,
    221     changePairRevision,
    222     storedPair,
    223     staleRoutes() {
    224       current = false;
    225     },
    226     close() {
    227       for (const scheduler of schedulers) closePublicScheduler(scheduler);
    228       f.close();
    229     }
    230   };
    231 }