app

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

private-send-reservations.ts (5591B)


      1 import { finalizeEvent, type NostrEvent } from 'applesauce-core/helpers';
      2 import { verifyEnvelope } from '../../../src/lib/nostr/verified-envelope.ts';
      3 import { captureEnquiryContext } from '../../../src/lib/messaging/enquiry-context.ts';
      4 import {
      5   captureEnquiryRumor,
      6   type RumorPlan
      7 } from '../../../src/lib/messaging/rumor-plan.ts';
      8 import {
      9   openBrowserDatabase,
     10   closeBrowserDatabase,
     11   browserDatabaseTransaction
     12 } from '../../../src/lib/persistence/database.ts';
     13 import {
     14   createIdentitySession,
     15   connectIdentity,
     16   probeIdentityMessaging,
     17   disconnectIdentity
     18 } from '../../../src/lib/runtime/identity-session.ts';
     19 import { createPrivateSendReservationRepository } from '../../../src/lib/persistence/private-send-reservations.ts';
     20 import {
     21   reserveSendIdentity,
     22   reservedSendSnapshot,
     23   reservedSendRumorWire
     24 } from '../../../src/lib/messaging/send-identity.ts';
     25 export { reserveSendIdentity, reservedSendSnapshot, reservedSendRumorWire };
     26 export { stopRumorPlan } from '../../../src/lib/messaging/rumor-plan.ts';
     27 export const owner =
     28   '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798';
     29 export const command = '12345678-1234-4234-8234-123456789abc';
     30 export type Shared = { event: NostrEvent; milliseconds: number };
     31 // Controlled source-only clock/provider fixtures; real browser IDB/WebLocks,
     32 // never installed extensions, cryptographic messaging or real clock Q evidence.
     33 export async function makeFixture(
     34   shared?: Shared,
     35   clock: 'controlled' | 'real' = 'controlled'
     36 ) {
     37   const previousNow = Date.now;
     38   let milliseconds = shared?.milliseconds ?? previousNow(),
     39     signs = 0,
     40     encrypts = 0,
     41     decrypts = 0;
     42   if (clock === 'controlled') Date.now = () => milliseconds;
     43   function publicFood() {
     44     const key = crypto.getRandomValues(new Uint8Array(32));
     45     try {
     46       return finalizeEvent(
     47         {
     48           kind: 30402,
     49           created_at: 1700000060,
     50           content: 'Public carrots',
     51           tags: [
     52             ['d', 'carrots'],
     53             ['title', 'Carrots'],
     54             ['summary', 'Fresh carrots'],
     55             ['published_at', '1700000000'],
     56             ['location', 'Victoria'],
     57             ['price', '3.5', 'CAD'],
     58             ['radroots:price_unit', 'lb'],
     59             ['status', 'active']
     60           ]
     61         },
     62         key
     63       );
     64     } finally {
     65       key.fill(0);
     66     }
     67   }
     68   const event = shared?.event ?? publicFood(),
     69     proof = verifyEnvelope(JSON.stringify(event));
     70   if (!proof.ok) throw Error('invalid public source fixture');
     71   const context = captureEnquiryContext(proof.value);
     72   if (!context) throw Error('invalid Food context');
     73   const capturedContext = context;
     74   Object.defineProperty(window, 'nostr', {
     75     configurable: true,
     76     value: {
     77       getPublicKey: () => Promise.resolve(owner),
     78       signEvent: () => {
     79         signs++;
     80         return Promise.reject(Error('unexpected sign'));
     81       },
     82       nip44: {
     83         encrypt: (_peer: string, text: string) => {
     84           encrypts++;
     85           return Promise.resolve('fixture:' + text);
     86         },
     87         decrypt: (_peer: string, text: string) => {
     88           decrypts++;
     89           return Promise.resolve(text.slice(8));
     90         }
     91       }
     92     }
     93   });
     94   const identity = createIdentitySession();
     95   await connectIdentity(identity);
     96   await probeIdentityMessaging(identity, 'reviewed_self_copy');
     97   const opened = await openBrowserDatabase();
     98   if (opened.state !== 'ready')
     99     throw Error('browser fixture database unavailable');
    100   const database = opened.owner,
    101     repository = createPrivateSendReservationRepository(database, owner);
    102   if (!repository) throw Error('invalid source repository');
    103   function plan(
    104     text = 'Private reservation sentinel',
    105     seconds = Math.floor(Date.now() / 1000)
    106   ) {
    107     const value = captureEnquiryRumor(identity, capturedContext, text, seconds);
    108     if (!value) throw Error('expected local source plan');
    109     return value;
    110   }
    111   async function rows() {
    112     const transaction = browserDatabaseTransaction(
    113         database,
    114         ['private_sends'],
    115         'readonly'
    116       ),
    117       request = transaction.objectStore('private_sends').getAll();
    118     return await new Promise<unknown[]>((resolve, reject) => {
    119       transaction.addEventListener('complete', () =>
    120         resolve(request.result as unknown[])
    121       );
    122       transaction.addEventListener('abort', () =>
    123         reject(Error('inspection aborted'))
    124       );
    125     });
    126   }
    127   async function inject(value: unknown) {
    128     const transaction = browserDatabaseTransaction(
    129       database,
    130       ['private_sends'],
    131       'readwrite'
    132     );
    133     transaction.objectStore('private_sends').put(value);
    134     await new Promise<void>((resolve, reject) => {
    135       transaction.addEventListener('complete', () => resolve());
    136       transaction.addEventListener('abort', () =>
    137         reject(Error('fixture injection aborted'))
    138       );
    139     });
    140   }
    141   return {
    142     identity,
    143     repository,
    144     database,
    145     event,
    146     plan,
    147     rows,
    148     inject,
    149     shared: (): Shared => ({ event, milliseconds }),
    150     setTime: (value: number) => {
    151       if (clock !== 'controlled') throw Error('real clock cannot be frozen');
    152       milliseconds = value;
    153     },
    154     counts: () => ({ signs, encrypts, decrypts }),
    155     reserve: (id: string, value: RumorPlan) =>
    156       reserveSendIdentity(
    157         repository,
    158         identity,
    159         id,
    160         value,
    161         'reviewed_private_intent'
    162       ),
    163     disconnect: () => disconnectIdentity(identity),
    164     close() {
    165       disconnectIdentity(identity);
    166       closeBrowserDatabase(database);
    167       Date.now = previousNow;
    168     }
    169   };
    170 }