app

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

private-storage.ts (6754B)


      1 import { generateSecretKey, finalizeEvent } from 'applesauce-core/helpers';
      2 import { nip44 } from 'applesauce-core/helpers/encryption';
      3 import {
      4   openBrowserDatabase,
      5   browserDatabaseTransaction,
      6   closeBrowserDatabase
      7 } from '../../../src/lib/persistence/database.ts';
      8 import {
      9   decodePrivateRecord,
     10   privateRecordWire
     11 } from '../../../src/lib/persistence/private-records.ts';
     12 import {
     13   createPrivateStorageRepository,
     14   commitPrivateRecord,
     15   loadPrivateRecord,
     16   inspectPrivateStorage
     17 } from '../../../src/lib/persistence/private-storage.ts';
     18 import {
     19   createPrivateSendReservationRepository,
     20   reservePrivateSendReservation
     21 } from '../../../src/lib/persistence/private-send-reservations.ts';
     22 export {
     23   decodePrivateRecord,
     24   privateRecordWire,
     25   commitPrivateRecord,
     26   loadPrivateRecord,
     27   inspectPrivateStorage
     28 };
     29 export const owner =
     30   '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798';
     31 export const peer =
     32   'c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5';
     33 export const command = '12345678-1234-4234-8234-123456789abc';
     34 export const id = (index: number) =>
     35   '12345678-1234-4234-8234-' + index.toString(16).padStart(12, '0');
     36 // Real browser IDB; generated disposable fixture crypto only, not a genuine
     37 // nested exchange or installed extension/operator qualification.
     38 export async function makeFixture() {
     39   const opened = await openBrowserDatabase();
     40   if (opened.state !== 'ready') throw Error('browser storage unavailable');
     41   const database = opened.owner,
     42     repository = createPrivateStorageRepository(database, owner),
     43     reservations = createPrivateSendReservationRepository(database, owner);
     44   if (!repository || !reservations) throw Error('invalid fixture namespace');
     45   const repo = repository,
     46     reservedRepo = reservations;
     47   function reservation(index: number) {
     48     return {
     49       schema: 1,
     50       family: 'private_send_reservation',
     51       owner,
     52       id: id(index),
     53       revision: 0,
     54       peer,
     55       rumorHash: index.toString(16).padStart(64, '0'),
     56       createdAt: 1700000000
     57     };
     58   }
     59   function outer(destination = owner, index = 0, padded = false) {
     60     const secret = generateSecretKey();
     61     let conversation: Uint8Array | undefined;
     62     try {
     63       conversation = nip44.v2.utils.getConversationKey(secret, destination);
     64       const event = finalizeEvent(
     65         {
     66           kind: 1059,
     67           created_at: 1700000000 + index,
     68           tags: [['p', destination]],
     69           content: nip44.v2.encrypt(
     70             'HCP080 private plaintext sentinel',
     71             conversation
     72           )
     73         },
     74         secret
     75       );
     76       const wire = JSON.stringify(event);
     77       // Detached valid signed raw JSON whitespace fixtures measure actual
     78       // stored JSON UTF8 bytes; they are not factory/nested admission claims.
     79       return {
     80         eventId: event.id,
     81         wire: padded
     82           ? wire + '\n'.repeat(32768 - new TextEncoder().encode(wire).length)
     83           : wire
     84       };
     85     } finally {
     86       conversation?.fill(0);
     87       secret.fill(0);
     88     }
     89   }
     90   function operation(index: number, padded = false) {
     91     return {
     92       ...reservation(index),
     93       family: 'private_send_operation',
     94       revision: 1,
     95       self: outer(owner, index, padded),
     96       peerArtifact: padded ? outer(peer, index, padded) : null
     97     };
     98   }
     99   function probe(index: number, prepared = false, padded = false) {
    100     const origin = 'wss://inbox.example.org',
    101       policyWire = JSON.stringify({
    102         schemaVersion: 1,
    103         public: [
    104           {
    105             origin: 'wss://public.example.org',
    106             read: true,
    107             write: false,
    108             nip50: false
    109           }
    110         ],
    111         inbox: [{ origin, read: true, write: true }],
    112         postingEnabled: false,
    113         messagingEnabled: true,
    114         operatorDenylist: []
    115       });
    116     return {
    117       schema: 1,
    118       family: 'private_access_probe',
    119       owner,
    120       id: id(index),
    121       revision: prepared ? 1 : 0,
    122       rumorHash: index.toString(16).padStart(64, '0'),
    123       createdAt: 1700000000,
    124       binding: {
    125         preferenceId: 'f'.repeat(64),
    126         preferenceCreatedAt: 1699999999,
    127         readTargets: [origin],
    128         archiveTargets: [origin],
    129         policyWire,
    130         operatorWire: JSON.stringify({
    131           schemaVersion: 1,
    132           revision: 1,
    133           authority: 'source_fixture',
    134           policyWire,
    135           evidenceSha256: 'a'.repeat(64),
    136           relays: [
    137             {
    138               origin,
    139               auth: 'not_required',
    140               recipientRead: 'supported',
    141               namedArchiveAck: 'supported',
    142               exactReadback: 'supported',
    143               retention: 'operator_defined'
    144             }
    145           ]
    146         })
    147       },
    148       self: prepared ? outer(owner, index, padded) : null,
    149       receipts: []
    150     };
    151   }
    152   function received(index: number, padded = false) {
    153     const artifact = outer(owner, index, padded);
    154     return {
    155       schema: 1,
    156       family: 'received_envelope',
    157       owner,
    158       id: artifact.eventId,
    159       revision: 0,
    160       outer: artifact.wire,
    161       observedAtMilliseconds: 1700000000000,
    162       sources: ['wss://inbox.example.org'],
    163       read: null
    164     };
    165   }
    166   function handle<T extends { owner: string; id: string }>(record: T) {
    167     const result = decodePrivateRecord(
    168       JSON.stringify(record),
    169       record.owner,
    170       record.id
    171     );
    172     if (!result.ok) throw Error('invalid fixture record');
    173     return result.value;
    174   }
    175   async function rows(
    176     store: 'private_sends' | 'received_envelopes' | 'public_drafts'
    177   ) {
    178     const tx = browserDatabaseTransaction(database, [store], 'readonly'),
    179       request = tx.objectStore(store).getAll();
    180     return await new Promise<unknown[]>((resolve, reject) => {
    181       tx.addEventListener('complete', () =>
    182         resolve(request.result as unknown[])
    183       );
    184       tx.addEventListener('abort', () => reject(Error('inspection aborted')));
    185     });
    186   }
    187   async function inject(
    188     store: 'private_sends' | 'received_envelopes',
    189     values: unknown[]
    190   ) {
    191     const tx = browserDatabaseTransaction(database, [store], 'readwrite');
    192     for (const value of values) tx.objectStore(store).put(value);
    193     await new Promise<void>((resolve, reject) => {
    194       tx.addEventListener('complete', () => resolve());
    195       tx.addEventListener('abort', () => reject(Error('injection aborted')));
    196     });
    197   }
    198   return {
    199     database,
    200     repository: repo,
    201     reservation,
    202     operation,
    203     probe,
    204     received,
    205     handle,
    206     rows,
    207     inject,
    208     reserve: (index: number) =>
    209       reservePrivateSendReservation(
    210         reservedRepo,
    211         JSON.stringify(reservation(index)),
    212         1700000000,
    213         () => true
    214       ),
    215     close: () => closeBrowserDatabase(database)
    216   };
    217 }