app

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

seal-builder.ts (10204B)


      1 import {
      2   finalizeEvent,
      3   generateSecretKey,
      4   getPublicKey,
      5   verifiedSymbol,
      6   type UnsignedEvent
      7 } from 'applesauce-core/helpers';
      8 import { nip44 } from 'applesauce-core/helpers/encryption';
      9 import { verifyEnvelope } from '../../../src/lib/nostr/verified-envelope.ts';
     10 import { captureEnquiryContext } from '../../../src/lib/messaging/enquiry-context.ts';
     11 import { captureEnquiryRumor } from '../../../src/lib/messaging/rumor-plan.ts';
     12 import {
     13   openBrowserDatabase,
     14   closeBrowserDatabase,
     15   browserDatabaseTransaction
     16 } from '../../../src/lib/persistence/database.ts';
     17 import { createPrivateSendReservationRepository } from '../../../src/lib/persistence/private-send-reservations.ts';
     18 import {
     19   reserveSendIdentity,
     20   reservedSendRumorWire
     21 } from '../../../src/lib/messaging/send-identity.ts';
     22 import {
     23   createIdentitySession,
     24   connectIdentity,
     25   probeIdentityMessaging,
     26   identitySessionSnapshot,
     27   disconnectIdentity
     28 } from '../../../src/lib/runtime/identity-session.ts';
     29 import {
     30   capturePrivateSealOperation,
     31   buildPrivateSeal,
     32   stopPrivateSeal,
     33   expirePrivateSealWait,
     34   privateSealSnapshot
     35 } from '../../../src/lib/nostr/seal-builder.ts';
     36 import {
     37   browserExtensionScheduler,
     38   extensionSchedulerSnapshot
     39 } from '../../../src/lib/nostr/extension-scheduler.ts';
     40 export {
     41   capturePrivateSealOperation,
     42   buildPrivateSeal,
     43   stopPrivateSeal,
     44   expirePrivateSealWait,
     45   privateSealSnapshot
     46 };
     47 export type Mode =
     48   | 'normal'
     49   | 'wrong_cipher'
     50   | 'wrong_author'
     51   | 'wrong_tags'
     52   | 'wrong_time'
     53   | 'cached_bad_id'
     54   | 'missing'
     55   | 'declined'
     56   | 'changed_key'
     57   | 'hold_encrypt'
     58   | 'hold_sign'
     59   | 'wrong_plaintext'
     60   | 'declined_decrypt'
     61   | 'hold_decrypt'
     62   | 'getter_reentry'
     63   | 'stop_capability_getter'
     64   | 'stop_capability_after_key';
     65 // Ephemeral source-only provider: actual stock SDK encryption/signature and real
     66 // Chromium IDB/WebLocks. No installed extension/relay/client qualification.
     67 export async function makeFixture() {
     68   const secret = generateSecretKey(),
     69     peerSecret = generateSecretKey(),
     70     owner = getPublicKey(secret),
     71     peer = getPublicKey(peerSecret);
     72   let mode: Mode = 'normal',
     73     keys = 0,
     74     encrypts = 0,
     75     signs = 0,
     76     decrypts = 0,
     77     capabilityReads = 0,
     78     reentrantReads = 0,
     79     postStopEncrypts = 0,
     80     getterStopped = false,
     81     watched: ReturnType<typeof capturePrivateSealOperation>,
     82     release: (() => void) | undefined;
     83   function encryptTo(target: string, text: string) {
     84     const conversation = nip44.v2.utils.getConversationKey(secret, target);
     85     try {
     86       return nip44.v2.encrypt(text, conversation);
     87     } finally {
     88       conversation.fill(0);
     89     }
     90   }
     91   function sign(template: UnsignedEvent) {
     92     const input =
     93       mode === 'wrong_cipher'
     94         ? { ...template, content: encryptTo(peer, 'different immutable rumor') }
     95         : mode === 'wrong_tags'
     96           ? { ...template, tags: [['client', 'leak']] }
     97           : mode === 'wrong_time'
     98             ? { ...template, created_at: template.created_at + 1 }
     99             : template;
    100     const signed = finalizeEvent(
    101       input,
    102       mode === 'wrong_author' ? peerSecret : secret
    103     );
    104     return mode === 'cached_bad_id'
    105       ? { ...signed, id: '0'.repeat(64), [verifiedSymbol]: true }
    106       : {
    107           ...signed,
    108           plaintext: 'never retained sentinel',
    109           toJSON: () => {
    110             throw Error('unexpected provider conversion');
    111           }
    112         };
    113   }
    114   const provider = {
    115     getPublicKey: () => {
    116       keys++;
    117       return Promise.resolve(mode === 'changed_key' ? peer : owner);
    118     },
    119     signEvent: (template: UnsignedEvent) => {
    120       signs++;
    121       return mode === 'hold_sign'
    122         ? new Promise<ReturnType<typeof sign>>((resolve) => {
    123             release = () => resolve(sign(template));
    124           })
    125         : Promise.resolve(sign(template));
    126     },
    127     get nip44() {
    128       capabilityReads++;
    129       if (
    130         watched &&
    131         (mode === 'stop_capability_getter' ||
    132           (mode === 'stop_capability_after_key' && capabilityReads === 2))
    133       ) {
    134         stopPrivateSeal(watched);
    135         return undefined;
    136       }
    137       return mode === 'missing'
    138         ? undefined
    139         : {
    140             get encrypt() {
    141               const scheduler = browserExtensionScheduler(),
    142                 slot = scheduler && extensionSchedulerSnapshot(scheduler);
    143               if (
    144                 mode === 'getter_reentry' &&
    145                 watched &&
    146                 slot &&
    147                 slot.state === 'active' &&
    148                 slot.pending === 'encrypt'
    149               ) {
    150                 reentrantReads++;
    151                 getterStopped = true;
    152                 stopPrivateSeal(watched);
    153               }
    154               return (target: string, text: string) => {
    155                 encrypts++;
    156                 if (getterStopped) postStopEncrypts++;
    157                 if (mode === 'declined')
    158                   return Promise.reject(Error('private failure must not leak'));
    159                 if (mode === 'hold_encrypt')
    160                   return new Promise<string>((resolve) => {
    161                     release = () => resolve(encryptTo(target, text));
    162                   });
    163                 return Promise.resolve(
    164                   encryptTo(
    165                     target,
    166                     mode === 'wrong_plaintext' ? 'substitute rumor' : text
    167                   )
    168                 );
    169               };
    170             },
    171             decrypt: (target: string, cipher: string) => {
    172               decrypts++;
    173               if (mode === 'declined_decrypt')
    174                 return Promise.reject(Error('decrypt refused'));
    175               const decryptNow = () => {
    176                 const conversation = nip44.v2.utils.getConversationKey(
    177                   secret,
    178                   target
    179                 );
    180                 try {
    181                   return nip44.v2.decrypt(cipher, conversation);
    182                 } finally {
    183                   conversation.fill(0);
    184                 }
    185               };
    186               if (mode === 'hold_decrypt')
    187                 return new Promise<string>((resolve) => {
    188                   release = () => resolve(decryptNow());
    189                 });
    190               return Promise.resolve(decryptNow());
    191             }
    192           };
    193     }
    194   };
    195   Object.defineProperty(window, 'nostr', {
    196     configurable: true,
    197     value: provider
    198   });
    199   const identity = createIdentitySession();
    200   await connectIdentity(identity);
    201   await probeIdentityMessaging(identity, 'reviewed_self_copy');
    202   const food = finalizeEvent(
    203     {
    204       kind: 30402,
    205       created_at: 1700000060,
    206       content: 'Public carrots',
    207       tags: [
    208         ['d', 'carrots'],
    209         ['title', 'Carrots'],
    210         ['summary', 'Fresh carrots'],
    211         ['published_at', '1700000000'],
    212         ['location', 'Victoria'],
    213         ['price', '3.5', 'CAD'],
    214         ['radroots:price_unit', 'lb'],
    215         ['status', 'active']
    216       ]
    217     },
    218     peerSecret
    219   );
    220   const proof = verifyEnvelope(JSON.stringify(food));
    221   if (!proof.ok) throw Error('invalid public fixture');
    222   const context = captureEnquiryContext(proof.value);
    223   if (!context) throw Error('invalid context');
    224   const reservationTime = Date.now();
    225   const plan = captureEnquiryRumor(
    226     identity,
    227     context,
    228     'Private seal sentinel',
    229     Math.floor(reservationTime / 1000)
    230   );
    231   if (!plan) throw Error('missing plan');
    232   const opened = await openBrowserDatabase();
    233   if (opened.state !== 'ready') throw Error('missing database');
    234   const database = opened.owner,
    235     repository = createPrivateSendReservationRepository(database, owner);
    236   if (!repository) throw Error('missing repository');
    237   // Controlled fixture second across actual asynchronous IDB/WebLock setup.
    238   // Production admission still requires its real current observed second.
    239   const liveNow = Date.now;
    240   let reservation: Awaited<ReturnType<typeof reserveSendIdentity>>;
    241   Date.now = () => reservationTime;
    242   try {
    243     reservation = await reserveSendIdentity(
    244       repository,
    245       identity,
    246       '12345678-1234-4234-8234-123456789abc',
    247       plan,
    248       'reviewed_private_intent'
    249     );
    250   } finally {
    251     Date.now = liveNow;
    252   }
    253   if (reservation.status !== 'reserved')
    254     throw Error('missing reservation: ' + reservation.status);
    255   const reserved = reservation.identity;
    256   const original = reservedSendRumorWire(reserved);
    257   return {
    258     owner,
    259     peer,
    260     identity,
    261     reserved,
    262     operation: (
    263       role: unknown = 'peer',
    264       review: unknown = 'reviewed_private_seal'
    265     ) => {
    266       watched = capturePrivateSealOperation(identity, reserved, role, review);
    267       return watched;
    268     },
    269     mode: (value: Mode) => {
    270       mode = value;
    271       capabilityReads = 0;
    272     },
    273     counts: () => ({
    274       keys,
    275       encrypts,
    276       decrypts,
    277       signs,
    278       reentrantReads,
    279       postStopEncrypts
    280     }),
    281     identityState: () => identitySessionSnapshot(identity).state,
    282     settle: () => {
    283       release?.();
    284     },
    285     slot: () => {
    286       const scheduler = browserExtensionScheduler();
    287       return scheduler ? extensionSchedulerSnapshot(scheduler) : undefined;
    288     },
    289     disconnect: () => disconnectIdentity(identity),
    290     async stored() {
    291       const tx = browserDatabaseTransaction(
    292           database,
    293           ['private_sends'],
    294           'readonly'
    295         ),
    296         request = tx.objectStore('private_sends').getAll();
    297       return await new Promise<string>((resolve, reject) => {
    298         tx.addEventListener('complete', () =>
    299           resolve(JSON.stringify(request.result))
    300         );
    301         tx.addEventListener('abort', () => reject(Error('inspection aborted')));
    302       });
    303     },
    304     decrypt(wire: string, role: 'peer' | 'self') {
    305       const seal = JSON.parse(wire) as { content: string };
    306       const conversation = nip44.v2.utils.getConversationKey(
    307         role === 'peer' ? peerSecret : secret,
    308         owner
    309       );
    310       try {
    311         return {
    312           equal: nip44.v2.decrypt(seal.content, conversation) === original,
    313           seal
    314         };
    315       } finally {
    316         conversation.fill(0);
    317       }
    318     },
    319     close() {
    320       disconnectIdentity(identity);
    321       closeBrowserDatabase(database);
    322       secret.fill(0);
    323       peerSecret.fill(0);
    324       delete window.nostr;
    325     }
    326   };
    327 }