app

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

resume-preparation.ts (12452B)


      1 import {
      2   finalizeEvent,
      3   getPublicKey,
      4   type UnsignedEvent
      5 } from 'applesauce-core/helpers';
      6 import { nip44 } from 'applesauce-core/helpers/encryption';
      7 import { verifyEnvelope } from '../../../src/lib/nostr/verified-envelope.ts';
      8 import {
      9   createIdentitySession,
     10   connectIdentity,
     11   probeIdentityMessaging,
     12   disconnectIdentity
     13 } from '../../../src/lib/runtime/identity-session.ts';
     14 import {
     15   openBrowserDatabase,
     16   closeBrowserDatabase,
     17   browserDatabaseTransaction
     18 } from '../../../src/lib/persistence/database.ts';
     19 import {
     20   createPrivateStorageRepository,
     21   loadPrivateRecord
     22 } from '../../../src/lib/persistence/private-storage.ts';
     23 import {
     24   privateRecordSnapshot,
     25   privateRecordWire,
     26   decodePrivateRecord
     27 } from '../../../src/lib/persistence/private-records.ts';
     28 import { createPrivateSendReservationRepository } from '../../../src/lib/persistence/private-send-reservations.ts';
     29 import { captureEnquiryContext } from '../../../src/lib/messaging/enquiry-context.ts';
     30 import {
     31   captureEnquiryRumor,
     32   stopRumorPlan,
     33   rumorPlanSnapshot
     34 } from '../../../src/lib/messaging/rumor-plan.ts';
     35 import {
     36   reserveSendIdentity,
     37   reservedSendSnapshot
     38 } from '../../../src/lib/messaging/send-identity.ts';
     39 import {
     40   captureSelfRecoveryPreparation,
     41   prepareSelfRecovery,
     42   stopSelfRecoveryPreparation
     43 } from '../../../src/lib/messaging/prepare-send.ts';
     44 import {
     45   browserExtensionScheduler,
     46   extensionSchedulerSnapshot
     47 } from '../../../src/lib/nostr/extension-scheduler.ts';
     48 import { validateRelayPolicy } from '../../../src/lib/config/relays.ts';
     49 import {
     50   createPublicScheduler,
     51   createPublicRun,
     52   openInboxRequest,
     53   closePublicScheduler
     54 } from '../../../src/lib/nostr/request-scope.ts';
     55 import { createInboxResolver } from '../../../src/lib/messaging/resolve-inbox.ts';
     56 import { createInboxRoutePlan } from '../../../src/lib/messaging/inbox-routing.ts';
     57 import {
     58   captureResumePreparation,
     59   resumeEncryptedPreparation,
     60   resumePreparationSnapshot,
     61   resumeRecoveredRumor,
     62   stopResumePreparation
     63 } from '../../../src/lib/messaging/resume-preparation.ts';
     64 export {
     65   captureResumePreparation,
     66   resumeEncryptedPreparation,
     67   resumePreparationSnapshot,
     68   resumeRecoveredRumor,
     69   stopResumePreparation,
     70   rumorPlanSnapshot
     71 };
     72 // Public disposable fixture keys, never installed operator credentials. Stable
     73 // only so an actual page reload can unlock the same actual stored ciphertext.
     74 const command = '12345678-1234-4234-8234-123456789abc',
     75   marker = 'HCP083_PRIVATE_RECOVERY_MEMORY_ONLY_SENTINEL';
     76 type Mode =
     77   | 'normal'
     78   | 'changed_key'
     79   | 'hold_decrypt'
     80   | 'declined_decrypt'
     81   | 'wrong_plaintext';
     82 export async function makeFixture(initialise = true) {
     83   const secret = new Uint8Array(32).fill(83),
     84     peerSecret = new Uint8Array(32).fill(84),
     85     owner = getPublicKey(secret),
     86     peer = getPublicKey(peerSecret);
     87   let mode: Mode = 'normal',
     88     keys = 0,
     89     encrypts = 0,
     90     decrypts = 0,
     91     signs = 0,
     92     release: (() => void) | undefined;
     93   function encrypt(target: string, text: string) {
     94     const conversation = nip44.v2.utils.getConversationKey(secret, target);
     95     try {
     96       return nip44.v2.encrypt(text, conversation);
     97     } finally {
     98       conversation.fill(0);
     99     }
    100   }
    101   function decrypt(target: string, wire: string) {
    102     const conversation = nip44.v2.utils.getConversationKey(secret, target);
    103     try {
    104       return nip44.v2.decrypt(wire, conversation);
    105     } finally {
    106       conversation.fill(0);
    107     }
    108   }
    109   Object.defineProperty(window, 'nostr', {
    110     configurable: true,
    111     value: {
    112       getPublicKey: () => {
    113         keys++;
    114         return Promise.resolve(mode === 'changed_key' ? peer : owner);
    115       },
    116       signEvent: (template: UnsignedEvent) => {
    117         signs++;
    118         return Promise.resolve(finalizeEvent(template, secret));
    119       },
    120       nip44: {
    121         encrypt: (target: string, text: string) => {
    122           encrypts++;
    123           return Promise.resolve(encrypt(target, text));
    124         },
    125         decrypt: (target: string, wire: string) => {
    126           decrypts++;
    127           if (mode === 'declined_decrypt')
    128             return Promise.reject(Error('controlled decryption refusal'));
    129           const work = () =>
    130             mode === 'wrong_plaintext' ? '{}' : decrypt(target, wire);
    131           return mode === 'hold_decrypt'
    132             ? new Promise<string>((resolve) => {
    133                 release = () => resolve(work());
    134               })
    135             : Promise.resolve(work());
    136         }
    137       }
    138     }
    139   });
    140   const identity = createIdentitySession();
    141   await connectIdentity(identity);
    142   await probeIdentityMessaging(identity, 'reviewed_self_copy');
    143   const opened = await openBrowserDatabase();
    144   if (opened.state !== 'ready') throw Error('fixture storage unavailable');
    145   const database = opened.owner,
    146     repository = createPrivateStorageRepository(database, owner);
    147   if (!repository) throw Error('fixture namespace unavailable');
    148   if (initialise) {
    149     const listing = finalizeEvent(
    150       {
    151         kind: 30402,
    152         created_at: 1700000060,
    153         content: 'Public carrots',
    154         tags: [
    155           ['d', 'carrots'],
    156           ['title', 'Carrots'],
    157           ['summary', 'Fresh carrots'],
    158           ['published_at', '1700000000'],
    159           ['location', 'Victoria'],
    160           ['price', '3.5', 'CAD'],
    161           ['radroots:price_unit', 'lb'],
    162           ['status', 'active']
    163         ]
    164       },
    165       peerSecret
    166     );
    167     const verified = verifyEnvelope(JSON.stringify(listing)),
    168       context = verified.ok && captureEnquiryContext(verified.value),
    169       observed = Date.now();
    170     const plan =
    171       context &&
    172       captureEnquiryRumor(
    173         identity,
    174         context,
    175         marker,
    176         Math.floor(observed / 1000)
    177       );
    178     const reservations = createPrivateSendReservationRepository(
    179       database,
    180       owner
    181     );
    182     if (!plan || !reservations)
    183       throw Error('fixture original intent unavailable');
    184     const realNow = Date.now;
    185     Date.now = () => observed;
    186     let reserved: Awaited<ReturnType<typeof reserveSendIdentity>>;
    187     try {
    188       reserved = await reserveSendIdentity(
    189         reservations,
    190         identity,
    191         command,
    192         plan,
    193         'reviewed_private_intent'
    194       );
    195     } finally {
    196       Date.now = realNow;
    197     }
    198     if (!('identity' in reserved) || !reservedSendSnapshot(reserved.identity))
    199       throw Error('fixture original command unavailable');
    200     const preparation = captureSelfRecoveryPreparation(
    201       repository,
    202       identity,
    203       reserved.identity,
    204       'reviewed_self_recovery'
    205     );
    206     if (
    207       !preparation ||
    208       !['saved', 'existing'].includes(
    209         (await prepareSelfRecovery(preparation, 'reviewed_self_recovery'))
    210           .status
    211       )
    212     )
    213       throw Error('fixture actual self save unavailable');
    214     stopSelfRecoveryPreparation(preparation);
    215     stopRumorPlan(plan);
    216   }
    217   const discovery = 'wss://discovery.example.org',
    218     archive = 'wss://archive.example.org',
    219     destination = 'wss://peer.example.org';
    220   const policy = validateRelayPolicy(
    221     JSON.stringify({
    222       schemaVersion: 1,
    223       public: [{ origin: discovery, read: true, write: false, nip50: false }],
    224       inbox: [archive, destination].map((origin) => ({
    225         origin,
    226         read: true,
    227         write: true
    228       })),
    229       postingEnabled: false,
    230       messagingEnabled: false,
    231       operatorDenylist: []
    232     })
    233   );
    234   if (!policy) throw Error('fixture policy unavailable');
    235   const schedulers: ReturnType<typeof createPublicScheduler>[] = [],
    236     tokens: ReturnType<typeof captureResumePreparation>[] = [];
    237   let current = true;
    238   function resolve(asPeer: boolean) {
    239     const event = finalizeEvent(
    240       {
    241         kind: 10050,
    242         created_at: 100,
    243         tags: [['relay', asPeer ? destination : archive]],
    244         content: ''
    245       },
    246       asPeer ? peerSecret : secret
    247     );
    248     const scheduler = createPublicScheduler({
    249       now: () => 0,
    250       schedule: () => () => {}
    251     });
    252     schedulers.push(scheduler);
    253     const run = createPublicRun(scheduler, policy!);
    254     return createInboxResolver(
    255       run,
    256       event.pubkey,
    257       (next) =>
    258         openInboxRequest(
    259           run,
    260           event.pubkey,
    261           (sink) => {
    262             sink({ type: 'EVENT', from: discovery, id: 'fixture', event });
    263             sink({ type: 'EOSE', from: discovery, id: 'fixture' });
    264             return () => {};
    265           },
    266           next
    267         ),
    268       () => current
    269     );
    270   }
    271   const own = resolve(false),
    272     other = resolve(true),
    273     plan = createInboxRoutePlan(policy, owner, peer, own, other);
    274   if (!plan) throw Error('fixture genuine routing unavailable');
    275   async function row() {
    276     const loaded = await loadPrivateRecord(
    277       repository!,
    278       'private_sends',
    279       command
    280     );
    281     if (!loaded.ok) return undefined;
    282     const record = privateRecordSnapshot(loaded.value, owner, command),
    283       wire = privateRecordWire(loaded.value, owner, command);
    284     return record?.family === 'private_send_operation' && wire
    285       ? { record, wire }
    286       : undefined;
    287   }
    288   async function raw() {
    289     const tx = browserDatabaseTransaction(
    290         database,
    291         ['private_sends'],
    292         'readonly'
    293       ),
    294       request = tx.objectStore('private_sends').getAll();
    295     return new Promise<string>((resolve, reject) => {
    296       tx.addEventListener('complete', () =>
    297         resolve(JSON.stringify(request.result))
    298       );
    299       tx.addEventListener('abort', () => reject(Error('fixture read aborted')));
    300     });
    301   }
    302   async function write(kind: 'erase' | 'revision' | 'corrupt') {
    303     const original = kind === 'revision' ? await row() : undefined;
    304     const wire =
    305       original &&
    306       JSON.stringify({
    307         ...original.record,
    308         revision: original.record.revision + 1
    309       });
    310     if (
    311       kind === 'revision' &&
    312       (!wire || !decodePrivateRecord(wire, owner, command).ok)
    313     )
    314       throw Error('fixture successor unavailable');
    315     const tx = browserDatabaseTransaction(
    316         database,
    317         ['private_sends'],
    318         'readwrite'
    319       ),
    320       store = tx.objectStore('private_sends');
    321     if (kind === 'erase') store.delete([owner, command]);
    322     else
    323       store.put({
    324         owner,
    325         id: command,
    326         wire: kind === 'corrupt' ? '{"schema":999}' : wire
    327       });
    328     await new Promise<void>((resolve, reject) => {
    329       tx.addEventListener('complete', () => resolve());
    330       tx.addEventListener('abort', () =>
    331         reject(Error('fixture write aborted'))
    332       );
    333     });
    334   }
    335   return {
    336     owner,
    337     peer,
    338     command,
    339     marker,
    340     identity,
    341     repository,
    342     context: { plan, policy, own, other },
    343     row,
    344     raw,
    345     write,
    346     capture() {
    347       const token = captureResumePreparation(
    348         repository,
    349         identity,
    350         command,
    351         'reviewed_private_resume'
    352       );
    353       if (!token) throw Error('fixture resume unavailable');
    354       tokens.push(token);
    355       return token;
    356     },
    357     counts: () => ({ keys, encrypts, decrypts, signs }),
    358     mode: (next: Mode) => {
    359       mode = next;
    360     },
    361     settle: () => release?.(),
    362     pending: () => {
    363       const scheduler = browserExtensionScheduler(),
    364         slot = scheduler && extensionSchedulerSnapshot(scheduler);
    365       return slot?.state === 'active' && slot.pending === 'decrypt';
    366     },
    367     disconnect: () => disconnectIdentity(identity),
    368     decryptPeer(wire: string) {
    369       const outer = JSON.parse(wire) as { pubkey: string; content: string };
    370       const conversation = nip44.v2.utils.getConversationKey(
    371         peerSecret,
    372         outer.pubkey
    373       );
    374       let seal: { pubkey: string; content: string };
    375       try {
    376         seal = JSON.parse(
    377           nip44.v2.decrypt(outer.content, conversation)
    378         ) as typeof seal;
    379       } finally {
    380         conversation.fill(0);
    381       }
    382       const inner = nip44.v2.utils.getConversationKey(peerSecret, seal.pubkey);
    383       try {
    384         return JSON.parse(nip44.v2.decrypt(seal.content, inner)) as {
    385           id: string;
    386           created_at: number;
    387           content: string;
    388         };
    389       } finally {
    390         inner.fill(0);
    391       }
    392     },
    393     close() {
    394       current = false;
    395       for (const token of tokens) if (token) stopResumePreparation(token);
    396       for (const scheduler of schedulers) closePublicScheduler(scheduler);
    397       disconnectIdentity(identity);
    398       closeBrowserDatabase(database);
    399       secret.fill(0);
    400       peerSecret.fill(0);
    401       delete window.nostr;
    402     }
    403   };
    404 }