app

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

giftwrap-builder.ts (11347B)


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