app

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

private-validation-cache.ts (10908B)


      1 // CR005_TEST_ONLY: real IDB/validator, no nested/extension/operator/fullQ proof.
      2 import { finalizeEvent, generateSecretKey } from 'applesauce-core/helpers';
      3 import { nip44 } from 'applesauce-core/helpers/encryption';
      4 import { makeFixture as makeSigner } from './approved-signing.ts';
      5 import {
      6   openBrowserDatabase,
      7   closeBrowserDatabase,
      8   browserDatabaseTransaction
      9 } from '../../../src/lib/persistence/database.ts';
     10 import {
     11   createPrivateStorageRepository,
     12   loadPrivateRecord,
     13   listPrivateSendRecords,
     14   listPrivateReceivedRecords
     15 } from '../../../src/lib/persistence/private-storage.ts';
     16 import {
     17   decodePrivateRecord,
     18   privateRecordSnapshot
     19 } from '../../../src/lib/persistence/private-records.ts';
     20 import { readRetainedOuterMetadata } from '../../../src/lib/persistence/history-metadata-repository.ts';
     21 import {
     22   createIdentitySession,
     23   connectIdentity,
     24   probeIdentityMessaging,
     25   disconnectIdentity
     26 } from '../../../src/lib/runtime/identity-session.ts';
     27 import { createPrivateSession } from '../../../src/lib/runtime/private-session.ts';
     28 declare global {
     29   var __cr005VerifyCalls: number | undefined;
     30 }
     31 type Store = 'private_sends' | 'received_envelopes';
     32 type Row = { owner: string; id: string; wire: string };
     33 export async function createFixture() {
     34   const signer = makeSigner(),
     35     peer = makeSigner(),
     36     prior = Object.getOwnPropertyDescriptor(window, 'nostr'),
     37     owner = signer.owner;
     38   Object.defineProperty(window, 'nostr', {
     39     configurable: true,
     40     value: {
     41       getPublicKey: () => Promise.resolve(owner),
     42       signEvent: (t: Parameters<typeof signer.sign>[0]) =>
     43         Promise.resolve(signer.sign(t)),
     44       nip44: {
     45         encrypt: (p: string, t: string) =>
     46           Promise.resolve(signer.encrypt(p, t)),
     47         decrypt: (p: string, t: string) => Promise.resolve(signer.decrypt(p, t))
     48       }
     49     }
     50   });
     51   const identity = createIdentitySession();
     52   await connectIdentity(identity);
     53   await probeIdentityMessaging(identity, 'reviewed_self_copy');
     54   const session = await createPrivateSession(
     55       identity,
     56       'reviewed_private_session'
     57     ),
     58     opened = await openBrowserDatabase();
     59   if (!session || opened.state !== 'ready')
     60     throw Error('genuine fixture session/database absent');
     61   const database = opened.owner,
     62     repository = createPrivateStorageRepository(database, owner),
     63     foreign = createPrivateStorageRepository(database, peer.owner);
     64   if (!repository || !foreign) throw Error('genuine repositories absent');
     65   const repo = repository,
     66     foreignRepo = foreign,
     67     rows: Row[] = [],
     68     sends: Row[] = [],
     69     observed = Date.now();
     70   for (let index = 0; index < 2000; index++) {
     71     const secret = generateSecretKey(),
     72       conversation = nip44.v2.utils.getConversationKey(secret, owner);
     73     let outer;
     74     try {
     75       outer = finalizeEvent(
     76         {
     77           kind: 1059,
     78           created_at: Math.floor(observed / 1000) - index,
     79           tags: [['p', owner]],
     80           content: nip44.v2.encrypt(
     81             'CR005_TEST_ONLY_opaque_transport_seal',
     82             conversation
     83           )
     84         },
     85         secret
     86       );
     87     } finally {
     88       secret.fill(0);
     89       conversation.fill(0);
     90     }
     91     const record = {
     92         schema: 1,
     93         family: 'received_envelope',
     94         owner,
     95         id: outer.id,
     96         revision: 0,
     97         outer: JSON.stringify(outer),
     98         observedAtMilliseconds: observed,
     99         sources: ['wss://archive.example.org'],
    100         read: null
    101       },
    102       wire = JSON.stringify(record);
    103     if (!decodePrivateRecord(wire, owner, record.id).ok)
    104       throw Error('strict outer rejected');
    105     rows.push({ owner, id: record.id, wire });
    106   }
    107   for (let index = 0; index < 100; index++) {
    108     const id = crypto.randomUUID(),
    109       wire = JSON.stringify({
    110         schema: 1,
    111         family: 'private_send_reservation',
    112         owner,
    113         id,
    114         revision: 0,
    115         peer: peer.owner,
    116         rumorHash: 'a'.repeat(64),
    117         createdAt: Math.floor(observed / 1000)
    118       });
    119     if (!decodePrivateRecord(wire, owner, id).ok)
    120       throw Error('strict reservation rejected');
    121     sends.push({ owner, id, wire });
    122   }
    123   rows.sort((a, b) => a.id.localeCompare(b.id));
    124   const nativeCursor = Reflect.get<IDBIndex, 'openCursor'>(
    125     IDBIndex.prototype,
    126     'openCursor'
    127   );
    128   let visits = 0;
    129   IDBIndex.prototype.openCursor = function (...args) {
    130     const request = Reflect.apply(nativeCursor, this, args);
    131     request.addEventListener('success', () => {
    132       if (request.result) visits++;
    133     });
    134     return request;
    135   };
    136   async function put(store: Store, records: readonly unknown[], other = false) {
    137     const openedOther = other ? await openBrowserDatabase() : undefined;
    138     if (openedOther && openedOther.state !== 'ready')
    139       throw Error('second connection absent');
    140     const db = openedOther?.state === 'ready' ? openedOther.owner : database;
    141     try {
    142       const tx = browserDatabaseTransaction(db, [store], 'readwrite');
    143       for (const row of records) tx.objectStore(store).put(row);
    144       await new Promise<void>((resolve, reject) => {
    145         tx.addEventListener('complete', () => resolve());
    146         tx.addEventListener('abort', () =>
    147           reject(Error('actual fixture write aborted'))
    148         );
    149       });
    150     } finally {
    151       if (openedOther?.state === 'ready')
    152         closeBrowserDatabase(openedOther.owner);
    153     }
    154   }
    155   await put('received_envelopes', rows);
    156   await put('private_sends', sends);
    157   function reset() {
    158     visits = 0;
    159     globalThis.__cr005VerifyCalls = 0;
    160   }
    161   function measured(start: number) {
    162     return {
    163       cursorVisits: visits,
    164       verificationCalls: globalThis.__cr005VerifyCalls ?? 0,
    165       milliseconds: performance.now() - start
    166     };
    167   }
    168   async function sample(store: Store = 'received_envelopes') {
    169     reset();
    170     const start = performance.now(),
    171       row = store === 'private_sends' ? sends[0] : rows[0],
    172       result = await loadPrivateRecord(repo, store, row.id);
    173     return {
    174       ...measured(start),
    175       ok: result.ok,
    176       reason: result.ok ? null : result.reason,
    177       revision: result.ok
    178         ? privateRecordSnapshot(result.value, owner, row.id)?.revision
    179         : null
    180     };
    181   }
    182   return {
    183     owner,
    184     sample,
    185     async inventory() {
    186       reset();
    187       const start = performance.now(),
    188         result = await listPrivateReceivedRecords(repo);
    189       return {
    190         ...measured(start),
    191         ok: result.ok,
    192         count: result.ok ? result.value.length : null
    193       };
    194     },
    195     async metadata(other = false) {
    196       reset();
    197       const start = performance.now(),
    198         result = await readRetainedOuterMetadata(
    199           other ? foreignRepo : repo,
    200           session
    201         );
    202       return {
    203         ...measured(start),
    204         ok: result.ok,
    205         count: result.ok ? result.rows.length : null,
    206         reason: result.ok ? null : result.reason
    207       };
    208     },
    209     bytes: () => ({
    210       received: rows.reduce(
    211         (n, row) => n + new TextEncoder().encode(JSON.stringify(row)).length,
    212         0
    213       ),
    214       sends: sends.reduce(
    215         (n, row) => n + new TextEncoder().encode(JSON.stringify(row)).length,
    216         0
    217       )
    218     }),
    219     async changeTail(
    220       kind: 'valid' | 'metadata' | 'corrupt' | 'summary' | 'id',
    221       other = false
    222     ) {
    223       const original = rows.at(-1)!;
    224       let next: unknown;
    225       if (kind === 'summary')
    226         next = { ...original, untrustedSummary: { count: 0, bytes: 0 } };
    227       else {
    228         const record = JSON.parse(original.wire) as Record<string, unknown>;
    229         if (kind === 'valid' || kind === 'metadata') record.revision = 1;
    230         if (kind === 'metadata') {
    231           record.sources = [
    232             'wss://archive.example.org',
    233             'wss://peer.example.org'
    234           ];
    235           record.read = {
    236             rumorHash: 'b'.repeat(64),
    237             atMilliseconds: Date.now()
    238           };
    239         }
    240         if (kind === 'corrupt') record.outer = 'corrupt signed tail';
    241         if (kind === 'id') record.id = '0'.repeat(64);
    242         next = { ...original, wire: JSON.stringify(record) };
    243       }
    244       await put('received_envelopes', [next], other);
    245     },
    246     restoreTail: () => put('received_envelopes', [rows.at(-1)!]),
    247     async overfillReceived() {
    248       const secret = generateSecretKey(),
    249         conversation = nip44.v2.utils.getConversationKey(secret, owner);
    250       let event;
    251       try {
    252         event = finalizeEvent(
    253           {
    254             kind: 1059,
    255             created_at: Math.floor(Date.now() / 1000),
    256             tags: [['p', owner]],
    257             content: nip44.v2.encrypt(
    258               'CR005_TEST_ONLY_EXTRA_2001',
    259               conversation
    260             )
    261           },
    262           secret
    263         );
    264       } finally {
    265         secret.fill(0);
    266         conversation.fill(0);
    267       }
    268       const prior = JSON.parse(rows[0].wire) as Record<string, unknown>;
    269       const record = {
    270           ...prior,
    271           id: event.id,
    272           outer: JSON.stringify(event)
    273         },
    274         wire = JSON.stringify(record);
    275       if (!decodePrivateRecord(wire, owner, event.id).ok)
    276         throw Error('actual2001record invalid');
    277       await put('received_envelopes', [{ owner, id: event.id, wire }], true);
    278       const result = await listPrivateReceivedRecords(repo);
    279       return { ok: result.ok, reason: result.ok ? null : result.reason };
    280     },
    281     async overfillSends() {
    282       const extra = { ...sends[0], id: crypto.randomUUID() },
    283         record = JSON.parse(extra.wire) as Record<string, unknown>;
    284       record.id = extra.id;
    285       extra.wire = JSON.stringify(record);
    286       await put('private_sends', [extra], true);
    287       const result = await listPrivateSendRecords(repo);
    288       return { ok: result.ok, reason: result.ok ? null : result.reason };
    289     },
    290     async oversizeReceived() {
    291       const padded = rows.map((row) => {
    292           const record = JSON.parse(row.wire) as Record<string, unknown>;
    293           record.outer = String(record.outer) + '\n'.repeat(9000);
    294           return { ...row, wire: JSON.stringify(record) };
    295         }),
    296         bytes = padded.reduce(
    297           (n, row) => n + new TextEncoder().encode(JSON.stringify(row)).length,
    298           0
    299         );
    300       await put('received_envelopes', padded, true);
    301       const result = await listPrivateReceivedRecords(repo);
    302       return { bytes, ok: result.ok, reason: result.ok ? null : result.reason };
    303     },
    304     async foreignRead() {
    305       const result = await loadPrivateRecord(
    306         foreignRepo,
    307         'received_envelopes',
    308         rows[0].id
    309       );
    310       return { ok: result.ok, reason: result.ok ? null : result.reason };
    311     },
    312     close() {
    313       IDBIndex.prototype.openCursor = nativeCursor;
    314       disconnectIdentity(identity);
    315       closeBrowserDatabase(database);
    316       signer.close();
    317       peer.close();
    318       if (prior) Object.defineProperty(window, 'nostr', prior);
    319       else delete window.nostr;
    320     }
    321   };
    322 }